@uniformdev/transformer 1.1.36 → 1.1.37

package/dist/index.d.ts

@@ -148,6 +148,8 @@ interface ConvertCompositionsToEntriesOptions extends GlobalOptions {
     compositionTypes: string;
     componentsToReferences?: string;
     componentsToBlocks?: string;
+    slotsToReferences?: string;
+    slotsToBlocks?: string;
 }
 interface RemoveParameterOptions extends GlobalOptions {
     componentType: string;
@@ -461,6 +463,8 @@ interface ConvertCompositionsToEntriesInternalOptions {
     compositionTypes: string[];
     componentsToReferences: string[];
     componentsToBlocks: string[];
+    slotsToReferences: string[];
+    slotsToBlocks: string[];
     whatIf: boolean;
     strict: boolean;
 }
@@ -521,6 +525,7 @@ declare class CompositionConverterService {
     generateEntryFromFlattenedInstance(inst: FlattenedInstance): EntryDefinition;
     findFlattenTargets(slots: Record<string, ComponentInstance[]>, targetType: string, compositionId: string, compositionName: string, strict: boolean): FlattenedInstance[];
     private walkSlots;
+    findInstancesInSlot(slots: Record<string, ComponentInstance[]>, slotName: string, compositionId: string, compositionName: string, strict: boolean): FlattenedInstance[];
     private transformContentReferences;
     buildEntryIdMap(entriesDirFull: string): Promise<Map<string, string>>;
     buildSourceItemMap(entriesDirFull: string): Promise<Map<string, string>>;
@@ -528,6 +533,7 @@ declare class CompositionConverterService {
     private matchesType;
     private compareTypes;
     private expandWildcardTypes;
+    private expandWildcardSlots;
     private collectMatchingTypes;
     private truncate;
     private truncateName;

package/dist/index.js

@@ -597,11 +597,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);
@@ -618,7 +622,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`);
     }
@@ -635,6 +645,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);
@@ -735,6 +747,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;
@@ -800,7 +889,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();
@@ -840,6 +965,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(
@@ -908,6 +1062,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()) {
@@ -955,6 +1145,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);
     }
@@ -1121,6 +1347,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 = {};
@@ -1223,6 +1472,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;