@uniformdev/transformer 1.1.21 → 1.1.22

package/dist/index.d.ts

@@ -130,7 +130,8 @@ interface PropagateRootComponentSlotOptions extends GlobalOptions {
 }
 interface ConvertCompositionsToEntriesOptions extends GlobalOptions {
     compositionTypes: string;
-    flattenComponentIds?: string;
+    componentsToReferences?: string;
+    componentsToBlocks?: string;
 }
 interface RemoveParameterOptions extends GlobalOptions {
     componentType: string;
@@ -417,11 +418,13 @@ interface ConvertCompositionsToEntriesInternalOptions {
     contentTypesDir: string;
     entriesDir: string;
     compositionTypes: string[];
-    flattenComponentIds: string[];
+    componentsToReferences: string[];
+    componentsToBlocks: string[];
     whatIf: boolean;
     strict: boolean;
 }
 interface ContentTypeDefinition {
+    type?: string;
     id: string;
     name: string;
     fields: ContentTypeField[];
@@ -460,8 +463,9 @@ interface FlattenedInstance {
 interface ConvertResult {
     contentTypesWritten: number;
     entriesFromCompositions: number;
-    entriesFromFlattened: number;
+    entriesFromReferences: number;
     entriesReused: number;
+    blocksEmbedded: number;
 }
 declare class CompositionConverterService {
     private fileSystem;

package/dist/index.js

@@ -582,7 +582,8 @@ var CompositionConverterService = class {
       contentTypesDir,
       entriesDir,
       compositionTypes,
-      flattenComponentIds,
+      componentsToReferences,
+      componentsToBlocks,
       whatIf,
       strict
     } = options;
@@ -592,13 +593,17 @@ var CompositionConverterService = class {
     const entriesDirFull = this.fileSystem.resolvePath(rootDir, entriesDir);
     let contentTypesWritten = 0;
     let entriesFromCompositions = 0;
-    let entriesFromFlattened = 0;
+    let entriesFromReferences = 0;
     let entriesReused = 0;
+    let blocksEmbedded = 0;
     this.logger.info(`Composition types: ${compositionTypes.join(", ")}`);
-    if (flattenComponentIds.length > 0) {
-      this.logger.info(`Flatten component types: ${flattenComponentIds.join(", ")}`);
+    if (componentsToReferences.length > 0) {
+      this.logger.info(`Components to references: ${componentsToReferences.join(", ")}`);
     }
-    const sourceItemMap = flattenComponentIds.length > 0 ? await this.buildSourceItemMap(entriesDirFull) : /* @__PURE__ */ new Map();
+    if (componentsToBlocks.length > 0) {
+      this.logger.info(`Components to blocks: ${componentsToBlocks.join(", ")}`);
+    }
+    const sourceItemMap = componentsToReferences.length > 0 ? await this.buildSourceItemMap(entriesDirFull) : /* @__PURE__ */ new Map();
     if (sourceItemMap.size > 0) {
       this.logger.info(`Found ${sourceItemMap.size} existing entry(ies) with sourceItem values`);
     }
@@ -609,7 +614,7 @@ var CompositionConverterService = class {
     );
     if (compositionResults.length === 0) {
       this.logger.warn("No compositions found matching the specified types");
-      return { contentTypesWritten: 0, entriesFromCompositions: 0, entriesFromFlattened: 0, entriesReused: 0 };
+      return { contentTypesWritten: 0, entriesFromCompositions: 0, entriesFromReferences: 0, entriesReused: 0, blocksEmbedded: 0 };
     }
     this.logger.info(`Found ${compositionResults.length} composition(s)`);
     const rootComponentTypes = /* @__PURE__ */ new Set();
@@ -626,28 +631,76 @@ var CompositionConverterService = class {
       const contentType = this.generateContentType(component);
       contentTypeMap.set(rootType, contentType);
     }
-    const flattenContentTypeMap = /* @__PURE__ */ new Map();
-    const missingFlattenTypes = [];
-    const foundMissingFlattenTypes = /* @__PURE__ */ new Set();
-    for (const flattenType of flattenComponentIds) {
+    const allTargetTypes = [.../* @__PURE__ */ new Set([...componentsToReferences, ...componentsToBlocks])];
+    const targetContentTypeMap = /* @__PURE__ */ new Map();
+    const missingTargetTypes = [];
+    const foundMissingTargetTypes = /* @__PURE__ */ new Set();
+    const blockTypeIdMap = /* @__PURE__ */ new Map();
+    for (const targetType of allTargetTypes) {
       const isRootType = [...rootComponentTypes].some(
-        (rt) => this.compareTypes(rt, flattenType, strict)
+        (rt) => this.compareTypes(rt, targetType, strict)
       );
       if (isRootType) {
         continue;
       }
+      const isBlockType = componentsToBlocks.some(
+        (bt) => this.compareTypes(bt, targetType, strict)
+      );
+      const isRefType = componentsToReferences.some(
+        (rt) => this.compareTypes(rt, targetType, strict)
+      );
       try {
         const { component } = await this.componentService.loadComponent(
           componentsDirFull,
-          flattenType,
+          targetType,
           { strict }
         );
-        const contentType = this.generateContentType(component);
-        flattenContentTypeMap.set(flattenType, contentType);
+        if (isRefType) {
+          const contentType = this.generateContentType(component);
+          targetContentTypeMap.set(targetType, contentType);
+        }
+        if (isBlockType) {
+          let blockId = targetType;
+          let needsRename = false;
+          if (isRefType) {
+            needsRename = true;
+          }
+          if (!needsRename) {
+            const existingPath = this.fileSystem.joinPath(contentTypesDirFull, `${targetType}.json`);
+            if (await this.fileSystem.fileExists(existingPath)) {
+              try {
+                const existing = await this.fileSystem.readFile(existingPath);
+                if (existing?.type !== "block") {
+                  needsRename = true;
+                }
+              } catch {
+              }
+            }
+          }
+          if (needsRename) {
+            blockId = `${targetType}Block`;
+            this.logger.info(`Content type "${targetType}" already exists as non-block, using "${blockId}" for block`);
+          }
+          blockTypeIdMap.set(targetType, blockId);
+          const blockContentType = this.generateContentType(component);
+          blockContentType.type = "block";
+          blockContentType.id = blockId;
+          blockContentType.name = needsRename ? `${blockContentType.name} Block` : blockContentType.name;
+          targetContentTypeMap.set(blockId, blockContentType);
+        }
+        if (!isBlockType) {
+          if (!isRefType) {
+            const contentType = this.generateContentType(component);
+            targetContentTypeMap.set(targetType, contentType);
+          }
+        }
       } catch (error) {
         if (error instanceof ComponentNotFoundError) {
-          this.logger.info(`Flatten component type not found: ${flattenType}`);
-          missingFlattenTypes.push(flattenType);
+          this.logger.info(`Component type not found: ${targetType}`);
+          missingTargetTypes.push(targetType);
+          if (isBlockType) {
+            blockTypeIdMap.set(targetType, targetType);
+          }
           continue;
         }
         throw error;
@@ -659,48 +712,84 @@ var CompositionConverterService = class {
       const compositionName = comp._name ?? compositionId;
       const compositionType = comp.type;
       const entry = this.generateEntryFromComposition(composition);
-      const flattenedByType = /* @__PURE__ */ new Map();
-      if (flattenComponentIds.length > 0 && comp.slots) {
-        for (const flattenType of flattenComponentIds) {
-          if (this.compareTypes(flattenType, compositionType, strict)) {
+      const refsByType = /* @__PURE__ */ new Map();
+      if (componentsToReferences.length > 0 && comp.slots) {
+        for (const refType of componentsToReferences) {
+          if (this.compareTypes(refType, compositionType, strict)) {
             this.logger.warn(
-              `Skipping flatten of "${flattenType}" \u2014 same as root component type`
+              `Skipping reference of "${refType}" \u2014 same as root component type`
             );
             continue;
           }
           const instances = this.findFlattenTargets(
             comp.slots,
-            flattenType,
+            refType,
             compositionId,
             compositionName,
             strict
           );
           if (instances.length > 0) {
-            flattenedByType.set(flattenType, instances);
-            if (missingFlattenTypes.includes(flattenType)) {
-              foundMissingFlattenTypes.add(flattenType);
+            refsByType.set(refType, instances);
+            if (missingTargetTypes.includes(refType)) {
+              foundMissingTargetTypes.add(refType);
             }
           }
         }
       }
       const resolvedRefIds = /* @__PURE__ */ new Map();
-      for (const [flattenType, instances] of flattenedByType) {
+      for (const [refType, instances] of refsByType) {
         const refIds = [];
         for (const inst of instances) {
           const existingId = this.findExistingEntryBySourceItem(inst, sourceItemMap);
           refIds.push(existingId ?? inst.determinisiticId);
         }
-        resolvedRefIds.set(flattenType, refIds);
+        resolvedRefIds.set(refType, refIds);
       }
-      for (const [flattenType] of flattenedByType) {
-        entry.entry.fields[flattenType] = {
+      for (const [refType] of refsByType) {
+        entry.entry.fields[refType] = {
           type: "contentReference",
-          value: resolvedRefIds.get(flattenType)
+          value: resolvedRefIds.get(refType)
         };
       }
-      if (flattenComponentIds.length > 0) {
+      if (componentsToReferences.length > 0) {
         this.transformContentReferences(entry);
       }
+      const blocksByType = /* @__PURE__ */ new Map();
+      if (componentsToBlocks.length > 0 && comp.slots) {
+        for (const blockType of componentsToBlocks) {
+          if (this.compareTypes(blockType, compositionType, strict)) {
+            this.logger.warn(
+              `Skipping block of "${blockType}" \u2014 same as root component type`
+            );
+            continue;
+          }
+          const instances = this.findFlattenTargets(
+            comp.slots,
+            blockType,
+            compositionId,
+            compositionName,
+            strict
+          );
+          if (instances.length > 0) {
+            blocksByType.set(blockType, instances);
+            if (missingTargetTypes.includes(blockType)) {
+              foundMissingTargetTypes.add(blockType);
+            }
+          }
+        }
+      }
+      for (const [blockType, instances] of blocksByType) {
+        const resolvedBlockId = blockTypeIdMap.get(blockType) ?? blockType;
+        const blockValues = instances.map((inst) => ({
+          type: resolvedBlockId,
+          fields: { ...inst.instance.parameters ?? {} }
+        }));
+        entry.entry.fields[resolvedBlockId] = {
+          type: "$block",
+          value: blockValues
+        };
+        blocksEmbedded += instances.length;
+      }
       const entryId = entry.entry._id;
       const entryFilePath = this.fileSystem.joinPath(entriesDirFull, `${entryId}.json`);
       this.logger.action(
@@ -712,7 +801,7 @@ var CompositionConverterService = class {
         await this.fileSystem.writeFile(entryFilePath, entry);
       }
       entriesFromCompositions++;
-      for (const [flattenType, instances] of flattenedByType) {
+      for (const [refType, instances] of refsByType) {
         for (const inst of instances) {
           const existingId = this.findExistingEntryBySourceItem(inst, sourceItemMap);
           if (existingId) {
@@ -723,7 +812,7 @@ var CompositionConverterService = class {
             this.logger.action(
               whatIf,
               "UPDATE",
-              `${entriesDir}/${existingId}.json (${flattenType}, merged fields from "${this.truncate(compositionName, 50)}")`
+              `${entriesDir}/${existingId}.json (${refType}, merged fields from "${this.truncate(compositionName, 50)}")`
             );
             if (!whatIf) {
               const existingEntry = await this.fileSystem.readFile(existingEntryPath);
@@ -747,31 +836,53 @@ var CompositionConverterService = class {
           this.logger.action(
             whatIf,
             "WRITE",
-            `${entriesDir}/${inst.determinisiticId}.json (${flattenType} from "${this.truncate(compositionName, 50)}")`
+            `${entriesDir}/${inst.determinisiticId}.json (${refType} from "${this.truncate(compositionName, 50)}")`
           );
           if (!whatIf) {
             await this.fileSystem.writeFile(flatEntryPath, flatEntry);
           }
-          entriesFromFlattened++;
+          entriesFromReferences++;
         }
       }
     }
-    if (flattenComponentIds.length > 0) {
+    if (componentsToReferences.length > 0) {
       for (const contentType of contentTypeMap.values()) {
-        for (const flattenType of flattenComponentIds) {
-          if (this.compareTypes(flattenType, contentType.id, strict)) {
+        for (const refType of componentsToReferences) {
+          if (this.compareTypes(refType, contentType.id, strict)) {
             continue;
           }
-          if (missingFlattenTypes.includes(flattenType) && !foundMissingFlattenTypes.has(flattenType)) {
+          if (missingTargetTypes.includes(refType) && !foundMissingTargetTypes.has(refType)) {
             continue;
           }
           contentType.fields.push({
-            id: flattenType,
-            name: flattenType,
+            id: refType,
+            name: refType,
             type: "contentReference",
             typeConfig: {
               isMulti: true,
-              allowedContentTypes: [flattenType]
+              allowedContentTypes: [refType]
+            },
+            localizable: false
+          });
+        }
+      }
+    }
+    if (componentsToBlocks.length > 0) {
+      for (const contentType of contentTypeMap.values()) {
+        for (const blockType of componentsToBlocks) {
+          if (this.compareTypes(blockType, contentType.id, strict)) {
+            continue;
+          }
+          if (missingTargetTypes.includes(blockType) && !foundMissingTargetTypes.has(blockType)) {
+            continue;
+          }
+          const resolvedBlockId = blockTypeIdMap.get(blockType) ?? blockType;
+          contentType.fields.push({
+            id: resolvedBlockId,
+            name: resolvedBlockId,
+            type: "$block",
+            typeConfig: {
+              allowedContentTypes: [resolvedBlockId]
             },
             localizable: false
           });
@@ -781,25 +892,30 @@ var CompositionConverterService = class {
     for (const contentType of contentTypeMap.values()) {
       contentType.fields = this.componentService.sortParametersByGroup(contentType.fields);
     }
-    for (const contentType of flattenContentTypeMap.values()) {
+    for (const contentType of targetContentTypeMap.values()) {
       contentType.fields = this.componentService.sortParametersByGroup(contentType.fields);
     }
     for (const [typeName, contentType] of contentTypeMap) {
       const filePath = this.fileSystem.joinPath(contentTypesDirFull, `${typeName}.json`);
-      const fieldCount = contentType.fields.filter((f) => f.type !== "contentReference").length;
+      const baseFieldCount = contentType.fields.filter((f) => f.type !== "contentReference" && f.type !== "$block").length;
       const refCount = contentType.fields.filter((f) => f.type === "contentReference").length;
-      const refInfo = refCount > 0 ? ` + ${refCount} reference(s)` : "";
+      const blockCount = contentType.fields.filter((f) => f.type === "$block").length;
+      const extras = [
+        refCount > 0 ? `${refCount} reference(s)` : "",
+        blockCount > 0 ? `${blockCount} block(s)` : ""
+      ].filter(Boolean).join(", ");
+      const extrasInfo = extras ? ` + ${extras}` : "";
       this.logger.action(
         whatIf,
         "WRITE",
-        `${contentTypesDir}/${typeName}.json (${fieldCount} fields${refInfo})`
+        `${contentTypesDir}/${typeName}.json (${baseFieldCount} fields${extrasInfo})`
       );
       if (!whatIf) {
         await this.fileSystem.writeFile(filePath, contentType);
       }
       contentTypesWritten++;
     }
-    for (const [typeName, contentType] of flattenContentTypeMap) {
+    for (const [typeName, contentType] of targetContentTypeMap) {
       const filePath = this.fileSystem.joinPath(contentTypesDirFull, `${typeName}.json`);
       this.logger.action(
         whatIf,
@@ -811,15 +927,15 @@ var CompositionConverterService = class {
       }
       contentTypesWritten++;
     }
-    const neverFoundMissingTypes = missingFlattenTypes.filter(
-      (type) => !foundMissingFlattenTypes.has(type)
+    const neverFoundMissingTypes = missingTargetTypes.filter(
+      (type) => !foundMissingTargetTypes.has(type)
     );
     if (neverFoundMissingTypes.length > 0) {
       this.logger.warn(
-        `Flatten component type(s) not found in any composition: ${neverFoundMissingTypes.join(", ")}`
+        `Component type(s) not found in any composition: ${neverFoundMissingTypes.join(", ")}`
       );
     }
-    return { contentTypesWritten, entriesFromCompositions, entriesFromFlattened, entriesReused };
+    return { contentTypesWritten, entriesFromCompositions, entriesFromReferences, entriesReused, blocksEmbedded };
   }
   // --- Content Type Generation ---
   generateContentType(component) {