@deneb-ui/cli 2.0.30 → 2.0.32

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deneb-ui/cli",
-  "version": "2.0.30",
+  "version": "2.0.32",
   "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.30",
+    "@deneb-ui/core": "^2.0.32",
     "adm-zip": "^0.6.0",
     "recast": "^0.23.11"
   },

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

@@ -519,3 +519,62 @@ test('conflicting data-preview-static is stripped when element has editable mark
   const placementErrors = errors.filter((e) => e.includes('cannot share an element with data-preview-static'));
   assert.equal(placementErrors.length, 0);
 });
+
+test('sanitizeDuplicateBindings keeps a single useSiteData import', () => {
+  const { parseSource, printSource, sanitizeDuplicateBindings } = require('../ast.cjs');
+  const code = `'use client';
+import { useSiteData, contentText } from '@/lib/siteDataContext';
+import { useSiteData, contentObject } from '@deneb-ui/ui';
+export function Shop() {
+  const siteData = useSiteData();
+  return <div>{contentText(contentObject(siteData).title)}</div>;
+}
+`;
+  const ast = parseSource(code, 'shop.tsx');
+  sanitizeDuplicateBindings(ast);
+  const out = printSource(ast, code);
+  const importUses = [...out.matchAll(/import\s*\{([^}]+)\}\s*from/g)].flatMap((m) =>
+    m[1].split(',').map((s) => s.trim()).filter((s) => s === 'useSiteData')
+  );
+  assert.equal(importUses.length, 1);
+  assert.match(out, /siteDataContext/);
+  assert.doesNotMatch(out, /import\s*\{[^}]*useSiteData[^}]*\}\s*from\s*['"]@deneb-ui\/ui['"]/);
+});
+
+test('recursive SiteDataProvider wrappers are flattened to a package re-export', () => {
+  const { rewriteRecursiveSiteDataContext } = require('../transformer.cjs');
+  const code = `'use client';
+import { SiteDataProvider as BaseSiteDataProvider } from '@deneb-ui/ui';
+import initialSiteData from '@/data/site-data.json';
+export function SiteDataProvider({ children, ...props }) {
+  return (
+    <BaseSiteDataProvider initialSiteData={initialSiteData} {...props}>
+      {children}
+    </BaseSiteDataProvider>
+  );
+}
+`;
+  const out = rewriteRecursiveSiteDataContext(code);
+  assert.equal(out.updated, true);
+  assert.match(out.code, /export \{/);
+  assert.match(out.code, /SiteDataProvider/);
+  assert.match(out.code, /from '@deneb-ui\/ui'/);
+  assert.doesNotMatch(out.code, /export function SiteDataProvider/);
+  assert.doesNotMatch(out.code, /BaseSiteDataProvider/);
+});
+
+test('import plus export of useSiteData is rewritten to export-from', () => {
+  const { parseSource, printSource, sanitizeDuplicateBindings } = require('../ast.cjs');
+  const code = `'use client';
+import { SiteDataProvider as BaseSiteDataProvider, useSiteData, contentText } from '@deneb-ui/ui';
+export function SiteDataProvider({ children }) {
+  return <BaseSiteDataProvider>{children}</BaseSiteDataProvider>;
+}
+export { useSiteData, contentText };
+`;
+  const ast = parseSource(code, 'siteDataContext.tsx');
+  sanitizeDuplicateBindings(ast);
+  const out = printSource(ast, code);
+  assert.match(out, /export\s*\{[^}]*useSiteData[^}]*\}\s*from\s*['"]@deneb-ui\/ui['"]/);
+  assert.doesNotMatch(out, /import\s*\{[^}]*useSiteData/);
+});

package/src/arc/ast.cjs

@@ -264,25 +264,170 @@ function hasDirective(ast, value) {
   return false;
 }
 
+function localNameOfSpecifier(spec) {
+  return spec?.local?.name || spec?.imported?.name || spec?.exported?.name || null;
+}
+
+function dedupeImportSpecifiers(ast) {
+  const program = ast.program || ast;
+  const seenLocals = new Set();
+  for (const node of program.body || []) {
+    if (node.type !== 'ImportDeclaration' || !Array.isArray(node.specifiers)) continue;
+    node.specifiers = node.specifiers.filter((spec) => {
+      const local = localNameOfSpecifier(spec);
+      if (!local) return true;
+      if (seenLocals.has(local)) return false;
+      seenLocals.add(local);
+      return true;
+    });
+  }
+}
+
+function preferLocalSiteDataImport(ast) {
+  const program = ast.program || ast;
+  const body = program.body || [];
+  const localNames = new Set();
+  for (const node of body) {
+    if (node.type !== 'ImportDeclaration') continue;
+    const src = node.source && node.source.value;
+    if (typeof src !== 'string' || !/siteDataContext/.test(src)) continue;
+    for (const spec of node.specifiers || []) {
+      const local = localNameOfSpecifier(spec);
+      if (local) localNames.add(local);
+    }
+  }
+  if (localNames.size === 0) return;
+  for (const node of body) {
+    if (node.type !== 'ImportDeclaration') continue;
+    const src = node.source && node.source.value;
+    if (src !== '@deneb-ui/ui' && src !== 'deneb-ui' && src !== '@fivora/editable-components') continue;
+    node.specifiers = (node.specifiers || []).filter((spec) => !localNames.has(localNameOfSpecifier(spec)));
+  }
+}
+
+function dropImportedNameIfLocallyDeclared(ast) {
+  const program = ast.program || ast;
+  const declared = new Set();
+  for (const node of program.body || []) {
+    if (node.type === 'FunctionDeclaration' && node.id && node.id.name) {
+      declared.add(node.id.name);
+    }
+    if (node.type === 'ExportNamedDeclaration' && node.declaration) {
+      const decl = node.declaration;
+      if (decl.type === 'FunctionDeclaration' && decl.id && decl.id.name) {
+        declared.add(decl.id.name);
+      }
+      if (decl.type === 'VariableDeclaration') {
+        for (const d of decl.declarations || []) {
+          if (d.id && d.id.type === 'Identifier') declared.add(d.id.name);
+        }
+      }
+    }
+  }
+  if (declared.size === 0) return;
+  for (const node of program.body || []) {
+    if (node.type !== 'ImportDeclaration') continue;
+    node.specifiers = (node.specifiers || []).filter((spec) => !declared.has(localNameOfSpecifier(spec)));
+  }
+}
+
+function rewriteImportedReexports(ast) {
+  const program = ast.program || ast;
+  const importSourceByLocal = new Map();
+  for (const node of program.body || []) {
+    if (node.type !== 'ImportDeclaration') continue;
+    const src = node.source && node.source.value;
+    for (const spec of node.specifiers || []) {
+      const local = localNameOfSpecifier(spec);
+      if (local && src) importSourceByLocal.set(local, src);
+    }
+  }
+
+  const exportDecls = (program.body || []).filter(
+    (node) => node.type === 'ExportNamedDeclaration' && !node.source && node.specifiers && node.specifiers.length
+  );
+  for (const node of exportDecls) {
+    const groups = new Map();
+    const keep = [];
+    for (const spec of node.specifiers) {
+      const local = spec.local?.name;
+      const src = local && importSourceByLocal.get(local);
+      if (!src) {
+        keep.push(spec);
+        continue;
+      }
+      if (!groups.has(src)) groups.set(src, []);
+      groups.get(src).push(spec);
+    }
+    if (!groups.size) continue;
+    node.specifiers = keep;
+    let insertAt = program.body.indexOf(node) + 1;
+    for (const [src, specs] of groups.entries()) {
+      program.body.splice(insertAt, 0, b.exportNamedDeclaration(null, specs, b.stringLiteral(src)));
+      insertAt++;
+      for (const spec of specs) {
+        const local = spec.local?.name;
+        for (const imp of program.body) {
+          if (imp.type !== 'ImportDeclaration') continue;
+          if (!imp.specifiers) continue;
+          imp.specifiers = imp.specifiers.filter((s) => localNameOfSpecifier(s) !== local);
+        }
+      }
+    }
+  }
+}
+
+function stripEmptyImportAndExportDecls(ast) {
+  const program = ast.program || ast;
+  program.body = (program.body || []).filter((node) => {
+    if (node.type === 'ImportDeclaration') {
+      return (node.specifiers || []).length > 0;
+    }
+    if (node.type === 'ExportNamedDeclaration' && !node.declaration && !node.source) {
+      return (node.specifiers || []).length > 0;
+    }
+    return true;
+  });
+}
+
+function sanitizeDuplicateBindings(ast) {
+  dropImportedNameIfLocallyDeclared(ast);
+  preferLocalSiteDataImport(ast);
+  rewriteImportedReexports(ast);
+  dedupeImportSpecifiers(ast);
+  stripEmptyImportAndExportDecls(ast);
+}
+
 function ensureImport(ast, source, names) {
   const program = ast.program || ast;
   const body = program.body || [];
+
+  const alreadyImported = new Set();
+  for (const node of body) {
+    if (node.type === 'ImportDeclaration' && Array.isArray(node.specifiers)) {
+      for (const spec of node.specifiers) {
+        const local = spec.local?.name || spec.imported?.name;
+        if (local) alreadyImported.add(local);
+      }
+    }
+    if (node.type === 'FunctionDeclaration' && node.id?.name) alreadyImported.add(node.id.name);
+    if (node.type === 'ExportNamedDeclaration' && node.declaration?.type === 'FunctionDeclaration' && node.declaration.id?.name) {
+      alreadyImported.add(node.declaration.id.name);
+    }
+  }
+
+  const namesToImport = names.filter((name) => !alreadyImported.has(name));
+  if (namesToImport.length === 0) return;
+
   const existing = body.find((node) => node.type === 'ImportDeclaration' && node.source && node.source.value === source);
   if (existing) {
-    const already = new Set(
-      (existing.specifiers || [])
-        .filter((s) => s.type === 'ImportSpecifier')
-        .map((s) => s.imported?.name || s.local?.name)
-    );
-    for (const name of names) {
-      if (!already.has(name)) {
-        existing.specifiers.push(b.importSpecifier(b.identifier(name), b.identifier(name)));
-      }
+    for (const name of namesToImport) {
+      existing.specifiers.push(b.importSpecifier(b.identifier(name), b.identifier(name)));
     }
     return;
   }
 
-  const specifiers = names.map((name) => b.importSpecifier(b.identifier(name), b.identifier(name)));
+  const specifiers = namesToImport.map((name) => b.importSpecifier(b.identifier(name), b.identifier(name)));
   const decl = b.importDeclaration(specifiers, b.stringLiteral(source));
   let insertAt = 0;
   if (body[0] && body[0].type === 'ExpressionStatement') insertAt = 1;
@@ -332,6 +477,7 @@ module.exports = {
   hasDirective,
   ensureImport,
   ensureDefaultImport,
+  sanitizeDuplicateBindings,
   codeHasIdentifier,
   t,
   b,

package/src/arc/index.cjs

@@ -17,7 +17,7 @@ const { walkFiles, isJsxFile, rel, copyFilePreserve, writeJson, readJsonSafe, fi
 const { scanProject, buildDependencyGraph, inferOwnerScope } = require('./scanner.cjs');
 const { analyzeFile, collectDesignSnapshot } = require('./semantic.cjs');
 const { planTransformations } = require('./planner.cjs');
-const { applyFilePlan, instrumentLayoutSource, instrumentPageKey, resolveSiteDataSpecifier, ensureJsonModule, sanitizeContradictoryMarkersInSource } = require('./transformer.cjs');
+const { applyFilePlan, instrumentLayoutSource, instrumentPageKey, resolveSiteDataSpecifier, resolveSiteDataRuntimeSpecifier, rewriteRecursiveSiteDataContext, ensureJsonModule, sanitizeContradictoryMarkersInSource } = require('./transformer.cjs');
 const { parseSource } = require('./ast.cjs');
 const { buildSiteDataAndManifest, writeDataBank, loadExistingData, countSchemaFields } = require('./manifest.cjs');
 const { validateAstFiles, validateContracts, designPreservationScore, coverageMetrics } = require('./validator.cjs');
@@ -306,8 +306,9 @@ function runDenebArc(projectDir, projectName, options = {}) {
     backupFile(projectDir, backupDir, layoutFile);
     const layoutRel = rel(projectDir, layoutFile);
     const siteDataImport = resolveSiteDataSpecifier(profile, layoutRel);
+    const providerImport = resolveSiteDataRuntimeSpecifier(profile);
     const original = fs.readFileSync(layoutFile, 'utf8');
-    const instrumented = instrumentLayoutSource(original, siteDataImport);
+    const instrumented = instrumentLayoutSource(original, siteDataImport, providerImport);
     if (instrumented.updated && instrumented.code !== original) {
       fs.writeFileSync(layoutFile, instrumented.code, 'utf8');
       changedFiles.push(layoutRel);
@@ -315,6 +316,23 @@ function runDenebArc(projectDir, projectName, options = {}) {
     }
   }
 
+  const contextCandidates = [
+    path.join(projectDir, 'src', 'lib', 'siteDataContext.tsx'),
+    path.join(projectDir, 'src', 'lib', 'siteDataContext.ts'),
+    path.join(projectDir, 'lib', 'siteDataContext.tsx'),
+    path.join(projectDir, 'lib', 'siteDataContext.ts'),
+  ];
+  for (const abs of contextCandidates) {
+    if (!fs.existsSync(abs)) continue;
+    backupFile(projectDir, backupDir, abs);
+    const original = fs.readFileSync(abs, 'utf8');
+    const rewritten = rewriteRecursiveSiteDataContext(original);
+    if (rewritten.updated && rewritten.code !== original) {
+      fs.writeFileSync(abs, rewritten.code, 'utf8');
+      changedFiles.push(rel(projectDir, abs));
+    }
+  }
+
   for (const filePlan of plan.files) {
     if (!filePlan.transformations.length || filePlan.skippedFile) continue;
     const abs = path.join(projectDir, filePlan.file);

package/src/arc/transformer.cjs

@@ -2,6 +2,7 @@
 
 const recast = require('recast');
 const path = require('path');
+const fs = require('fs');
 const {
   parseSource,
   printSource,
@@ -12,6 +13,7 @@ const {
   hasDirective,
   ensureImport,
   ensureDefaultImport,
+  sanitizeDuplicateBindings,
   siteDataBinding,
   siteDataListBinding,
   jsxPreviewAttr,
@@ -370,6 +372,43 @@ function bindArrayDeclaration(ast, mapCallPath, listPath) {
   return bound;
 }
 
+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 injectSiteDataHook(ast) {
   const program = ast.program || ast;
   let injected = false;
@@ -508,11 +547,15 @@ function applyFilePlan(filePlan, profile) {
 
   const siteDataImport = resolveSiteDataSpecifier(profile, filePlan.file);
   if (isClient) {
-    ensureImport(ast, '@deneb-ui/ui', ['useSiteData']);
-    injectSiteDataHook(ast);
+    const runtimeSpecifier = resolveSiteDataRuntimeSpecifier(profile);
+    if (!fileAlreadyUsesSiteDataHook(ast)) {
+      injectSiteDataHook(ast);
+    }
+    ensureImport(ast, runtimeSpecifier, ['useSiteData']);
   } else {
     ensureDefaultImport(ast, siteDataImport, 'siteData');
   }
+  sanitizeDuplicateBindings(ast);
 
   // Sanitize any conflicting data-preview-static on elements with editable markers
   sanitizeContradictoryMarkers(ast);
@@ -610,57 +653,91 @@ function ensureHtmlBodyHydration(ast) {
   });
 }
 
-function instrumentLayoutSource(code, siteDataImport) {
-  if (/SiteDataProvider|DenebDataProvider/.test(code)) {
-    if (/suppressHydrationWarning/.test(code)) {
-      return { code, updated: false };
-    }
-    const ast = parseSource(code, 'layout.tsx');
-    ensureHtmlBodyHydration(ast);
-    return { code: printSource(ast, code), updated: true };
+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;
+}
 
-  const ast = parseSource(code, 'layout.tsx');
-  ensureHtmlBodyHydration(ast);
-  ensureImport(ast, '@deneb-ui/ui', ['SiteDataProvider']);
-  ensureDefaultImport(ast, siteDataImport, 'initialSiteData');
-
-  let wrapped = false;
+function ensureProviderInitialData(ast, ident) {
+  let added = false;
   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('initialSiteData'))
-                ),
-              ],
-              false
-            ),
-            b.jsxClosingElement(b.jsxIdentifier('SiteDataProvider')),
-            [pathNode.node],
-            false
-          )
-        );
-        wrapped = true;
-        return false;
+    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;
+}
 
-  if (!wrapped) {
+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 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 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/.test(code);
+  let wrapped = hasProvider;
+
+  if (!hasProvider) {
+    ensureImport(ast, providerImport, ['SiteDataProvider']);
     recast.types.visit(ast, {
-      visitJSXElement(pathNode) {
+      visitJSXExpressionContainer(pathNode) {
         if (wrapped) return false;
-        const name = getJsxName(pathNode.node);
-        if (name === 'Component') {
+        const expr = pathNode.node.expression;
+        if (expr && expr.type === 'Identifier' && expr.name === 'children') {
           pathNode.replace(
             b.jsxElement(
               b.jsxOpeningElement(
@@ -668,7 +745,7 @@ function instrumentLayoutSource(code, siteDataImport) {
                 [
                   b.jsxAttribute(
                     b.jsxIdentifier('initialSiteData'),
-                    b.jsxExpressionContainer(b.identifier('initialSiteData'))
+                    b.jsxExpressionContainer(b.identifier(jsonIdent))
                   ),
                 ],
                 false
@@ -684,9 +761,43 @@ function instrumentLayoutSource(code, siteDataImport) {
         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);
+        },
+      });
+    }
   }
 
-  return { code: printSource(ast, code), updated: wrapped };
+  ensureProviderInitialData(ast, jsonIdent);
+  sanitizeDuplicateBindings(ast);
+  const next = printSource(ast, code);
+  return { code: next, updated: next !== code };
 }
 
 function ensureJsonModule(tsconfig) {
@@ -752,6 +863,8 @@ module.exports = {
   instrumentLayoutSource,
   instrumentPageKey,
   resolveSiteDataSpecifier,
+  resolveSiteDataRuntimeSpecifier,
+  rewriteRecursiveSiteDataContext,
   ensureJsonModule,
   inferPageKey,
   sanitizeContradictoryMarkers,

package/src/tools/template-converter.cjs

@@ -615,8 +615,8 @@ function transformFileContent(filePath, pageKey, extractedData, backupDir, proje
       code = "'use client';\n\n" + code;
     }
 
-    // Add useSiteData import if needed
-    if (!code.includes('useSiteData')) {
+    // Add useSiteData import if needed. Skip when any binding already exists.
+    if (!/\buseSiteData\b/.test(code)) {
       code = code.replace(
         /(import\s+[^;]+;\n)/,
         `$1import { useSiteData } from '@deneb-ui/ui';\n`