@deneb-ui/cli 2.0.51 → 2.0.52

package/src/arc/residual.cjs

@@ -0,0 +1,400 @@
+'use strict';
+
+/**
+ * Pass B of the ARC planner: residual bind-or-static closure.
+ *
+ * Confidence cannot rescue dynamic leftovers (c_sem = 0.15). After Pass A,
+ * every remaining visible literal is either bound to a field or marked
+ * data-preview-static with a reason. This pass ignores the 0.60 skip floor.
+ */
+
+const recast = require('recast');
+const {
+  parseSource,
+  printSource,
+  getJsxName,
+  hasJsxAttribute,
+  findJsxAttribute,
+  collectJsxText,
+  wrapTextInEditableSpan,
+  jsxPreviewAttr,
+  jsxStaticAttr,
+  ensureStyleAttrs,
+  siteDataBinding,
+  b,
+} = require('./ast.cjs');
+const {
+  SKIP_TAGS,
+  HEADING_TAGS,
+  TEXT_TAGS,
+  ACTION_TAGS,
+  IMAGE_TAGS,
+  DECORATIVE_TAGS,
+  isIconComponent,
+} = require('./adapters.cjs');
+const { BROAD_CONTENT_CONTAINERS } = require('./fivora-contract.cjs');
+const { inferSection, inferFieldName, buildFieldPath, classifyFieldType } = require('./field-paths.cjs');
+const { isStaticSkipText } = require('./semantic.cjs');
+
+const LEAF_TEXT_TAGS = new Set([
+  ...HEADING_TAGS,
+  ...TEXT_TAGS,
+  'em', 'strong', 'small', 'b', 'i', 'u', 'code', 'time', 'cite', 'mark',
+  'dt', 'dd', 'th', 'td', 'legend', 'caption',
+]);
+
+const CHROME_TEXT_RE = /^(×|x|✕|✖|\+|−|-|•|·|…|\.|…|\||\/|©|®|™|\d+)$/i;
+const CART_CHROME_RE = /^(qty|quantity|subtotal|total|cart|checkout|remove|close|menu)$/i;
+
+function attrLiteral(node, name) {
+  const attr = findJsxAttribute(node, name);
+  if (!attr || !attr.value) return '';
+  if (attr.value.type === 'StringLiteral' || attr.value.type === 'Literal') return String(attr.value.value || '');
+  if (attr.value.type === 'JSXExpressionContainer') {
+    const expr = attr.value.expression;
+    if (expr && (expr.type === 'StringLiteral' || expr.type === 'Literal')) return String(expr.value || '');
+  }
+  return '';
+}
+
+function hasEditableMarker(node) {
+  return (
+    hasJsxAttribute(node, 'data-preview-field-path') ||
+    hasJsxAttribute(node, 'data-preview-list-path') ||
+    hasJsxAttribute(node, 'data-preview-item-path') ||
+    hasJsxAttribute(node, 'data-preview-static')
+  );
+}
+
+function ancestorHasStatic(pathNode) {
+  let current = pathNode.parent;
+  while (current) {
+    const node = current.node || current.value;
+    if (node && node.type === 'JSXElement' && hasJsxAttribute(node, 'data-preview-static')) return true;
+    current = current.parentPath || current.parent;
+  }
+  return false;
+}
+
+function inMapCallback(pathNode) {
+  let current = pathNode.parent;
+  while (current) {
+    const node = current.node || current.value;
+    if (
+      node &&
+      node.type === 'CallExpression' &&
+      node.callee &&
+      node.callee.type === 'MemberExpression' &&
+      node.callee.property &&
+      node.callee.property.name === 'map'
+    ) {
+      return true;
+    }
+    current = current.parentPath || current.parent;
+  }
+  return false;
+}
+
+function isMeaningfulVisibleText(text) {
+  const value = String(text || '').replace(/\s+/g, ' ').trim();
+  if (!value || value.length <= 2) return false;
+  if (!/\p{L}/u.test(value)) return false;
+  if (isStaticSkipText(value)) return false;
+  if (CHROME_TEXT_RE.test(value)) return false;
+  return true;
+}
+
+function isDecorativeCopy(text, tag, className) {
+  const value = String(text || '').replace(/\s+/g, ' ').trim();
+  if (!value) return true;
+  if (CHROME_TEXT_RE.test(value)) return true;
+  if (CART_CHROME_RE.test(value) && /cart|drawer|qty|quantity/i.test(className || '')) return true;
+  if (DECORATIVE_TAGS.has(tag) || tag === 'svg') return true;
+  if (/\bsr-only\b|\bhidden\b/.test(className || '')) return true;
+  return false;
+}
+
+function classifyResidual(node, text, tag) {
+  const className = attrLiteral(node, 'className') || attrLiteral(node, 'class');
+  const ariaHidden = attrLiteral(node, 'aria-hidden') === 'true' || hasJsxAttribute(node, 'hidden') || /(^|\s)hidden(\s|$)/.test(className);
+  if (ariaHidden || DECORATIVE_TAGS.has(tag) || isIconComponent(tag, '')) {
+    return { bind: false, reason: 'decorative-icon' };
+  }
+  if (isDecorativeCopy(text, tag, className)) {
+    return { bind: false, reason: 'chrome' };
+  }
+  if (IMAGE_TAGS.has(tag) && attrLiteral(node, 'src')) {
+    return { bind: true, kind: 'image', value: attrLiteral(node, 'src') };
+  }
+  if (isMeaningfulVisibleText(text)) {
+    return { bind: true, kind: 'text', value: text };
+  }
+  if (text && text.trim()) {
+    return { bind: false, reason: 'decorative-copy' };
+  }
+  return null;
+}
+
+function ensureStaticOnLeaf(node, reason) {
+  const tag = getJsxName(node);
+  if (BROAD_CONTENT_CONTAINERS.has(tag.toLowerCase()) || BROAD_CONTENT_CONTAINERS.has(tag)) {
+    return false;
+  }
+  if (hasJsxAttribute(node, 'data-preview-static') || hasEditableMarker(node)) return false;
+  node.openingElement.attributes.push(jsxStaticAttr(reason || 'decorative'));
+  return true;
+}
+
+function wrapFirstLiteralAsStatic(node, reason) {
+  const nextChildren = [];
+  let wrapped = false;
+  for (const child of node.children || []) {
+    if (!wrapped && child.type === 'JSXText' && child.value.replace(/\s+/g, '').length) {
+      const leading = child.value.match(/^\s*/)?.[0] || '';
+      const trailing = child.value.match(/\s*$/)?.[0] || '';
+      const text = child.value.trim();
+      if (leading) nextChildren.push(b.jsxText(leading));
+      nextChildren.push(
+        b.jsxElement(
+          b.jsxOpeningElement(b.jsxIdentifier('span'), [jsxStaticAttr(reason || 'decorative')], false),
+          b.jsxClosingElement(b.jsxIdentifier('span')),
+          [b.jsxText(text)],
+          false
+        )
+      );
+      if (trailing) nextChildren.push(b.jsxText(trailing));
+      wrapped = true;
+      continue;
+    }
+    nextChildren.push(child);
+  }
+  if (wrapped) node.children = nextChildren;
+  return wrapped;
+}
+
+function applyResidualPass({ code, file, ownerScope, usedPaths, componentName, role }) {
+  if (!code || !code.includes('<')) {
+    return { code, changed: false, fields: [], applied: 0 };
+  }
+
+  let ast;
+  try {
+    ast = parseSource(code, file);
+  } catch {
+    return { code, changed: false, fields: [], applied: 0 };
+  }
+
+  const fields = [];
+  let applied = 0;
+  const used = usedPaths instanceof Set ? usedPaths : new Set(usedPaths || []);
+
+  recast.types.visit(ast, {
+    visitJSXElement(pathNode) {
+      const node = pathNode.node;
+      const tag = getJsxName(node);
+      const lower = tag.toLowerCase();
+
+      if (!tag || SKIP_TAGS.has(tag) || tag === 'React.Fragment' || tag === 'Fragment') {
+        this.traverse(pathNode);
+        return;
+      }
+
+      if (hasEditableMarker(node) || ancestorHasStatic(pathNode)) {
+        this.traverse(pathNode);
+        return;
+      }
+
+      if (DECORATIVE_TAGS.has(tag) || isIconComponent(tag, '')) {
+        if (ensureStaticOnLeaf(node, 'decorative-icon')) applied++;
+        this.traverse(pathNode);
+        return;
+      }
+
+      const text = collectJsxText(node);
+      const src = attrLiteral(node, 'src');
+      const placeholder = attrLiteral(node, 'placeholder');
+      const alt = attrLiteral(node, 'alt');
+
+      const decision = classifyResidual(node, text, tag);
+      const insideMap = inMapCallback(pathNode);
+
+      if (insideMap && decision && decision.bind && ACTION_TAGS.has(tag)) {
+        // Repeated chrome inside a list stays static so we never couple parallel arrays.
+        if (BROAD_CONTENT_CONTAINERS.has(lower)) {
+          if (wrapFirstLiteralAsStatic(node, 'collection-chrome')) applied++;
+        } else if (ensureStaticOnLeaf(node, 'collection-chrome')) {
+          applied++;
+        }
+        this.traverse(pathNode);
+        return;
+      }
+
+      if (IMAGE_TAGS.has(tag) && src && !src.startsWith('{') && !hasJsxAttribute(node, 'data-preview-field-path')) {
+        const section = inferSection({
+          componentName,
+          fileName: file,
+          className: attrLiteral(node, 'className'),
+          tag,
+          role,
+        });
+        const field = buildFieldPath({
+          scope: ownerScope || 'home',
+          section,
+          field: inferFieldName('image', tag, src, {}),
+          used,
+        });
+        node.openingElement.attributes.push(jsxPreviewAttr(field));
+        const srcAttr = findJsxAttribute(node, 'src');
+        if (srcAttr) {
+          srcAttr.value = b.jsxExpressionContainer(siteDataBinding(field.split('.'), src, 'image'));
+        }
+        fields.push({ path: field, type: 'image', value: src });
+        applied++;
+        this.traverse(pathNode);
+        return;
+      }
+
+      if (placeholder && !hasJsxAttribute(node, 'data-preview-field-path')) {
+        const section = inferSection({ componentName, fileName: file, tag, role });
+        const field = buildFieldPath({
+          scope: ownerScope || 'home',
+          section,
+          field: inferFieldName('placeholder', tag, placeholder, {}),
+          used,
+        });
+        node.openingElement.attributes.push(jsxPreviewAttr(field));
+        const ph = findJsxAttribute(node, 'placeholder');
+        if (ph) {
+          ph.value = b.jsxExpressionContainer(siteDataBinding(field.split('.'), placeholder, 'text'));
+        }
+        fields.push({ path: field, type: 'text', value: placeholder });
+        applied++;
+      }
+
+      if (alt && isMeaningfulVisibleText(alt) && !hasJsxAttribute(node, 'data-preview-field-path')) {
+        const section = inferSection({ componentName, fileName: file, tag, role });
+        const field = buildFieldPath({
+          scope: ownerScope || 'home',
+          section,
+          field: inferFieldName('alt', tag, alt, {}),
+          used,
+        });
+        const altAttr = findJsxAttribute(node, 'alt');
+        if (altAttr) {
+          altAttr.value = b.jsxExpressionContainer(siteDataBinding(field.split('.'), alt, 'text'));
+        }
+        fields.push({ path: field, type: 'text', value: alt });
+        applied++;
+      }
+
+      if (decision && decision.bind && decision.kind === 'text' && isMeaningfulVisibleText(text)) {
+        const section = inferSection({
+          componentName,
+          fileName: file,
+          className: attrLiteral(node, 'className'),
+          tag,
+          role,
+        });
+        const field = buildFieldPath({
+          scope: ownerScope || 'home',
+          section,
+          field: inferFieldName('text', tag, text, { tag }),
+          used,
+        });
+        const fieldType = classifyFieldType('text', text);
+
+        if (BROAD_CONTENT_CONTAINERS.has(lower) || BROAD_CONTENT_CONTAINERS.has(tag)) {
+          const nextChildren = [];
+          let wrapped = false;
+          for (const child of node.children || []) {
+            if (!wrapped && child.type === 'JSXText' && child.value.replace(/\s+/g, '').length) {
+              const leading = child.value.match(/^\s*/)?.[0] || '';
+              const trailing = child.value.match(/\s*$/)?.[0] || '';
+              if (leading) nextChildren.push(b.jsxText(leading));
+              nextChildren.push(wrapTextInEditableSpan(field, text, fieldType));
+              if (trailing) nextChildren.push(b.jsxText(trailing));
+              wrapped = true;
+              continue;
+            }
+            nextChildren.push(child);
+          }
+          if (wrapped) {
+            node.children = nextChildren;
+            fields.push({ path: field, type: fieldType, value: text });
+            applied++;
+          }
+        } else if (LEAF_TEXT_TAGS.has(tag) || HEADING_TAGS.has(tag) || tag === 'button' || tag === 'Button') {
+          if (ACTION_TAGS.has(tag) && (hasJsxAttribute(node, 'href') || tag === 'a' || tag === 'Link')) {
+            const nextChildren = [];
+            let wrapped = false;
+            for (const child of node.children || []) {
+              if (!wrapped && child.type === 'JSXText' && child.value.replace(/\s+/g, '').length) {
+                const leading = child.value.match(/^\s*/)?.[0] || '';
+                const trailing = child.value.match(/\s*$/)?.[0] || '';
+                if (leading) nextChildren.push(b.jsxText(leading));
+                nextChildren.push(wrapTextInEditableSpan(field, text, fieldType));
+                if (trailing) nextChildren.push(b.jsxText(trailing));
+                wrapped = true;
+                continue;
+              }
+              nextChildren.push(child);
+            }
+            if (wrapped) {
+              node.children = nextChildren;
+              fields.push({ path: field, type: fieldType, value: text });
+              applied++;
+            }
+          } else {
+            node.openingElement.attributes.push(jsxPreviewAttr(field));
+            ensureStyleAttrs(node, field, tag === 'button' || tag === 'Button' ? 'button' : 'text');
+            const nextChildren = [];
+            let replaced = false;
+            for (const child of node.children || []) {
+              if (!replaced && child.type === 'JSXText' && child.value.replace(/\s+/g, '').length) {
+                nextChildren.push(b.jsxExpressionContainer(siteDataBinding(field.split('.'), text, fieldType)));
+                replaced = true;
+              } else {
+                nextChildren.push(child);
+              }
+            }
+            if (replaced) node.children = nextChildren;
+            fields.push({ path: field, type: fieldType, value: text });
+            applied++;
+          }
+        } else if (!BROAD_CONTENT_CONTAINERS.has(lower)) {
+          if (ensureStaticOnLeaf(node, 'non-leaf-copy')) applied++;
+        } else if (wrapFirstLiteralAsStatic(node, 'container-copy')) {
+          applied++;
+        }
+        this.traverse(pathNode);
+        return;
+      }
+
+      if (decision && !decision.bind && text) {
+        if (BROAD_CONTENT_CONTAINERS.has(lower)) {
+          if (wrapFirstLiteralAsStatic(node, decision.reason || 'decorative')) applied++;
+        } else if (ensureStaticOnLeaf(node, decision.reason || 'decorative')) {
+          applied++;
+        }
+      }
+
+      this.traverse(pathNode);
+    },
+  });
+
+  if (applied === 0) {
+    return { code, changed: false, fields: [], applied: 0 };
+  }
+
+  return {
+    code: printSource(ast, code),
+    changed: true,
+    fields,
+    applied,
+  };
+}
+
+module.exports = {
+  applyResidualPass,
+  isMeaningfulVisibleText,
+};

package/src/arc/scanner.cjs

@@ -277,8 +277,50 @@ function scanPagesRouterRoutes(pagesDir, projectDir) {
  * ever declares routes it actually found.
  */
 function keepExportableRoutes(routes) {
-  const exportable = routes.filter((route) => !route.dynamic);
-  return exportable.length ? exportable : routes;
+  const exportable = routes.filter((route) => !route.dynamic && (route.file || route.inferred));
+  return exportable.length ? exportable : routes.filter((route) => route.inferred);
+}
+
+function resolvePageFileOnDisk(projectDir, page) {
+  if (!page) return null;
+  if (page.file && fs.existsSync(path.join(projectDir, page.file))) return page.file.replace(/\\/g, '/');
+  const route = String(page.route || '').replace(/^\//, '').replace(/\/+$/, '');
+  const id = page.id === 'home' ? '' : page.id;
+  const segments = route || id || '';
+  const candidates = [];
+  if (!segments || page.id === 'home' || page.route === '/') {
+    candidates.push(
+      'src/app/page.tsx',
+      'src/app/page.jsx',
+      'src/app/page.js',
+      'app/page.tsx',
+      'app/page.jsx',
+      'app/page.js',
+      'pages/index.tsx',
+      'pages/index.jsx',
+      'pages/index.js',
+      'src/pages/index.tsx',
+      'src/pages/index.jsx',
+      'src/pages/index.js',
+    );
+  }
+  if (segments) {
+    for (const base of ['src/app', 'app']) {
+      for (const name of ['page.tsx', 'page.jsx', 'page.js']) {
+        candidates.push(`${base}/${segments}/${name}`);
+      }
+    }
+    for (const base of ['pages', 'src/pages']) {
+      for (const ext of ['tsx', 'jsx', 'js']) {
+        candidates.push(`${base}/${segments}.${ext}`);
+        candidates.push(`${base}/${segments}/index.${ext}`);
+      }
+    }
+  }
+  for (const relative of candidates) {
+    if (fs.existsSync(path.join(projectDir, relative))) return relative.replace(/\\/g, '/');
+  }
+  return null;
 }
 
 function detectLanguage(sourceFiles) {
@@ -610,4 +652,6 @@ module.exports = {
   resolveImportSpecifier,
   extractImportSpecifiers,
   parseTsconfig,
+  keepExportableRoutes,
+  resolvePageFileOnDisk,
 };

package/src/arc/semantic.cjs

@@ -128,8 +128,9 @@ function objectLiteralToPlain(node) {
       out[key] = val.quasis?.map((q) => q.value?.cooked || q.value?.raw || '').join('') || '';
     } else if (val.type === 'Identifier') {
       if (/^[A-Z]/.test(val.name)) {
-        // Component references (e.g. icon: Truck, Icon: ShieldCheck) are not merchant content
-        return null;
+        // Component references (e.g. icon: Truck) are not merchant content.
+        // Skip this key only so primitive siblings (title, body) stay convertible.
+        continue;
       }
       out[key] = val.name;
     } else if (val.type === 'UnaryExpression' && val.argument) {
@@ -349,12 +350,15 @@ function collectItemFieldUsage(callback, itemParam) {
   }
 
   let usesItemAsComponent = false;
+  const componentProps = new Set();
   recast.types.visit(callback, {
     visitJSXOpeningElement(pathNode) {
       const name = pathNode.node.name;
       if (name?.type === 'JSXMemberExpression') {
-        if (name.object?.type === 'Identifier' && name.object.name === itemParam) {
+        const objectName = name.object && name.object.name;
+        if ((name.object?.type === 'Identifier' || name.object?.type === 'JSXIdentifier') && objectName === itemParam) {
           usesItemAsComponent = true;
+          if (name.property?.name) componentProps.add(name.property.name);
         }
       }
       this.traverse(pathNode);
@@ -362,6 +366,7 @@ function collectItemFieldUsage(callback, itemParam) {
     visitJSXExpressionContainer(pathNode) {
       const properties = findItemMemberProperties(pathNode.node.expression);
       for (const property of properties) {
+        if (componentProps.has(property)) continue;
         const parent = pathNode.parent?.node || pathNode.parent?.value;
         if (parent?.type === 'JSXAttribute') {
           const attribute = parent.name?.name;
@@ -719,7 +724,6 @@ function analyzeFile({ code, relativeFile, profile, graph, ownerScope, component
         const objectItems = arr.items.every((item) => item.type === 'object');
         const boundProperties = [...itemUsage.keys()];
         const convertible =
-          !usesItemAsComponent &&
           objectItems &&
           boundProperties.length > 0 &&
           arr.items.some((item) => boundProperties.some((key) => key in item.value));