@uniformdev/transformer 1.1.15 → 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,6 +468,8 @@ 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;

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) {
@@ -1999,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) {