@deneb-ui/cli 2.0.46 → 2.0.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deneb-ui/cli",
-  "version": "2.0.46",
+  "version": "2.0.47",
   "description": "Official DENEB CLI — scaffold, convert, validate, and package Fivora-ready storefront templates.",
   "bin": {
     "deneb": "bin/index.js",
@@ -49,7 +49,7 @@
   "license": "MIT",
   "dependencies": {
     "@babel/parser": "^7.28.0",
-    "@deneb-ui/core": "^2.0.46",
+    "@deneb-ui/core": "^2.0.47",
     "@octokit/rest": "^22.0.1",
     "adm-zip": "^0.6.0",
     "dotenv": "^17.4.2",

package/src/arc/__tests__/arc.test.cjs

@@ -626,3 +626,78 @@ export { useSiteData, contentText };
   assert.match(out, /export\s*\{[^}]*useSiteData[^}]*\}\s*from\s*['"]@deneb-ui\/ui['"]/);
   assert.doesNotMatch(out, /import\s*\{[^}]*useSiteData/);
 });
+
+test('toCamel and optionalMember safely handle strings starting with numbers without syntax errors', () => {
+  const { toCamel } = require('../field-paths.cjs');
+  const { optionalMember, parseSource } = require('../ast.cjs');
+  const recast = require('recast');
+
+  // toCamel prefixes identifiers starting with a number
+  assert.equal(toCamel(['1800840AURA']), 'item1800840aura');
+  assert.equal(toCamel(['25-Min', 'Express']), 'item25MinExpress');
+
+  // optionalMember safely falls back to computed string literal for non-identifier keys
+  const chain = optionalMember(['siteData', 'content', 'home', '100EncryptedLabel']);
+  const code = recast.print(chain).code;
+  assert.equal(code, 'siteData?.content?.home?.["100EncryptedLabel"]');
+
+  // Verify it parses as valid JS without syntax errors
+  assert.doesNotThrow(() => parseSource(`const x = ${code};`, 'test.tsx'));
+});
+
+test('bindArrayDeclaration transforms module-scope array into DEFAULT_ fallback in client components', () => {
+  const clientCode = `'use client';
+import React from 'react';
+
+const BRANDS = [
+  { name: 'Apple' },
+  { name: 'Samsung' },
+];
+
+export function BrandMarquee() {
+  return (
+    <div>
+      {BRANDS.map((b) => (
+        <div key={b.name} className="brand-item">
+          <span>{b.name}</span>
+        </div>
+      ))}
+    </div>
+  );
+}
+`;
+
+  const profile = {
+    root: os.tmpdir(),
+    framework: 'nextjs',
+    router: 'next-app',
+    language: 'typescript',
+    cssSystems: ['tailwind'],
+    hasSrc: true,
+    aliasMap: { '@/*': ['src/*'] },
+  };
+
+  const analysis = analyzeFile({
+    code: clientCode,
+    relativeFile: 'src/components/BrandMarquee.tsx',
+    profile,
+    graph: { sharedFiles: [] },
+    ownerScope: 'home',
+    componentMeta: { name: 'BrandMarquee', role: 'about' },
+  });
+  analysis.code = clientCode;
+  analysis.relativeFile = 'src/components/BrandMarquee.tsx';
+
+  const plan = planTransformations({ profile, analyses: [analysis] });
+  const result = applyFilePlan(plan.files[0], profile);
+
+  assert.equal(result.changed, true);
+  // Module-scope array renamed to DEFAULT_BRANDS with literal array preserved
+  assert.match(result.code, /const DEFAULT_BRANDS = \[\s*\{\s*name:\s*['"]Apple['"]\s*\}/);
+  // Inside component body: useSiteData hook followed by dynamic BRANDS binding
+  assert.match(result.code, /const siteData = useSiteData\(\);/);
+  assert.match(result.code, /const BRANDS = siteData\?\.content\?\.home\?\.BRANDS \?\? DEFAULT_BRANDS;/);
+  // Verify AST parses cleanly
+  assert.doesNotThrow(() => parseSource(result.code, 'BrandMarquee.tsx'));
+});
+

package/src/arc/ast.cjs

@@ -158,10 +158,17 @@ function isJsxTextHeavy(node) {
   return meaningful.length > 0;
 }
 
+const VALID_IDENTIFIER_REGEX = /^[a-zA-Z_$][a-zA-Z0-9_$]*$/;
+
 function optionalMember(parts) {
   let expr = b.identifier(parts[0]);
   for (let i = 1; i < parts.length; i++) {
-    expr = b.optionalMemberExpression(expr, b.identifier(parts[i]), false, true);
+    const part = String(parts[i]);
+    if (VALID_IDENTIFIER_REGEX.test(part)) {
+      expr = b.optionalMemberExpression(expr, b.identifier(part), false, true);
+    } else {
+      expr = b.optionalMemberExpression(expr, b.stringLiteral(part), true, true);
+    }
   }
   return expr;
 }

package/src/arc/field-paths.cjs

@@ -15,13 +15,17 @@ function toCamel(parts) {
     .filter((w, i) => i === 0 || !STOP_WORDS.has(w.toLowerCase()))
     .slice(0, 5);
   if (!cleaned.length) return '';
-  return cleaned
+  const camel = cleaned
     .map((word, i) => {
       const lower = word.toLowerCase();
       if (i === 0) return lower;
       return lower.charAt(0).toUpperCase() + lower.slice(1);
     })
     .join('');
+  if (/^[0-9]/.test(camel)) {
+    return 'item' + camel.charAt(0).toUpperCase() + camel.slice(1);
+  }
+  return camel;
 }
 
 function inferSection(context) {

package/src/arc/transformer.cjs

@@ -238,7 +238,7 @@ function wrapLiteralTextChildren(node, fieldPath, fallback) {
  * emitted as JSX template literals (`items[${index}].title`) so added and
  * reordered items stay editable, which is what strict mode requires.
  */
-function applyCollectionTransform(ast, transform) {
+function applyCollectionTransform(ast, transform, isClient = false) {
   const listPath = transform.listField;
   const binding = transform.itemParam;
   if (!listPath || !binding) return false;
@@ -290,7 +290,7 @@ function applyCollectionTransform(ast, transform) {
     );
   }
 
-  return bindArrayDeclaration(ast, mapCall, listPath);
+  return bindArrayDeclaration(ast, mapCall, listPath, isClient);
 }
 
 function findMapCall(ast, loc) {
@@ -376,7 +376,40 @@ function findListContainer(mapCallPath) {
   return null;
 }
 
-function bindArrayDeclaration(ast, mapCallPath, listPath) {
+function isModuleLevel(pathNode) {
+  let current = pathNode.parentPath || pathNode.parent;
+  while (current) {
+    const type = current.node?.type;
+    if (
+      type === 'FunctionDeclaration' ||
+      type === 'FunctionExpression' ||
+      type === 'ArrowFunctionExpression'
+    ) {
+      return false;
+    }
+    if (type === 'Program') return true;
+    current = current.parentPath || current.parent;
+  }
+  return true;
+}
+
+function findEnclosingFunction(pathNode) {
+  let current = pathNode.parentPath || pathNode.parent;
+  while (current) {
+    const type = current.node?.type;
+    if (
+      type === 'FunctionDeclaration' ||
+      type === 'FunctionExpression' ||
+      type === 'ArrowFunctionExpression'
+    ) {
+      return current;
+    }
+    current = current.parentPath || current.parent;
+  }
+  return null;
+}
+
+function bindArrayDeclaration(ast, mapCallPath, listPath, isClient = false) {
   const arrayName = mapCallPath.node.callee.object?.name;
   if (!arrayName) return false;
   let bound = false;
@@ -392,6 +425,33 @@ function bindArrayDeclaration(ast, mapCallPath, listPath) {
         this.traverse(pathNode);
         return;
       }
+
+      if (isClient && isModuleLevel(pathNode)) {
+        const defaultName = 'DEFAULT_' + arrayName;
+        node.id.name = defaultName;
+        const fnPath = findEnclosingFunction(mapCallPath);
+        if (fnPath && fnPath.node.body?.type === 'BlockStatement') {
+          const body = fnPath.node.body.body;
+          const already = body.some((stmt) => recast.print(stmt).code.includes(`const ${arrayName} =`));
+          if (!already) {
+            const localDecl = b.variableDeclaration('const', [
+              b.variableDeclarator(
+                b.identifier(arrayName),
+                siteDataListBinding(listPath.split('.'), b.identifier(defaultName))
+              ),
+            ]);
+            const hookIdx = body.findIndex((stmt) => recast.print(stmt).code.includes('useSiteData'));
+            if (hookIdx >= 0) {
+              body.splice(hookIdx + 1, 0, localDecl);
+            } else {
+              body.unshift(localDecl);
+            }
+          }
+        }
+        bound = true;
+        return false;
+      }
+
       node.init = siteDataListBinding(listPath.split('.'), node.init);
       bound = true;
       return false;
@@ -549,7 +609,7 @@ function applyFilePlan(filePlan, profile) {
 
     if (transform.operation === 'collection-conversion') {
       try {
-        if (applyCollectionTransform(ast, transform)) applied++;
+        if (applyCollectionTransform(ast, transform, isClient)) applied++;
         else failures.push({ loc: transform.loc, reason: 'collection-not-bindable' });
       } catch (err) {
         failures.push({ loc: transform.loc, reason: err.message });