@bravostudioai/react 0.1.28 → 0.1.29

package/src/codegen/propQualification.ts

@@ -0,0 +1,284 @@
+/**
+ * Reusable prop name qualification utilities
+ *
+ * When multiple components/inputs have the same base prop name,
+ * this module provides utilities to make each name unique by using
+ * minimal distinguishing parent paths.
+ */
+
+import { generateQualifiedPropName, findMinimalDistinguishingPath, arraysEqual } from './parser';
+
+/**
+ * Base interface for items that can have their prop names qualified
+ */
+export interface QualifiableItem {
+  id: string;
+  name: string;
+  propName: string;
+  _parentPath?: string[];
+}
+
+/**
+ * Groups items by their prop name
+ */
+function groupByPropName<T extends QualifiableItem>(
+  items: T[]
+): Map<string, T[]> {
+  const groups = new Map<string, T[]>();
+
+  items.forEach((item) => {
+    const baseName = item.propName;
+    if (!groups.has(baseName)) {
+      groups.set(baseName, []);
+    }
+    groups.get(baseName)!.push(item);
+  });
+
+  return groups;
+}
+
+/**
+ * Applies minimal distinguishing paths to a group of items with duplicate names
+ */
+function applyMinimalPaths<T extends QualifiableItem>(group: T[]): void {
+  group.forEach((item) => {
+    const otherPaths = group
+      .filter((other) => other.id !== item.id)
+      .map((other) => other._parentPath || []);
+
+    const minimalPath = findMinimalDistinguishingPath(
+      item._parentPath || [],
+      otherPaths
+    );
+
+    item.propName = generateQualifiedPropName(
+      item.name || 'item',
+      minimalPath
+    );
+  });
+}
+
+/**
+ * Expands distinguishing paths iteratively until all names are unique
+ */
+function expandPathsUntilUnique<T extends QualifiableItem>(
+  group: T[],
+  allItems: T[]
+): void {
+  let hasDuplicates = true;
+  let iteration = 0;
+  const maxIterations = 10; // Safety limit
+
+  while (hasDuplicates && iteration < maxIterations) {
+    iteration++;
+
+    // Group by current qualified names
+    const qualifiedNameGroups = new Map<string, T[]>();
+    group.forEach((item) => {
+      if (!qualifiedNameGroups.has(item.propName)) {
+        qualifiedNameGroups.set(item.propName, []);
+      }
+      qualifiedNameGroups.get(item.propName)!.push(item);
+    });
+
+    hasDuplicates = false;
+
+    // For each group of duplicated qualified names, expand their paths
+    qualifiedNameGroups.forEach((dupGroup) => {
+      if (dupGroup.length > 1) {
+        hasDuplicates = true;
+
+        dupGroup.forEach((item) => {
+          const fullPath = item._parentPath || [];
+          const otherFullPaths = dupGroup
+            .filter((other) => other.id !== item.id)
+            .map((other) => other._parentPath || []);
+
+          // Find common prefix length
+          let commonPrefixLength = 0;
+          const maxCommonLength = Math.min(
+            fullPath.length,
+            ...otherFullPaths.map((p) => p.length)
+          );
+
+          for (let i = 0; i < maxCommonLength; i++) {
+            const thisPart = fullPath[i];
+            const allMatch = otherFullPaths.every((otherPath) => otherPath[i] === thisPart);
+            if (allMatch) {
+              commonPrefixLength++;
+            } else {
+              break;
+            }
+          }
+
+          // Use progressively more of the distinguishing suffix
+          const distinguishingSuffix = fullPath.slice(commonPrefixLength);
+
+          // Try expanding until unique
+          let foundUnique = false;
+          for (
+            let suffixLength = 1;
+            suffixLength <= distinguishingSuffix.length;
+            suffixLength++
+          ) {
+            const expandedPath = distinguishingSuffix.slice(0, suffixLength);
+            const testQualifiedName = generateQualifiedPropName(
+              item.name || 'item',
+              expandedPath
+            );
+
+            // Check if unique among ALL items
+            const isUnique = allItems.every((otherItem) => {
+              if (otherItem.id === item.id) return true;
+
+              // If in same duplicate group, compare expanded paths
+              if (dupGroup.some((d) => d.id === otherItem.id)) {
+                const otherFullPath = otherItem._parentPath || [];
+                const otherCommonPrefixLength = Math.min(
+                  commonPrefixLength,
+                  otherFullPath.length
+                );
+                const otherDistinguishingSuffix = otherFullPath.slice(
+                  otherCommonPrefixLength
+                );
+                const otherExpandedPath = otherDistinguishingSuffix.slice(
+                  0,
+                  suffixLength
+                );
+                const otherQualifiedName = generateQualifiedPropName(
+                  otherItem.name || 'item',
+                  otherExpandedPath
+                );
+                return testQualifiedName !== otherQualifiedName;
+              }
+
+              // For items outside duplicate group, check final prop name
+              return testQualifiedName !== otherItem.propName;
+            });
+
+            if (isUnique) {
+              item.propName = testQualifiedName;
+              foundUnique = true;
+              break;
+            }
+          }
+
+          // If still not unique, use the distinguishing suffix we found
+          if (!foundUnique) {
+            item.propName = generateQualifiedPropName(
+              item.name || 'item',
+              distinguishingSuffix.length > 0 ? distinguishingSuffix : []
+            );
+          }
+        });
+      }
+    });
+  }
+}
+
+/**
+ * Applies numeric suffixes as a last resort for items with identical paths
+ */
+function applyNumericSuffixes<T extends QualifiableItem>(group: T[]): void {
+  // Group by final qualified names
+  const finalQualifiedNameGroups = new Map<string, T[]>();
+  group.forEach((item) => {
+    if (!finalQualifiedNameGroups.has(item.propName)) {
+      finalQualifiedNameGroups.set(item.propName, []);
+    }
+    finalQualifiedNameGroups.get(item.propName)!.push(item);
+  });
+
+  finalQualifiedNameGroups.forEach((finalDupGroup, finalQualifiedName) => {
+    if (finalDupGroup.length > 1) {
+      // Check if all duplicates have identical paths
+      const allPathsIdentical = finalDupGroup.every((item) => {
+        const thisPath = item._parentPath || [];
+        return finalDupGroup.every((otherItem) => {
+          if (otherItem.id === item.id) return true;
+          const otherPath = otherItem._parentPath || [];
+          return arraysEqual(thisPath, otherPath);
+        });
+      });
+
+      // Only use numeric suffixes if paths are truly identical
+      if (allPathsIdentical) {
+        finalDupGroup.forEach((item, index) => {
+          if (index > 0) {
+            item.propName = `${finalQualifiedName}${index + 1}`;
+          }
+        });
+      }
+    }
+  });
+}
+
+/**
+ * Cleans up temporary _parentPath property from an item
+ */
+function cleanupParentPath<T extends QualifiableItem>(item: T): void {
+  delete item._parentPath;
+}
+
+/**
+ * Qualifies a single group of items with duplicate prop names
+ */
+function qualifyGroup<T extends QualifiableItem>(
+  group: T[],
+  allItems: T[]
+): void {
+  if (group.length === 1) {
+    cleanupParentPath(group[0]);
+    return;
+  }
+
+  // Step 1: Apply minimal distinguishing paths
+  applyMinimalPaths(group);
+
+  // Step 2: Iteratively expand paths until all are unique
+  expandPathsUntilUnique(group, allItems);
+
+  // Step 3: Apply numeric suffixes as last resort
+  applyNumericSuffixes(group);
+
+  // Step 4: Cleanup temporary properties
+  group.forEach(cleanupParentPath);
+}
+
+/**
+ * Qualifies duplicate prop names using minimal distinguishing paths.
+ *
+ * When multiple components have the same prop name, this function
+ * finds the shortest parent path segment that makes each name unique.
+ *
+ * Algorithm:
+ * 1. Group items by base prop name
+ * 2. For each group with duplicates:
+ *    a. Find minimal distinguishing paths
+ *    b. Iteratively expand paths if duplicates remain
+ *    c. Apply numeric suffixes if paths are identical
+ *
+ * @param items - Components/inputs to qualify (will be modified in place)
+ * @returns The same items array with qualified propName values
+ *
+ * @example
+ * const items = [
+ *   { id: '1', name: 'Title', propName: 'title', _parentPath: ['Header'] },
+ *   { id: '2', name: 'Title', propName: 'title', _parentPath: ['Footer'] }
+ * ];
+ * qualifyPropNames(items);
+ * // Result: items[0].propName = 'headerTitle', items[1].propName = 'footerTitle'
+ */
+export function qualifyPropNames<T extends QualifiableItem>(
+  items: T[]
+): T[] {
+  if (items.length === 0) return items;
+
+  const propNameGroups = groupByPropName(items);
+
+  propNameGroups.forEach((group) => {
+    qualifyGroup(group, items);
+  });
+
+  return items;
+}