@developer_tribe/react-builder 0.1.16 → 0.1.18

package/src/utils/novaToJson.ts

@@ -229,25 +229,56 @@ function mapFooterFromGeneralComponents(generalComponents: any[]): Node | null {
   const footer = generalComponents.find((gc) => gc?.layout === 'footer-layout');
   if (!footer) return null;
   const texts = (footer?.attributes?.texts || []) as any[];
-  const children: Node[] = [];
+  const linkedWords: { text_key?: string; color?: string; page?: string }[] =
+    [];
+  let baseTextKey: string | undefined;
+  let baseTextColor: string | undefined;
 
   for (const t of texts) {
     if (t?.layout === 'Text') {
       const textKey = t?.attributes?.text_localization_key || '';
       const color = t?.attributes?.text_color || undefined;
-      children.push({
-        type: 'text',
-        attributes: color ? { color } : undefined,
-        children: textKey,
-      });
+      if (!baseTextKey) baseTextKey = textKey;
+      if (!baseTextColor && typeof color === 'string') baseTextColor = color;
+
+      // Extract linked words if present
+      const lws = (t?.attributes?.linkedwords || []) as any[];
+      for (const w of lws) {
+        if (w?.layout === 'LinkedWords') {
+          const text_key = w?.attributes?.linked_word_localization_key as
+            | string
+            | undefined;
+          const lwColor = w?.attributes?.linked_word_color as
+            | string
+            | undefined;
+          const page = w?.attributes?.page as string | undefined;
+          linkedWords.push({ text_key, color: lwColor, page });
+        }
+      }
     }
   }
 
-  if (children.length === 0) return null;
+  const attributes: Record<string, unknown> = { gap: 8 };
+  if (baseTextKey) attributes.textLocalizationKey = baseTextKey;
+  if (baseTextColor) attributes.textColor = baseTextColor;
+  const first = linkedWords[0];
+  const second = linkedWords[1];
+  if (first) {
+    if (first.text_key)
+      attributes.linkedWordFirstLocalizationKey = first.text_key;
+    if (first.color) attributes.linkedWordFirstColor = first.color;
+    if (first.page) attributes.linkedWordFirstPage = first.page;
+  }
+  if (second) {
+    if (second.text_key)
+      attributes.linkedWordSecondLocalizationKey = second.text_key;
+    if (second.color) attributes.linkedWordSecondColor = second.color;
+    if (second.page) attributes.linkedWordSecondPage = second.page;
+  }
 
   return {
     type: 'OnboardFooter',
-    attributes: { gap: 8 },
-    children,
+    attributes,
+    children: undefined as unknown as Node,
   } as NodeData;
 }

package/src/utils/patterns.ts

@@ -26,6 +26,10 @@ type Pattern = {
     children: unknown;
     attributes: Record<string, string | string[]>;
   };
+  // Optional custom complex types referenced by attributes like "X[]" or "X"
+  // Each entry maps a type name (e.g., "EventObject") to its field schema
+  // where the inner record maps fieldName -> primitive type or enum options
+  types?: Record<string, Record<string, string | string[]>>;
 };
 
 const patterns: Pattern[] = [
@@ -61,3 +65,35 @@ export function getAttributeSchema(
   const p = getPatternByType(type);
   return p?.pattern.attributes;
 }
+
+/**
+ * Returns the schema of a custom complex type declared under a component pattern's `types` block.
+ * For example, OnboardButton.pattern.types.EventObject
+ */
+export function getTypeSchema(
+  componentType?: string | null,
+  typeName?: string | null,
+): Record<string, string | string[]> | undefined {
+  if (!componentType || !typeName) return undefined;
+  const p = getPatternByType(componentType);
+  // Some JSON imports may not type-check "types" so we fallback to any access
+  const types: Record<string, Record<string, string | string[]>> | undefined = (
+    p as unknown as {
+      types?: Record<string, Record<string, string | string[]>>;
+    }
+  )?.types;
+  return types?.[typeName];
+}
+
+/** Utility: returns true if the type name refers to a primitive scalar */
+export function isPrimitiveType(typeName: string): boolean {
+  return (
+    typeName === 'string' || typeName === 'number' || typeName === 'boolean'
+  );
+}
+
+/** Utility: parse `X[]` forms and return the item type if present */
+export function getArrayItemType(typeName: string): string | null {
+  if (typeof typeName !== 'string') return null;
+  return typeName.endsWith('[]') ? typeName.slice(0, -2) : null;
+}