@wix/zero-config-implementation 1.101.0 → 1.102.0

package/dist/index.js

@@ -82737,10 +82737,10 @@ ${n}`, {
     props: { phase: "conversion" }
   });
 }
-function xL(t, e) {
+function xL(t, e, r = /* @__PURE__ */ new Set()) {
   return [
     ...Ame(t.cssCustomProperties, e),
-    ...Eme(t.elements, e)
+    ...Eme(t.elements, e, r)
   ];
 }
 function Ame(t, e) {
@@ -82752,14 +82752,19 @@ function Ame(t, e) {
   }
   return r;
 }
-function Eme(t, e) {
+function Eme(t, e, r = /* @__PURE__ */ new Set()) {
   if (!t) return [];
-  const r = [];
-  for (const [n, i] of Object.entries(t)) {
-    const s = `${e}.elements.${n}`, a = gy.ELEMENT_TYPE.UNKNOWN_ElementType;
-    (!i.elementType || i.elementType === a) && r.push(`${s}: elementType is not set or UNKNOWN`), i.inlineElement && r.push(...xL(i.inlineElement, `${s}.inlineElement`));
+  const n = [];
+  for (const [i, s] of Object.entries(t)) {
+    const a = `${e}.elements.${i}`, o = gy.ELEMENT_TYPE.UNKNOWN_ElementType;
+    if ((!s.elementType || s.elementType === o) && n.push(`${a}: elementType is not set or UNKNOWN`), r.has(i) && n.push(`${a}: part name "${i}" is already used by an ancestor element`), s.inlineElement) {
+      const u = new Set(r);
+      u.add(i), n.push(
+        ...xL(s.inlineElement, `${a}.inlineElement`, u)
+      );
+    }
   }
-  return r;
+  return n;
 }
 const Fme = Ire;
 function Sme(t, e, r) {

package/package.json

@@ -4,7 +4,7 @@
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
-  "version": "1.101.0",
+  "version": "1.102.0",
   "description": "Core library for extracting component manifests from JS and CSS files",
   "type": "module",
   "main": "dist/index.js",
@@ -106,5 +106,5 @@
       ]
     }
   },
-  "falconPackageHash": "7aa5841bf5ff6a0fa0800fc3d71a267d6e96dbe084125f5fd56fc333"
+  "falconPackageHash": "96d9e739c8567fd3813b698d6e9d84d175e3def2393dbaec37e6a9e7"
 }

package/src/validators/editor-element-validator.test.ts

@@ -139,4 +139,95 @@ describe('validateEditorElement', () => {
     })
     expect(() => validateEditorElement(editorElement, 'MyButton')).toThrow('MyButton')
   })
+
+  it('throws ValidationError when a part name is reused on a direct child element', () => {
+    const editorElement = buildMinimalEditorElement({
+      elements: {
+        element1: buildInlineElementItem({
+          inlineElement: {
+            selector: '.element1',
+            displayName: 'Element1',
+            elements: {
+              element1: buildInlineElementItem(),
+            },
+          },
+        }),
+      },
+    })
+    expect(() => validateEditorElement(editorElement, 'TestComponent')).toThrow(
+      'editorElement.elements.element1.inlineElement.elements.element1: part name "element1" is already used by an ancestor element',
+    )
+  })
+
+  it('throws ValidationError when a part name is reused on a grandchild, not just a direct child', () => {
+    const editorElement = buildMinimalEditorElement({
+      elements: {
+        outer: buildInlineElementItem({
+          inlineElement: {
+            selector: '.outer',
+            displayName: 'Outer',
+            elements: {
+              middle: buildInlineElementItem({
+                inlineElement: {
+                  selector: '.middle',
+                  displayName: 'Middle',
+                  elements: {
+                    outer: buildInlineElementItem(),
+                  },
+                },
+              }),
+            },
+          },
+        }),
+      },
+    })
+    expect(() => validateEditorElement(editorElement, 'TestComponent')).toThrow(
+      'editorElement.elements.outer.inlineElement.elements.middle.inlineElement.elements.outer: part name "outer" is already used by an ancestor element',
+    )
+  })
+
+  it('does not throw when the same part name is reused across unrelated sibling subtrees', () => {
+    const editorElement = buildMinimalEditorElement({
+      elements: {
+        left: buildInlineElementItem({
+          inlineElement: {
+            selector: '.left',
+            displayName: 'Left',
+            elements: { shared: buildInlineElementItem() },
+          },
+        }),
+        right: buildInlineElementItem({
+          inlineElement: {
+            selector: '.right',
+            displayName: 'Right',
+            elements: { shared: buildInlineElementItem() },
+          },
+        }),
+      },
+    })
+    expect(() => validateEditorElement(editorElement, 'TestComponent')).not.toThrow()
+  })
+
+  it('does not throw for a deeply nested tree with all-unique part names', () => {
+    const editorElement = buildMinimalEditorElement({
+      elements: {
+        outer: buildInlineElementItem({
+          inlineElement: {
+            selector: '.outer',
+            displayName: 'Outer',
+            elements: {
+              middle: buildInlineElementItem({
+                inlineElement: {
+                  selector: '.middle',
+                  displayName: 'Middle',
+                  elements: { inner: buildInlineElementItem() },
+                },
+              }),
+            },
+          },
+        }),
+      },
+    })
+    expect(() => validateEditorElement(editorElement, 'TestComponent')).not.toThrow()
+  })
 })

package/src/validators/editor-element-validator.ts

@@ -21,10 +21,14 @@ export function validateEditorElement(editorElement: RawEditorElement, component
   })
 }
 
-function collectElementViolations(element: AnyElement, elementPath: string): string[] {
+function collectElementViolations(
+  element: AnyElement,
+  elementPath: string,
+  ancestorNames: ReadonlySet<string> = new Set(),
+): string[] {
   return [
     ...validateCssCustomProperties(element.cssCustomProperties, elementPath),
-    ...validateElementsMap(element.elements, elementPath),
+    ...validateElementsMap(element.elements, elementPath, ancestorNames),
   ]
 }
 
@@ -44,7 +48,11 @@ function validateCssCustomProperties(
   return violations
 }
 
-function validateElementsMap(elements: Record<string, ElementItem> | undefined, elementPath: string): string[] {
+function validateElementsMap(
+  elements: Record<string, ElementItem> | undefined,
+  elementPath: string,
+  ancestorNames: ReadonlySet<string> = new Set(),
+): string[] {
   if (!elements) return []
 
   const violations: string[] = []
@@ -56,8 +64,16 @@ function validateElementsMap(elements: Record<string, ElementItem> | undefined,
       violations.push(`${itemPath}: elementType is not set or UNKNOWN`)
     }
 
+    if (ancestorNames.has(elementKey)) {
+      violations.push(`${itemPath}: part name "${elementKey}" is already used by an ancestor element`)
+    }
+
     if (elementItem.inlineElement) {
-      violations.push(...collectElementViolations(elementItem.inlineElement, `${itemPath}.inlineElement`))
+      const descendantAncestorNames = new Set(ancestorNames)
+      descendantAncestorNames.add(elementKey)
+      violations.push(
+        ...collectElementViolations(elementItem.inlineElement, `${itemPath}.inlineElement`, descendantAncestorNames),
+      )
     }
   }
   return violations