@uniformdev/transformer 1.1.21 → 1.1.23

package/README.md

@@ -0,0 +1,3 @@
+# Transformer
+
+It's a nodejs rewritten version of decomissioned Siphon.Transform.exe that takes in Uniform serialization and changes. See [001-basics.md](001-basics.md).

package/dist/cli/index.js

@@ -592,7 +592,8 @@ var CompositionConverterService = class {
       contentTypesDir,
       entriesDir,
       compositionTypes,
-      flattenComponentIds,
+      componentsToReferences,
+      componentsToBlocks,
       whatIf,
       strict
     } = options;
@@ -602,13 +603,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`);
     }
@@ -619,7 +624,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();
@@ -636,28 +641,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;
@@ -669,48 +722,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(
@@ -722,7 +811,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) {
@@ -733,7 +822,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);
@@ -757,31 +846,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
           });
@@ -791,25 +902,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,
@@ -821,15 +937,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) {
@@ -4174,13 +4290,16 @@ import { Command as Command10 } from "commander";
 function createConvertCompositionsToEntriesCommand() {
   const command = new Command10("convert-compositions-to-entries");
   command.description(
-    "Converts compositions into content entries, optionally flattening nested components into separate referenced entries."
+    "Converts compositions into content entries, optionally converting nested components into references or blocks."
   ).option(
     "--compositionTypes <types>",
     "Pipe-separated list of composition types to convert (e.g., ProductDetailPage|ArticlePage)"
   ).option(
-    "--flattenComponentIds <types>",
-    "Pipe-separated list of component types to flatten into separate entries (e.g., DetailHero|ArticleDetail)"
+    "--componentsToReferences <types>",
+    "Pipe-separated list of component types to convert into separate referenced entries (e.g., DetailHero|ArticleDetail)"
+  ).option(
+    "--componentsToBlocks <types>",
+    "Pipe-separated list of component types to convert into inline blocks (e.g., DetailHero|ArticleDetail)"
   ).hook("preAction", (thisCommand) => {
     const opts = thisCommand.opts();
     const requiredOptions = [
@@ -4196,7 +4315,8 @@ function createConvertCompositionsToEntriesCommand() {
     const options = {
       ...globalOpts,
       compositionTypes: opts.compositionTypes,
-      flattenComponentIds: opts.flattenComponentIds
+      componentsToReferences: opts.componentsToReferences,
+      componentsToBlocks: opts.componentsToBlocks
     };
     const logger = new Logger();
     const fileSystem = new FileSystemService();
@@ -4210,7 +4330,9 @@ function createConvertCompositionsToEntriesCommand() {
     );
     try {
       const compositionTypes = options.compositionTypes.split("|").map((t) => t.trim()).filter((t) => t.length > 0);
-      const flattenComponentIds = options.flattenComponentIds ? options.flattenComponentIds.split("|").map((t) => t.trim()).filter((t) => t.length > 0) : [];
+      const parsePipeSeparated = (value) => value ? value.split("|").map((t) => t.trim()).filter((t) => t.length > 0) : [];
+      const componentsToReferences = parsePipeSeparated(options.componentsToReferences);
+      const componentsToBlocks = parsePipeSeparated(options.componentsToBlocks);
       const result = await converter.convert({
         rootDir: options.rootDir,
         compositionsDir: options.compositionsDir,
@@ -4218,14 +4340,16 @@ function createConvertCompositionsToEntriesCommand() {
         contentTypesDir: options.contentTypesDir,
         entriesDir: options.entriesDir,
         compositionTypes,
-        flattenComponentIds,
+        componentsToReferences,
+        componentsToBlocks,
         whatIf: options.whatIf ?? false,
         strict: options.strict ?? false
       });
-      const flatInfo = result.entriesFromFlattened > 0 ? `, ${result.entriesFromFlattened} from flattened components` : "";
+      const refInfo = result.entriesFromReferences > 0 ? `, ${result.entriesFromReferences} from references` : "";
       const reusedInfo = result.entriesReused > 0 ? `, ${result.entriesReused} reused existing` : "";
+      const blocksInfo = result.blocksEmbedded > 0 ? `, ${result.blocksEmbedded} block(s) embedded` : "";
       logger.success(
-        `${result.contentTypesWritten} content type(s), ${result.entriesFromCompositions} entry(ies) from compositions${flatInfo}${reusedInfo}`
+        `${result.contentTypesWritten} content type(s), ${result.entriesFromCompositions} entry(ies) from compositions${refInfo}${reusedInfo}${blocksInfo}`
       );
     } catch (error) {
       if (error instanceof TransformError) {
@@ -4779,7 +4903,7 @@ function createRemoveFieldCommand() {
 // package.json
 var package_default = {
   name: "@uniformdev/transformer",
-  version: "1.1.21",
+  version: "1.1.23",
   description: "CLI tool for transforming Uniform.dev serialization files offline",
   type: "module",
   bin: {