@uniformdev/transformer 1.1.4 → 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 {

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