@uniformdev/transformer 1.1.18 → 1.1.20

package/dist/index.d.ts

@@ -198,6 +198,7 @@ declare class ComponentService {
         filePath: string;
     }>;
     saveComponent(filePath: string, component: ComponentDefinition): Promise<void>;
+    private sortComponentArrays;
     findParameter(component: ComponentDefinition, parameterName: string, options?: FindOptions$1): Parameter | undefined;
     isGroupParameter(parameter: Parameter): boolean;
     resolveGroupParameters(component: ComponentDefinition, groupParameter: Parameter, options?: FindOptions$1): Parameter[];
@@ -488,7 +489,7 @@ declare function computeGuidHash(guidOrSeed: string): string;
 
 /**
  * Recursively walks through a value and regenerates all `_id` properties that contain UUIDs.
- * Uses computeGuidHash(originalValue + jsonPath) to produce deterministic new IDs.
+ * Uses computeGuidHash(jsonPath) to produce deterministic new IDs based purely on position.
  * Also creates a deep clone of the value — the original is not modified.
  */
 declare function regenerateIds<T>(value: T, basePath: string): T;

package/dist/index.js

@@ -179,7 +179,27 @@ var ComponentService = class {
     throw new ComponentNotFoundError(componentType, componentsDir);
   }
   async saveComponent(filePath, component) {
-    await this.fileSystem.writeFile(filePath, component);
+    const sorted = this.sortComponentArrays(component);
+    await this.fileSystem.writeFile(filePath, sorted);
+  }
+  sortComponentArrays(component) {
+    const result = { ...component };
+    if (result.parameters) {
+      result.parameters = [...result.parameters].sort((a, b) => a.id.localeCompare(b.id));
+    }
+    if (result.slots) {
+      result.slots = [...result.slots].sort((a, b) => a.id.localeCompare(b.id)).map((slot) => {
+        if (slot.allowedComponents) {
+          return { ...slot, allowedComponents: [...slot.allowedComponents].sort((a, b) => a.localeCompare(b)) };
+        }
+        return slot;
+      });
+    }
+    const variants = result.variants;
+    if (Array.isArray(variants)) {
+      result.variants = [...variants].sort((a, b) => a.id.localeCompare(b.id));
+    }
+    return result;
   }
   findParameter(component, parameterName, options = {}) {
     const { strict = false } = options;
@@ -664,9 +684,26 @@ var CompositionConverterService = class {
         for (const inst of instances) {
           const existingId = this.findExistingEntryBySourceItem(inst, sourceItemMap);
           if (existingId) {
-            this.logger.info(
-              `Reusing existing entry ${existingId} for ${flattenType} (sourceItem match)`
+            const existingEntryPath = this.fileSystem.joinPath(
+              entriesDirFull,
+              `${existingId}.json`
+            );
+            this.logger.action(
+              whatIf,
+              "UPDATE",
+              `${entriesDir}/${existingId}.json (${flattenType}, merged fields from "${this.truncate(compositionName, 50)}")`
             );
+            if (!whatIf) {
+              const existingEntry = await this.fileSystem.readFile(existingEntryPath);
+              if (existingEntry?.entry) {
+                const instanceFields = inst.instance.parameters ?? {};
+                existingEntry.entry.fields = {
+                  ...existingEntry.entry.fields,
+                  ...instanceFields
+                };
+                await this.fileSystem.writeFile(existingEntryPath, existingEntry);
+              }
+            }
             entriesReused++;
             continue;
           }
@@ -994,7 +1031,7 @@ function walkAndRegenerate(value, currentPath) {
     for (const [key, val] of Object.entries(obj)) {
       const childPath = `${currentPath}.${key}`;
       if (key === "_id" && typeof val === "string" && UUID_PATTERN.test(val)) {
-        result[key] = computeGuidHash(val + childPath);
+        result[key] = computeGuidHash(childPath);
       } else {
         result[key] = walkAndRegenerate(val, childPath);
       }