@uniformdev/transformer 1.1.27 → 1.1.29

package/dist/index.d.ts

@@ -484,7 +484,10 @@ declare class CompositionConverterService {
     buildEntryIdMap(entriesDirFull: string): Promise<Map<string, string>>;
     buildSourceItemMap(entriesDirFull: string): Promise<Map<string, string>>;
     private findExistingEntryBySourceItem;
+    private matchesType;
     private compareTypes;
+    private expandWildcardTypes;
+    private collectMatchingTypes;
     private truncate;
     private truncateName;
 }

package/dist/index.js

@@ -587,8 +587,8 @@ var CompositionConverterService = class {
       whatIf,
       strict
     } = options;
-    const componentsToReferences = [...new Set(rawComponentsToReferences)];
-    const componentsToBlocks = [...new Set(rawComponentsToBlocks)];
+    const initialComponentsToReferences = [...new Set(rawComponentsToReferences)];
+    const initialComponentsToBlocks = [...new Set(rawComponentsToBlocks)];
     const compositionsDirFull = this.fileSystem.resolvePath(rootDir, compositionsDir);
     const componentsDirFull = this.fileSystem.resolvePath(rootDir, componentsDir);
     const contentTypesDirFull = this.fileSystem.resolvePath(rootDir, contentTypesDir);
@@ -599,13 +599,13 @@ var CompositionConverterService = class {
     let entriesReused = 0;
     let blocksEmbedded = 0;
     this.logger.info(`Composition types: ${compositionTypes.join(", ")}`);
-    if (componentsToReferences.length > 0) {
-      this.logger.info(`Components to references: ${componentsToReferences.join(", ")}`);
+    if (initialComponentsToReferences.length > 0) {
+      this.logger.info(`Components to references: ${initialComponentsToReferences.join(", ")}`);
     }
-    if (componentsToBlocks.length > 0) {
-      this.logger.info(`Components to blocks: ${componentsToBlocks.join(", ")}`);
+    if (initialComponentsToBlocks.length > 0) {
+      this.logger.info(`Components to blocks: ${initialComponentsToBlocks.join(", ")}`);
     }
-    const sourceItemMap = componentsToReferences.length > 0 ? await this.buildSourceItemMap(entriesDirFull) : /* @__PURE__ */ new Map();
+    const sourceItemMap = initialComponentsToReferences.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`);
     }
@@ -620,19 +620,29 @@ var CompositionConverterService = class {
       return { contentTypesWritten: 0, entriesFromCompositions: 0, entriesFromReferences: 0, entriesReused: 0, blocksEmbedded: 0 };
     }
     this.logger.info(`Found ${compositionResults.length} composition(s)`);
+    const componentsToReferences = this.expandWildcardTypes(compositionResults, initialComponentsToReferences, strict);
+    const componentsToBlocks = this.expandWildcardTypes(compositionResults, initialComponentsToBlocks, strict);
     const rootComponentTypes = /* @__PURE__ */ new Set();
     for (const { composition } of compositionResults) {
       rootComponentTypes.add(composition.composition.type);
     }
     const contentTypeMap = /* @__PURE__ */ new Map();
     for (const rootType of rootComponentTypes) {
-      const { component } = await this.componentService.loadComponent(
-        componentsDirFull,
-        rootType,
-        { strict }
-      );
-      const contentType = this.generateContentType(component);
-      contentTypeMap.set(rootType, contentType);
+      try {
+        const { component } = await this.componentService.loadComponent(
+          componentsDirFull,
+          rootType,
+          { strict }
+        );
+        const contentType = this.generateContentType(component);
+        contentTypeMap.set(rootType, contentType);
+      } catch (error) {
+        if (error instanceof ComponentNotFoundError) {
+          this.logger.warn(`Component not found: ${rootType} \u2014 skipping content type generation`);
+          continue;
+        }
+        throw error;
+      }
     }
     const allTargetTypes = [.../* @__PURE__ */ new Set([...componentsToReferences, ...componentsToBlocks])];
     const targetContentTypeMap = /* @__PURE__ */ new Map();
@@ -714,7 +724,8 @@ var CompositionConverterService = class {
       const compositionId = comp._id;
       const compositionName = comp._name ?? compositionId;
       const compositionType = comp.type;
-      const existingEntryPath = existingEntryMap.get(compositionId);
+      const compSourceItem = comp.parameters?.sourceItem?.value;
+      const existingEntryPath = existingEntryMap.get(compositionId) ?? (compSourceItem != null ? existingEntryMap.get(String(compSourceItem)) : void 0);
       let entry;
       let isExistingEntry = false;
       if (existingEntryPath) {
@@ -723,7 +734,7 @@ var CompositionConverterService = class {
           entry = existingEntry;
           isExistingEntry = true;
           this.logger.info(
-            `Found existing entry "${compositionId}" \u2014 merging references and blocks`
+            `Found existing entry "${existingEntry.entry._id}" \u2014 merging references and blocks`
           );
         } else {
           entry = this.generateEntryFromComposition(composition);
@@ -1148,11 +1159,57 @@ var CompositionConverterService = class {
     return sourceItemMap.get(String(sourceItemParam.value));
   }
   // --- Utilities ---
+  matchesType(instanceType, pattern, strict) {
+    if (!pattern.includes("*")) {
+      return strict ? instanceType === pattern : instanceType.toLowerCase() === pattern.toLowerCase();
+    }
+    const flags = strict ? "" : "i";
+    const escaped = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*");
+    const regex = new RegExp(`^${escaped}$`, flags);
+    return regex.test(instanceType);
+  }
   compareTypes(type1, type2, strict) {
-    if (strict) {
-      return type1 === type2;
+    if (type1.includes("*")) return this.matchesType(type2, type1, strict);
+    if (type2.includes("*")) return this.matchesType(type1, type2, strict);
+    return strict ? type1 === type2 : type1.toLowerCase() === type2.toLowerCase();
+  }
+  expandWildcardTypes(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) {
+          this.collectMatchingTypes(composition.composition.slots, pattern, strict, matched);
+        }
+      }
+      if (matched.size === 0) {
+        this.logger.warn(`Wildcard pattern "${pattern}" did not match any component types`);
+      } else {
+        this.logger.info(`Wildcard "${pattern}" expanded to: ${[...matched].join(", ")}`);
+      }
+      for (const type of matched) {
+        expanded.push(type);
+      }
+    }
+    return [...new Set(expanded)];
+  }
+  collectMatchingTypes(slots, pattern, strict, matched) {
+    for (const instances of Object.values(slots)) {
+      if (!Array.isArray(instances)) continue;
+      for (const instance of instances) {
+        if (instance._pattern) continue;
+        if (this.matchesType(instance.type, pattern, strict)) {
+          matched.add(instance.type);
+        }
+        if (instance.slots) {
+          this.collectMatchingTypes(instance.slots, pattern, strict, matched);
+        }
+      }
     }
-    return type1.toLowerCase() === type2.toLowerCase();
   }
   truncate(str, maxLength) {
     if (str.length <= maxLength) return str;