@bravostudioai/react 0.1.28 → 0.1.29

package/src/codegen/parser.ts

@@ -6,7 +6,20 @@ import {
   SelectInputInfo,
   ActionButtonInfo,
 } from "./types";
+import { qualifyPropNames } from "./propQualification";
 
+/**
+ * Sanitizes a component name into a valid camelCase prop name
+ *
+ * Removes special characters, handles spaces, and converts to camelCase.
+ *
+ * @param name - Raw component name from Figma/design tool
+ * @returns Valid JavaScript property name
+ *
+ * @example
+ * sanitizePropName("My Component!") // "myComponent"
+ * sanitizePropName("user-name") // "userName"
+ */
 export function sanitizePropName(name: string): string {
   // Convert to camelCase and remove invalid characters
   const cleaned = name
@@ -350,219 +363,8 @@ export function findSlidersAndDataBindings(pageData: any): SliderInfo[] {
           } as ComponentInfo & { _parentPath: string[] });
         }
 
-        // Detect duplicates and qualify them with minimal distinguishing paths
-        // First pass: collect all base prop names and group duplicates
-        const propNameGroups = new Map<
-          string,
-          Array<ComponentInfo & { _parentPath: string[] }>
-        >();
-        components.forEach((comp) => {
-          const compWithPath = comp as ComponentInfo & {
-            _parentPath: string[];
-          };
-          const baseName = comp.propName;
-          if (!propNameGroups.has(baseName)) {
-            propNameGroups.set(baseName, []);
-          }
-          propNameGroups.get(baseName)!.push(compWithPath);
-        });
-
-        // Second pass: for each group with duplicates, find minimal distinguishing paths
-        // and ensure all qualified names are unique
-        propNameGroups.forEach((group, _baseName) => {
-          if (group.length === 1) {
-            // No duplicates, keep the simple name
-            return;
-          }
-
-          // First, find minimal distinguishing paths for all components
-          group.forEach((comp) => {
-            const otherPaths = group
-              .filter((c) => c.id !== comp.id)
-              .map((c) => c._parentPath || []);
-
-            const minimalPath = findMinimalDistinguishingPath(
-              comp._parentPath || [],
-              otherPaths
-            );
-
-            // Use the minimal distinguishing path to qualify the name
-            comp.propName = generateQualifiedPropName(
-              comp.name || "item",
-              minimalPath
-            );
-          });
-
-          // Check if qualified names are still duplicates and expand paths if needed
-          let hasDuplicates = true;
-          let iteration = 0;
-          const maxIterations = 10; // Safety limit
-
-          while (hasDuplicates && iteration < maxIterations) {
-            iteration++;
-            const qualifiedNameGroups = new Map<
-              string,
-              Array<ComponentInfo & { _parentPath: string[] }>
-            >();
-            group.forEach((comp) => {
-              if (!qualifiedNameGroups.has(comp.propName)) {
-                qualifiedNameGroups.set(comp.propName, []);
-              }
-              qualifiedNameGroups.get(comp.propName)!.push(comp);
-            });
-
-            hasDuplicates = false;
-            // For each group of still-duplicated qualified names, expand their paths
-            qualifiedNameGroups.forEach((dupGroup, _qualifiedName) => {
-              if (dupGroup.length > 1) {
-                hasDuplicates = true;
-                // Expand the distinguishing path for each duplicate
-                dupGroup.forEach((comp) => {
-                  // Find a longer distinguishing path by comparing with others in the duplicate group
-                  const fullPath = comp._parentPath || [];
-                  const otherFullPaths = dupGroup
-                    .filter((c) => c.id !== comp.id)
-                    .map((c) => c._parentPath || []);
-
-                  // Find where this path diverges from others in the duplicate group
-                  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) => {
-                      return otherPath[i] === thisPart;
-                    });
-                    if (allMatch) {
-                      commonPrefixLength++;
-                    } else {
-                      break;
-                    }
-                  }
-
-                  // Use progressively more of the distinguishing suffix until unique
-                  const distinguishingSuffix =
-                    fullPath.slice(commonPrefixLength);
-
-                  // Try expanding the distinguishing suffix until we find a unique name
-                  let foundUnique = false;
-                  for (
-                    let suffixLength = 1;
-                    suffixLength <= distinguishingSuffix.length;
-                    suffixLength++
-                  ) {
-                    const expandedPath = distinguishingSuffix.slice(
-                      0,
-                      suffixLength
-                    );
-                    const testQualifiedName = generateQualifiedPropName(
-                      comp.name || "item",
-                      expandedPath
-                    );
-
-                    // Check if this qualified name is unique among ALL components (not just duplicates)
-                    const isUnique = components.every((otherComp) => {
-                      if (otherComp.id === comp.id) return true;
-                      // If other component is in the same duplicate group, compare expanded paths
-                      if (dupGroup.some((c) => c.id === otherComp.id)) {
-                        const otherFullPath =
-                          (
-                            otherComp as ComponentInfo & {
-                              _parentPath: string[];
-                            }
-                          )._parentPath || [];
-                        const otherCommonPrefixLength = Math.min(
-                          commonPrefixLength,
-                          otherFullPath.length
-                        );
-                        const otherDistinguishingSuffix = otherFullPath.slice(
-                          otherCommonPrefixLength
-                        );
-                        const otherExpandedPath =
-                          otherDistinguishingSuffix.slice(0, suffixLength);
-                        const otherQualifiedName = generateQualifiedPropName(
-                          otherComp.name || "item",
-                          otherExpandedPath
-                        );
-                        return testQualifiedName !== otherQualifiedName;
-                      }
-                      // For components outside the duplicate group, just check the final prop name
-                      return testQualifiedName !== otherComp.propName;
-                    });
-
-                    if (isUnique) {
-                      comp.propName = testQualifiedName;
-                      foundUnique = true;
-                      break;
-                    }
-                  }
-
-                  // If we couldn't find a unique name with the distinguishing suffix,
-                  // use the distinguishing suffix we found (it's the minimal we can do)
-                  // We'll handle truly identical paths with numeric suffixes in the final pass
-                  if (!foundUnique) {
-                    // Use the distinguishing suffix - it's the minimal distinguishing part
-                    // Even if it's not globally unique yet, it's better than the full path
-                    comp.propName = generateQualifiedPropName(
-                      comp.name || "item",
-                      distinguishingSuffix.length > 0
-                        ? distinguishingSuffix
-                        : []
-                    );
-                  }
-                });
-              }
-            });
-          }
-
-          // Final check: if there are still duplicates after using full paths,
-          // and they have identical paths, use numeric suffixes as last resort
-          const finalQualifiedNameGroups = new Map<
-            string,
-            Array<ComponentInfo & { _parentPath: string[] }>
-          >();
-          group.forEach((comp) => {
-            if (!finalQualifiedNameGroups.has(comp.propName)) {
-              finalQualifiedNameGroups.set(comp.propName, []);
-            }
-            finalQualifiedNameGroups.get(comp.propName)!.push(comp);
-          });
-
-          finalQualifiedNameGroups.forEach(
-            (finalDupGroup, finalQualifiedName) => {
-              if (finalDupGroup.length > 1) {
-                // Check if all duplicates have identical paths
-                const allPathsIdentical = finalDupGroup.every((comp) => {
-                  const thisPath = comp._parentPath || [];
-                  return finalDupGroup.every((otherComp) => {
-                    if (otherComp.id === comp.id) return true;
-                    const otherPath = otherComp._parentPath || [];
-                    return arraysEqual(thisPath, otherPath);
-                  });
-                });
-
-                // Only use numeric suffixes if paths are truly identical
-                if (allPathsIdentical) {
-                  let index = 0;
-                  finalDupGroup.forEach((comp) => {
-                    if (index > 0) {
-                      comp.propName = `${finalQualifiedName}${index + 1}`;
-                    }
-                    index++;
-                  });
-                }
-              }
-            }
-          );
-
-          // Remove the temporary _parentPath property
-          group.forEach((comp) => {
-            delete (comp as any)._parentPath;
-          });
-        });
+        // Qualify duplicate prop names using minimal distinguishing paths
+        qualifyPropNames(components);
 
         // If we have an image component, remove color components with similar names
         // (they're usually placeholders/backgrounds)
@@ -623,6 +425,15 @@ export function findSlidersAndDataBindings(pageData: any): SliderInfo[] {
   return sliders;
 }
 
+/**
+ * Finds standalone data-bound components (not in sliders)
+ *
+ * Locates components tagged with encore:data (but not encore:data:array)
+ * for standalone data binding at the page level.
+ *
+ * @param pageData - Page definition from Encore service
+ * @returns Array of component metadata
+ */
 export function findStandaloneComponents(pageData: any): ComponentInfo[] {
   const components: ComponentInfo[] = [];
   const sliderIds = new Set<string>();
@@ -722,209 +533,21 @@ export function findStandaloneComponents(pageData: any): ComponentInfo[] {
     body.forEach((node: any) => traverse(node));
   }
 
-  // Detect duplicates and qualify them with minimal distinguishing paths
-  // First pass: collect all base prop names and group duplicates
-  const propNameGroups = new Map<
-    string,
-    Array<ComponentInfo & { _parentPath: string[] }>
-  >();
-  components.forEach((comp) => {
-    const compWithPath = comp as ComponentInfo & { _parentPath: string[] };
-    const baseName = comp.propName;
-    if (!propNameGroups.has(baseName)) {
-      propNameGroups.set(baseName, []);
-    }
-    propNameGroups.get(baseName)!.push(compWithPath);
-  });
-
-  // Second pass: for each group with duplicates, find minimal distinguishing paths
-  // and ensure all qualified names are unique
-  propNameGroups.forEach((group, _baseName) => {
-    if (group.length === 1) {
-      // No duplicates, keep the simple name
-      return;
-    }
-
-    // First, find minimal distinguishing paths for all components
-    group.forEach((comp) => {
-      const otherPaths = group
-        .filter((c) => c.id !== comp.id)
-        .map((c) => c._parentPath || []);
-
-      const minimalPath = findMinimalDistinguishingPath(
-        comp._parentPath || [],
-        otherPaths
-      );
-
-      // Use the minimal distinguishing path to qualify the name
-      comp.propName = generateQualifiedPropName(
-        comp.name || "item",
-        minimalPath
-      );
-    });
-
-    // Check if qualified names are still duplicates and expand paths if needed
-    let hasDuplicates = true;
-    let iteration = 0;
-    const maxIterations = 10; // Safety limit
-
-    while (hasDuplicates && iteration < maxIterations) {
-      iteration++;
-      const qualifiedNameGroups = new Map<
-        string,
-        Array<ComponentInfo & { _parentPath: string[] }>
-      >();
-      group.forEach((comp) => {
-        if (!qualifiedNameGroups.has(comp.propName)) {
-          qualifiedNameGroups.set(comp.propName, []);
-        }
-        qualifiedNameGroups.get(comp.propName)!.push(comp);
-      });
-
-      hasDuplicates = false;
-      // For each group of still-duplicated qualified names, expand their paths
-      qualifiedNameGroups.forEach((dupGroup, _qualifiedName) => {
-        if (dupGroup.length > 1) {
-          hasDuplicates = true;
-          // Expand the distinguishing path for each duplicate
-          dupGroup.forEach((comp) => {
-            // Find a longer distinguishing path by comparing with others in the duplicate group
-            const fullPath = comp._parentPath || [];
-            const otherFullPaths = dupGroup
-              .filter((c) => c.id !== comp.id)
-              .map((c) => c._parentPath || []);
-
-            // Find where this path diverges from others in the duplicate group
-            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) => {
-                return otherPath[i] === thisPart;
-              });
-              if (allMatch) {
-                commonPrefixLength++;
-              } else {
-                break;
-              }
-            }
-
-            // Use progressively more of the distinguishing suffix until unique
-            const distinguishingSuffix = fullPath.slice(commonPrefixLength);
-
-            // Try expanding the distinguishing suffix until we find a unique name
-            let foundUnique = false;
-            for (
-              let suffixLength = 1;
-              suffixLength <= distinguishingSuffix.length;
-              suffixLength++
-            ) {
-              const expandedPath = distinguishingSuffix.slice(0, suffixLength);
-              const testQualifiedName = generateQualifiedPropName(
-                comp.name || "item",
-                expandedPath
-              );
-
-              // Check if this qualified name is unique among ALL components (not just duplicates)
-              const isUnique = components.every((otherComp) => {
-                if (otherComp.id === comp.id) return true;
-                // If other component is in the same duplicate group, compare expanded paths
-                if (dupGroup.some((c) => c.id === otherComp.id)) {
-                  const otherFullPath =
-                    (otherComp as ComponentInfo & { _parentPath: string[] })
-                      ._parentPath || [];
-                  const otherCommonPrefixLength = Math.min(
-                    commonPrefixLength,
-                    otherFullPath.length
-                  );
-                  const otherDistinguishingSuffix = otherFullPath.slice(
-                    otherCommonPrefixLength
-                  );
-                  const otherExpandedPath = otherDistinguishingSuffix.slice(
-                    0,
-                    suffixLength
-                  );
-                  const otherQualifiedName = generateQualifiedPropName(
-                    otherComp.name || "item",
-                    otherExpandedPath
-                  );
-                  return testQualifiedName !== otherQualifiedName;
-                }
-                // For components outside the duplicate group, just check the final prop name
-                return testQualifiedName !== otherComp.propName;
-              });
-
-              if (isUnique) {
-                comp.propName = testQualifiedName;
-                foundUnique = true;
-                break;
-              }
-            }
-
-            // If we couldn't find a unique name with the distinguishing suffix,
-            // use the full path to ensure uniqueness (even if it makes names longer)
-            if (!foundUnique) {
-              comp.propName = generateQualifiedPropName(
-                comp.name || "item",
-                fullPath
-              );
-            }
-          });
-        }
-      });
-    }
-
-    // Final check: if there are still duplicates after using full paths,
-    // and they have identical paths, use numeric suffixes as last resort
-    const finalQualifiedNameGroups = new Map<
-      string,
-      Array<ComponentInfo & { _parentPath: string[] }>
-    >();
-    group.forEach((comp) => {
-      if (!finalQualifiedNameGroups.has(comp.propName)) {
-        finalQualifiedNameGroups.set(comp.propName, []);
-      }
-      finalQualifiedNameGroups.get(comp.propName)!.push(comp);
-    });
-
-    finalQualifiedNameGroups.forEach((finalDupGroup, finalQualifiedName) => {
-      if (finalDupGroup.length > 1) {
-        // Check if all duplicates have identical paths
-        const allPathsIdentical = finalDupGroup.every((comp) => {
-          const thisPath = comp._parentPath || [];
-          return finalDupGroup.every((otherComp) => {
-            if (otherComp.id === comp.id) return true;
-            const otherPath = otherComp._parentPath || [];
-            return arraysEqual(thisPath, otherPath);
-          });
-        });
-
-        // Only use numeric suffixes if paths are truly identical
-        if (allPathsIdentical) {
-          let index = 0;
-          finalDupGroup.forEach((comp) => {
-            if (index > 0) {
-              comp.propName = `${finalQualifiedName}${index + 1}`;
-            }
-            index++;
-          });
-        }
-      }
-    });
-
-    // Remove the temporary _parentPath property
-    group.forEach((comp) => {
-      delete (comp as any)._parentPath;
-    });
-  });
+  // Qualify duplicate prop names using minimal distinguishing paths
+  qualifyPropNames(components);
 
   return components;
 }
 
+/**
+ * Finds input groups (radio button-like components) in the page
+ *
+ * Locates stateful sets tagged with encore:input-group for coordinated
+ * selection behavior.
+ *
+ * @param pageData - Page definition from Encore service
+ * @returns Array of input group metadata
+ */
 export function findInputGroups(pageData: any): InputGroupInfo[] {
   const groupsMap = new Map<string, InputGroupInfo>();
 
@@ -985,6 +608,15 @@ export function findInputGroups(pageData: any): InputGroupInfo[] {
   return Array.from(groupsMap.values());
 }
 
+/**
+ * Finds forms and their input fields in the page
+ *
+ * Locates containers tagged with encore:form and extracts all input
+ * components within them for form submission handling.
+ *
+ * @param pageData - Page definition from Encore service
+ * @returns Array of form metadata with input fields
+ */
 export function findForms(pageData: any): FormInfo[] {
   const forms: FormInfo[] = [];
 
@@ -1215,48 +847,7 @@ export function findStandaloneSelectInputs(
  * Qualifies select input prop names to ensure uniqueness.
  */
 function qualifySelectInputs(selectInputs: SelectInputInfo[]): void {
-  const propNameGroups = new Map<
-    string,
-    Array<SelectInputInfo & { _parentPath: string[] }>
-  >();
-
-  selectInputs.forEach((input) => {
-    const inputWithPath = input as SelectInputInfo & { _parentPath: string[] };
-    const baseName = input.propName;
-    if (!propNameGroups.has(baseName)) {
-      propNameGroups.set(baseName, []);
-    }
-    propNameGroups.get(baseName)!.push(inputWithPath);
-  });
-
-  propNameGroups.forEach((group, _baseName) => {
-    if (group.length === 1) {
-      delete (group[0] as any)._parentPath;
-      return;
-    }
-
-    // Find minimal distinguishing paths for duplicates
-    group.forEach((input) => {
-      const otherPaths = group
-        .filter((i) => i.id !== input.id)
-        .map((i) => i._parentPath || []);
-
-      const minimalPath = findMinimalDistinguishingPath(
-        input._parentPath || [],
-        otherPaths
-      );
-
-      input.propName = generateQualifiedPropName(
-        input.name || "input",
-        minimalPath
-      );
-    });
-
-    // Clean up
-    group.forEach((input) => {
-      delete (input as any)._parentPath;
-    });
-  });
+  qualifyPropNames(selectInputs);
 }
 
 /**
@@ -1349,50 +940,7 @@ export function findActionButtons(pageData: any): ActionButtonInfo[] {
  * Qualifies action button prop names to ensure uniqueness.
  */
 function qualifyActionButtons(buttons: ActionButtonInfo[]): void {
-  const propNameGroups = new Map<
-    string,
-    Array<ActionButtonInfo & { _parentPath: string[] }>
-  >();
-
-  buttons.forEach((button) => {
-    const buttonWithPath = button as ActionButtonInfo & {
-      _parentPath: string[];
-    };
-    const baseName = button.propName;
-    if (!propNameGroups.has(baseName)) {
-      propNameGroups.set(baseName, []);
-    }
-    propNameGroups.get(baseName)!.push(buttonWithPath);
-  });
-
-  propNameGroups.forEach((group, _baseName) => {
-    if (group.length === 1) {
-      delete (group[0] as any)._parentPath;
-      return;
-    }
-
-    // Find minimal distinguishing paths for duplicates
-    group.forEach((button) => {
-      const otherPaths = group
-        .filter((b) => b.id !== button.id)
-        .map((b) => b._parentPath || []);
-
-      const minimalPath = findMinimalDistinguishingPath(
-        button._parentPath || [],
-        otherPaths
-      );
-
-      button.propName = generateQualifiedPropName(
-        button.name || "button",
-        minimalPath
-      );
-    });
-
-    // Clean up
-    group.forEach((button) => {
-      delete (button as any)._parentPath;
-    });
-  });
+  qualifyPropNames(buttons);
 }
 
 /**
@@ -1401,214 +949,6 @@ function qualifyActionButtons(buttons: ActionButtonInfo[]): void {
  */
 export function qualifyFormInputs(forms: FormInfo[]): void {
   forms.forEach((form) => {
-    const inputs = form.inputs;
-
-    // Group inputs by base prop name
-    const propNameGroups = new Map<
-      string,
-      Array<FormInfo["inputs"][0] & { _parentPath: string[] }>
-    >();
-
-    inputs.forEach((input) => {
-      const inputWithPath = input as FormInfo["inputs"][0] & {
-        _parentPath: string[];
-      };
-      const baseName = input.propName;
-      if (!propNameGroups.has(baseName)) {
-        propNameGroups.set(baseName, []);
-      }
-      propNameGroups.get(baseName)!.push(inputWithPath);
-    });
-
-    // For each group with duplicates, find minimal distinguishing paths
-    propNameGroups.forEach((group, _baseName) => {
-      if (group.length === 1) {
-        // No duplicates, keep the simple name
-        // Remove the temporary _parentPath property
-        delete (group[0] as any)._parentPath;
-        return;
-      }
-
-      // Find minimal distinguishing paths for all inputs
-      group.forEach((input) => {
-        const otherPaths = group
-          .filter((i) => i.id !== input.id)
-          .map((i) => i._parentPath || []);
-
-        const minimalPath = findMinimalDistinguishingPath(
-          input._parentPath || [],
-          otherPaths
-        );
-
-        // Use the minimal distinguishing path to qualify the name
-        input.propName = generateQualifiedPropName(
-          input.name || "input",
-          minimalPath
-        );
-      });
-
-      // Check if qualified names are still duplicates and expand paths if needed
-      let hasDuplicates = true;
-      let iteration = 0;
-      const maxIterations = 10; // Safety limit
-
-      while (hasDuplicates && iteration < maxIterations) {
-        iteration++;
-        const qualifiedNameGroups = new Map<
-          string,
-          Array<FormInfo["inputs"][0] & { _parentPath: string[] }>
-        >();
-        group.forEach((input) => {
-          if (!qualifiedNameGroups.has(input.propName)) {
-            qualifiedNameGroups.set(input.propName, []);
-          }
-          qualifiedNameGroups.get(input.propName)!.push(input);
-        });
-
-        hasDuplicates = false;
-        // For each group of still-duplicated qualified names, expand their paths
-        qualifiedNameGroups.forEach((dupGroup, _qualifiedName) => {
-          if (dupGroup.length > 1) {
-            hasDuplicates = true;
-            // Expand the distinguishing path for each duplicate
-            dupGroup.forEach((input) => {
-              const fullPath = input._parentPath || [];
-              const otherFullPaths = dupGroup
-                .filter((i) => i.id !== input.id)
-                .map((i) => i._parentPath || []);
-
-              // Find where this path diverges from others in the duplicate group
-              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) => {
-                  return otherPath[i] === thisPart;
-                });
-                if (allMatch) {
-                  commonPrefixLength++;
-                } else {
-                  break;
-                }
-              }
-
-              // Use progressively more of the distinguishing suffix until unique
-              const distinguishingSuffix = fullPath.slice(commonPrefixLength);
-
-              // Try expanding the distinguishing suffix until we find a unique name
-              let foundUnique = false;
-              for (
-                let suffixLength = 1;
-                suffixLength <= distinguishingSuffix.length;
-                suffixLength++
-              ) {
-                const expandedPath = distinguishingSuffix.slice(
-                  0,
-                  suffixLength
-                );
-                const testQualifiedName = generateQualifiedPropName(
-                  input.name || "input",
-                  expandedPath
-                );
-
-                // Check if this qualified name is unique among ALL inputs in this form
-                const isUnique = inputs.every((otherInput) => {
-                  if (otherInput.id === input.id) return true;
-                  // If other input is in the same duplicate group, compare expanded paths
-                  if (dupGroup.some((i) => i.id === otherInput.id)) {
-                    const otherFullPath =
-                      (
-                        otherInput as FormInfo["inputs"][0] & {
-                          _parentPath: string[];
-                        }
-                      )._parentPath || [];
-                    const otherCommonPrefixLength = Math.min(
-                      commonPrefixLength,
-                      otherFullPath.length
-                    );
-                    const otherDistinguishingSuffix = otherFullPath.slice(
-                      otherCommonPrefixLength
-                    );
-                    const otherExpandedPath = otherDistinguishingSuffix.slice(
-                      0,
-                      suffixLength
-                    );
-                    const otherQualifiedName = generateQualifiedPropName(
-                      otherInput.name || "input",
-                      otherExpandedPath
-                    );
-                    return testQualifiedName !== otherQualifiedName;
-                  }
-                  // For inputs outside the duplicate group, just check the final prop name
-                  return testQualifiedName !== otherInput.propName;
-                });
-
-                if (isUnique) {
-                  input.propName = testQualifiedName;
-                  foundUnique = true;
-                  break;
-                }
-              }
-
-              // If we couldn't find a unique name with the distinguishing suffix,
-              // use the distinguishing suffix we found (it's the minimal we can do)
-              if (!foundUnique) {
-                input.propName = generateQualifiedPropName(
-                  input.name || "input",
-                  distinguishingSuffix.length > 0 ? distinguishingSuffix : []
-                );
-              }
-            });
-          }
-        });
-      }
-
-      // Final check: if there are still duplicates after using full paths,
-      // and they have identical paths, use numeric suffixes as last resort
-      const finalQualifiedNameGroups = new Map<
-        string,
-        Array<FormInfo["inputs"][0] & { _parentPath: string[] }>
-      >();
-      group.forEach((input) => {
-        if (!finalQualifiedNameGroups.has(input.propName)) {
-          finalQualifiedNameGroups.set(input.propName, []);
-        }
-        finalQualifiedNameGroups.get(input.propName)!.push(input);
-      });
-
-      finalQualifiedNameGroups.forEach((finalDupGroup, finalQualifiedName) => {
-        if (finalDupGroup.length > 1) {
-          // Check if all duplicates have identical paths
-          const allPathsIdentical = finalDupGroup.every((input) => {
-            const thisPath = input._parentPath || [];
-            return finalDupGroup.every((otherInput) => {
-              if (otherInput.id === input.id) return true;
-              const otherPath = otherInput._parentPath || [];
-              return arraysEqual(thisPath, otherPath);
-            });
-          });
-
-          // Only use numeric suffixes if paths are truly identical
-          if (allPathsIdentical) {
-            let index = 0;
-            finalDupGroup.forEach((input) => {
-              if (index > 0) {
-                input.propName = `${finalQualifiedName}${index + 1}`;
-              }
-              index++;
-            });
-          }
-        }
-      });
-
-      // Remove the temporary _parentPath property
-      group.forEach((input) => {
-        delete (input as any)._parentPath;
-      });
-    });
+    qualifyPropNames(form.inputs);
   });
 }