@uniformdev/transformer 1.1.7 → 1.1.9

package/dist/cli/index.js

@@ -900,7 +900,7 @@ var PatternAnalyzerService = class {
     this.logger = logger;
   }
   async analyze(options) {
-    const { rootDir, compositionsDir, projectMapNodesDir, minGroupSize, depth, threshold } = options;
+    const { rootDir, compositionsDir, projectMapNodesDir, minGroupSize, depth, threshold, subset } = options;
     const compositionsPath = this.fileSystem.resolvePath(rootDir, compositionsDir);
     const projectMapNodesPath = this.fileSystem.resolvePath(rootDir, projectMapNodesDir);
     const projectMapNodes = await this.loadProjectMapNodes(projectMapNodesPath);
@@ -926,7 +926,9 @@ var PatternAnalyzerService = class {
       }
     }
     let groups;
-    if (threshold === 0) {
+    if (subset) {
+      groups = this.clusterBySubset(loadedCompositions, depth);
+    } else if (threshold === 0) {
       const fingerprintGroups = /* @__PURE__ */ new Map();
       for (const item of loadedCompositions) {
         if (!fingerprintGroups.has(item.fingerprint)) {
@@ -960,34 +962,77 @@ var PatternAnalyzerService = class {
         }
         continue;
       }
-      group.sort((a, b) => {
-        const idA = a.composition.composition._id ?? "";
-        const idB = b.composition.composition._id ?? "";
-        return idA.localeCompare(idB);
-      });
-      const firstComposition = group[0].composition;
-      const rootType = firstComposition.composition.type;
-      const firstName = this.getCompositionName(firstComposition);
-      rootTypeCounts.set(rootType, (rootTypeCounts.get(rootType) ?? 0) + 1);
-      const structureDescription = this.generateStructureDescription(firstComposition);
-      const compositions = group.map(({ composition, filePath }) => ({
-        id: composition.composition._id ?? "unknown",
-        name: this.getCompositionName(composition),
-        projectMapNodeSlug: this.resolveProjectMapSlug(composition, projectMapNodes),
-        filePath
-      }));
-      const fingerprint = group[0].fingerprint;
-      const patternGroup = {
-        name: rootType,
-        // Temporary name, will be updated below if disambiguation needed
-        structureDescription,
-        fingerprint,
-        compositions,
-        _rootType: rootType,
-        _firstName: firstName
-      };
-      patterns.push(patternGroup);
-      patternCompositionsData.set(patternGroup, group.map((g) => g.composition));
+      if (subset) {
+        const nodeCache = /* @__PURE__ */ new Map();
+        for (const item of group) {
+          const id = item.composition.composition._id ?? "";
+          nodeCache.set(id, this.parseCompositionToNode(item.composition, depth));
+        }
+        group.sort((a, b) => {
+          const idA = a.composition.composition._id ?? "";
+          const idB = b.composition.composition._id ?? "";
+          const countA = this.countNodes(nodeCache.get(idA));
+          const countB = this.countNodes(nodeCache.get(idB));
+          if (countB !== countA) return countB - countA;
+          return idA.localeCompare(idB);
+        });
+        let mergedNode = nodeCache.get(group[0].composition.composition._id ?? "");
+        for (let i = 1; i < group.length; i++) {
+          const id = group[i].composition.composition._id ?? "";
+          mergedNode = this.mergeComponentNodes(mergedNode, nodeCache.get(id));
+        }
+        const firstComposition = group[0].composition;
+        const rootType = firstComposition.composition.type;
+        const firstName = this.getCompositionName(firstComposition);
+        rootTypeCounts.set(rootType, (rootTypeCounts.get(rootType) ?? 0) + 1);
+        const structureDescription = this.generateStructureDescriptionFromNode(mergedNode);
+        const compositions = group.map(({ composition, filePath }) => ({
+          id: composition.composition._id ?? "unknown",
+          name: this.getCompositionName(composition),
+          projectMapNodeSlug: this.resolveProjectMapSlug(composition, projectMapNodes),
+          filePath
+        }));
+        const fingerprint = group[0].fingerprint;
+        const patternGroup = {
+          name: rootType,
+          structureDescription,
+          fingerprint,
+          compositions,
+          _rootType: rootType,
+          _firstName: firstName
+        };
+        patterns.push(patternGroup);
+        patternCompositionsData.set(patternGroup, group.map((g) => g.composition));
+      } else {
+        group.sort((a, b) => {
+          const idA = a.composition.composition._id ?? "";
+          const idB = b.composition.composition._id ?? "";
+          return idA.localeCompare(idB);
+        });
+        const firstComposition = group[0].composition;
+        const rootType = firstComposition.composition.type;
+        const firstName = this.getCompositionName(firstComposition);
+        rootTypeCounts.set(rootType, (rootTypeCounts.get(rootType) ?? 0) + 1);
+        const structureDescription = this.generateStructureDescription(firstComposition);
+        const compositions = group.map(({ composition, filePath }) => ({
+          id: composition.composition._id ?? "unknown",
+          name: this.getCompositionName(composition),
+          projectMapNodeSlug: this.resolveProjectMapSlug(composition, projectMapNodes),
+          filePath
+        }));
+        const fingerprint = group[0].fingerprint;
+        const patternGroup = {
+          name: rootType,
+          // Temporary name, will be updated below if disambiguation needed
+          structureDescription,
+          fingerprint,
+          compositions,
+          _rootType: rootType,
+          _firstName: firstName
+        };
+        patterns.push(patternGroup);
+        patternCompositionsData.set(patternGroup, group.map((g) => g.composition));
+      }
     }
     for (const pattern of patterns) {
       const p = pattern;
@@ -1098,8 +1143,7 @@ var PatternAnalyzerService = class {
     const sortedSlotNames = Object.keys(slots).sort();
     for (const slotName of sortedSlotNames) {
       const instances = slots[slotName];
-      if (!Array.isArray(instances)) {
-        node.slots.set(slotName, []);
+      if (!Array.isArray(instances) || instances.length === 0) {
         continue;
       }
       const nextDepth = remainingDepth === -1 ? -1 : remainingDepth - 1;
@@ -1138,6 +1182,158 @@ var PatternAnalyzerService = class {
     }
     return distance;
   }
+  /**
+   * Checks if `smaller` is a structural subset of `larger`.
+   * Same root type required. For each slot in `smaller`, that slot must exist
+   * in `larger` with at least the same components at the same positions.
+   * `larger` may have extra slots or extra trailing components. Recursive.
+   */
+  isSubsetOf(smaller, larger) {
+    if (smaller.type !== larger.type) {
+      return false;
+    }
+    for (const [slotName, smallerChildren] of smaller.slots) {
+      const largerChildren = larger.slots.get(slotName);
+      if (!largerChildren) {
+        return false;
+      }
+      if (smallerChildren.length > largerChildren.length) {
+        return false;
+      }
+      for (let i = 0; i < smallerChildren.length; i++) {
+        if (!this.isSubsetOf(smallerChildren[i], largerChildren[i])) {
+          return false;
+        }
+      }
+    }
+    return true;
+  }
+  /**
+   * Counts total component instances in a tree (root + all descendants).
+   */
+  countNodes(node) {
+    let count = 1;
+    for (const children of node.slots.values()) {
+      for (const child of children) {
+        count += this.countNodes(child);
+      }
+    }
+    return count;
+  }
+  /**
+   * Merges two ComponentNode trees into a combined superset structure.
+   * Takes the union of all slots and the maximum components at each position.
+   * Both nodes must have the same root type.
+   */
+  mergeComponentNodes(a, b) {
+    if (a.type !== b.type) {
+      return a;
+    }
+    const mergedSlots = /* @__PURE__ */ new Map();
+    const allSlotNames = /* @__PURE__ */ new Set([...a.slots.keys(), ...b.slots.keys()]);
+    for (const slotName of allSlotNames) {
+      const aChildren = a.slots.get(slotName) ?? [];
+      const bChildren = b.slots.get(slotName) ?? [];
+      const maxLen = Math.max(aChildren.length, bChildren.length);
+      const mergedChildren = [];
+      for (let i = 0; i < maxLen; i++) {
+        const aChild = aChildren[i];
+        const bChild = bChildren[i];
+        if (aChild && bChild) {
+          if (aChild.type === bChild.type) {
+            mergedChildren.push(this.mergeComponentNodes(aChild, bChild));
+          } else {
+            mergedChildren.push(this.countNodes(aChild) >= this.countNodes(bChild) ? aChild : bChild);
+          }
+        } else {
+          mergedChildren.push(aChild ?? bChild);
+        }
+      }
+      mergedSlots.set(slotName, mergedChildren);
+    }
+    return { type: a.type, slots: mergedSlots };
+  }
+  /**
+   * Clusters compositions using Union-Find based on subset relationship.
+   * Two compositions are unioned if either is a structural subset of the other.
+   */
+  clusterBySubset(compositions, depth) {
+    const n = compositions.length;
+    if (n === 0) return [];
+    const parsedNodes = compositions.map(
+      (item) => this.parseCompositionToNode(item.composition, depth)
+    );
+    const parent = Array.from({ length: n }, (_, i) => i);
+    const rank = Array(n).fill(0);
+    const find = (x) => {
+      if (parent[x] !== x) {
+        parent[x] = find(parent[x]);
+      }
+      return parent[x];
+    };
+    const union = (x, y) => {
+      const rootX = find(x);
+      const rootY = find(y);
+      if (rootX !== rootY) {
+        if (rank[rootX] < rank[rootY]) {
+          parent[rootX] = rootY;
+        } else if (rank[rootX] > rank[rootY]) {
+          parent[rootY] = rootX;
+        } else {
+          parent[rootY] = rootX;
+          rank[rootX]++;
+        }
+      }
+    };
+    for (let i = 0; i < n; i++) {
+      for (let j = i + 1; j < n; j++) {
+        if (parsedNodes[i].type !== parsedNodes[j].type) {
+          continue;
+        }
+        if (this.isSubsetOf(parsedNodes[i], parsedNodes[j]) || this.isSubsetOf(parsedNodes[j], parsedNodes[i])) {
+          union(i, j);
+        }
+      }
+    }
+    const groups = /* @__PURE__ */ new Map();
+    for (let i = 0; i < n; i++) {
+      const root = find(i);
+      if (!groups.has(root)) {
+        groups.set(root, []);
+      }
+      groups.get(root).push(compositions[i]);
+    }
+    return Array.from(groups.values());
+  }
+  /**
+   * Generates a structure description from a ComponentNode tree (instead of a Composition).
+   */
+  generateStructureDescriptionFromNode(node) {
+    return this.generateNodeDescriptionFromNode(node, 0);
+  }
+  generateNodeDescriptionFromNode(node, depth) {
+    if (node.slots.size === 0) {
+      return node.type;
+    }
+    const sortedSlotNames = [...node.slots.keys()].sort();
+    const slotDescriptions = sortedSlotNames.map((slotName) => {
+      const children = node.slots.get(slotName);
+      if (children.length === 0) {
+        return null;
+      }
+      const instanceTypes = children.map((child) => {
+        if (child.slots.size > 0) {
+          return this.generateNodeDescriptionFromNode(child, depth + 1);
+        }
+        return child.type;
+      });
+      return `${slotName}[${instanceTypes.join(", ")}]`;
+    }).filter(Boolean);
+    if (slotDescriptions.length === 0) {
+      return node.type;
+    }
+    return `${node.type} > ${slotDescriptions.join(" > ")}`;
+  }
   /**
    * Extracts all unique component types from a composition recursively.
    */
@@ -1255,17 +1451,21 @@ var PatternAnalyzerService = class {
       return type;
     }
     const sortedSlotNames = Object.keys(slots).sort();
-    const slotFingerprints = sortedSlotNames.map((slotName) => {
+    const slotFingerprints = [];
+    for (const slotName of sortedSlotNames) {
       const instances = slots[slotName];
       if (!Array.isArray(instances) || instances.length === 0) {
-        return `${slotName}:[]`;
+        continue;
       }
       const nextDepth = remainingDepth === -1 ? -1 : remainingDepth - 1;
       const instanceFingerprints = instances.map(
         (instance) => this.generateNodeFingerprint(instance.type, instance.slots, nextDepth)
       );
-      return `${slotName}:[${instanceFingerprints.join(",")}]`;
-    });
+      slotFingerprints.push(`${slotName}:[${instanceFingerprints.join(",")}]`);
+    }
+    if (slotFingerprints.length === 0) {
+      return type;
+    }
     return `${type}{${slotFingerprints.join(";")}}`;
   }
   /**
@@ -1583,7 +1783,7 @@ function createFindCompositionPatternCandidatesCommand() {
     "--threshold <count>",
     "Number of component differences allowed while still matching (0 = exact match)",
     "0"
-  ).option("--format <format>", "Output format: text or json", "text").option("--brief", "Skip structure and composition details in text output").hook("preAction", (thisCommand) => {
+  ).option("--format <format>", "Output format: text or json", "text").option("--brief", "Skip structure and composition details in text output").option("--subset", "Group compositions where one structure is a subset of another", false).hook("preAction", (thisCommand) => {
     const opts = thisCommand.opts();
     const minGroupSize = parseInt(opts.minGroupSize, 10);
     if (isNaN(minGroupSize) || minGroupSize < 2) {
@@ -1612,7 +1812,8 @@ function createFindCompositionPatternCandidatesCommand() {
       depth: parseInt(opts.depth, 10),
       threshold: parseInt(opts.threshold, 10),
       format: opts.format,
-      brief: opts.brief ?? false
+      brief: opts.brief ?? false,
+      subset: opts.subset ?? false
     };
     const logger = new Logger();
     const fileSystem = new FileSystemService();
@@ -1627,7 +1828,8 @@ function createFindCompositionPatternCandidatesCommand() {
         minGroupSize: options.minGroupSize,
         depth: options.depth,
         threshold: options.threshold,
-        strict: options.strict ?? false
+        strict: options.strict ?? false,
+        subset: options.subset ?? false
       });
       if (options.format === "json") {
         console.log(analyzer.formatJsonOutput(result));
@@ -3375,7 +3577,7 @@ function createPropagateRootComponentSlotCommand() {
 // package.json
 var package_default = {
   name: "@uniformdev/transformer",
-  version: "1.1.7",
+  version: "1.1.9",
   description: "CLI tool for transforming Uniform.dev serialization files offline",
   type: "module",
   bin: {