@uniformdev/transformer 1.1.14 → 1.1.16

package/dist/index.d.ts

@@ -452,6 +452,7 @@ interface ConvertResult {
     contentTypesWritten: number;
     entriesFromCompositions: number;
     entriesFromFlattened: number;
+    entriesReused: number;
 }
 declare class CompositionConverterService {
     private fileSystem;
@@ -467,8 +468,11 @@ declare class CompositionConverterService {
     findFlattenTargets(slots: Record<string, ComponentInstance[]>, targetType: string, compositionId: string, compositionName: string, strict: boolean): FlattenedInstance[];
     private walkSlots;
     private transformContentReferences;
+    buildSourceItemMap(entriesDirFull: string): Promise<Map<string, string>>;
+    private findExistingEntryBySourceItem;
     private compareTypes;
     private truncate;
+    private truncateName;
 }
 /**
  * Computes a deterministic UUID v4 from a string seed.

package/dist/index.js

@@ -1676,10 +1676,15 @@ var CompositionConverterService = class {
     let contentTypesWritten = 0;
     let entriesFromCompositions = 0;
     let entriesFromFlattened = 0;
+    let entriesReused = 0;
     this.logger.info(`Composition types: ${compositionTypes.join(", ")}`);
     if (flattenComponentIds.length > 0) {
       this.logger.info(`Flatten component types: ${flattenComponentIds.join(", ")}`);
     }
+    const sourceItemMap = flattenComponentIds.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`);
+    }
     const compositionResults = await this.compositionService.findCompositionsByTypes(
       compositionsDirFull,
       compositionTypes,
@@ -1687,7 +1692,7 @@ var CompositionConverterService = class {
     );
     if (compositionResults.length === 0) {
       this.logger.warn("No compositions found matching the specified types");
-      return { contentTypesWritten: 0, entriesFromCompositions: 0, entriesFromFlattened: 0 };
+      return { contentTypesWritten: 0, entriesFromCompositions: 0, entriesFromFlattened: 0, entriesReused: 0 };
     }
     this.logger.info(`Found ${compositionResults.length} composition(s)`);
     const rootComponentTypes = /* @__PURE__ */ new Set();
@@ -1761,10 +1766,19 @@ var CompositionConverterService = class {
           }
         }
       }
+      const resolvedRefIds = /* @__PURE__ */ new Map();
       for (const [flattenType, instances] of flattenedByType) {
+        const refIds = [];
+        for (const inst of instances) {
+          const existingId = this.findExistingEntryBySourceItem(inst, sourceItemMap);
+          refIds.push(existingId ?? inst.determinisiticId);
+        }
+        resolvedRefIds.set(flattenType, refIds);
+      }
+      for (const [flattenType] of flattenedByType) {
         entry.entry.fields[flattenType] = {
           type: "contentReference",
-          value: instances.map((inst) => inst.determinisiticId)
+          value: resolvedRefIds.get(flattenType)
         };
       }
       if (flattenComponentIds.length > 0) {
@@ -1783,6 +1797,14 @@ var CompositionConverterService = class {
       entriesFromCompositions++;
       for (const [flattenType, instances] of flattenedByType) {
         for (const inst of instances) {
+          const existingId = this.findExistingEntryBySourceItem(inst, sourceItemMap);
+          if (existingId) {
+            this.logger.info(
+              `Reusing existing entry ${existingId} for ${flattenType} (sourceItem match)`
+            );
+            entriesReused++;
+            continue;
+          }
           const flatEntry = this.generateEntryFromFlattenedInstance(inst);
           const flatEntryPath = this.fileSystem.joinPath(
             entriesDirFull,
@@ -1857,7 +1879,7 @@ var CompositionConverterService = class {
         `Flatten component type(s) not found in any composition: ${neverFoundMissingTypes.join(", ")}`
       );
     }
-    return { contentTypesWritten, entriesFromCompositions, entriesFromFlattened };
+    return { contentTypesWritten, entriesFromCompositions, entriesFromFlattened, entriesReused };
   }
   // --- Content Type Generation ---
   generateContentType(component) {
@@ -1908,10 +1930,11 @@ var CompositionConverterService = class {
       }
     }
     const entryId = computeGuidHash(`entry${comp._id}`);
+    const entryName = this.truncateName(comp._name ?? comp._id, 60);
     return {
       entry: {
         _id: entryId,
-        _name: comp._name ?? comp._id,
+        _name: entryName,
         type: comp.type,
         fields: { ...comp.parameters ?? {} },
         ...extraRootProps
@@ -1920,10 +1943,14 @@ var CompositionConverterService = class {
     };
   }
   generateEntryFromFlattenedInstance(inst) {
+    const entryName = this.truncateName(
+      `${inst.componentType} (from ${inst.compositionName})`,
+      60
+    );
     return {
       entry: {
         _id: inst.determinisiticId,
-        _name: `${inst.componentType} (from ${inst.compositionName})`,
+        _name: entryName,
         type: inst.componentType,
         fields: { ...inst.instance.parameters ?? {} }
       }
@@ -1994,6 +2021,30 @@ var CompositionConverterService = class {
       };
     }
   }
+  // --- Source Item Matching ---
+  async buildSourceItemMap(entriesDirFull) {
+    const sourceItemMap = /* @__PURE__ */ new Map();
+    const entryFiles = await this.fileSystem.findFiles(entriesDirFull, "*.json");
+    for (const filePath of entryFiles) {
+      try {
+        const entryData = await this.fileSystem.readFile(filePath);
+        const sourceItemField = entryData?.entry?.fields?.sourceItem;
+        if (sourceItemField?.value != null) {
+          sourceItemMap.set(String(sourceItemField.value), entryData.entry._id);
+        }
+      } catch {
+        continue;
+      }
+    }
+    return sourceItemMap;
+  }
+  findExistingEntryBySourceItem(inst, sourceItemMap) {
+    const sourceItemParam = inst.instance.parameters?.sourceItem;
+    if (sourceItemParam?.value == null) {
+      return void 0;
+    }
+    return sourceItemMap.get(String(sourceItemParam.value));
+  }
   // --- Utilities ---
   compareTypes(type1, type2, strict) {
     if (strict) {
@@ -2005,6 +2056,10 @@ var CompositionConverterService = class {
     if (str.length <= maxLength) return str;
     return str.substring(0, maxLength - 3) + "...";
   }
+  truncateName(name, maxLength) {
+    if (name.length <= maxLength) return name;
+    return name.substring(0, maxLength);
+  }
 };
 function computeGuidHash(guidOrSeed) {
   let uuidStr;