@uniformdev/transformer 1.1.36 → 1.1.38

package/dist/cli/index.js

@@ -607,11 +607,15 @@ var CompositionConverterService = class {
       compositionTypes,
       componentsToReferences: rawComponentsToReferences,
       componentsToBlocks: rawComponentsToBlocks,
+      slotsToReferences: rawSlotsToReferences,
+      slotsToBlocks: rawSlotsToBlocks,
       whatIf,
       strict
     } = options;
     const initialComponentsToReferences = [...new Set(rawComponentsToReferences)];
     const initialComponentsToBlocks = [...new Set(rawComponentsToBlocks)];
+    const initialSlotsToReferences = [...new Set(rawSlotsToReferences)];
+    const initialSlotsToBlocks = [...new Set(rawSlotsToBlocks)];
     const compositionsDirFull = this.fileSystem.resolvePath(rootDir, compositionsDir);
     const componentsDirFull = this.fileSystem.resolvePath(rootDir, componentsDir);
     const contentTypesDirFull = this.fileSystem.resolvePath(rootDir, contentTypesDir);
@@ -628,7 +632,13 @@ var CompositionConverterService = class {
     if (initialComponentsToBlocks.length > 0) {
       this.logger.info(`Components to blocks: ${initialComponentsToBlocks.join(", ")}`);
     }
-    const sourceItemMap = initialComponentsToReferences.length > 0 ? await this.buildSourceItemMap(entriesDirFull) : /* @__PURE__ */ new Map();
+    if (initialSlotsToReferences.length > 0) {
+      this.logger.info(`Slots to references: ${initialSlotsToReferences.join(", ")}`);
+    }
+    if (initialSlotsToBlocks.length > 0) {
+      this.logger.info(`Slots to blocks: ${initialSlotsToBlocks.join(", ")}`);
+    }
+    const sourceItemMap = initialComponentsToReferences.length > 0 || initialSlotsToReferences.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`);
     }
@@ -645,6 +655,8 @@ var CompositionConverterService = class {
     this.logger.info(`Found ${compositionResults.length} composition(s)`);
     const componentsToReferences = this.expandWildcardTypes(compositionResults, initialComponentsToReferences, strict);
     const componentsToBlocks = this.expandWildcardTypes(compositionResults, initialComponentsToBlocks, strict);
+    const slotsToReferences = this.expandWildcardSlots(compositionResults, initialSlotsToReferences, strict);
+    const slotsToBlocks = this.expandWildcardSlots(compositionResults, initialSlotsToBlocks, strict);
     const rootComponentTypes = /* @__PURE__ */ new Set();
     for (const { composition } of compositionResults) {
       rootComponentTypes.add(composition.composition.type);
@@ -745,6 +757,83 @@ var CompositionConverterService = class {
         throw error;
       }
     }
+    const slotToRefTypes = /* @__PURE__ */ new Map();
+    const slotToBlockTypes = /* @__PURE__ */ new Map();
+    for (const slotName of slotsToReferences) slotToRefTypes.set(slotName, /* @__PURE__ */ new Set());
+    for (const slotName of slotsToBlocks) slotToBlockTypes.set(slotName, /* @__PURE__ */ new Set());
+    for (const { composition: discoverComp } of compositionResults) {
+      const dc = discoverComp.composition;
+      if (!dc.slots) continue;
+      const dcName = dc._name ?? dc._id;
+      for (const slotName of slotsToReferences) {
+        const instances = this.findInstancesInSlot(dc.slots, slotName, dc._id, dcName, strict);
+        for (const inst of instances) {
+          if (!this.compareTypes(inst.componentType, dc.type, strict)) {
+            slotToRefTypes.get(slotName).add(inst.componentType);
+          }
+        }
+      }
+      for (const slotName of slotsToBlocks) {
+        const instances = this.findInstancesInSlot(dc.slots, slotName, dc._id, dcName, strict);
+        for (const inst of instances) {
+          if (!this.compareTypes(inst.componentType, dc.type, strict)) {
+            slotToBlockTypes.get(slotName).add(inst.componentType);
+          }
+        }
+      }
+    }
+    const allSlotRefTypes = /* @__PURE__ */ new Set();
+    for (const types of slotToRefTypes.values()) for (const t of types) allSlotRefTypes.add(t);
+    const allSlotBlockTypes = /* @__PURE__ */ new Set();
+    for (const types of slotToBlockTypes.values()) for (const t of types) allSlotBlockTypes.add(t);
+    const allSlotTargetTypes = /* @__PURE__ */ new Set([...allSlotRefTypes, ...allSlotBlockTypes]);
+    for (const targetType of allSlotTargetTypes) {
+      if (targetContentTypeMap.has(targetType) || missingTargetTypes.includes(targetType)) continue;
+      const isRootType = [...rootComponentTypes].some((rt) => this.compareTypes(rt, targetType, strict));
+      if (isRootType) continue;
+      const isSlotBlockType = allSlotBlockTypes.has(targetType);
+      const isSlotRefType = allSlotRefTypes.has(targetType);
+      try {
+        const { component } = await this.componentService.loadComponent(componentsDirFull, targetType, { strict });
+        if (isSlotRefType) {
+          const contentType = this.generateContentType(component);
+          targetContentTypeMap.set(targetType, contentType);
+          this.logger.debug(`Generated slot reference content type "${targetType}" with ${contentType.fields.length} field(s)`);
+        }
+        if (isSlotBlockType && !blockTypeIdMap.has(targetType)) {
+          let blockId = targetType;
+          let needsRename = isSlotRefType;
+          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);
+          this.logger.debug(`Generated slot block content type "${blockId}" with ${blockContentType.fields.length} field(s)`);
+        }
+      } catch (error) {
+        if (error instanceof ComponentNotFoundError) {
+          this.logger.info(`Component type not found: ${targetType}`);
+          if (isSlotBlockType && !blockTypeIdMap.has(targetType)) blockTypeIdMap.set(targetType, targetType);
+          continue;
+        }
+        throw error;
+      }
+    }
     for (const { composition } of compositionResults) {
       const comp = composition.composition;
       const compositionId = comp._id;
@@ -810,7 +899,43 @@ var CompositionConverterService = class {
           value: resolvedRefIds.get(refType)
         };
       }
-      if (componentsToReferences.length > 0) {
+      const refsBySlot = /* @__PURE__ */ new Map();
+      if (slotsToReferences.length > 0 && comp.slots) {
+        for (const slotName of slotsToReferences) {
+          const instances = this.findInstancesInSlot(
+            comp.slots,
+            slotName,
+            compositionId,
+            compositionName,
+            strict
+          );
+          const filtered = instances.filter((inst) => {
+            if (this.compareTypes(inst.componentType, compositionType, strict)) {
+              this.logger.warn(`Skipping reference of "${inst.componentType}" in slot "${slotName}" \u2014 same as root component type`);
+              return false;
+            }
+            return true;
+          });
+          this.logger.debug(`Composition "${compositionName}": found ${filtered.length} instance(s) in reference slot "${slotName}"`);
+          if (filtered.length > 0) refsBySlot.set(slotName, filtered);
+        }
+      }
+      const resolvedSlotRefIds = /* @__PURE__ */ new Map();
+      for (const [slotName, instances] of refsBySlot) {
+        const refIds = [];
+        for (const inst of instances) {
+          const existingId = this.findExistingEntryBySourceItem(inst, sourceItemMap);
+          refIds.push(existingId ?? inst.determinisiticId);
+        }
+        resolvedSlotRefIds.set(slotName, refIds);
+      }
+      for (const [slotName] of refsBySlot) {
+        entry.entry.fields[slotName] = {
+          type: "contentReference",
+          value: resolvedSlotRefIds.get(slotName)
+        };
+      }
+      if (componentsToReferences.length > 0 || slotsToReferences.length > 0) {
         this.transformContentReferences(entry);
       }
       const blocksByType = /* @__PURE__ */ new Map();
@@ -850,6 +975,35 @@ var CompositionConverterService = class {
         };
         blocksEmbedded += instances.length;
       }
+      const blocksBySlot = /* @__PURE__ */ new Map();
+      if (slotsToBlocks.length > 0 && comp.slots) {
+        for (const slotName of slotsToBlocks) {
+          const instances = this.findInstancesInSlot(
+            comp.slots,
+            slotName,
+            compositionId,
+            compositionName,
+            strict
+          );
+          const filtered = instances.filter((inst) => {
+            if (this.compareTypes(inst.componentType, compositionType, strict)) {
+              this.logger.warn(`Skipping block of "${inst.componentType}" in slot "${slotName}" \u2014 same as root component type`);
+              return false;
+            }
+            return true;
+          });
+          this.logger.debug(`Composition "${compositionName}": found ${filtered.length} instance(s) in block slot "${slotName}"`);
+          if (filtered.length > 0) blocksBySlot.set(slotName, filtered);
+        }
+      }
+      for (const [slotName, instances] of blocksBySlot) {
+        const blockValues = instances.map((inst) => ({
+          type: blockTypeIdMap.get(inst.componentType) ?? inst.componentType,
+          fields: { ...inst.instance.parameters ?? {} }
+        }));
+        entry.entry.fields[slotName] = { type: "$block", value: blockValues };
+        blocksEmbedded += instances.length;
+      }
       const entryId = entry.entry._id;
       if (isExistingEntry) {
         this.logger.action(
@@ -918,6 +1072,42 @@ var CompositionConverterService = class {
           entriesFromReferences++;
         }
       }
+      for (const [, instances] of refsBySlot) {
+        for (const inst of instances) {
+          const existingId = this.findExistingEntryBySourceItem(inst, sourceItemMap);
+          if (existingId) {
+            const existingSlotEntryPath = this.fileSystem.joinPath(entriesDirFull, `${existingId}.json`);
+            this.logger.action(
+              whatIf,
+              "UPDATE",
+              `${entriesDir}/${existingId}.json (${inst.componentType}, merged fields from "${this.truncate(compositionName, 50)}")`
+            );
+            if (!whatIf) {
+              const existingEntry = await this.fileSystem.readFile(existingSlotEntryPath);
+              if (existingEntry?.entry) {
+                existingEntry.entry.fields = {
+                  ...existingEntry.entry.fields,
+                  ...inst.instance.parameters ?? {}
+                };
+                await this.fileSystem.writeFile(existingSlotEntryPath, existingEntry);
+              }
+            }
+            entriesReused++;
+            continue;
+          }
+          const flatEntry = this.generateEntryFromFlattenedInstance(inst);
+          const flatEntryPath = this.fileSystem.joinPath(entriesDirFull, `${inst.determinisiticId}.json`);
+          this.logger.action(
+            whatIf,
+            "WRITE",
+            `${entriesDir}/${inst.determinisiticId}.json (${inst.componentType} from "${this.truncate(compositionName, 50)}")`
+          );
+          if (!whatIf) {
+            await this.fileSystem.writeFile(flatEntryPath, flatEntry);
+          }
+          entriesFromReferences++;
+        }
+      }
     }
     if (componentsToReferences.length > 0) {
       for (const contentType of contentTypeMap.values()) {
@@ -965,6 +1155,42 @@ var CompositionConverterService = class {
         }
       }
     }
+    if (slotsToReferences.length > 0) {
+      for (const contentType of contentTypeMap.values()) {
+        for (const slotName of slotsToReferences) {
+          const typesInSlot = slotToRefTypes.get(slotName) ?? /* @__PURE__ */ new Set();
+          const allowedTypes = [...typesInSlot].filter(
+            (t) => !this.compareTypes(t, contentType.id, strict)
+          );
+          if (allowedTypes.length === 0) continue;
+          contentType.fields.push({
+            id: slotName,
+            name: slotName,
+            type: "contentReference",
+            typeConfig: { isMulti: true, allowedTypes },
+            localizable: false
+          });
+          this.logger.debug(`Field "${slotName}" (contentReference, allowedTypes: ${allowedTypes.join(", ")}) added to content type "${contentType.id}"`);
+        }
+      }
+    }
+    if (slotsToBlocks.length > 0) {
+      for (const contentType of contentTypeMap.values()) {
+        for (const slotName of slotsToBlocks) {
+          const typesInSlot = slotToBlockTypes.get(slotName) ?? /* @__PURE__ */ new Set();
+          const resolvedBlockIds = [...typesInSlot].filter((t) => !this.compareTypes(t, contentType.id, strict)).map((t) => blockTypeIdMap.get(t) ?? t);
+          if (resolvedBlockIds.length === 0) continue;
+          contentType.fields.push({
+            id: slotName,
+            name: slotName,
+            type: "$block",
+            typeConfig: { allowedTypes: resolvedBlockIds },
+            localizable: false
+          });
+          this.logger.debug(`Field "${slotName}" ($block, allowedTypes: ${resolvedBlockIds.join(", ")}) added to content type "${contentType.id}"`);
+        }
+      }
+    }
     for (const contentType of contentTypeMap.values()) {
       contentType.fields = this.componentService.sortParametersByGroup(contentType.fields);
     }
@@ -1131,6 +1357,29 @@ var CompositionConverterService = class {
       }
     }
   }
+  // --- Slot-Based Instance Finding ---
+  findInstancesInSlot(slots, slotName, compositionId, compositionName, strict) {
+    const results = [];
+    for (const [name, instances] of Object.entries(slots)) {
+      const matches = strict ? name === slotName : name.toLowerCase() === slotName.toLowerCase();
+      if (!matches) continue;
+      if (!Array.isArray(instances)) continue;
+      for (let i = 0; i < instances.length; i++) {
+        const instance = instances[i];
+        if (instance._pattern) continue;
+        const path2 = `${compositionId}-${name}-[${i}]-${instance.type}`;
+        results.push({
+          instance,
+          path: path2,
+          determinisiticId: computeGuidHash(path2),
+          componentType: instance.type,
+          compositionId,
+          compositionName
+        });
+      }
+    }
+    return results;
+  }
   // --- Content Reference Transformation ---
   transformContentReferences(entry) {
     const dataResources = {};
@@ -1233,6 +1482,34 @@ var CompositionConverterService = class {
     }
     return [...new Set(expanded)];
   }
+  expandWildcardSlots(compositionResults, patterns, strict) {
+    const expanded = [];
+    for (const pattern of patterns) {
+      if (!pattern.includes("*")) {
+        expanded.push(pattern);
+        continue;
+      }
+      const matched = /* @__PURE__ */ new Set();
+      for (const { composition } of compositionResults) {
+        if (composition.composition.slots) {
+          for (const slotName of Object.keys(composition.composition.slots)) {
+            if (this.matchesType(slotName, pattern, strict)) {
+              matched.add(slotName);
+            }
+          }
+        }
+      }
+      if (matched.size === 0) {
+        this.logger.warn(`Wildcard pattern "${pattern}" did not match any slot names`);
+      } else {
+        this.logger.info(`Wildcard "${pattern}" expanded to: ${[...matched].join(", ")}`);
+      }
+      for (const name of matched) {
+        expanded.push(name);
+      }
+    }
+    return [...new Set(expanded)];
+  }
   collectMatchingTypes(slots, pattern, strict, matched) {
     for (const instances of Object.values(slots)) {
       if (!Array.isArray(instances)) continue;
@@ -4488,6 +4765,12 @@ function createConvertCompositionsToEntriesCommand() {
   ).option(
     "--componentsToBlocks <types>",
     "Pipe-separated list of component types to convert into inline blocks (e.g., DetailHero|ArticleDetail)"
+  ).option(
+    "--slotsToReferences <slots>",
+    "Pipe-separated list of slot names whose instances should be converted into separate referenced entries (e.g., main|sidebar)"
+  ).option(
+    "--slotsToBlocks <slots>",
+    "Pipe-separated list of slot names whose instances should be converted into inline blocks (e.g., main|sidebar)"
   ).option("--verbose", "Enable verbose output with detailed progress information").hook("preAction", (thisCommand) => {
     const opts = thisCommand.opts();
     const requiredOptions = [
@@ -4504,7 +4787,9 @@ function createConvertCompositionsToEntriesCommand() {
       ...globalOpts,
       compositionTypes: opts.compositionTypes,
       componentsToReferences: opts.componentsToReferences,
-      componentsToBlocks: opts.componentsToBlocks
+      componentsToBlocks: opts.componentsToBlocks,
+      slotsToReferences: opts.slotsToReferences,
+      slotsToBlocks: opts.slotsToBlocks
     };
     const logger = new Logger(opts.verbose ?? false);
     const fileSystem = new FileSystemService();
@@ -4521,6 +4806,8 @@ function createConvertCompositionsToEntriesCommand() {
       const parsePipeSeparated = (value) => value ? [...new Set(value.split("|").map((t) => t.trim()).filter((t) => t.length > 0))] : [];
       const componentsToReferences = parsePipeSeparated(options.componentsToReferences);
       const componentsToBlocks = parsePipeSeparated(options.componentsToBlocks);
+      const slotsToReferences = parsePipeSeparated(options.slotsToReferences);
+      const slotsToBlocks = parsePipeSeparated(options.slotsToBlocks);
       const result = await converter.convert({
         rootDir: options.rootDir,
         compositionsDir: options.compositionsDir,
@@ -4530,6 +4817,8 @@ function createConvertCompositionsToEntriesCommand() {
         compositionTypes,
         componentsToReferences,
         componentsToBlocks,
+        slotsToReferences,
+        slotsToBlocks,
         whatIf: options.whatIf ?? false,
         strict: options.strict ?? false
       });
@@ -5621,6 +5910,7 @@ var BlockFieldFlattenerService = class {
       parameterId,
       whatIf,
       strict,
+      excludeSet,
       "composition"
     );
     const compositionPatternsResult = await this.flattenInDirectory(
@@ -5629,6 +5919,7 @@ var BlockFieldFlattenerService = class {
       parameterId,
       whatIf,
       strict,
+      excludeSet,
       "compositionPattern"
     );
     const componentPatternsResult = await this.flattenInDirectory(
@@ -5637,6 +5928,7 @@ var BlockFieldFlattenerService = class {
       parameterId,
       whatIf,
       strict,
+      excludeSet,
       "componentPattern"
     );
     const totalFiles = compositionsResult.filesModified + compositionPatternsResult.filesModified + componentPatternsResult.filesModified;
@@ -5713,7 +6005,7 @@ var BlockFieldFlattenerService = class {
       }
     }
   }
-  async flattenInDirectory(directory, componentId, parameterId, whatIf, strict, label) {
+  async flattenInDirectory(directory, componentId, parameterId, whatIf, strict, excludeSet, label) {
     let files;
     try {
       files = await this.fileSystem.findFiles(directory, "**/*.{json,yaml,yml}");
@@ -5731,8 +6023,8 @@ var BlockFieldFlattenerService = class {
         continue;
       }
       if (!composition?.composition) continue;
-      const treeCount = this.flattenBlocksInTree(composition.composition, componentId, parameterId, strict);
-      const overridesCount = this.flattenBlocksInOverrides(composition, componentId, parameterId, strict);
+      const treeCount = this.flattenBlocksInTree(composition.composition, componentId, parameterId, strict, excludeSet);
+      const overridesCount = this.flattenBlocksInOverrides(composition, componentId, parameterId, strict, excludeSet);
       const totalCount = treeCount + overridesCount;
       if (totalCount > 0) {
         const relativePath = filePath.replace(directory, "").replace(/^[/\\]/, "");
@@ -5750,7 +6042,7 @@ var BlockFieldFlattenerService = class {
     }
     return { filesModified, instancesUpdated };
   }
-  flattenBlocksInTree(node, componentId, parameterId, strict) {
+  flattenBlocksInTree(node, componentId, parameterId, strict, excludeSet) {
     let count = 0;
     if (this.compareIds(node.type, componentId, strict) && node.parameters) {
       const matchingKey = this.findKeyName(node.parameters, parameterId, strict);
@@ -5760,7 +6052,9 @@ var BlockFieldFlattenerService = class {
         if (Array.isArray(items) && items.length === 1) {
           const blockItem = items[0];
           for (const [fieldId, fieldValue] of Object.entries(blockItem.fields ?? {})) {
-            node.parameters[fieldId] = fieldValue;
+            if (!excludeSet.has(fieldId.toLowerCase())) {
+              node.parameters[fieldId] = fieldValue;
+            }
           }
         }
         delete node.parameters[matchingKey];
@@ -5771,28 +6065,29 @@ var BlockFieldFlattenerService = class {
       for (const slotInstances of Object.values(node.slots)) {
         if (!Array.isArray(slotInstances)) continue;
         for (const instance of slotInstances) {
-          count += this.flattenBlocksInTree(instance, componentId, parameterId, strict);
+          count += this.flattenBlocksInTree(instance, componentId, parameterId, strict, excludeSet);
         }
       }
     }
     return count;
   }
-  flattenBlocksInOverrides(composition, componentId, parameterId, strict) {
+  flattenBlocksInOverrides(composition, componentId, parameterId, strict, excludeSet) {
     if (!composition.composition._overrides) return 0;
     let count = 0;
     if (this.compareIds(composition.composition.type, componentId, strict)) {
-      count += this.flattenOverrideMap(composition.composition._overrides, parameterId, strict);
+      count += this.flattenOverrideMap(composition.composition._overrides, parameterId, strict, excludeSet);
     }
     count += this.flattenOverridesForMatchingInstances(
       composition.composition,
       composition.composition._overrides,
       componentId,
       parameterId,
-      strict
+      strict,
+      excludeSet
     );
     return count;
   }
-  flattenOverrideMap(overrides, parameterId, strict) {
+  flattenOverrideMap(overrides, parameterId, strict, excludeSet) {
     let count = 0;
     for (const override of Object.values(overrides)) {
       if (!override.parameters) continue;
@@ -5803,7 +6098,9 @@ var BlockFieldFlattenerService = class {
       if (Array.isArray(items) && items.length === 1) {
         const blockItem = items[0];
         for (const [fieldId, fieldValue] of Object.entries(blockItem.fields ?? {})) {
-          override.parameters[fieldId] = fieldValue;
+          if (!excludeSet.has(fieldId.toLowerCase())) {
+            override.parameters[fieldId] = fieldValue;
+          }
         }
       }
       delete override.parameters[matchingKey];
@@ -5811,7 +6108,7 @@ var BlockFieldFlattenerService = class {
     }
     return count;
   }
-  flattenOverridesForMatchingInstances(node, overrides, componentId, parameterId, strict) {
+  flattenOverridesForMatchingInstances(node, overrides, componentId, parameterId, strict, excludeSet) {
     let count = 0;
     if (node.slots) {
       for (const slotInstances of Object.values(node.slots)) {
@@ -5827,7 +6124,9 @@ var BlockFieldFlattenerService = class {
                 if (Array.isArray(items) && items.length === 1) {
                   const blockItem = items[0];
                   for (const [fieldId, fieldValue] of Object.entries(blockItem.fields ?? {})) {
-                    override.parameters[fieldId] = fieldValue;
+                    if (!excludeSet.has(fieldId.toLowerCase())) {
+                      override.parameters[fieldId] = fieldValue;
+                    }
                   }
                 }
                 delete override.parameters[matchingKey];
@@ -5835,7 +6134,7 @@ var BlockFieldFlattenerService = class {
               }
             }
           }
-          count += this.flattenOverridesForMatchingInstances(instance, overrides, componentId, parameterId, strict);
+          count += this.flattenOverridesForMatchingInstances(instance, overrides, componentId, parameterId, strict, excludeSet);
         }
       }
     }
@@ -6074,7 +6373,7 @@ function createRemoveOrphanEntriesCommand() {
 // package.json
 var package_default = {
   name: "@uniformdev/transformer",
-  version: "1.1.36",
+  version: "1.1.38",
   description: "CLI tool for transforming Uniform.dev serialization files offline",
   type: "module",
   bin: {