@uniformdev/transformer 1.1.3 → 1.1.5

package/dist/index.d.ts

@@ -221,6 +221,11 @@ declare class CompositionService {
         composition: Composition;
         filePath: string;
     }[]>;
+    findCompositionsByTypes(compositionsDir: string, compositionTypes: string[], options?: FindOptions): Promise<{
+        composition: Composition;
+        filePath: string;
+    }[]>;
+    private normalizeCompositionTypes;
     findComponentInstances(composition: Composition, componentType: string, options?: FindOptions): FoundComponentInstance[];
     private searchSlots;
     getRootOverrides(composition: Composition): Record<string, ParameterValue>;
@@ -272,6 +277,7 @@ declare class PropertyPropagatorService {
     private logger;
     constructor(fileSystem: FileSystemService, componentService: ComponentService, compositionService: CompositionService, logger: Logger);
     propagate(options: PropagateOptions): Promise<PropagateResult>;
+    private parsePipeSeparatedValues;
 }
 
 interface RenameSlotInternalOptions {
@@ -366,6 +372,8 @@ declare class ComponentAdderService {
     private logger;
     constructor(fileSystem: FileSystemService, componentService: ComponentService, logger: Logger);
     private compareIds;
+    private parseParentComponentTypes;
+    private matchesAnyParentType;
     private parseParameters;
     private generateId;
     private regenerateInstanceIds;

package/dist/index.js

@@ -362,13 +362,22 @@ var CompositionService = class {
     await this.fileSystem.writeFile(filePath, composition);
   }
   async findCompositionsByType(compositionsDir, compositionType, options = {}) {
+    return this.findCompositionsByTypes(compositionsDir, [compositionType], options);
+  }
+  async findCompositionsByTypes(compositionsDir, compositionTypes, options = {}) {
     const { strict = false } = options;
+    const normalizedTypes = this.normalizeCompositionTypes(compositionTypes, strict);
+    if (normalizedTypes.length === 0) {
+      return [];
+    }
     const files = await this.fileSystem.findFiles(compositionsDir, "**/*.{json,yaml,yml}");
     const results = [];
     for (const filePath of files) {
       try {
         const composition = await this.loadComposition(filePath);
-        if (composition.composition?.type && this.compareTypes(composition.composition.type, compositionType, strict)) {
+        if (composition.composition?.type && normalizedTypes.some(
+          (type) => this.compareTypes(composition.composition.type, type, strict)
+        )) {
           results.push({ composition, filePath });
         }
       } catch {
@@ -376,6 +385,22 @@ var CompositionService = class {
     }
     return results;
   }
+  normalizeCompositionTypes(compositionTypes, strict) {
+    const normalized = [];
+    for (const type of compositionTypes) {
+      const trimmed = type.trim();
+      if (!trimmed) {
+        continue;
+      }
+      const exists = normalized.some(
+        (existing) => strict ? existing === trimmed : existing.toLowerCase() === trimmed.toLowerCase()
+      );
+      if (!exists) {
+        normalized.push(trimmed);
+      }
+    }
+    return normalized;
+  }
   findComponentInstances(composition, componentType, options = {}) {
     const { strict = false } = options;
     const results = [];
@@ -500,26 +525,51 @@ var PropertyPropagatorService = class {
       deleteSourceParameter
     } = options;
     const findOptions = { strict };
+    const compositionTypes = this.parsePipeSeparatedValues(compositionType, strict);
     const fullComponentsDir = this.fileSystem.resolvePath(rootDir, componentsDir);
     const fullCompositionsDir = this.fileSystem.resolvePath(rootDir, compositionsDir);
-    this.logger.info(`Loading component: ${compositionType}`);
-    const { component: sourceComponent, filePath: sourceFilePath } = await this.componentService.loadComponent(fullComponentsDir, compositionType, findOptions);
+    const sourceComponents = [];
+    for (const sourceType of compositionTypes) {
+      this.logger.info(`Loading component: ${sourceType}`);
+      const { component: sourceComponent, filePath: sourceFilePath } = await this.componentService.loadComponent(fullComponentsDir, sourceType, findOptions);
+      sourceComponents.push({ sourceType, sourceFilePath, sourceComponent });
+    }
     this.logger.info(`Loading component: ${targetComponentType}`);
     const { component: targetComponent, filePath: targetFilePath } = await this.componentService.loadComponent(fullComponentsDir, targetComponentType, findOptions);
-    const propertyNames = property.split("|").map((p) => p.trim());
-    const { parameters: resolvedParams, notFound } = this.componentService.resolveProperties(
-      sourceComponent,
-      propertyNames,
-      findOptions
-    );
-    if (notFound.length > 0) {
-      throw new PropertyNotFoundError(notFound.join(", "), compositionType);
+    const propertyNames = property.split("|").map((p) => p.trim()).filter((p) => p.length > 0);
+    const resolvedParams = [];
+    const resolvedNames = [];
+    for (const { sourceType, sourceComponent } of sourceComponents) {
+      const { parameters: sourceParams, notFound } = this.componentService.resolveProperties(
+        sourceComponent,
+        propertyNames,
+        findOptions
+      );
+      if (notFound.length > 0) {
+        throw new PropertyNotFoundError(notFound.join(", "), sourceType);
+      }
+      for (const param of sourceParams) {
+        const exists = resolvedParams.some(
+          (existing) => strict ? existing.id === param.id : existing.id.toLowerCase() === param.id.toLowerCase()
+        );
+        if (!exists) {
+          resolvedParams.push(param);
+          resolvedNames.push(param.id);
+        }
+      }
+    }
+    const groupSources = [];
+    for (const { sourceType, sourceComponent } of sourceComponents) {
+      for (const name of propertyNames) {
+        const param = this.componentService.findParameter(sourceComponent, name, findOptions);
+        if (param && this.componentService.isGroupParameter(param)) {
+          const groupSource = `${sourceType}.${name}`;
+          if (!groupSources.includes(groupSource)) {
+            groupSources.push(groupSource);
+          }
+        }
+      }
     }
-    const resolvedNames = resolvedParams.map((p) => p.id);
-    const groupSources = propertyNames.filter((name) => {
-      const param = this.componentService.findParameter(sourceComponent, name, findOptions);
-      return param && this.componentService.isGroupParameter(param);
-    });
     if (groupSources.length > 0) {
       this.logger.info(
         `Resolved properties: ${resolvedNames.join(", ")} (from ${groupSources.join(", ")})`
@@ -594,9 +644,9 @@ var PropertyPropagatorService = class {
     if (componentModified && !whatIf) {
       await this.componentService.saveComponent(targetFilePath, modifiedComponent);
     }
-    const compositions = await this.compositionService.findCompositionsByType(
+    const compositions = await this.compositionService.findCompositionsByTypes(
       fullCompositionsDir,
-      compositionType,
+      compositionTypes,
       findOptions
     );
     let modifiedCompositions = 0;
@@ -643,31 +693,41 @@ var PropertyPropagatorService = class {
         modifiedCompositions++;
       }
     }
-    let sourceComponentModified = false;
+    let modifiedSourceComponents = 0;
     if (deleteSourceParameter) {
-      let modifiedSource = { ...sourceComponent };
-      for (const param of resolvedParams) {
-        this.logger.action(whatIf, "DELETE", `Parameter "${param.id}" from ${compositionType}`);
-        modifiedSource = this.componentService.removeParameter(modifiedSource, param.id, findOptions);
-        sourceComponentModified = true;
-      }
-      const beforeGroupCount = modifiedSource.parameters?.filter(
-        (p) => this.componentService.isGroupParameter(p)
-      ).length ?? 0;
-      modifiedSource = this.componentService.removeEmptyGroups(modifiedSource);
-      const afterGroupCount = modifiedSource.parameters?.filter(
-        (p) => this.componentService.isGroupParameter(p)
-      ).length ?? 0;
-      if (afterGroupCount < beforeGroupCount) {
-        const removedCount = beforeGroupCount - afterGroupCount;
-        this.logger.action(
-          whatIf,
-          "DELETE",
-          `${removedCount} empty group(s) from ${compositionType}`
-        );
-      }
-      if (sourceComponentModified && !whatIf) {
-        await this.componentService.saveComponent(sourceFilePath, modifiedSource);
+      for (const { sourceType, sourceFilePath, sourceComponent } of sourceComponents) {
+        let modifiedSource = { ...sourceComponent };
+        let sourceComponentModified = false;
+        for (const param of resolvedParams) {
+          const exists = this.componentService.findParameter(modifiedSource, param.id, findOptions);
+          if (exists) {
+            this.logger.action(whatIf, "DELETE", `Parameter "${param.id}" from ${sourceType}`);
+            modifiedSource = this.componentService.removeParameter(modifiedSource, param.id, findOptions);
+            sourceComponentModified = true;
+          }
+        }
+        const beforeGroupCount = modifiedSource.parameters?.filter(
+          (p) => this.componentService.isGroupParameter(p)
+        ).length ?? 0;
+        modifiedSource = this.componentService.removeEmptyGroups(modifiedSource);
+        const afterGroupCount = modifiedSource.parameters?.filter(
+          (p) => this.componentService.isGroupParameter(p)
+        ).length ?? 0;
+        if (afterGroupCount < beforeGroupCount) {
+          const removedCount = beforeGroupCount - afterGroupCount;
+          this.logger.action(
+            whatIf,
+            "DELETE",
+            `${removedCount} empty group(s) from ${sourceType}`
+          );
+          sourceComponentModified = true;
+        }
+        if (sourceComponentModified) {
+          modifiedSourceComponents++;
+        }
+        if (sourceComponentModified && !whatIf) {
+          await this.componentService.saveComponent(sourceFilePath, modifiedSource);
+        }
       }
       for (const { composition, filePath } of compositions) {
         const relativePath = filePath.replace(fullCompositionsDir, "").replace(/^[/\\]/, "");
@@ -686,11 +746,24 @@ var PropertyPropagatorService = class {
       }
     }
     return {
-      modifiedComponents: (componentModified ? 1 : 0) + (sourceComponentModified ? 1 : 0),
+      modifiedComponents: (componentModified ? 1 : 0) + modifiedSourceComponents,
       modifiedCompositions,
       propagatedInstances
     };
   }
+  parsePipeSeparatedValues(value, strict) {
+    const entries = value.split("|").map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+    const normalized = [];
+    for (const entry of entries) {
+      const exists = normalized.some(
+        (existing) => strict ? existing === entry : existing.toLowerCase() === entry.toLowerCase()
+      );
+      if (!exists) {
+        normalized.push(entry);
+      }
+    }
+    return normalized;
+  }
 };
 
 // src/core/services/slot-renamer.service.ts
@@ -1114,6 +1187,12 @@ var ComponentAdderService = class {
     }
     return id1.toLowerCase() === id2.toLowerCase();
   }
+  parseParentComponentTypes(parentComponentType) {
+    return parentComponentType.split("|").map((t) => t.trim()).filter((t) => t.length > 0);
+  }
+  matchesAnyParentType(instanceType, parentTypes, strict) {
+    return parentTypes.some((pt) => this.compareIds(instanceType, pt, strict));
+  }
   parseParameters(parameterString) {
     const result = {};
     if (!parameterString) return result;
@@ -1187,18 +1266,9 @@ var ComponentAdderService = class {
     const fullCompositionPatternsDir = this.fileSystem.resolvePath(rootDir, compositionPatternsDir);
     const fullComponentPatternsDir = this.fileSystem.resolvePath(rootDir, componentPatternsDir);
     const findOptions = { strict };
-    this.logger.info(`Loading parent component: ${parentComponentType}`);
-    const { component: parentComponent, filePath: parentComponentFilePath } = await this.componentService.loadComponent(fullComponentsDir, parentComponentType, findOptions);
-    if (!parentComponent.slots) {
-      parentComponent.slots = [];
-    }
-    let slotDef = parentComponent.slots.find(
-      (s) => this.compareIds(s.id, slot, strict)
-    );
-    if (!slotDef) {
-      this.logger.info(`Slot "${slot}" not found on component "${parentComponentType}", creating it`);
-      slotDef = { id: slot, name: slot, allowedComponents: [] };
-      parentComponent.slots.push(slotDef);
+    const parentTypes = this.parseParentComponentTypes(parentComponentType);
+    if (parentTypes.length === 0) {
+      throw new TransformError("parentComponentType cannot be empty");
     }
     this.logger.info(`Validating new component: ${newComponentType}`);
     try {
@@ -1212,35 +1282,50 @@ var ComponentAdderService = class {
       throw error;
     }
     let allowedComponentsUpdated = false;
-    const slotIndex = parentComponent.slots?.findIndex(
-      (s) => this.compareIds(s.id, slotDef.id, strict)
-    );
-    if (slotIndex !== void 0 && slotIndex >= 0) {
-      const actualSlot = parentComponent.slots[slotIndex];
-      if (!actualSlot.allowedComponents) {
-        actualSlot.allowedComponents = [];
+    for (const parentType of parentTypes) {
+      this.logger.info(`Loading parent component: ${parentType}`);
+      const { component: parentComponent, filePath: parentComponentFilePath } = await this.componentService.loadComponent(fullComponentsDir, parentType, findOptions);
+      if (!parentComponent.slots) {
+        parentComponent.slots = [];
       }
-      const isAlreadyAllowed = actualSlot.allowedComponents.some(
-        (c) => this.compareIds(c, newComponentType, strict)
+      let slotDef = parentComponent.slots.find(
+        (s) => this.compareIds(s.id, slot, strict)
       );
-      if (!isAlreadyAllowed) {
-        this.logger.action(
-          whatIf,
-          "UPDATE",
-          `Adding "${newComponentType}" to allowedComponents for slot "${slot}" on component "${parentComponentType}"`
+      if (!slotDef) {
+        this.logger.info(`Slot "${slot}" not found on component "${parentType}", creating it`);
+        slotDef = { id: slot, name: slot, allowedComponents: [] };
+        parentComponent.slots.push(slotDef);
+      }
+      const slotIndex = parentComponent.slots?.findIndex(
+        (s) => this.compareIds(s.id, slotDef.id, strict)
+      );
+      if (slotIndex !== void 0 && slotIndex >= 0) {
+        const actualSlot = parentComponent.slots[slotIndex];
+        if (!actualSlot.allowedComponents) {
+          actualSlot.allowedComponents = [];
+        }
+        const isAlreadyAllowed = actualSlot.allowedComponents.some(
+          (c) => this.compareIds(c, newComponentType, strict)
         );
-        actualSlot.allowedComponents.push(newComponentType);
-        if (!whatIf) {
-          await this.componentService.saveComponent(parentComponentFilePath, parentComponent);
+        if (!isAlreadyAllowed) {
+          this.logger.action(
+            whatIf,
+            "UPDATE",
+            `Adding "${newComponentType}" to allowedComponents for slot "${slot}" on component "${parentType}"`
+          );
+          actualSlot.allowedComponents.push(newComponentType);
+          if (!whatIf) {
+            await this.componentService.saveComponent(parentComponentFilePath, parentComponent);
+          }
+          allowedComponentsUpdated = true;
         }
-        allowedComponentsUpdated = true;
       }
     }
     const parsedParams = this.parseParameters(paramString);
     const newInstance = this.createComponentInstance(newComponentType, parsedParams);
     const compositionsResult = await this.addComponentToDirectory(
       fullCompositionsDir,
-      parentComponentType,
+      parentTypes,
       slot,
       newInstance,
       whatIf,
@@ -1249,7 +1334,7 @@ var ComponentAdderService = class {
     );
     const compositionPatternsResult = await this.addComponentToDirectory(
       fullCompositionPatternsDir,
-      parentComponentType,
+      parentTypes,
       slot,
       newInstance,
       whatIf,
@@ -1258,7 +1343,7 @@ var ComponentAdderService = class {
     );
     const componentPatternsResult = await this.addComponentToDirectory(
       fullComponentPatternsDir,
-      parentComponentType,
+      parentTypes,
       slot,
       newInstance,
       whatIf,
@@ -1267,7 +1352,7 @@ var ComponentAdderService = class {
     );
     this.logger.info("");
     this.logger.info(
-      `Summary: ${allowedComponentsUpdated ? "1 component definition updated, " : ""}${compositionsResult} composition(s), ${compositionPatternsResult} composition pattern(s), ${componentPatternsResult} component pattern(s) updated. ${compositionsResult + compositionPatternsResult + componentPatternsResult} instance(s) added.`
+      `Summary: ${allowedComponentsUpdated ? `${parentTypes.length} component definition(s) updated, ` : ""}${compositionsResult} composition(s), ${compositionPatternsResult} composition pattern(s), ${componentPatternsResult} component pattern(s) updated. ${compositionsResult + compositionPatternsResult + componentPatternsResult} instance(s) added.`
     );
     return {
       allowedComponentsUpdated,
@@ -1298,18 +1383,9 @@ var ComponentAdderService = class {
     const fullCompositionPatternsDir = this.fileSystem.resolvePath(rootDir, compositionPatternsDir);
     const fullComponentPatternsDir = this.fileSystem.resolvePath(rootDir, componentPatternsDir);
     const findOptions = { strict };
-    this.logger.info(`Loading parent component: ${parentComponentType}`);
-    const { component: parentComponent } = await this.componentService.loadComponent(fullComponentsDir, parentComponentType, findOptions);
-    if (!parentComponent.slots) {
-      parentComponent.slots = [];
-    }
-    let slotDef = parentComponent.slots.find(
-      (s) => this.compareIds(s.id, slot, strict)
-    );
-    if (!slotDef) {
-      this.logger.info(`Slot "${slot}" not found on component "${parentComponentType}", creating it`);
-      slotDef = { id: slot, name: slot, allowedComponents: [] };
-      parentComponent.slots.push(slotDef);
+    const parentTypes = this.parseParentComponentTypes(parentComponentType);
+    if (parentTypes.length === 0) {
+      throw new TransformError("parentComponentType cannot be empty");
     }
     this.logger.info(`Loading component pattern: ${componentPatternId}`);
     const pattern = await this.loadComponentPattern(
@@ -1323,32 +1399,45 @@ var ComponentAdderService = class {
         `Component pattern "${componentPatternId}" has no valid definition or missing type`
       );
     }
-    let allowedComponentsUpdated = false;
     const componentTypeInPattern = patternDefinition.type;
-    const slotIndex = parentComponent.slots?.findIndex(
-      (s) => this.compareIds(s.id, slotDef.id, strict)
-    );
-    if (slotIndex !== void 0 && slotIndex >= 0) {
-      const actualSlot = parentComponent.slots[slotIndex];
-      if (!actualSlot.allowedComponents) {
-        actualSlot.allowedComponents = [];
+    let allowedComponentsUpdated = false;
+    for (const parentType of parentTypes) {
+      this.logger.info(`Loading parent component: ${parentType}`);
+      const { component: parentComponent, filePath: parentComponentFilePath } = await this.componentService.loadComponent(fullComponentsDir, parentType, findOptions);
+      if (!parentComponent.slots) {
+        parentComponent.slots = [];
       }
-      const isAlreadyAllowed = actualSlot.allowedComponents.some(
-        (c) => this.compareIds(c, componentTypeInPattern, strict)
+      let slotDef = parentComponent.slots.find(
+        (s) => this.compareIds(s.id, slot, strict)
       );
-      if (!isAlreadyAllowed) {
-        this.logger.action(
-          whatIf,
-          "UPDATE",
-          `Adding "${componentTypeInPattern}" to allowedComponents for slot "${slot}" on component "${parentComponentType}"`
+      if (!slotDef) {
+        this.logger.info(`Slot "${slot}" not found on component "${parentType}", creating it`);
+        slotDef = { id: slot, name: slot, allowedComponents: [] };
+        parentComponent.slots.push(slotDef);
+      }
+      const slotIndex = parentComponent.slots?.findIndex(
+        (s) => this.compareIds(s.id, slotDef.id, strict)
+      );
+      if (slotIndex !== void 0 && slotIndex >= 0) {
+        const actualSlot = parentComponent.slots[slotIndex];
+        if (!actualSlot.allowedComponents) {
+          actualSlot.allowedComponents = [];
+        }
+        const isAlreadyAllowed = actualSlot.allowedComponents.some(
+          (c) => this.compareIds(c, componentTypeInPattern, strict)
         );
-        actualSlot.allowedComponents.push(componentTypeInPattern);
-        if (!whatIf) {
-          await this.componentService.loadComponent(fullComponentsDir, parentComponentType, findOptions).then(
-            ({ filePath }) => this.componentService.saveComponent(filePath, parentComponent)
+        if (!isAlreadyAllowed) {
+          this.logger.action(
+            whatIf,
+            "UPDATE",
+            `Adding "${componentTypeInPattern}" to allowedComponents for slot "${slot}" on component "${parentType}"`
           );
+          actualSlot.allowedComponents.push(componentTypeInPattern);
+          if (!whatIf) {
+            await this.componentService.saveComponent(parentComponentFilePath, parentComponent);
+          }
+          allowedComponentsUpdated = true;
         }
-        allowedComponentsUpdated = true;
       }
     }
     const newInstance = {
@@ -1358,7 +1447,7 @@ var ComponentAdderService = class {
     };
     const compositionsResult = await this.addComponentToDirectory(
       fullCompositionsDir,
-      parentComponentType,
+      parentTypes,
       slot,
       newInstance,
       whatIf,
@@ -1367,7 +1456,7 @@ var ComponentAdderService = class {
     );
     const compositionPatternsResult = await this.addComponentToDirectory(
       fullCompositionPatternsDir,
-      parentComponentType,
+      parentTypes,
       slot,
       newInstance,
       whatIf,
@@ -1376,7 +1465,7 @@ var ComponentAdderService = class {
     );
     const componentPatternsResult = await this.addComponentToDirectory(
       fullComponentPatternsDir,
-      parentComponentType,
+      parentTypes,
       slot,
       newInstance,
       whatIf,
@@ -1385,7 +1474,7 @@ var ComponentAdderService = class {
     );
     this.logger.info("");
     this.logger.info(
-      `Summary: ${allowedComponentsUpdated ? "1 component definition updated, " : ""}${compositionsResult} composition(s), ${compositionPatternsResult} composition pattern(s), ${componentPatternsResult} component pattern(s) updated. ${compositionsResult + compositionPatternsResult + componentPatternsResult} instance(s) added.`
+      `Summary: ${allowedComponentsUpdated ? `${parentTypes.length} component definition(s) updated, ` : ""}${compositionsResult} composition(s), ${compositionPatternsResult} composition pattern(s), ${componentPatternsResult} component pattern(s) updated. ${compositionsResult + compositionPatternsResult + componentPatternsResult} instance(s) added.`
     );
     return {
       allowedComponentsUpdated,
@@ -1436,7 +1525,7 @@ var ComponentAdderService = class {
     }
     return raw;
   }
-  async addComponentToDirectory(directory, parentComponentType, slot, newInstance, whatIf, strict, dirType) {
+  async addComponentToDirectory(directory, parentTypes, slot, newInstance, whatIf, strict, dirType) {
     const exists = await this.fileSystem.fileExists(directory);
     if (!exists) {
       this.logger.detail(`${dirType} directory does not exist, skipping`);
@@ -1469,7 +1558,7 @@ var ComponentAdderService = class {
         }
         const rootInstance = composition.composition;
         let modified = false;
-        if (this.compareIds(rootInstance.type, parentComponentType, strict)) {
+        if (this.matchesAnyParentType(rootInstance.type, parentTypes, strict)) {
           if (!rootInstance.slots) {
             rootInstance.slots = {};
           }
@@ -1481,7 +1570,7 @@ var ComponentAdderService = class {
         if (rootInstance.slots) {
           const nestedModified = this.addComponentToNestedSlots(
             rootInstance.slots,
-            parentComponentType,
+            parentTypes,
             slot,
             newInstance,
             strict
@@ -1515,12 +1604,12 @@ var ComponentAdderService = class {
     }
     return filesModified;
   }
-  addComponentToNestedSlots(slots, parentComponentType, slot, newInstance, strict) {
+  addComponentToNestedSlots(slots, parentTypes, slot, newInstance, strict) {
     let modified = false;
     for (const slotInstances of Object.values(slots)) {
       if (!Array.isArray(slotInstances)) continue;
       for (const instance of slotInstances) {
-        if (this.compareIds(instance.type, parentComponentType, strict)) {
+        if (this.matchesAnyParentType(instance.type, parentTypes, strict)) {
           if (!instance.slots) {
             instance.slots = {};
           }
@@ -1532,7 +1621,7 @@ var ComponentAdderService = class {
         if (instance.slots) {
           const nestedModified = this.addComponentToNestedSlots(
             instance.slots,
-            parentComponentType,
+            parentTypes,
             slot,
             newInstance,
             strict