@deneb-ui/cli 2.0.87 → 2.0.89

package/src/arc/transforms/routing/shared-layout.cjs

@@ -0,0 +1,294 @@
+'use strict';
+
+const recast = require('recast');
+const {
+  parseSource,
+  printSource,
+  getJsxName,
+  hasJsxAttribute,
+  ensureImport,
+  ensureDefaultImport,
+  sanitizeDuplicateBindings,
+  b,
+} = require('../../ast.cjs');
+
+function ensureHtmlBodyHydration(ast) {
+  recast.types.visit(ast, {
+    visitJSXOpeningElement(pathNode) {
+      const name = pathNode.node.name;
+      const tag = name && name.type === 'JSXIdentifier' ? name.name : '';
+      if (tag === 'html' || tag === 'body') {
+        const has = (pathNode.node.attributes || []).some(
+          (attr) => attr.type === 'JSXAttribute' && attr.name && attr.name.name === 'suppressHydrationWarning',
+        );
+        if (!has) {
+          pathNode.node.attributes.push(b.jsxAttribute(b.jsxIdentifier('suppressHydrationWarning')));
+        }
+      }
+      this.traverse(pathNode);
+    },
+  });
+}
+
+function findSiteDataJsonLocalName(ast) {
+  const program = ast.program || ast;
+  for (const node of program.body || []) {
+    if (node.type !== 'ImportDeclaration') continue;
+    const src = node.source && node.source.value;
+    if (typeof src !== 'string' || !/site-data\.json/.test(src)) continue;
+    const spec = (node.specifiers || []).find((s) => s.type === 'ImportDefaultSpecifier');
+    if (spec && spec.local) return spec.local.name;
+  }
+  return null;
+}
+
+function ensureProviderInitialData(ast, ident) {
+  let added = false;
+  recast.types.visit(ast, {
+    visitJSXOpeningElement(pathNode) {
+      const name = pathNode.node.name;
+      const tag = name && name.type === 'JSXIdentifier' ? name.name : '';
+      if (tag === 'SiteDataProvider' || tag === 'DenebDataProvider' || tag === 'DenebSiteDataProvider') {
+        const has = hasJsxAttribute(pathNode.node, 'initialSiteData');
+        if (!has) {
+          pathNode.node.attributes = pathNode.node.attributes || [];
+          pathNode.node.attributes.push(
+            b.jsxAttribute(
+              b.jsxIdentifier('initialSiteData'),
+              b.jsxExpressionContainer(b.identifier(ident))
+            )
+          );
+          added = true;
+        }
+      }
+      this.traverse(pathNode);
+    },
+  });
+  return added;
+}
+
+function injectDualModeTheme(ast, jsonIdent, providerImport = '@deneb-ui/ui') {
+  if (!ast) return;
+  let hasThemeStyles = false;
+  let hasThemeToggle = false;
+  recast.types.visit(ast, {
+    visitJSXIdentifier(pathNode) {
+      if (pathNode.node.name === 'ThemeStyles') hasThemeStyles = true;
+      if (pathNode.node.name === 'ThemeToggle') hasThemeToggle = true;
+      this.traverse(pathNode);
+    },
+  });
+
+  const importsToAdd = [];
+  if (!hasThemeStyles) importsToAdd.push('ThemeStyles');
+  if (!hasThemeToggle) importsToAdd.push('ThemeToggle');
+  if (importsToAdd.length === 0) return;
+
+  if (!hasThemeStyles) {
+    let stylesInjected = false;
+    const snippet = parseSource(
+      `<ThemeStyles theme={${jsonIdent}?.template?.structure?.theme || ${jsonIdent}?.theme} enableDualMode />`,
+      'snippet.tsx'
+    );
+    const stylesEl = snippet.program.body[0].expression;
+
+    // Try <head> first
+    recast.types.visit(ast, {
+      visitJSXElement(pathNode) {
+        if (stylesInjected) return false;
+        const name = getJsxName(pathNode.node);
+        if (name === 'head' || name === 'Head') {
+          pathNode.node.children = [b.jsxText('\n        '), stylesEl, ...(pathNode.node.children || [])];
+          stylesInjected = true;
+          return false;
+        }
+        this.traverse(pathNode);
+      },
+    });
+
+    // If no <head>, inject inside SiteDataProvider or <body>
+    if (!stylesInjected) {
+      recast.types.visit(ast, {
+        visitJSXElement(pathNode) {
+          if (stylesInjected) return false;
+          const name = getJsxName(pathNode.node);
+          if (name === 'SiteDataProvider' || name === 'body') {
+            pathNode.node.children = [b.jsxText('\n        '), stylesEl, ...(pathNode.node.children || [])];
+            stylesInjected = true;
+            return false;
+          }
+          this.traverse(pathNode);
+        },
+      });
+    }
+  }
+
+  if (!hasThemeToggle) {
+    let toggleInjected = false;
+    const snippet = parseSource(
+      '<ThemeToggle showLabel className="fixed bottom-6 left-6 z-40" />',
+      'snippet.tsx'
+    );
+    const toggleEl = snippet.program.body[0].expression;
+
+    recast.types.visit(ast, {
+      visitJSXElement(pathNode) {
+        if (toggleInjected) return false;
+        const name = getJsxName(pathNode.node);
+        if (name === 'SiteDataProvider' || name === 'body') {
+          pathNode.node.children = [...(pathNode.node.children || []), b.jsxText('\n        '), toggleEl];
+          toggleInjected = true;
+          return false;
+        }
+        this.traverse(pathNode);
+      },
+    });
+  }
+
+  ensureImport(ast, providerImport || '@deneb-ui/ui', importsToAdd);
+}
+
+function injectPlatformAdditionalPages(ast, providerImport) {
+  if (!ast) return;
+  let alreadyPresent = false;
+  recast.types.visit(ast, {
+    visitJSXIdentifier(pathNode) {
+      if (pathNode.node.name === 'PlatformAdditionalPages') {
+        alreadyPresent = true;
+        return false;
+      }
+      this.traverse(pathNode);
+    },
+  });
+  if (alreadyPresent) return;
+
+  let injected = false;
+  recast.types.visit(ast, {
+    visitJSXElement(pathNode) {
+      if (injected) return false;
+      const name = getJsxName(pathNode.node);
+      if (name === 'main') {
+        const parent = pathNode.parent;
+        if (!parent || !Array.isArray(parent.node.children)) {
+          this.traverse(pathNode);
+          return;
+        }
+        const siblings = parent.node.children;
+        const idx = siblings.indexOf(pathNode.node);
+        if (idx === -1) {
+          this.traverse(pathNode);
+          return;
+        }
+        const platformElement = b.jsxElement(
+          b.jsxOpeningElement(
+            b.jsxIdentifier('PlatformAdditionalPages'),
+            [],
+            true
+          ),
+          null,
+          [],
+          true
+        );
+        const newline = b.jsxText('\n            ');
+        siblings.splice(idx + 1, 0, newline, platformElement);
+        ensureImport(ast, providerImport || '@deneb-ui/ui', ['PlatformAdditionalPages']);
+        injected = true;
+        return false;
+      }
+      this.traverse(pathNode);
+    },
+  });
+}
+
+function instrumentLayoutSource(code, siteDataImport, providerImport = '@deneb-ui/ui') {
+  const ast = parseSource(code, 'layout.tsx');
+  ensureHtmlBodyHydration(ast);
+
+  let jsonIdent = findSiteDataJsonLocalName(ast);
+  if (!jsonIdent) {
+    jsonIdent = 'initialSiteData';
+    ensureDefaultImport(ast, siteDataImport, jsonIdent);
+  }
+
+  const hasProvider = /SiteDataProvider|DenebDataProvider|<Providers\b/.test(code);
+  let wrapped = hasProvider;
+
+  if (!hasProvider) {
+    ensureImport(ast, providerImport, ['SiteDataProvider']);
+    recast.types.visit(ast, {
+      visitJSXExpressionContainer(pathNode) {
+        if (wrapped) return false;
+        const expr = pathNode.node.expression;
+        if (expr && expr.type === 'Identifier' && expr.name === 'children') {
+          pathNode.replace(
+            b.jsxElement(
+              b.jsxOpeningElement(
+                b.jsxIdentifier('SiteDataProvider'),
+                [
+                  b.jsxAttribute(
+                    b.jsxIdentifier('initialSiteData'),
+                    b.jsxExpressionContainer(b.identifier(jsonIdent))
+                  ),
+                ],
+                false
+              ),
+              b.jsxClosingElement(b.jsxIdentifier('SiteDataProvider')),
+              [pathNode.node],
+              false
+            )
+          );
+          wrapped = true;
+          return false;
+        }
+        this.traverse(pathNode);
+      },
+    });
+
+    if (!wrapped) {
+      recast.types.visit(ast, {
+        visitJSXElement(pathNode) {
+          if (wrapped) return false;
+          const name = getJsxName(pathNode.node);
+          if (name === 'Component') {
+            pathNode.replace(
+              b.jsxElement(
+                b.jsxOpeningElement(
+                  b.jsxIdentifier('SiteDataProvider'),
+                  [
+                    b.jsxAttribute(
+                      b.jsxIdentifier('initialSiteData'),
+                      b.jsxExpressionContainer(b.identifier(jsonIdent))
+                    ),
+                  ],
+                  false
+                ),
+                b.jsxClosingElement(b.jsxIdentifier('SiteDataProvider')),
+                [pathNode.node],
+                false
+              )
+            );
+            wrapped = true;
+            return false;
+          }
+          this.traverse(pathNode);
+        },
+      });
+    }
+  }
+
+  ensureProviderInitialData(ast, jsonIdent);
+  injectPlatformAdditionalPages(ast, providerImport);
+  injectDualModeTheme(ast, jsonIdent, providerImport);
+  sanitizeDuplicateBindings(ast);
+  const next = printSource(ast, code);
+  return { code: next, updated: next !== code };
+}
+
+module.exports = {
+  instrumentLayoutSource,
+  ensureHtmlBodyHydration,
+  findSiteDataJsonLocalName,
+  ensureProviderInitialData,
+  injectDualModeTheme,
+  injectPlatformAdditionalPages,
+};

package/src/arc/transforms/runtime/provider.cjs

@@ -0,0 +1,230 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const recast = require('recast');
+const { b } = require('../../ast.cjs');
+
+const CANONICAL_SITE_DATA_CONTEXT = `'use client';
+
+export {
+  SiteDataProvider,
+  useSiteData,
+  contentText,
+  contentObject,
+  contentList,
+  PREVIEW_DATA_MESSAGE,
+  LEGACY_PREVIEW_DATA_MESSAGE,
+  PREVIEW_READY_MESSAGE,
+  LEGACY_PREVIEW_READY_MESSAGE,
+  PREVIEW_FOCUS_MESSAGE,
+  LEGACY_PREVIEW_FOCUS_MESSAGE,
+  PREVIEW_FIELD_ATTRIBUTE,
+} from '@deneb-ui/ui';
+
+export type { SiteData, SiteDataProviderProps } from '@deneb-ui/ui';
+`;
+
+function fileAlreadyUsesSiteDataHook(ast) {
+  let found = false;
+  recast.types.visit(ast, {
+    visitCallExpression(pathNode) {
+      const callee = pathNode.node.callee;
+      if (callee && callee.type === 'Identifier' && callee.name === 'useSiteData') {
+        found = true;
+        return false;
+      }
+      this.traverse(pathNode);
+    },
+  });
+  return found;
+}
+
+function resolveSiteDataRuntimeSpecifier(profile) {
+  const root = profile && profile.root;
+  if (!root) return '@deneb-ui/ui';
+  const candidates = [
+    ['src/lib/siteDataContext.tsx', '@/lib/siteDataContext'],
+    ['src/lib/siteDataContext.ts', '@/lib/siteDataContext'],
+    ['lib/siteDataContext.tsx', '@/lib/siteDataContext'],
+    ['lib/siteDataContext.ts', '@/lib/siteDataContext'],
+  ];
+  const hasAt = Object.keys(profile.aliasMap || {}).some((k) => k === '@/*' || k.startsWith('@/'));
+  for (const [relative, alias] of candidates) {
+    if (!fs.existsSync(path.join(root, relative))) continue;
+    if (hasAt) return alias;
+    const fromAbs = path.join(root, 'src/components/placeholder.tsx');
+    const toAbs = path.join(root, relative.replace(/\.tsx?$/, ''));
+    let relSpec = path.relative(path.dirname(fromAbs), toAbs).replace(/\\/g, '/');
+    if (!relSpec.startsWith('.')) relSpec = './' + relSpec;
+    return relSpec;
+  }
+  return '@deneb-ui/ui';
+}
+
+function functionReferencesSiteData(fn) {
+  if (!fn || !fn.body) return false;
+  let found = false;
+  recast.types.visit(fn.body, {
+    visitIdentifier(pathNode) {
+      if (pathNode.node.name === 'siteData') {
+        found = true;
+        return false;
+      }
+      this.traverse(pathNode);
+    },
+  });
+  return found;
+}
+
+function injectSiteDataHook(ast) {
+  let injected = false;
+  let anyFunctionReferencedSiteData = false;
+  let alreadyHasUseSiteData = false;
+
+  recast.types.visit(ast, {
+    visitCallExpression(pathNode) {
+      if (pathNode.node.callee && pathNode.node.callee.name === 'useSiteData') {
+        alreadyHasUseSiteData = true;
+        return false;
+      }
+      this.traverse(pathNode);
+    },
+  });
+
+  function injectIntoFunction(fn) {
+    if (!fn || !fn.body || fn.body.type !== 'BlockStatement') return false;
+    const body = fn.body.body;
+    const already = body.some((stmt) => recast.print(stmt).code.includes('useSiteData'));
+    if (already) return false;
+    const hook = b.variableDeclaration('const', [
+      b.variableDeclarator(
+        b.identifier('siteData'),
+        b.callExpression(b.identifier('useSiteData'), [])
+      ),
+    ]);
+    body.unshift(hook);
+    alreadyHasUseSiteData = true;
+    return true;
+  }
+
+  // Pass 1: Inject useSiteData() into EVERY component function that references siteData
+  recast.types.visit(ast, {
+    visitFunctionDeclaration(pathNode) {
+      if (functionReferencesSiteData(pathNode.node)) {
+        anyFunctionReferencedSiteData = true;
+        if (injectIntoFunction(pathNode.node)) injected = true;
+      }
+      this.traverse(pathNode);
+    },
+    visitFunctionExpression(pathNode) {
+      if (functionReferencesSiteData(pathNode.node)) {
+        anyFunctionReferencedSiteData = true;
+        if (injectIntoFunction(pathNode.node)) injected = true;
+      }
+      this.traverse(pathNode);
+    },
+    visitArrowFunctionExpression(pathNode) {
+      if (functionReferencesSiteData(pathNode.node)) {
+        anyFunctionReferencedSiteData = true;
+        if (injectIntoFunction(pathNode.node)) injected = true;
+      }
+      this.traverse(pathNode);
+    },
+  });
+
+  // Pass 2: If no component references siteData yet (e.g. before subsequent AST edits),
+  // ensure the primary component receives useSiteData()
+  if (!injected && !anyFunctionReferencedSiteData && !alreadyHasUseSiteData) {
+    recast.types.visit(ast, {
+      visitExportDefaultDeclaration(pathNode) {
+        if (injected) return false;
+        const decl = pathNode.node.declaration;
+        if (decl && (decl.type === 'FunctionDeclaration' || decl.type === 'ArrowFunctionExpression' || decl.type === 'FunctionExpression')) {
+          injected = injectIntoFunction(decl);
+        }
+        this.traverse(pathNode);
+      },
+      visitFunctionDeclaration(pathNode) {
+        if (injected) return false;
+        const name = pathNode.node.id && pathNode.node.id.name;
+        if (name && /^[A-Z]/.test(name)) {
+          injected = injectIntoFunction(pathNode.node);
+          return false;
+        }
+        this.traverse(pathNode);
+      },
+      visitVariableDeclarator(pathNode) {
+        if (injected) return false;
+        const id = pathNode.node.id;
+        const init = pathNode.node.init;
+        if (id && id.type === 'Identifier' && /^[A-Z]/.test(id.name) && init && (init.type === 'ArrowFunctionExpression' || init.type === 'FunctionExpression')) {
+          injected = injectIntoFunction(init);
+          return false;
+        }
+        this.traverse(pathNode);
+      },
+    });
+  }
+
+  if (!injected && !anyFunctionReferencedSiteData && !alreadyHasUseSiteData) {
+    recast.types.visit(ast, {
+      visitFunctionDeclaration(pathNode) {
+        if (injected) return false;
+        injected = injectIntoFunction(pathNode.node);
+        return false;
+      },
+    });
+  }
+
+  return injected;
+}
+
+function resolveSiteDataSpecifier(profile, fromRelativeFile) {
+  const aliases = (profile && profile.aliasMap) || {};
+  const hasAt = Object.keys(aliases).some((k) => k === '@/*' || k.startsWith('@/'));
+  const hasSrc = Boolean(profile && profile.hasSrc);
+  const siteDataRel = hasSrc ? 'src/data/site-data.json' : 'data/site-data.json';
+  if (hasAt && hasSrc) return '@/data/site-data.json';
+
+  const root = profile && profile.root ? profile.root : process.cwd();
+  const fromAbs = path.join(root, fromRelativeFile || 'page.tsx');
+  const toAbs = path.join(root, siteDataRel);
+  let relSpec = path.relative(path.dirname(fromAbs), toAbs).replace(/\\/g, '/');
+  if (!relSpec.startsWith('.')) relSpec = './' + relSpec;
+  return relSpec;
+}
+
+function rewriteRecursiveSiteDataContext(code) {
+  const recursive =
+    /export\s+function\s+SiteDataProvider\b/.test(code) &&
+    /<(?:Base)?SiteDataProvider\b/.test(code);
+  if (!recursive) return { code, updated: false };
+  return { code: CANONICAL_SITE_DATA_CONTEXT, updated: true };
+}
+
+function ensureJsonModule(tsconfig) {
+  if (!tsconfig || !tsconfig.compilerOptions) return { config: tsconfig, changed: false };
+  if (tsconfig.compilerOptions.resolveJsonModule) return { config: tsconfig, changed: false };
+  return {
+    config: {
+      ...tsconfig,
+      compilerOptions: {
+        ...tsconfig.compilerOptions,
+        resolveJsonModule: true,
+      },
+    },
+    changed: true,
+  };
+}
+
+module.exports = {
+  CANONICAL_SITE_DATA_CONTEXT,
+  fileAlreadyUsesSiteDataHook,
+  resolveSiteDataRuntimeSpecifier,
+  functionReferencesSiteData,
+  injectSiteDataHook,
+  resolveSiteDataSpecifier,
+  rewriteRecursiveSiteDataContext,
+  ensureJsonModule,
+};

package/src/arc/transforms/transform-context.cjs

@@ -0,0 +1,118 @@
+'use strict';
+
+const recast = require('recast');
+const {
+  locKey,
+  getJsxName,
+  findJsxAttribute,
+  hasJsxAttribute,
+  jsxPreviewAttr,
+  b,
+} = require('../ast.cjs');
+
+function findElementByLoc(ast, loc, tagName = null) {
+  if (!loc && !tagName) return null;
+  const parts = loc ? loc.split(':') : [];
+  const targetLoc = parts.length > 4 ? parts.slice(0, 4).join(':') : loc;
+  let found = null;
+  recast.types.visit(ast, {
+    visitJSXElement(pathNode) {
+      const k = locKey(pathNode.node);
+      const name = getJsxName(pathNode.node);
+      if (loc && (k === targetLoc || k === loc || (parts.length >= 2 && k && k.startsWith(`${parts[0]}:${parts[1]}`)))) {
+        found = pathNode;
+        return false;
+      }
+      if (!loc && tagName && (name === tagName || name.endsWith(`.${tagName}`))) {
+        found = pathNode;
+        return false;
+      }
+      this.traverse(pathNode);
+    },
+  });
+  return found;
+}
+
+function replaceAttrValue(node, attrName, expression) {
+  const attr = findJsxAttribute(node, attrName);
+  if (!attr) {
+    node.openingElement.attributes.push(
+      b.jsxAttribute(b.jsxIdentifier(attrName), b.jsxExpressionContainer(expression))
+    );
+    return;
+  }
+  attr.value = b.jsxExpressionContainer(expression);
+}
+
+function stripStaticAttribute(node) {
+  if (node && node.openingElement && Array.isArray(node.openingElement.attributes)) {
+    node.openingElement.attributes = node.openingElement.attributes.filter(
+      (attr) => !(attr.type === 'JSXAttribute' && attr.name && attr.name.name === 'data-preview-static')
+    );
+  }
+}
+
+function ensurePreviewPath(node, fieldPath) {
+  stripStaticAttribute(node);
+  if (hasJsxAttribute(node, 'data-preview-field-path')) return;
+  node.openingElement.attributes.push(jsxPreviewAttr(fieldPath));
+}
+
+function findAncestorJsxElement(pathNode) {
+  let current = pathNode.parent;
+  while (current) {
+    const candidate = current.node || current.value;
+    if (candidate?.type === 'JSXElement') return candidate;
+    current = current.parentPath || current.parent;
+  }
+  return null;
+}
+
+function inferButtonKind(tag) {
+  if (tag === 'button' || tag === 'Button') return 'button';
+  return 'text';
+}
+
+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;
+}
+
+module.exports = {
+  findElementByLoc,
+  replaceAttrValue,
+  stripStaticAttribute,
+  ensurePreviewPath,
+  findAncestorJsxElement,
+  inferButtonKind,
+  isModuleLevel,
+  findEnclosingFunction,
+};

package/src/arc/types/acceptance.d.ts

@@ -0,0 +1,50 @@
+export type AcceptanceGateName =
+  | 'Source Analysis'
+  | 'AST Transformation'
+  | 'TypeScript / JS Validation'
+  | 'Next.js Build'
+  | 'Fivora Contract'
+  | 'Manifest / Site Data'
+  | 'Runtime Data Binding'
+  | 'Runtime Collection Operations'
+  | 'Runtime Image Editing'
+  | 'Route Coverage'
+  | 'Design Preservation'
+  | 'Control-Only Protection';
+
+export interface GateResult {
+  name: AcceptanceGateName;
+  passed: boolean;
+  critical: boolean;
+  details?: string;
+}
+
+export type ConversionStatus = 'CONVERSION_PASSED' | 'CONVERSION_INCOMPLETE' | 'CONVERSION_FAILED';
+
+export interface AcceptanceEvaluation {
+  passed: boolean;
+  status: ConversionStatus;
+  gates: Record<string, GateResult>;
+  allCriticalPassed: boolean;
+  editabilityCoverage: number;
+  designPreservation: number;
+}
+
+export declare const ACCEPTANCE_GATES: Record<string, AcceptanceGateName>;
+
+export declare function evaluateAcceptanceGates(metrics: {
+  sourceAnalysis?: { passed?: boolean };
+  astTransformation?: { passed?: boolean };
+  typescriptValidation?: { passed?: boolean };
+  buildSuccess?: { passed?: boolean };
+  fivoraAudit?: { passed?: boolean };
+  fivoraContract?: { passed?: boolean };
+  manifestValid?: boolean;
+  runtimeEditabilityScore?: number;
+  collectionOpsPassed?: boolean;
+  imageEditingPassed?: boolean;
+  routeCoveragePassed?: boolean;
+  designPreservationScore?: number;
+  controlOnlyValid?: boolean;
+  editabilityCoverage?: number;
+}): AcceptanceEvaluation;