@wix/zero-config-implementation 1.10.0 → 1.11.0

package/dist/index.js

@@ -40527,9 +40527,13 @@ function PL(e, t, r) {
   const n = t.types.filter((A) => A.value !== "undefined" && A.value !== "null");
   if (n.length === 0)
     return e.dataType = $e.text, e.text = {}, mt(void 0);
-  if (n.length <= 2 && n.every((A) => A.kind === "literal" && (A.value === !0 || A.value === !1)))
+  if (n.length <= 2 && n.every(
+    (A) => A.kind === "literal" && (A.value === !0 || A.value === !1)
+  ))
     return e.dataType = $e.booleanValue, mt(void 0);
-  if (n.every((A) => A.kind === "literal" && typeof A.value == "string"))
+  if (n.every(
+    (A) => A.kind === "literal" && typeof A.value == "string"
+  ))
     return e.dataType = $e.textEnum, e.textEnum = {
       options: n.map((A) => ({
         value: String(A.value || ""),

package/package.json

@@ -4,7 +4,7 @@
     "registry": "https://registry.npmjs.org/",
     "access": "public"
   },
-  "version": "1.10.0",
+  "version": "1.11.0",
   "description": "Core library for extracting component manifests from JS and CSS files",
   "type": "module",
   "main": "dist/index.js",
@@ -74,5 +74,5 @@
       ]
     }
   },
-  "falconPackageHash": "21d3bc497b17268af6551d502a02de709d17f09eaa98040d2017ae4b"
+  "falconPackageHash": "72ed033142da89f1b47261236ac0406e5d01201b896daec0491a39ff"
 }

package/src/converters/data-item-builder.ts

@@ -148,13 +148,15 @@ function handlePrimitiveType(
   const typeValue = (resolvedType.value as string | undefined)?.toLowerCase() || propInfo.type.toLowerCase()
 
   if (typeValue.includes('string')) {
-    if (bindings?.some((b) => b.attribute === 'dir')) {
+    if (bindings?.some((binding) => binding.attribute === 'dir')) {
       dataItem.dataType = DATA_TYPE.direction
-    } else if (bindings?.some((b) => b.attribute === 'href' && b.element === 'a' && !b.concatenated)) {
+    } else if (
+      bindings?.some((binding) => binding.attribute === 'href' && binding.element === 'a' && !binding.concatenated)
+    ) {
       dataItem.dataType = DATA_TYPE.webUrl
-    } else if (bindings?.some((b) => b.attribute === 'id')) {
+    } else if (bindings?.some((binding) => binding.attribute === 'id')) {
       dataItem.dataType = DATA_TYPE.guid
-    } else if (bindings?.some((b) => b.attribute === 'pattern')) {
+    } else if (bindings?.some((binding) => binding.attribute === 'pattern')) {
       dataItem.dataType = DATA_TYPE.regex
     } else {
       dataItem.dataType = DATA_TYPE.text
@@ -299,21 +301,26 @@ function handleUnionType(
 
   // Check if it's a boolean type (union of true | false literals)
   const isBooleanLiteralUnion =
-    validTypes.length <= 2 && validTypes.every((t) => t.kind === 'literal' && (t.value === true || t.value === false))
+    validTypes.length <= 2 &&
+    validTypes.every(
+      (validType) => validType.kind === 'literal' && (validType.value === true || validType.value === false),
+    )
   if (isBooleanLiteralUnion) {
     dataItem.dataType = DATA_TYPE.booleanValue
     return ok(undefined)
   }
 
   // Check if it's a union of string literals (enum-like)
-  const allStringLiterals = validTypes.every((t) => t.kind === 'literal' && typeof t.value === 'string')
+  const allStringLiterals = validTypes.every(
+    (validType) => validType.kind === 'literal' && typeof validType.value === 'string',
+  )
   if (allStringLiterals) {
     dataItem.dataType = DATA_TYPE.textEnum
     dataItem.textEnum = {
       options: validTypes
-        .map((t) => ({
-          value: String(t.value || ''),
-          displayName: formatDisplayName(String(t.value || '')),
+        .map((validType) => ({
+          value: String(validType.value || ''),
+          displayName: formatDisplayName(String(validType.value || '')),
         }))
         .filter((opt) => opt.value),
     }

package/src/converters/to-editor-component.ts

@@ -78,17 +78,17 @@ function buildElements(
 ): Record<string, ElementItem> {
   const result: Record<string, ElementItem> = {}
 
-  for (const el of elements) {
-    const elementData = innerElementProps?.get(el.traceId)
+  for (const element of elements) {
+    const elementData = innerElementProps?.get(element.traceId)
     const data = elementData && propUsages ? buildData(elementData, propUsages) : undefined
-    const cssProps = buildCssProperties(el)
-    const cssCustomProps = buildCssCustomPropertiesForElement(el)
+    const cssProps = buildCssProperties(element)
+    const cssCustomProps = buildCssCustomPropertiesForElement(element)
 
-    result[el.name] = {
+    result[element.name] = {
       elementType: ELEMENTS.ELEMENT_TYPE.inlineElement,
       inlineElement: {
-        selector: buildSelector(el),
-        displayName: formatDisplayName(el.name),
+        selector: buildSelector(element),
+        displayName: formatDisplayName(element.name),
         // Add data from inner element props if available
         ...(data && Object.keys(data).length > 0 && { data }),
         // CSS properties from heuristic + matched CSS files
@@ -96,7 +96,8 @@ function buildElements(
         // CSS custom properties from matched rules for this element
         ...(Object.keys(cssCustomProps).length > 0 && { cssCustomProperties: cssCustomProps }),
         // Recursively build nested elements
-        elements: el.children.length > 0 ? buildElements(el.children, innerElementProps, propUsages) : undefined,
+        elements:
+          element.children.length > 0 ? buildElements(element.children, innerElementProps, propUsages) : undefined,
       },
     }
   }

package/src/information-extractors/css/parse.ts

@@ -140,10 +140,10 @@ function parseAllProperties(cssString: string): Map<string, CSSProperty[]> {
 
               for (const keyframe of rule.value.keyframes) {
                 // Each keyframe has selectors like 'from', 'to', '50%'
-                const keyframeSelectors = keyframe.selectors.map((s) => {
-                  if (typeof s === 'string') return s
-                  if ('percentage' in s) return `${s.percentage}%`
-                  return String(s)
+                const keyframeSelectors = keyframe.selectors.map((selector) => {
+                  if (typeof selector === 'string') return selector
+                  if ('percentage' in selector) return `${selector.percentage}%`
+                  return String(selector)
                 })
 
                 const properties: CSSProperty[] = []

package/src/information-extractors/css/selector-matcher.ts

@@ -73,16 +73,16 @@ function enrichElements(
   matchesByTraceId: Map<string, CssSelectorMatch[]>,
   customPropsByTraceId: Map<string, Record<string, string>>,
 ): ExtractedElement[] {
-  return elements.map((el) => {
+  return elements.map((element) => {
     const data: MatchedCssData = {
-      matches: matchesByTraceId.get(el.traceId) ?? [],
-      customProperties: customPropsByTraceId.get(el.traceId) ?? {},
+      matches: matchesByTraceId.get(element.traceId) ?? [],
+      customProperties: customPropsByTraceId.get(element.traceId) ?? {},
     }
-    el.extractorData.set('css-matcher', data)
+    element.extractorData.set('css-matcher', data)
 
     return {
-      ...el,
-      children: enrichElements(el.children, matchesByTraceId, customPropsByTraceId),
+      ...element,
+      children: enrichElements(element.children, matchesByTraceId, customPropsByTraceId),
     }
   })
 }

package/src/information-extractors/ts/components.ts

@@ -10,7 +10,7 @@ import { resolveType } from './utils/semantic-type-resolver'
 const sharedPropFilter = (prop: PropItem) => {
   // Exclude props inherited from node_modules (e.g. HTMLAttributes)
   if (prop.declarations && prop.declarations.length > 0) {
-    return !prop.declarations.every((d) => d.fileName.includes('node_modules'))
+    return !prop.declarations.every((declaration) => declaration.fileName.includes('node_modules'))
   }
   return true
 }
@@ -69,7 +69,7 @@ function findDefaultExportName(program: ts.Program, filePath: string): string |
   const moduleSymbol = checker.getSymbolAtLocation(sourceFile)
   if (!moduleSymbol) return undefined
 
-  const defaultSymbol = checker.getExportsOfModule(moduleSymbol).find((s) => s.getName() === 'default')
+  const defaultSymbol = checker.getExportsOfModule(moduleSymbol).find((symbol) => symbol.getName() === 'default')
   if (!defaultSymbol) return undefined
 
   // For `export default Foo` the symbol is an alias — resolve it to get 'Foo'
@@ -158,11 +158,11 @@ function findPropsType(
   if (!moduleSymbol) return undefined
 
   const exports = checker.getExportsOfModule(moduleSymbol)
-  let componentSymbol = exports.find((s) => s.getName() === componentName)
+  let componentSymbol = exports.find((symbol) => symbol.getName() === componentName)
 
   // If not found by name, check whether the default export resolves to the component
   if (!componentSymbol) {
-    const defaultSymbol = exports.find((s) => s.getName() === 'default')
+    const defaultSymbol = exports.find((symbol) => symbol.getName() === 'default')
     if (defaultSymbol && (defaultSymbol.getFlags() & ts.SymbolFlags.Alias) !== 0) {
       const resolved = checker.getAliasedSymbol(defaultSymbol)
       if (resolved.getName() === componentName) {

package/src/manifest-pipeline.ts

@@ -292,21 +292,21 @@ function extractBindings(
 }
 
 function convertElements(elements: ExtractedElement[]): CoupledComponentInfo['elements'] {
-  return elements.map((el) => {
+  return elements.map((element) => {
     // Get prop-tracker data for boundProps
-    const propTrackerData = el.extractorData.get('prop-tracker') as PropTrackerData | undefined
+    const propTrackerData = element.extractorData.get('prop-tracker') as PropTrackerData | undefined
 
     return {
-      traceId: el.traceId,
-      name: el.name,
-      tag: el.tag,
-      attributes: el.attributes,
-      extractorData: el.extractorData,
-      children: convertElements(el.children),
+      traceId: element.traceId,
+      name: element.name,
+      tag: element.tag,
+      attributes: element.attributes,
+      extractorData: element.extractorData,
+      children: convertElements(element.children),
       // Legacy fields
       boundProps: propTrackerData?.boundProps ?? [],
       role: propTrackerData?.role,
-      hasTextContent: el.hasTextContent,
+      hasTextContent: element.hasTextContent,
     }
   })
 }