@salla.sa/twilight-theme-engine 1.0.0-beta.4

package/dist/vite/index.js

@@ -0,0 +1,2193 @@
+import { tanstackHeadAdapter } from '../chunk-6Q5BFHFA.js';
+import { nextjsHeadAdapter } from '../chunk-HOSHJBPS.js';
+import { setHeadAdapter } from '../chunk-B3EFOE57.js';
+import { RouteId } from '../chunk-MTONGOJD.js';
+import '../chunk-KIPZQN3Y.js';
+import '../chunk-T72DAX7R.js';
+import '../chunk-DGUM43GV.js';
+import { readdir, readFile } from 'fs/promises';
+import { dirname, resolve, relative, join, basename, sep } from 'path';
+import { parseSync } from 'oxc-parser';
+import { existsSync, mkdirSync, writeFileSync, readFileSync, statSync } from 'fs';
+import { createHash } from 'crypto';
+import { fileURLToPath, pathToFileURL } from 'url';
+import Module, { createRequire } from 'module';
+import { transformSync } from 'esbuild';
+
+// src/vite/plugins/salla-hydration.plugin.ts
+var TAG_START_RE = /<(?:salla|custom)-[a-z][a-z0-9-]*/g;
+function webHydrationPlugin() {
+  return {
+    name: "twilight:web-hydration",
+    enforce: "pre",
+    transform(code, id) {
+      if (!/\.[jt]sx$/.test(id)) return null;
+      if (!/<(?:salla|custom)-[a-z]/.test(code)) return null;
+      let result = "";
+      let lastIndex = 0;
+      TAG_START_RE.lastIndex = 0;
+      let match;
+      while ((match = TAG_START_RE.exec(code)) !== null) {
+        const tagStart = match.index;
+        const afterTag = tagStart + match[0].length;
+        let i = afterTag;
+        let braceDepth = 0;
+        let closingPos = -1;
+        let isSelfClosing = false;
+        while (i < code.length) {
+          const ch = code[i];
+          if (ch === "{") {
+            braceDepth++;
+          } else if (ch === "}") {
+            braceDepth--;
+          } else if (braceDepth === 0 && ch === ">") {
+            isSelfClosing = i > 0 && code[i - 1] === "/";
+            closingPos = i;
+            break;
+          }
+          i++;
+        }
+        if (closingPos === -1) break;
+        const propsSlice = code.slice(afterTag, isSelfClosing ? closingPos - 1 : closingPos);
+        if (propsSlice.includes("suppressHydrationWarning")) {
+          TAG_START_RE.lastIndex = closingPos + 1;
+          continue;
+        }
+        const insertPos = isSelfClosing ? closingPos - 1 : closingPos;
+        result += code.slice(lastIndex, insertPos) + " suppressHydrationWarning";
+        lastIndex = insertPos;
+        TAG_START_RE.lastIndex = closingPos + 1;
+      }
+      if (lastIndex === 0) return null;
+      result += code.slice(lastIndex);
+      return { code: result };
+    }
+  };
+}
+var VIRTUAL_ID = "virtual:twilight/theme-translations";
+var RESOLVED_ID = "\0" + VIRTUAL_ID;
+function themeTranslationsPlugin(localesDir) {
+  let resolvedLocalesDir;
+  return {
+    name: "twilight:translations",
+    configResolved(config) {
+      if (localesDir) {
+        resolvedLocalesDir = resolve(config.root, localesDir);
+      }
+    },
+    resolveId(id) {
+      if (id === VIRTUAL_ID) return RESOLVED_ID;
+    },
+    async load(id) {
+      if (id !== RESOLVED_ID) return;
+      if (!resolvedLocalesDir) return "export default {};";
+      try {
+        const files = await readdir(resolvedLocalesDir);
+        const jsonFiles = files.filter((f) => f.endsWith(".json"));
+        if (jsonFiles.length === 0) return "export default {};";
+        const entries = [];
+        for (const file of jsonFiles) {
+          const locale = basename(file, ".json");
+          const content = await readFile(join(resolvedLocalesDir, file), "utf-8");
+          const data = JSON.parse(content);
+          entries.push(`  '${locale}.trans': ${JSON.stringify(data)}`);
+        }
+        return `export default {
+${entries.join(",\n")}
+};
+`;
+      } catch {
+        return "export default {};";
+      }
+    },
+    configureServer(server) {
+      if (!resolvedLocalesDir) return;
+      server.watcher.add(join(resolvedLocalesDir, "*.json"));
+      server.watcher.on("change", (file) => {
+        if (file.startsWith(resolvedLocalesDir) && file.endsWith(".json")) {
+          const mod = server.moduleGraph.getModuleById(RESOLVED_ID);
+          if (mod) server.moduleGraph.invalidateModule(mod);
+        }
+      });
+      server.watcher.on("add", (file) => {
+        if (file.startsWith(resolvedLocalesDir) && file.endsWith(".json")) {
+          const mod = server.moduleGraph.getModuleById(RESOLVED_ID);
+          if (mod) server.moduleGraph.invalidateModule(mod);
+        }
+      });
+    }
+  };
+}
+
+// src/vite/plugins/best-practices/rules/no-deep-component-import.ts
+var COMPONENT_FOLDERS = [
+  "common",
+  "cart",
+  "product",
+  "layout",
+  "home",
+  "modal",
+  "drawer",
+  "dropdown",
+  "collapse",
+  "toast",
+  "navigation"
+];
+var FOLDERS_PATTERN = COMPONENT_FOLDERS.join("|");
+var DEEP_IMPORT_RE = new RegExp(
+  `(?:import|from)\\s+.*['"](?:\\.\\.\\/)+(${FOLDERS_PATTERN})\\/([^'"]+)['"]`,
+  "g"
+);
+var noDeepComponentImport = {
+  name: "no-deep-component-import",
+  description: "Enforce imports from barrel exports (index.ts) to preserve lazy loading.",
+  severity: "warn",
+  check(context) {
+    const violations = [];
+    const lines = context.code.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (!line.includes("import") && !line.includes("from")) continue;
+      DEEP_IMPORT_RE.lastIndex = 0;
+      let match;
+      while ((match = DEEP_IMPORT_RE.exec(line)) !== null) {
+        const folder = match[1];
+        violations.push({
+          rule: "no-deep-component-import",
+          message: `Deep import into '${folder}/' bypasses the barrel export and breaks lazy loading.`,
+          line: i + 1,
+          recommendation: `Import from '../${folder}' (barrel export) instead of '../${folder}/${match[2]}'.`
+        });
+      }
+    }
+    return violations;
+  }
+};
+
+// src/vite/plugins/best-practices/rules/no-window-location-reload.ts
+var RELOAD_RE = /window\s*\.\s*location\s*\.\s*reload\s*\(/g;
+var noWindowLocationReload = {
+  name: "no-window-location-reload",
+  description: "Disallow window.location.reload() in React components.",
+  severity: "error",
+  check(context) {
+    const violations = [];
+    const lines = context.code.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      RELOAD_RE.lastIndex = 0;
+      if (RELOAD_RE.test(line)) {
+        violations.push({
+          rule: "no-window-location-reload",
+          message: "window.location.reload() forces a full page reload, discarding React state.",
+          line: i + 1,
+          recommendation: "Use React state for empty-state handling, React key prop to remount components, or router.invalidate() to refetch loaders."
+        });
+      }
+    }
+    return violations;
+  }
+};
+
+// src/vite/plugins/best-practices/rules/no-manual-dom.ts
+var DOM_METHODS = [
+  { pattern: /document\s*\.\s*querySelector\s*\(/g, name: "document.querySelector()" },
+  { pattern: /document\s*\.\s*querySelectorAll\s*\(/g, name: "document.querySelectorAll()" },
+  { pattern: /document\s*\.\s*getElementById\s*\(/g, name: "document.getElementById()" },
+  {
+    pattern: /document\s*\.\s*getElementsByClassName\s*\(/g,
+    name: "document.getElementsByClassName()"
+  },
+  { pattern: /\.classList\s*\.\s*(?:add|remove|toggle)\s*\(/g, name: "classList manipulation" }
+];
+var noManualDom = {
+  name: "no-manual-dom",
+  description: "Disallow direct DOM manipulation in React components.",
+  severity: "warn",
+  check(context) {
+    const violations = [];
+    const lines = context.code.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (!line.includes("document") && !line.includes("classList")) continue;
+      for (const method of DOM_METHODS) {
+        method.pattern.lastIndex = 0;
+        if (method.pattern.test(line)) {
+          violations.push({
+            rule: "no-manual-dom",
+            message: `${method.name} performs direct DOM manipulation outside React's control.`,
+            line: i + 1,
+            recommendation: "Use useRef() for element access and React state/clsx() for class toggling."
+          });
+        }
+      }
+    }
+    return violations;
+  }
+};
+
+// src/vite/plugins/best-practices/rules/no-img-without-dimensions.ts
+var IMG_TAG_RE = /<img\s([^>]*?)\/?>/gi;
+var noImgWithoutDimensions = {
+  name: "no-img-without-dimensions",
+  description: "Require width and height on <img> elements to prevent layout shifts (CLS).",
+  severity: "info",
+  check(context) {
+    if (!/\.[jt]sx$/.test(context.id)) return [];
+    const violations = [];
+    const lines = context.code.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (!line.includes("<img")) continue;
+      IMG_TAG_RE.lastIndex = 0;
+      let match;
+      while ((match = IMG_TAG_RE.exec(line)) !== null) {
+        const attrs = match[1];
+        const hasWidth = /\bwidth\s*[={]/.test(attrs);
+        const hasHeight = /\bheight\s*[={]/.test(attrs);
+        if (!hasWidth || !hasHeight) {
+          violations.push({
+            rule: "no-img-without-dimensions",
+            message: "<img> without explicit width/height causes layout shifts (CLS).",
+            line: i + 1,
+            recommendation: "Add width and height attributes, or use the <Image> component which handles this automatically."
+          });
+        }
+      }
+    }
+    return violations;
+  }
+};
+
+// src/vite/plugins/best-practices/rules/no-direct-product-card-import.ts
+var DIRECT_PRODUCT_CARD_IMPORT_RE = /(?:import|from)\s+.*['"](?:\.\.\/)+product\/ProductCard['"]/g;
+var ALLOWED_PATHS = ["/ProductCard.tsx", "/ProductCard.test.tsx", ".test.", ".spec."];
+var noDirectProductCardImport = {
+  name: "no-direct-product-card-import",
+  description: "Prevent direct imports of ProductCard to ensure registry override works correctly.",
+  severity: "error",
+  check(context) {
+    const violations = [];
+    if (ALLOWED_PATHS.some((path) => context.relativeId.includes(path))) {
+      return violations;
+    }
+    const lines = context.code.split("\n");
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      if (!line.includes("import") && !line.includes("from")) continue;
+      DIRECT_PRODUCT_CARD_IMPORT_RE.lastIndex = 0;
+      if (DIRECT_PRODUCT_CARD_IMPORT_RE.test(line)) {
+        violations.push({
+          rule: "no-direct-product-card-import",
+          message: `Direct import of ProductCard bypasses the registry override mechanism.`,
+          line: i + 1,
+          recommendation: `Import ProductCard from barrel export '../product' or use registry override to customize.`
+        });
+      }
+    }
+    return violations;
+  }
+};
+
+// src/vite/plugins/best-practices/hooks-registry.ts
+var ROUTE_HOOK_MAP = [
+  // Product Page
+  {
+    pattern: /ProductPage|product\.tsx$/,
+    routeType: "product",
+    expectedHooks: [
+      { hook: "product:start", severity: "warn" },
+      { hook: "product:details.start", severity: "warn" },
+      { hook: "product:details.end", severity: "warn" },
+      { hook: "product:single.description.start", severity: "warn" },
+      { hook: "product:single.description", severity: "warn" },
+      { hook: "product:single.description.end", severity: "warn" },
+      { hook: "product:single.form.start", severity: "warn" },
+      { hook: "product:single.form.end", severity: "warn" },
+      { hook: "product:related.start", severity: "warn" },
+      { hook: "product:related.end", severity: "warn" },
+      { hook: "product:end", severity: "warn" }
+    ]
+  },
+  // Cart Page
+  {
+    pattern: /CartPage|cart\.tsx$/,
+    routeType: "cart",
+    expectedHooks: [
+      { hook: "cart:start", severity: "warn" },
+      { hook: "cart:items.start", severity: "warn" },
+      { hook: "cart:items.end", severity: "warn" },
+      { hook: "cart:summary.start", severity: "warn" },
+      { hook: "cart:summary.end", severity: "warn" },
+      { hook: "cart:submit.start", severity: "warn" },
+      { hook: "cart:submit.end", severity: "warn" },
+      { hook: "cart:end", severity: "warn" }
+    ]
+  },
+  // Home Page
+  {
+    pattern: /routes\/home\/HomePage\.tsx$/,
+    routeType: "home",
+    expectedHooks: [
+      { hook: "home:start", severity: "warn" },
+      { hook: "home:content", severity: "warn" },
+      { hook: "home:end", severity: "warn" }
+    ]
+  },
+  // Blog Index
+  {
+    pattern: /BlogPage|blog\.tsx$/,
+    routeType: "blog",
+    expectedHooks: [
+      { hook: "blog:start", severity: "warn" },
+      { hook: "blog:items.start", severity: "warn" },
+      { hook: "blog:items.end", severity: "warn" },
+      { hook: "blog:end", severity: "warn" }
+    ]
+  },
+  // Blog Single
+  {
+    pattern: /BlogSinglePage/,
+    routeType: "blog-single",
+    expectedHooks: [
+      { hook: "blog:single.start", severity: "warn" },
+      { hook: "blog:single.end", severity: "warn" },
+      { hook: "blog:single.related.start", severity: "warn" },
+      { hook: "blog:single.related.end", severity: "warn" }
+    ]
+  },
+  // Blog Category
+  {
+    pattern: /BlogCategoryPage/,
+    routeType: "blog-category",
+    expectedHooks: [
+      { hook: "blog:category.start", severity: "warn" },
+      { hook: "blog:category.end", severity: "warn" }
+    ]
+  },
+  // Blog Tag
+  {
+    pattern: /BlogTagPage/,
+    routeType: "blog-tag",
+    expectedHooks: [
+      { hook: "blog:tag.start", severity: "warn" },
+      { hook: "blog:tag.end", severity: "warn" }
+    ]
+  },
+  // Blog Author
+  {
+    pattern: /BlogAuthorPage/,
+    routeType: "blog-author",
+    expectedHooks: [
+      { hook: "blog:author.start", severity: "warn" },
+      { hook: "blog:author.end", severity: "warn" }
+    ]
+  },
+  // Product Listing
+  {
+    pattern: /ProductListPage\.tsx$/,
+    routeType: "product-listing",
+    expectedHooks: [
+      { hook: "product:list.start", severity: "warn" },
+      { hook: "product:list.items.start", severity: "warn" },
+      { hook: "product:list.items.end", severity: "warn" },
+      { hook: "product:list.end", severity: "warn" }
+    ]
+  },
+  // Brands
+  {
+    pattern: /BrandsPage\.tsx$/,
+    routeType: "brands",
+    expectedHooks: [
+      { hook: "brands:index.items.start", severity: "warn" },
+      { hook: "brands:index.items.end", severity: "warn" }
+    ]
+  },
+  // Thank You
+  {
+    pattern: /ThankYouPage\.tsx$/,
+    routeType: "thank-you",
+    expectedHooks: [
+      { hook: "thank-you:start", severity: "warn" },
+      { hook: "thank-you:items.start", severity: "warn" },
+      { hook: "thank-you:items.end", severity: "warn" },
+      { hook: "thank-you:end", severity: "warn" }
+    ]
+  },
+  // Not Found
+  {
+    pattern: /not-found/,
+    routeType: "not-found",
+    expectedHooks: [
+      { hook: "notfound:start", severity: "warn" },
+      { hook: "notfound:content", severity: "warn" },
+      { hook: "notfound:end", severity: "warn" }
+    ]
+  },
+  // Account - Profile
+  {
+    pattern: /ProfilePage\.tsx$/,
+    routeType: "customer-profile",
+    expectedHooks: [
+      { hook: "customer:profile.start", severity: "warn" },
+      { hook: "customer:profile.form.start", severity: "warn" },
+      { hook: "customer:profile.form.end", severity: "warn" },
+      { hook: "customer:profile.end", severity: "warn" }
+    ]
+  },
+  // Account - Orders
+  {
+    pattern: /OrdersPage\.tsx$/,
+    routeType: "customer-orders",
+    expectedHooks: [
+      { hook: "customer:orders.index.items.start", severity: "warn" },
+      { hook: "customer:orders.index.items.end", severity: "warn" }
+    ]
+  },
+  // Account - Order Single
+  {
+    pattern: /OrderSinglePage\.tsx$/,
+    routeType: "customer-order-single",
+    expectedHooks: [
+      { hook: "customer:orders.single.details.start", severity: "warn" },
+      { hook: "customer:orders.single.details.end", severity: "warn" }
+    ]
+  },
+  // Account - Notifications
+  {
+    pattern: /NotificationsPage\.tsx$/,
+    routeType: "customer-notifications",
+    expectedHooks: [
+      { hook: "customer:notifications.items.start", severity: "warn" },
+      { hook: "customer:notifications.items.end", severity: "warn" }
+    ]
+  },
+  // Account - Wallet
+  {
+    pattern: /WalletPage\.tsx$/,
+    routeType: "customer-wallet",
+    expectedHooks: [
+      { hook: "customer:wallet.transactions.start", severity: "warn" },
+      { hook: "customer:wallet.transactions.end", severity: "warn" }
+    ]
+  },
+  // Account - Settings
+  {
+    pattern: /SettingsPage\.tsx$/,
+    routeType: "customer-settings",
+    expectedHooks: [
+      { hook: "customer:settings.start", severity: "warn" },
+      { hook: "customer:settings.end", severity: "warn" }
+    ]
+  },
+  // Account - Wishlist
+  {
+    pattern: /WishlistPage\.tsx$/,
+    routeType: "customer-wishlist",
+    expectedHooks: [
+      { hook: "customer:wishlist.items.start", severity: "warn" },
+      { hook: "customer:wishlist.items.end", severity: "warn" }
+    ]
+  }
+];
+function getExpectedHooks(filePath) {
+  for (const entry of ROUTE_HOOK_MAP) {
+    if (entry.pattern.test(filePath)) {
+      return entry.expectedHooks;
+    }
+  }
+  return null;
+}
+
+// src/vite/plugins/best-practices/rules/require-page-hooks.ts
+var HOOK_NAME_ENUM_TO_STRING = {
+  BODY_START: "body:start",
+  BODY_END: "body:end",
+  BODY_INNER: "body:inner",
+  HEAD_START: "head:start",
+  HEAD_END: "head:end",
+  HEAD_INNER: "head:inner",
+  HEADER_START: "header:start",
+  HEADER_END: "header:end",
+  FOOTER_START: "footer:start",
+  FOOTER_END: "footer:end",
+  PRODUCT_DESCRIPTION_START: "product:single.description.start",
+  PRODUCT_DESCRIPTION: "product:single.description",
+  PRODUCT_DESCRIPTION_END: "product:single.description.end",
+  PRODUCT_FORM_START: "product:single.form.start",
+  PRODUCT_FORM_END: "product:single.form.end",
+  CART_ITEMS_START: "cart:items.start",
+  CART_ITEMS_END: "cart:items.end",
+  CART_SUMMARY_START: "cart:summary.start",
+  CART_SUMMARY_END: "cart:summary.end",
+  SEARCH_START: "search:start",
+  SEARCH_ITEMS_START: "search:items.start",
+  SEARCH_ITEMS_END: "search:items.end",
+  SEARCH_END: "search:end",
+  HOMEPAGE_SLIDER: "homepage:slider",
+  HOMEPAGE_BANNERS: "homepage:banners",
+  HOMEPAGE_FEATURED: "homepage:featured"
+};
+function isNodeModules(path) {
+  return path.includes("node_modules");
+}
+function isLocalImport(importPath) {
+  return importPath.startsWith(".") || importPath.startsWith("/");
+}
+function importsThemeEngineRoutes(code) {
+  const importRegex = /import\s+.*\s+from\s+['"]@salla\.sa\/twilight-theme-engine\/routes\/[^'"]+['"]/;
+  return importRegex.test(code);
+}
+function resolveImportPath(importer, importPath) {
+  const dir = dirname(importer);
+  const resolved = resolve(dir, importPath);
+  if (existsSync(resolved)) {
+    try {
+      if (statSync(resolved).isFile()) {
+        return resolved;
+      }
+    } catch {
+    }
+  }
+  for (const ext of [".ts", ".tsx", ".js", ".jsx"]) {
+    const withExt = resolved + ext;
+    if (existsSync(withExt)) return withExt;
+  }
+  for (const index of ["index.ts", "index.tsx", "index.js", "index.jsx"]) {
+    const indexPath = resolve(resolved, index);
+    if (existsSync(indexPath)) return indexPath;
+  }
+  return null;
+}
+function extractHookNameFromAttrValue(attrValue) {
+  if (!attrValue || typeof attrValue !== "object") return null;
+  const value = attrValue;
+  if ((value.type === "Literal" || value.type === "StringLiteral") && typeof value.value === "string") {
+    return value.value;
+  }
+  if (value.type === "JSXExpressionContainer") {
+    const expr = value.expression;
+    if (expr?.type === "MemberExpression") {
+      const object = expr.object;
+      const property = expr.property;
+      if (object?.type === "Identifier" && object.name === "HookName" && property?.type === "Identifier" && typeof property.name === "string") {
+        return HOOK_NAME_ENUM_TO_STRING[property.name] || null;
+      }
+    }
+  }
+  return null;
+}
+function extractHooksFromAst(node, hooks) {
+  if (!node || typeof node !== "object") return;
+  const obj = node;
+  if (obj.type === "JSXElement") {
+    const opening = obj.openingElement;
+    if (opening && typeof opening === "object") {
+      const name = opening.name;
+      if (name?.type === "JSXIdentifier" && name.name === "HookSlot") {
+        const attributes = opening.attributes;
+        if (Array.isArray(attributes)) {
+          for (const attr of attributes) {
+            if (attr && typeof attr === "object") {
+              const attrObj = attr;
+              if (attrObj.type === "JSXAttribute") {
+                const attrName = attrObj.name;
+                if (attrName?.type === "JSXIdentifier" && attrName.name === "name") {
+                  const hookName = extractHookNameFromAttrValue(attrObj.value);
+                  if (hookName) hooks.add(hookName);
+                }
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  if (obj.type === "CallExpression") {
+    const callee = obj.callee;
+    if (callee?.type === "MemberExpression") {
+      const object = callee.object;
+      const property = callee.property;
+      if (object?.type === "Identifier" && object.name === "hookRegistry" && property?.type === "Identifier" && property.name === "register") {
+        const args = obj.arguments;
+        if (Array.isArray(args) && args.length > 0) {
+          const firstArg = args[0];
+          const expr = firstArg.expression || firstArg;
+          if ((expr?.type === "Literal" || expr?.type === "StringLiteral") && typeof expr.value === "string") {
+            hooks.add(expr.value);
+          } else if (expr?.type === "MemberExpression") {
+            const argObject = expr.object;
+            const argProperty = expr.property;
+            if (argObject?.type === "Identifier" && argObject.name === "HookName" && argProperty?.type === "Identifier" && typeof argProperty.name === "string") {
+              const hookName = HOOK_NAME_ENUM_TO_STRING[argProperty.name];
+              if (hookName) hooks.add(hookName);
+            }
+          }
+        }
+      }
+    }
+  }
+  for (const key of Object.keys(obj)) {
+    if (key === "loc" || key === "range" || key === "start" || key === "end") continue;
+    const child = obj[key];
+    if (Array.isArray(child)) {
+      for (const item of child) {
+        extractHooksFromAst(item, hooks);
+      }
+    } else if (typeof child === "object" && child !== null) {
+      extractHooksFromAst(child, hooks);
+    }
+  }
+}
+function findDynamicImportsInNode(node, filePath, visited, hooks) {
+  if (!node || typeof node !== "object") return;
+  const obj = node;
+  if (obj.type === "ImportExpression") {
+    const source = obj.source;
+    if ((source?.type === "Literal" || source?.type === "StringLiteral") && typeof source.value === "string") {
+      const importPath = source.value;
+      if (isLocalImport(importPath)) {
+        const resolved = resolveImportPath(filePath, importPath);
+        if (resolved) {
+          const nestedHooks = findHooksInFile(resolved, visited);
+          for (const hook of nestedHooks) {
+            hooks.add(hook);
+          }
+        }
+      }
+    }
+  }
+  for (const key of Object.keys(obj)) {
+    if (key === "loc" || key === "range" || key === "start" || key === "end") continue;
+    const child = obj[key];
+    if (Array.isArray(child)) {
+      for (const item of child) {
+        findDynamicImportsInNode(item, filePath, visited, hooks);
+      }
+    } else if (typeof child === "object" && child !== null) {
+      findDynamicImportsInNode(child, filePath, visited, hooks);
+    }
+  }
+}
+function findHooksInFile(filePath, visited = /* @__PURE__ */ new Set()) {
+  if (visited.has(filePath)) return /* @__PURE__ */ new Set();
+  if (isNodeModules(filePath)) return /* @__PURE__ */ new Set();
+  visited.add(filePath);
+  const hooks = /* @__PURE__ */ new Set();
+  try {
+    const code = readFileSync(filePath, "utf-8");
+    const ast = parseSync(filePath, code, {
+      sourceType: "module",
+      preserveParens: false
+    });
+    extractHooksFromAst(ast.program, hooks);
+    const body = ast.program?.body;
+    if (Array.isArray(body)) {
+      for (const stmt of body) {
+        if (stmt && typeof stmt === "object") {
+          const stmtObj = stmt;
+          if (stmtObj.type === "ImportDeclaration") {
+            const source = stmtObj.source;
+            if ((source?.type === "Literal" || source?.type === "StringLiteral") && typeof source.value === "string") {
+              const importPath = source.value;
+              if (isLocalImport(importPath)) {
+                const resolved = resolveImportPath(filePath, importPath);
+                if (resolved) {
+                  const nestedHooks = findHooksInFile(resolved, visited);
+                  for (const hook of nestedHooks) {
+                    hooks.add(hook);
+                  }
+                }
+              }
+            }
+          }
+          if (stmtObj.type === "ExportNamedDeclaration") {
+            const source = stmtObj.source;
+            if (source && (source.type === "Literal" || source.type === "StringLiteral") && typeof source.value === "string") {
+              const importPath = source.value;
+              if (isLocalImport(importPath)) {
+                const resolved = resolveImportPath(filePath, importPath);
+                if (resolved) {
+                  const nestedHooks = findHooksInFile(resolved, visited);
+                  for (const hook of nestedHooks) {
+                    hooks.add(hook);
+                  }
+                }
+              }
+            }
+          }
+          findDynamicImportsInNode(stmtObj, filePath, visited, hooks);
+        }
+      }
+    }
+  } catch {
+  }
+  return hooks;
+}
+function getLineForHook(code, hookName) {
+  const lines = code.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].includes(hookName)) {
+      return i + 1;
+    }
+  }
+  return 1;
+}
+var requirePageHooks = {
+  name: "require-page-hooks",
+  description: "Ensure route files include expected HookSlot or hookRegistry entries for customization.",
+  severity: "warn",
+  check(context) {
+    const violations = [];
+    const expectedHooks = getExpectedHooks(context.relativeId);
+    if (!expectedHooks) return violations;
+    if (importsThemeEngineRoutes(context.code)) {
+      return violations;
+    }
+    let foundHooks;
+    try {
+      foundHooks = findHooksInFile(context.id);
+    } catch {
+      foundHooks = /* @__PURE__ */ new Set();
+    }
+    if (foundHooks.size === 0) {
+      try {
+        const ast = parseSync(context.id, context.code, {
+          sourceType: "module",
+          preserveParens: false
+        });
+        extractHooksFromAst(ast.program, foundHooks);
+      } catch {
+      }
+    }
+    for (const expected of expectedHooks) {
+      if (!foundHooks.has(expected.hook)) {
+        violations.push({
+          rule: "require-page-hooks",
+          message: `Missing expected hook '${expected.hook}' in ${context.relativeId}`,
+          line: getLineForHook(context.code, "HookSlot") || 1,
+          recommendation: `Add <HookSlot name="${expected.hook}" /> or hookRegistry.register('${expected.hook}', ...) to enable theme customization.`
+        });
+      }
+    }
+    return violations;
+  }
+};
+
+// src/vite/plugins/best-practices/rules/index.ts
+var builtinRules = [
+  noDeepComponentImport,
+  noWindowLocationReload,
+  noManualDom,
+  noImgWithoutDimensions,
+  noDirectProductCardImport,
+  requirePageHooks
+];
+
+// src/vite/plugins/best-practices/reporter.ts
+var COLORS = {
+  reset: "\x1B[0m",
+  red: "\x1B[31m",
+  yellow: "\x1B[33m",
+  cyan: "\x1B[36m",
+  dim: "\x1B[2m",
+  bold: "\x1B[1m",
+  green: "\x1B[32m"
+};
+var SEVERITY_LABEL = {
+  error: `${COLORS.red}ERROR${COLORS.reset}`,
+  warn: `${COLORS.yellow}WARN${COLORS.reset}`,
+  info: `${COLORS.cyan}INFO${COLORS.reset}`
+};
+var SEVERITY_ICON = {
+  error: `${COLORS.red}\u2718${COLORS.reset}`,
+  warn: `${COLORS.yellow}\u26A0${COLORS.reset}`,
+  info: `${COLORS.cyan}\u2139${COLORS.reset}`
+};
+function formatViolation(violation, severity, relativeId) {
+  const loc = `${COLORS.dim}${relativeId}:${violation.line}${COLORS.reset}`;
+  const icon = SEVERITY_ICON[severity];
+  const label = SEVERITY_LABEL[severity];
+  const rule = `${COLORS.dim}(${violation.rule})${COLORS.reset}`;
+  return [
+    `  ${icon} ${label} ${rule}`,
+    `    ${loc}`,
+    `    ${violation.message}`,
+    `    ${COLORS.green}\u2192 ${violation.recommendation}${COLORS.reset}`
+  ].join("\n");
+}
+function formatSummary(errors, warnings, infos) {
+  const parts = [];
+  if (errors > 0) parts.push(`${COLORS.red}${errors} error(s)${COLORS.reset}`);
+  if (warnings > 0) parts.push(`${COLORS.yellow}${warnings} warning(s)${COLORS.reset}`);
+  if (infos > 0) parts.push(`${COLORS.cyan}${infos} info(s)${COLORS.reset}`);
+  return `${COLORS.bold}[twilight:best-practices]${COLORS.reset} ${parts.join(", ")}`;
+}
+var fileHashCache = /* @__PURE__ */ new Map();
+function hash(content) {
+  return createHash("md5").update(content).digest("hex");
+}
+function matchesGlob(id, patterns) {
+  return patterns.some((p) => {
+    if (/[\\^$|+?(){}[\]\\\\]/.test(p)) return false;
+    const regex = new RegExp(
+      "^" + p.replace(/\./g, "\\.").replace(/\*\*/g, "\0GLOBSTAR\0").replace(/\*/g, "[^/]*").replace(/\0GLOBSTAR\0/g, ".*") + "$"
+    );
+    return regex.test(id);
+  });
+}
+function bestPracticesPlugin(options = {}) {
+  const {
+    include = ["**/*.ts", "**/*.tsx"],
+    exclude = ["**/node_modules/**", "**/dist/**", "**/*.d.ts", "**/.twilight/**"],
+    disabledRules = [],
+    severityOverrides = {},
+    browserConsole = false
+  } = options;
+  const enabledRules = builtinRules.filter((r) => !disabledRules.includes(r.name));
+  let projectRoot = "";
+  return {
+    name: "twilight:best-practices",
+    apply: "build",
+    enforce: "pre",
+    configResolved(config) {
+      projectRoot = config.root;
+    },
+    transform(code, id) {
+      if (!/\.[jt]sx?$/.test(id)) return null;
+      const relativeId = relative(projectRoot, id);
+      if (!matchesGlob(relativeId, include)) return null;
+      if (matchesGlob(relativeId, exclude)) return null;
+      const h = hash(code);
+      if (fileHashCache.get(id) === h) return null;
+      fileHashCache.set(id, h);
+      const context = { code, id, relativeId };
+      const allViolations = [];
+      for (const rule of enabledRules) {
+        const severity = severityOverrides[rule.name] ?? rule.severity;
+        const violations = rule.check(context);
+        for (const v of violations) {
+          allViolations.push({ violation: v, severity });
+        }
+      }
+      if (allViolations.length === 0) return null;
+      const counts = { error: 0, warn: 0, info: 0 };
+      const lines = [];
+      for (const { violation, severity } of allViolations) {
+        counts[severity]++;
+        lines.push(formatViolation(violation, severity, relativeId));
+      }
+      console.error("\n" + lines.join("\n"));
+      console.error(formatSummary(counts.error, counts.warn, counts.info) + "\n");
+      if (browserConsole && allViolations.length > 0) {
+        const consoleStatements = allViolations.map(({ violation, severity }) => {
+          const method = severity === "error" ? "error" : severity === "warn" ? "warn" : "info";
+          const msg = `[twilight:${violation.rule}] ${violation.message}\\n  \u2192 ${violation.recommendation}\\n  at ${relativeId}:${violation.line}`;
+          return `console.${method}(${JSON.stringify(msg)});`;
+        }).join("\n");
+        return {
+          code: code + "\n" + consoleStatements,
+          map: null
+        };
+      }
+      return null;
+    }
+  };
+}
+function findEngineSrc(startDir) {
+  let dir = startDir;
+  for (let i = 0; i < 6; i++) {
+    const candidate = resolve(dir, "src");
+    if (existsSync(resolve(candidate, "index.ts"))) return candidate;
+    dir = resolve(dir, "..");
+  }
+  return null;
+}
+var engineSrc = findEngineSrc(dirname(fileURLToPath(import.meta.url)));
+var PKG = "@salla.sa/twilight-theme-engine";
+var ESCAPED_PKG = PKG.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var SAFE_SUBPATH = /^[a-zA-Z0-9/_-]+$/;
+function pkgPattern(subpath) {
+  if (subpath && !SAFE_SUBPATH.test(subpath))
+    throw new Error(`Invalid package subpath: ${subpath}`);
+  return new RegExp(`^${ESCAPED_PKG}${subpath ? "/" + subpath : ""}$`);
+}
+var ALIASES = !engineSrc ? [] : [
+  { find: pkgPattern("i18n"), replacement: resolve(engineSrc, "providers/i18n.ts") },
+  { find: pkgPattern("hooks"), replacement: resolve(engineSrc, "hooks/index.ts") },
+  {
+    find: pkgPattern("hooks/useAsyncFn"),
+    replacement: resolve(engineSrc, "hooks/useAsyncFn.ts")
+  },
+  { find: pkgPattern("hooks/useStore"), replacement: resolve(engineSrc, "hooks/useStore.ts") },
+  { find: pkgPattern("hooks/useTheme"), replacement: resolve(engineSrc, "hooks/useTheme.ts") },
+  { find: pkgPattern("hooks/useMoney"), replacement: resolve(engineSrc, "hooks/useMoney.tsx") },
+  { find: pkgPattern("hooks/useAsset"), replacement: resolve(engineSrc, "hooks/useAsset.ts") },
+  {
+    find: pkgPattern("hooks/useProduct"),
+    replacement: resolve(engineSrc, "hooks/useProduct.ts")
+  },
+  {
+    find: pkgPattern("hooks/useDocumentClass"),
+    replacement: resolve(engineSrc, "hooks/useDocumentClass.ts")
+  },
+  {
+    find: pkgPattern("hooks/useCoupon"),
+    replacement: resolve(engineSrc, "hooks/useCoupon.ts")
+  },
+  {
+    find: pkgPattern("hooks/useWishlist"),
+    replacement: resolve(engineSrc, "hooks/useWishlist.ts")
+  },
+  {
+    find: pkgPattern("hooks/useBlogLike"),
+    replacement: resolve(engineSrc, "hooks/useBlogLike.ts")
+  },
+  {
+    find: pkgPattern("hooks/useComments"),
+    replacement: resolve(engineSrc, "hooks/useComments.ts")
+  },
+  {
+    find: pkgPattern("hooks/HookRegistry"),
+    replacement: resolve(engineSrc, "hooks/HookRegistry.ts")
+  },
+  { find: pkgPattern("hooks/HookSlot"), replacement: resolve(engineSrc, "hooks/HookSlot.tsx") },
+  { find: pkgPattern("hooks/useHook"), replacement: resolve(engineSrc, "hooks/useHook.ts") },
+  { find: pkgPattern("hooks/useGtm"), replacement: resolve(engineSrc, "hooks/useGtm.ts") },
+  { find: pkgPattern("contexts"), replacement: resolve(engineSrc, "contexts/index.ts") },
+  { find: pkgPattern("utils"), replacement: resolve(engineSrc, "utils/index.ts") },
+  { find: pkgPattern("utils/baseHead"), replacement: resolve(engineSrc, "utils/baseHead.ts") },
+  { find: pkgPattern("utils/head"), replacement: resolve(engineSrc, "utils/head.ts") },
+  { find: pkgPattern("types"), replacement: resolve(engineSrc, "types/index.ts") },
+  { find: pkgPattern("types/hooks"), replacement: resolve(engineSrc, "types/hooks.ts") },
+  { find: pkgPattern("eslint"), replacement: resolve(engineSrc, "eslint/index.ts") },
+  { find: pkgPattern("vite"), replacement: resolve(engineSrc, "vite/index.ts") },
+  { find: pkgPattern("routes"), replacement: resolve(engineSrc, "routes/index.ts") },
+  { find: pkgPattern("routes/home"), replacement: resolve(engineSrc, "routes/home/index.tsx") },
+  { find: pkgPattern("routes/cart"), replacement: resolve(engineSrc, "routes/cart/index.tsx") },
+  {
+    find: pkgPattern("routes/product"),
+    replacement: resolve(engineSrc, "routes/product/index.tsx")
+  },
+  {
+    find: pkgPattern("routes/product-listing"),
+    replacement: resolve(engineSrc, "routes/product-listing/index.tsx")
+  },
+  { find: pkgPattern("routes/blog"), replacement: resolve(engineSrc, "routes/blog/index.tsx") },
+  {
+    find: pkgPattern("routes/brands"),
+    replacement: resolve(engineSrc, "routes/brands/index.tsx")
+  },
+  {
+    find: pkgPattern("routes/account"),
+    replacement: resolve(engineSrc, "routes/account/index.tsx")
+  },
+  {
+    find: pkgPattern("routes/account/orders"),
+    replacement: resolve(engineSrc, "routes/account/orders/index.tsx")
+  },
+  {
+    find: pkgPattern("routes/loyalty"),
+    replacement: resolve(engineSrc, "routes/loyalty/index.tsx")
+  },
+  { find: pkgPattern("routes/page"), replacement: resolve(engineSrc, "routes/page/index.tsx") },
+  {
+    find: pkgPattern("routes/testimonials"),
+    replacement: resolve(engineSrc, "routes/testimonials/index.tsx")
+  },
+  {
+    find: pkgPattern("routes/thank-you"),
+    replacement: resolve(engineSrc, "routes/thank-you/index.tsx")
+  },
+  {
+    find: pkgPattern("routes/seo-redirects"),
+    replacement: resolve(engineSrc, "routes/seo-redirects.ts")
+  },
+  { find: pkgPattern("skeleton"), replacement: resolve(engineSrc, "skeleton.ts") },
+  { find: pkgPattern("tanstack"), replacement: resolve(engineSrc, "tanstack/index.ts") },
+  { find: pkgPattern("nextjs"), replacement: resolve(engineSrc, "nextjs/index.ts") },
+  { find: pkgPattern("dom"), replacement: resolve(engineSrc, "dom/index.ts") },
+  {
+    find: pkgPattern("components/modal"),
+    replacement: resolve(engineSrc, "components/modal/index.ts")
+  },
+  {
+    find: pkgPattern("components/drawer"),
+    replacement: resolve(engineSrc, "components/drawer/index.ts")
+  },
+  {
+    find: pkgPattern("components/dropdown"),
+    replacement: resolve(engineSrc, "components/dropdown/index.ts")
+  },
+  {
+    find: pkgPattern("components/collapse"),
+    replacement: resolve(engineSrc, "components/collapse/index.ts")
+  },
+  {
+    find: pkgPattern("components/toast"),
+    replacement: resolve(engineSrc, "components/toast/index.ts")
+  },
+  {
+    find: pkgPattern("components/cart"),
+    replacement: resolve(engineSrc, "components/cart/index.ts")
+  },
+  {
+    find: pkgPattern("components/product"),
+    replacement: resolve(engineSrc, "components/product/index.ts")
+  },
+  {
+    find: pkgPattern("components/layout"),
+    replacement: resolve(engineSrc, "components/layout/index.ts")
+  },
+  {
+    find: pkgPattern("components/home"),
+    replacement: resolve(engineSrc, "components/home/index.ts")
+  },
+  {
+    find: pkgPattern("components/common"),
+    replacement: resolve(engineSrc, "components/common/index.ts")
+  },
+  { find: pkgPattern("modal"), replacement: resolve(engineSrc, "components/modal/index.ts") },
+  { find: pkgPattern("drawer"), replacement: resolve(engineSrc, "components/drawer/index.ts") },
+  {
+    find: pkgPattern("dropdown"),
+    replacement: resolve(engineSrc, "components/dropdown/index.ts")
+  },
+  {
+    find: pkgPattern("collapse"),
+    replacement: resolve(engineSrc, "components/collapse/index.ts")
+  },
+  { find: pkgPattern("toast"), replacement: resolve(engineSrc, "components/toast/index.ts") },
+  { find: pkgPattern("cart"), replacement: resolve(engineSrc, "components/cart/index.ts") },
+  {
+    find: pkgPattern("product"),
+    replacement: resolve(engineSrc, "components/product/index.ts")
+  },
+  { find: pkgPattern("layout"), replacement: resolve(engineSrc, "components/layout/index.ts") },
+  { find: pkgPattern("home"), replacement: resolve(engineSrc, "components/home/index.ts") },
+  { find: pkgPattern("common"), replacement: resolve(engineSrc, "components/common/index.ts") },
+  { find: pkgPattern("providers"), replacement: resolve(engineSrc, "providers/index.ts") },
+  { find: pkgPattern("api/types"), replacement: resolve(engineSrc, "api/types.ts") },
+  { find: pkgPattern("api/client"), replacement: resolve(engineSrc, "api/client.ts") },
+  { find: pkgPattern("api/store"), replacement: resolve(engineSrc, "api/store.ts") },
+  {
+    find: pkgPattern("api/translations"),
+    replacement: resolve(engineSrc, "api/translations.ts")
+  },
+  { find: pkgPattern("api/cart"), replacement: resolve(engineSrc, "api/cart.ts") },
+  { find: pkgPattern("api/product"), replacement: resolve(engineSrc, "api/product.ts") },
+  { find: pkgPattern("api/home"), replacement: resolve(engineSrc, "api/home.ts") },
+  { find: pkgPattern("api/brands"), replacement: resolve(engineSrc, "api/brands.ts") },
+  { find: pkgPattern("api/loyalty"), replacement: resolve(engineSrc, "api/loyalty.ts") },
+  { find: pkgPattern("api/order"), replacement: resolve(engineSrc, "api/order.ts") },
+  { find: pkgPattern("api/category"), replacement: resolve(engineSrc, "api/category.ts") },
+  { find: pkgPattern("api/page"), replacement: resolve(engineSrc, "api/page.ts") },
+  { find: pkgPattern("api/menu"), replacement: resolve(engineSrc, "api/menu.ts") },
+  {
+    find: pkgPattern("api/notification"),
+    replacement: resolve(engineSrc, "api/notification.ts")
+  },
+  { find: pkgPattern("api/wishlist"), replacement: resolve(engineSrc, "api/wishlist.ts") },
+  { find: pkgPattern("api/profile"), replacement: resolve(engineSrc, "api/profile.ts") },
+  {
+    find: pkgPattern("tracking"),
+    replacement: resolve(engineSrc, "components/tracking/index.ts")
+  },
+  { find: pkgPattern("store"), replacement: resolve(engineSrc, "components/store/index.ts") },
+  { find: pkgPattern(""), replacement: resolve(engineSrc, "index.ts") }
+];
+function packageAliasesPlugin() {
+  return {
+    name: "twilight:package-aliases",
+    enforce: "pre",
+    config() {
+      return {
+        resolve: {
+          alias: ALIASES
+        }
+      };
+    }
+  };
+}
+
+// src/tanstack/templates/locale-wrapper.ts
+function getLocaleWrapperTemplate(baseRoutesImport) {
+  const mainPkg = baseRoutesImport.replace(/\/routes$/, "");
+  return `// @auto-generated
+// @ts-nocheck \u2014 params types are generated by TanStack Router on pnpm dev
+import { createFileRoute, Outlet, redirect } from '@tanstack/react-router';
+import { FALLBACK_LOCALE, isLocale } from '${baseRoutesImport}';
+import { store } from '${mainPkg}/api/store';
+
+export const Route = createFileRoute('/{-$locale}')({
+  beforeLoad: ({ params, location }) => {
+    const { locale } = params;
+    if (!locale) return;
+    if (!isLocale(locale)) {
+      throw redirect({ to: \`/\${FALLBACK_LOCALE}\${location.pathname}\`, replace: true });
+    }
+  },
+  loader: async ({ params, context, location }) => {
+    const settings = await context.queryClient.ensureQueryData(store.queries.settings());
+    const isMultilingual = settings?.store?.settings?.is_multilingual ?? true;
+
+    if (!isMultilingual && params.locale) {
+      throw redirect({
+        to: location.pathname.slice(\`/\${params.locale}\`.length) || '/',
+        replace: true,
+      });
+    }
+    if (isMultilingual && !params.locale) {
+      throw redirect({ to: \`/\${FALLBACK_LOCALE}\${location.pathname}\`, replace: true });
+    }
+  },
+  component: () => <Outlet />,
+});
+`;
+}
+
+// src/tanstack/templates/redirect.ts
+function getRedirectTemplate(baseRoutesImport) {
+  return `// @auto-generated
+// @ts-nocheck \u2014 params types are generated by TanStack Router on pnpm dev
+import { createFileRoute, redirect } from '@tanstack/react-router';
+import { FALLBACK_LOCALE } from '${baseRoutesImport}';
+
+type RedirectType =
+  | 'products'
+  | 'categories'
+  | 'brands'
+  | 'pages'
+  | 'blog_articles'
+  | 'blog_categories'
+  | 'products_tags'
+  | 'reviews_link'
+  | 'book_now';
+
+export const Route = createFileRoute('/{-$locale}/redirect/$type/$id')({
+  loader: async ({ params }) => {
+    const { type, id } = params;
+    const locale = params.locale || FALLBACK_LOCALE;
+
+    let redirectPath: string;
+    const slug = '-';
+
+    switch (type as RedirectType) {
+      case 'products':
+        redirectPath = \`/\${locale}/\${slug}/p\${id}\`;
+        break;
+      case 'categories':
+        redirectPath = \`/\${locale}/\${slug}/c\${id}\`;
+        break;
+      case 'brands':
+        redirectPath = \`/\${locale}/brands/\${id}\`;
+        break;
+      case 'pages':
+        redirectPath = \`/\${locale}/page-\${id}\`;
+        break;
+      case 'blog_articles':
+        redirectPath = \`/\${locale}/blog/\${slug}/a-\${id}\`;
+        break;
+      case 'blog_categories':
+        redirectPath = \`/\${locale}/blog/\${slug}/c-\${id}\`;
+        break;
+      case 'products_tags':
+        redirectPath = \`/\${locale}/\${slug}/tag-\${id}\`;
+        break;
+      case 'book_now':
+        redirectPath = \`/\${locale}/landing/\${id}\`;
+        break;
+      case 'reviews_link':
+      default:
+        redirectPath = \`/\${locale}\`;
+    }
+
+    throw redirect({ to: redirectPath });
+  },
+});
+`;
+}
+
+// src/tanstack/templates/account-layout.ts
+function getAccountLayoutTemplate(baseRoutesImport) {
+  const mainPkg = baseRoutesImport.replace(/\/routes$/, "");
+  return `// @auto-generated
+// @ts-nocheck \u2014 params types are generated by TanStack Router on pnpm dev
+import { createFileRoute, Outlet, useMatches } from '@tanstack/react-router';
+import { useComponent } from '${mainPkg}';
+import { CustomerLayout } from '${mainPkg}/components/layout';
+import { CustomerLayoutSkeleton } from '${mainPkg}/skeleton';
+
+const ACCOUNT_LAYOUT_PENDING_KEY = 'account:layout-pending';
+
+function AccountLayoutComponent() {
+  const matches = useMatches();
+  const page = matches.reduceRight(
+    (found, m) => found ?? (m.loaderData?.page ? m.loaderData.page : null),
+    null,
+  );
+
+  return (
+    <CustomerLayout page={page}>
+      <Outlet />
+    </CustomerLayout>
+  );
+}
+
+function AccountLayoutPendingComponent() {
+  const AccountLayoutPending = useComponent(ACCOUNT_LAYOUT_PENDING_KEY);
+  return AccountLayoutPending ? <AccountLayoutPending /> : <CustomerLayoutSkeleton />;
+}
+
+export const Route = createFileRoute('/{-$locale}/account')({
+  component: AccountLayoutComponent,
+  pendingComponent: AccountLayoutPendingComponent,
+});
+`;
+}
+
+// src/vite/adapters/tanstack.adapter.ts
+var DEFAULT_ROUTES_DIR = "./app/routes";
+var DEFAULT_ROUTES_FILE = "./app/routes.ts";
+var DEFAULT_ROOT_ROUTE = "__root.tsx";
+var DEFAULT_BASE_ROUTES = [
+  // Core routes
+  {
+    path: "/",
+    file: "index.tsx",
+    factory: "createHomeRouteConfig",
+    id: RouteId.INDEX,
+    isIndex: true
+  },
+  { path: "/cart", file: "cart.tsx", factory: "createCartRouteConfig", id: RouteId.CART },
+  { path: "/search", file: "search.tsx", factory: "createSearchRouteConfig", id: RouteId.SEARCH },
+  // Product listing routes
+  {
+    path: "/latest-products",
+    file: "latest-products.tsx",
+    factory: "createLatestProductsRouteConfig",
+    id: RouteId.PRODUCT_INDEX_LATEST
+  },
+  {
+    path: "/most-sales-products",
+    file: "most-sales-products.tsx",
+    factory: "createMostSalesProductsRouteConfig",
+    id: RouteId.PRODUCT_INDEX_SALES
+  },
+  {
+    path: "/offers",
+    file: "offers.tsx",
+    factory: "createOffersRouteConfig",
+    id: RouteId.PRODUCT_INDEX_OFFERS
+  },
+  // Blog routes
+  { path: "/blog", file: "blog.tsx", factory: "createBlogRouteConfig", id: RouteId.BLOG_INDEX },
+  {
+    path: "/blog/author/$id",
+    file: "blog_.author.$id.tsx",
+    factory: "createBlogAuthorRouteConfig",
+    id: RouteId.BLOG_INDEX_AUTHOR
+  },
+  {
+    path: "/blog/$slug/a-{$id}",
+    file: "blog_.$slug.a-$id.tsx",
+    factory: "createBlogSingleRouteConfig",
+    id: RouteId.BLOG_SINGLE
+  },
+  {
+    path: "/blog/$slug/c-{$id}",
+    file: "blog_.$slug.c-$id.tsx",
+    factory: "createBlogCategoryRouteConfig",
+    id: RouteId.BLOG_INDEX_CATEGORY
+  },
+  {
+    path: "/blog/$slug/tag-{$id}",
+    file: "blog_.$slug.tag-$id.tsx",
+    factory: "createBlogTagRouteConfig",
+    id: RouteId.BLOG_INDEX_TAG
+  },
+  // Brands routes
+  {
+    path: "/brands",
+    file: "brands.tsx",
+    factory: "createBrandsRouteConfig",
+    id: RouteId.BRANDS_INDEX
+  },
+  {
+    path: "/brands/$id",
+    file: "brands.$id.tsx",
+    factory: "createBrandSingleRouteConfig",
+    id: RouteId.BRANDS_SINGLE
+  },
+  // Tag routes
+  {
+    path: "/tags/$id",
+    file: "tags.$id.tsx",
+    factory: "createTagRouteConfig",
+    id: RouteId.PRODUCT_INDEX_TAG
+  },
+  // Customer routes
+  {
+    path: "/account",
+    file: "account.tsx",
+    factory: "createAccountLayoutConfig",
+    id: RouteId.CUSTOMER_LAYOUT,
+    isLayout: true
+  },
+  {
+    path: "/account/profile",
+    file: "account.profile.tsx",
+    factory: "createProfileRouteConfig",
+    id: RouteId.CUSTOMER_PROFILE
+  },
+  {
+    path: "/account/wishlist",
+    file: "account.wishlist.tsx",
+    factory: "createWishlistRouteConfig",
+    id: RouteId.CUSTOMER_WISHLIST
+  },
+  {
+    path: "/account/wallet",
+    file: "account.wallet.tsx",
+    factory: "createWalletRouteConfig",
+    id: RouteId.CUSTOMER_WALLET
+  },
+  {
+    path: "/account/notifications",
+    file: "account.notifications.tsx",
+    factory: "createNotificationsRouteConfig",
+    id: RouteId.CUSTOMER_NOTIFICATIONS
+  },
+  {
+    path: "/account/settings",
+    file: "account.settings.tsx",
+    factory: "createSettingsRouteConfig",
+    id: RouteId.CUSTOMER_SETTINGS
+  },
+  {
+    path: "/account/orders",
+    file: "account.orders.tsx",
+    factory: "createOrdersRouteConfig",
+    id: RouteId.CUSTOMER_ORDERS_INDEX
+  },
+  {
+    path: "/account/orders/$id",
+    file: "account.orders.$id.tsx",
+    factory: "createOrderSingleRouteConfig",
+    id: RouteId.CUSTOMER_ORDERS_SINGLE
+  },
+  {
+    path: "/pending-orders",
+    file: "pending-orders.tsx",
+    factory: "createPendingOrdersRedirectConfig",
+    id: RouteId.CUSTOMER_ORDERS_INDEX_PENDING
+  },
+  // Other routes
+  {
+    path: "/loyalty",
+    file: "loyalty.tsx",
+    factory: "createLoyaltyRouteConfig",
+    id: RouteId.LOYALTY
+  },
+  {
+    path: "/testimonials",
+    file: "testimonials.tsx",
+    factory: "createTestimonialsRouteConfig",
+    id: RouteId.TESTIMONIALS
+  },
+  {
+    path: "/thank-you/$orderId",
+    file: "thank-you.$orderId.tsx",
+    factory: "createThankYouRouteConfig",
+    id: RouteId.THANK_YOU
+  },
+  // SEO-friendly slug routes
+  {
+    path: "/$slug/c{$id}",
+    file: "$slug.c$id.tsx",
+    factory: "createSlugCategoryRouteConfig",
+    id: RouteId.PRODUCT_INDEX
+  },
+  {
+    path: "/$slug/p{$id}",
+    file: "$slug.p$id.tsx",
+    factory: "createSlugProductRouteConfig",
+    id: RouteId.PRODUCT_SINGLE
+  },
+  {
+    path: "/$slug/brand-{$id}",
+    file: "$slug.brand-$id.tsx",
+    factory: "createSlugBrandRedirectConfig",
+    id: RouteId.BRANDS_SINGLE
+  },
+  {
+    path: "/$slug/tag-{$id}",
+    file: "$slug.tag-$id.tsx",
+    factory: "createSlugTagRouteConfig",
+    id: RouteId.PRODUCT_INDEX_TAG
+  },
+  {
+    path: "/$slug/page-{$id}",
+    file: "$slug.page-$id.tsx",
+    factory: "createSlugPageRouteConfig",
+    id: RouteId.PAGE_SINGLE
+  }
+];
+function loadRoutesFile(filePath) {
+  if (!existsSync(filePath)) return [];
+  const raw = readFileSync(filePath, "utf-8");
+  let code;
+  try {
+    const result = transformSync(raw, {
+      loader: "ts",
+      format: "cjs",
+      target: "node18"
+    });
+    code = result.code;
+  } catch (err) {
+    console.warn(`[twilight-react:tanstack] Failed to transpile ${basename(filePath)}:`, err);
+    return [];
+  }
+  const projectRequire = createRequire(resolve(process.cwd(), "package.json"));
+  let exported;
+  try {
+    const m = new Module(filePath);
+    m.filename = filePath;
+    m.paths = Module._nodeModulePaths(dirname(filePath));
+    m.require = projectRequire;
+    m._compile(code, filePath);
+    exported = m.exports;
+  } catch (err) {
+    console.warn(`[twilight-react:tanstack] Failed to evaluate ${basename(filePath)}:`, err);
+    return [];
+  }
+  if (!Array.isArray(exported.routes)) return [];
+  const routes = [];
+  for (const node of exported.routes) {
+    if (!node || typeof node !== "object" || !node.file) continue;
+    if (node.type === "index") {
+      routes.push({
+        path: "/",
+        file: node.file,
+        factory: `createCustomRoute_${node.file.replace(/[^a-zA-Z0-9]/g, "_")}`,
+        isIndex: true
+      });
+    } else if (node.type === "route" && node.path) {
+      routes.push({
+        path: node.path,
+        file: node.file,
+        factory: `createCustomRoute_${node.file.replace(/[^a-zA-Z0-9]/g, "_")}`
+      });
+    }
+  }
+  if (routes.length > 0) {
+    console.log(
+      `[twilight-react:tanstack] Loaded ${routes.length} custom route(s) from ${basename(filePath)}`
+    );
+  }
+  return routes;
+}
+var FACTORY_TO_MODULE = {
+  createHomeRouteConfig: "Home",
+  createCartRouteConfig: "Cart",
+  // All product listing routes use the unified ProductListing module
+  createSearchRouteConfig: "ProductListing",
+  createLatestProductsRouteConfig: "ProductListing",
+  createMostSalesProductsRouteConfig: "ProductListing",
+  createOffersRouteConfig: "ProductListing",
+  createSlugCategoryRouteConfig: "ProductListing",
+  createSlugTagRouteConfig: "ProductListing",
+  createTagRouteConfig: "ProductListing",
+  createBrandSingleRouteConfig: "ProductListing",
+  createBlogRouteConfig: "Blog",
+  createBlogSingleRouteConfig: "BlogSingle",
+  createBlogAuthorRouteConfig: "BlogAuthorRoute",
+  createBlogCategoryRouteConfig: "BlogCategoryRoute",
+  createBlogTagRouteConfig: "BlogTagRoute",
+  createBrandsRouteConfig: "Brands",
+  createProfileRouteConfig: "Profile",
+  createWishlistRouteConfig: "Wishlist",
+  createWalletRouteConfig: "Wallet",
+  createNotificationsRouteConfig: "Notifications",
+  createSettingsRouteConfig: "Settings",
+  createOrdersRouteConfig: "Orders",
+  createOrderSingleRouteConfig: "OrderSingle",
+  createAccountLayoutConfig: "AccountLayout",
+  createLoyaltyRouteConfig: "Loyalty",
+  createTestimonialsRouteConfig: "Testimonials",
+  createThankYouRouteConfig: "ThankYou",
+  // Other routes
+  createSlugProductRouteConfig: "Product",
+  createSlugPageRouteConfig: "PageSingle",
+  // SEO slug redirect (redirect-only, no component)
+  createSlugBrandRedirectConfig: "slugBrandRedirect",
+  // Pending orders redirect
+  createPendingOrdersRedirectConfig: "pendingOrdersRedirect"
+};
+var REDIRECT_ONLY_MODULES = /* @__PURE__ */ new Set(["slugBrandRedirect", "pendingOrdersRedirect"]);
+var MODULE_SUBPATH = {
+  Home: "home",
+  Cart: "cart",
+  ProductListing: "product-listing",
+  Blog: "blog",
+  BlogSingle: "blog",
+  BlogAuthorRoute: "blog",
+  BlogCategoryRoute: "blog",
+  BlogTagRoute: "blog",
+  Brands: "brands",
+  BrandSingle: "brands",
+  Profile: "account",
+  Wishlist: "account",
+  Wallet: "account",
+  Notifications: "account",
+  Settings: "account",
+  Orders: "account/orders",
+  OrderSingle: "account/orders",
+  Loyalty: "loyalty",
+  PageSingle: "page",
+  Testimonials: "testimonials",
+  ThankYou: "thank-you",
+  Product: "product",
+  slugBrandRedirect: "seo-redirects",
+  pendingOrdersRedirect: "seo-redirects"
+};
+var MODULE_LOADER_TYPE = {
+  Home: "HomeLoaderData",
+  Cart: "CartPageProps",
+  ProductListing: "ProductListLoaderData",
+  Blog: "BlogPageProps",
+  BlogSingle: "BlogSinglePageProps",
+  BlogAuthorRoute: "BlogAuthorLoaderData",
+  BlogCategoryRoute: "BlogCategoryLoaderData",
+  BlogTagRoute: "BlogTagLoaderData",
+  Brands: "BrandsPageProps",
+  BrandSingle: "ProductListLoaderData",
+  Profile: "ProfilePageProps",
+  Wishlist: "WishlistPageProps",
+  Wallet: "WalletPageProps",
+  Notifications: "NotificationsPageProps",
+  Settings: "SettingsPageProps",
+  Orders: "OrdersPageProps",
+  OrderSingle: "OrderSinglePageProps",
+  Loyalty: "LoyaltyPageProps",
+  PageSingle: "PageSingleProps",
+  Testimonials: "TestimonialsPageProps",
+  ThankYou: "ThankYouPageProps",
+  Product: "ProductPageProps"
+};
+var PAGINATED_MODULES = /* @__PURE__ */ new Set(["Wishlist"]);
+var PAGINATED_NO_LOCALE = /* @__PURE__ */ new Set(["Wallet"]);
+var SORT_PAGINATED_MODULES = /* @__PURE__ */ new Set(["ProductListing"]);
+var SORT_PAGINATED_FACTORIES = /* @__PURE__ */ new Set([
+  "createSearchRouteConfig",
+  "createSlugTagRouteConfig",
+  "createTagRouteConfig",
+  "createBrandSingleRouteConfig"
+]);
+var DEFERRED_ROUTES = /* @__PURE__ */ new Set();
+var STATUS_FILTERED_MODULES = /* @__PURE__ */ new Set(["Orders"]);
+var MODULE_PENDING_SKELETON = {
+  Home: "HomeSkeleton",
+  Product: "ProductDetailSkeleton",
+  Blog: "BlogSkeleton",
+  BlogSingle: "BlogSkeleton",
+  BlogAuthorRoute: "BlogSkeleton",
+  BlogCategoryRoute: "BlogSkeleton",
+  BlogTagRoute: "BlogSkeleton",
+  Cart: "CartSkeleton",
+  Profile: "CustomerPageSkeleton",
+  Wishlist: "CustomerPageSkeleton",
+  Wallet: "CustomerPageSkeleton",
+  Notifications: "CustomerPageSkeleton",
+  Settings: "CustomerPageSkeleton",
+  Orders: "CustomerPageSkeleton",
+  OrderSingle: "CustomerPageSkeleton"
+};
+var FACTORY_LOADER_PARAMS = {
+  // /$slug/c{$id} → category.loader({ id }) — slug is SEO-only, not used by loader
+  createSlugCategoryRouteConfig: { id: "id" },
+  // /$slug/p{$id} → product.loader({ id })
+  createSlugProductRouteConfig: { id: "id" },
+  // /$slug/tag-{$id} → productListLoader({ source: 'tags', id })
+  createSlugTagRouteConfig: { id: "id" },
+  // /$slug/page-{$id} → pageSingle.loader({ id }) — slug is SEO-only, not used by loader
+  createSlugPageRouteConfig: { id: "id" },
+  // /tags/$id → productListLoader({ source: 'tags', id })
+  createTagRouteConfig: { id: "id" },
+  // /brands/$id → productListLoader({ source: 'brands', id })
+  createBrandSingleRouteConfig: { id: "id" }
+};
+var FACTORY_STATIC_PARAMS = {
+  createLatestProductsRouteConfig: {
+    source: "latest",
+    title: "Latest Products",
+    slug: "latest-products"
+  },
+  createMostSalesProductsRouteConfig: {
+    source: "sales",
+    title: "Most Sales Products",
+    slug: "most-sales-products"
+  },
+  createOffersRouteConfig: {
+    source: "offers",
+    title: "Offers",
+    slug: "offers"
+  }
+};
+function getParamMapping(routePath, factory) {
+  if (factory && FACTORY_LOADER_PARAMS[factory]) {
+    const mapping = FACTORY_LOADER_PARAMS[factory];
+    const entries = Object.entries(mapping).map(
+      ([loaderParam, urlParam]) => `${loaderParam}: params.${urlParam}`
+    );
+    if (factory === "createTagRouteConfig" || factory === "createSlugTagRouteConfig") {
+      return `{ source: 'tags', ${entries.join(", ")} }`;
+    }
+    if (factory === "createBrandSingleRouteConfig") {
+      return `{ source: 'brands', ${entries.join(", ")} }`;
+    }
+    return `{ ${entries.join(", ")} }`;
+  }
+  const paramMatches = routePath.match(/\$([a-zA-Z]+)/g);
+  if (!paramMatches || paramMatches.length === 0) return "";
+  const params = paramMatches.map((match) => {
+    const paramName = match.slice(1);
+    return `${paramName}: params.${paramName}`;
+  });
+  return `{ ${params.join(", ")} }`;
+}
+function toTanstackRoutePath(route) {
+  if (route.isIndex) return "/{-$locale}/";
+  return `/{-$locale}${route.path}`;
+}
+function generateRouteFileContent(route, baseImport) {
+  const routePath = route.isIndex ? "/" : route.path;
+  const tanstackRoutePath = toTanstackRoutePath(route);
+  const moduleName = FACTORY_TO_MODULE[route.factory];
+  if (moduleName) {
+    const hasParams = routePath.includes("$");
+    const paramMapping = getParamMapping(routePath, route.factory);
+    const isRedirectOnly = REDIRECT_ONLY_MODULES.has(moduleName);
+    const subpath = MODULE_SUBPATH[moduleName];
+    const moduleImport = subpath ? `${baseImport}/${subpath}` : baseImport;
+    if (route.factory === "createSlugBrandRedirectConfig") {
+      const loaderImport = "slugBrandRedirectLoader";
+      const redirectParamMapping = paramMapping ? paramMapping.replace(/\s*}$/, ", locale: params.locale }") : "{ locale: params.locale }";
+      const loaderCall2 = `({ params }) =>
+    ${loaderImport}({
+      params: ${redirectParamMapping},
+    })`;
+      return `// @auto-generated
+import { createFileRoute } from '@tanstack/react-router';
+import { ${loaderImport} } from '${baseImport}/seo-redirects';
+
+export const Route = createFileRoute('${tanstackRoutePath}')({
+  loader: ${loaderCall2},
+});
+`;
+    }
+    if (route.factory === "createPendingOrdersRedirectConfig") {
+      const loaderImport = "pendingOrdersRedirectLoader";
+      return `// @auto-generated
+import { createFileRoute } from '@tanstack/react-router';
+import { ${loaderImport} } from '${baseImport}/seo-redirects';
+
+export const Route = createFileRoute('${tanstackRoutePath}')({
+  loader: ({ params }) =>
+    ${loaderImport}({
+      params: { locale: params.locale },
+    }),
+});
+`;
+    }
+    const loaderType = MODULE_LOADER_TYPE[moduleName];
+    const typeImport = loaderType ? `
+import type { ${loaderType} } from '${moduleImport}';` : "";
+    const extraTypeImport = "";
+    const importName = moduleName;
+    const staticParams = route.factory ? FACTORY_STATIC_PARAMS[route.factory] : void 0;
+    const loaderCall = staticParams ? `({ params }) => ${importName}.loader({ params: ${JSON.stringify(staticParams)}, locale: params.locale })` : hasParams ? `({ params }) => ${importName}.loader({ params: ${paramMapping}, locale: params.locale })` : `({ params }) => ${importName}.loader({ locale: params.locale })`;
+    if (isRedirectOnly) {
+      return `// @auto-generated
+import { createFileRoute } from '@tanstack/react-router';
+import { ${importName} } from '${moduleImport}';
+
+export const Route = createFileRoute('${tanstackRoutePath}')({
+  loader: ${loaderCall},
+});
+`;
+    }
+    if (route.factory === "createSearchRouteConfig") {
+      const componentFn2 = loaderType ? `function ${importName}Component() {
+  const data: ${loaderType} = Route.useLoaderData();
+  return <${importName}.Component {...data} />;
+}` : `function ${importName}Component() {
+  const data = Route.useLoaderData();
+  return <${importName}.Component {...data} />;
+}`;
+      return `// @auto-generated
+import { createFileRoute } from '@tanstack/react-router';
+import { ${importName} } from '${moduleImport}';${typeImport}${extraTypeImport}
+import { withHead } from '${baseImport.replace("/routes", "")}/tanstack';
+
+/**
+ * Search route configuration with URL query parameter support.
+ * Uses validateSearch for type-safe search params and loaderDeps to pass
+ * them to the loader.
+ */
+export const Route = createFileRoute('${tanstackRoutePath}')({
+  validateSearch: (search: Record<string, unknown>) => ({ q: (search.q as string) || '' }),
+  loaderDeps: ({ search }) => ({ q: search.q }),
+  loader: ({ deps, params }): Promise<${loaderType}> =>
+    ${importName}.loader({
+      params: { source: 'search' },
+      search: { q: deps.q },
+      locale: params.locale,
+    }),
+  head: withHead(${importName}),
+  component: ${importName}Component,
+});
+
+/**
+ * Search page component.
+ * Uses Route.useLoaderData() to access the data loaded by the route loader,
+ * following React best practices for data fetching in route components.
+ */
+${componentFn2}
+`;
+    }
+    const isDeferred = DEFERRED_ROUTES.has(moduleName);
+    const PRETTIER_INDENT = 10;
+    const PRETTIER_PRINT_WIDTH = 100;
+    const getTypedLoaderCall = (returnType2, name, args) => {
+      const inline = `({ params }): ${returnType2} => ${name}.loader(${args})`;
+      const lineLength = PRETTIER_INDENT + inline.length + 1;
+      if (lineLength <= PRETTIER_PRINT_WIDTH) {
+        return inline;
+      }
+      return `({ params }): ${returnType2} =>
+    ${name}.loader(${args})`;
+    };
+    const returnType = isDeferred ? loaderType : `Promise<${loaderType}>`;
+    const typedLoaderCall = loaderType ? staticParams ? (
+      // Static params routes - expanded object format for Prettier
+      // Each param on its own line with proper nesting
+      `({ params }): ${returnType} =>
+    ${importName}.loader({
+      params: {
+        source: '${staticParams.source}',
+        title: '${staticParams.title}',
+        slug: '${staticParams.slug}',
+      },
+      locale: params.locale,
+    })`
+    ) : hasParams ? (
+      // Routes with URL params - check if inline fits
+      getTypedLoaderCall(
+        returnType,
+        importName,
+        `{ params: ${paramMapping}, locale: params.locale }`
+      )
+    ) : (
+      // Routes without params - check if inline fits
+      getTypedLoaderCall(returnType, importName, "{ locale: params.locale }")
+    ) : loaderCall;
+    const skeletonName = MODULE_PENDING_SKELETON[moduleName];
+    const skeletonModulePath = baseImport.replace(/\/routes$/, "/skeleton");
+    const skeletonImport = skeletonName ? `
+import { ${skeletonName} } from '${skeletonModulePath}';` : "";
+    const pendingLine = skeletonName ? `
+  pendingComponent: () => <${skeletonName} />,` : "";
+    const headImport = `import { withHead } from '${baseImport.replace("/routes", "")}/tanstack';`;
+    const headCallback = route.isIndex ? `withHead(${importName})` : `withHead(${importName})`;
+    const componentFn = isDeferred ? `function ${importName}Component() {
+  const data: ${loaderType} = Route.useLoaderData();
+  return <${importName}.Component components={data.components} />;
+}` : loaderType ? `function ${importName}Component() {
+  const data: ${loaderType} = Route.useLoaderData();
+  return <${importName}.Component {...data} />;
+}` : `function ${importName}Component() {
+  const data = Route.useLoaderData();
+  return <${importName}.Component {...data} />;
+}`;
+    const routeDescription = route.isIndex ? "Home (index) route configuration." : `${importName} route configuration.`;
+    if (SORT_PAGINATED_MODULES.has(moduleName) || SORT_PAGINATED_FACTORIES.has(route.factory)) {
+      const sortLoaderCall = staticParams ? `({ deps, params }): ${returnType} =>
+    ${importName}.loader({
+      params: {
+        source: '${staticParams?.source}',
+        title: '${staticParams?.title}',
+        slug: '${staticParams?.slug}',
+      },
+      search: { page: deps.page, sort: deps.sort },
+      locale: params.locale,
+    })` : hasParams ? `({ deps, params }): ${returnType} =>
+    ${importName}.loader({
+      params: ${paramMapping},
+      search: { page: deps.page, sort: deps.sort },
+      locale: params.locale,
+    })` : `({ deps, params }): ${returnType} =>
+    ${importName}.loader({
+      search: { page: deps.page, sort: deps.sort },
+      locale: params.locale,
+    })`;
+      return `// @auto-generated
+import { createFileRoute } from '@tanstack/react-router';
+import { ${importName} } from '${moduleImport}';${typeImport}${skeletonImport}
+${headImport}
+
+/**
+ * ${routeDescription}
+ * Loads page data via loader and renders the ${importName} component.
+ */
+export const Route = createFileRoute('${tanstackRoutePath}')({
+  validateSearch: (search: Record<string, unknown>) => {
+    const page = Number(search.page) || 1;
+    const sort = (search.sort as string) || undefined;
+    return { ...(page > 1 ? { page } : {}), ...(sort ? { sort } : {}) };
+  },
+  loaderDeps: ({ search }) => ({ page: search.page, sort: search.sort }),
+  loader: ${sortLoaderCall},
+  head: ${headCallback},${pendingLine}
+  component: ${importName}Component,
+});
+
+/**
+ * ${importName} page component.
+ * Uses Route.useLoaderData() to access the data loaded by the route loader,
+ * following React best practices for data fetching in route components.
+ */
+${componentFn}
+`;
+    }
+    if (PAGINATED_MODULES.has(moduleName) || PAGINATED_NO_LOCALE.has(moduleName)) {
+      const isNoLocale = PAGINATED_NO_LOCALE.has(moduleName);
+      const loaderArgs = isNoLocale ? `{ search: { page: deps.page ?? 1 } }` : `{ search: { page: deps.page ?? 1 }, locale: params.locale }`;
+      const loaderDestructuring = isNoLocale ? "{ deps }" : "{ deps, params }";
+      return `// @auto-generated
+import { createFileRoute } from '@tanstack/react-router';
+import { ${importName} } from '${moduleImport}';${typeImport}${skeletonImport}
+${headImport}
+
+/**
+ * ${routeDescription}
+ * Loads page data via loader and renders the ${importName} component.
+ */
+export const Route = createFileRoute('${tanstackRoutePath}')({
+  validateSearch: (search: Record<string, unknown>) => {
+    const page = Number(search.page) || 1;
+    return page > 1 ? { page } : {};
+  },
+  loaderDeps: ({ search }) => ({ page: search.page }),
+  loader: (${loaderDestructuring}): ${returnType} =>
+    ${importName}.loader(${loaderArgs}),
+  head: ${headCallback},${pendingLine}
+  component: ${importName}Component,
+});
+
+/**
+ * ${importName} page component.
+ * Uses Route.useLoaderData() to access the data loaded by the route loader,
+ * following React best practices for data fetching in route components.
+ */
+${componentFn}
+`;
+    }
+    if (STATUS_FILTERED_MODULES.has(moduleName)) {
+      return `// @auto-generated
+import { createFileRoute } from '@tanstack/react-router';
+import { ${importName} } from '${moduleImport}';${typeImport}${skeletonImport}
+${headImport}
+
+/**
+ * ${routeDescription}
+ * Loads page data via loader and renders the ${importName} component.
+ */
+export const Route = createFileRoute('${tanstackRoutePath}')({
+  validateSearch: (search: Record<string, unknown>) => {
+    const status = (search.status as string) || undefined;
+    return status ? { status } : {};
+  },
+  loaderDeps: ({ search }) => ({ status: search.status }),
+  loader: ({ deps, params }): ${returnType} =>
+    ${importName}.loader({ search: { status: deps.status }, locale: params.locale }),
+  head: ${headCallback},${pendingLine}
+  component: ${importName}Component,
+});
+
+/**
+ * ${importName} page component.
+ * Uses Route.useLoaderData() to access the data loaded by the route loader,
+ * following React best practices for data fetching in route components.
+ */
+${componentFn}
+`;
+    }
+    return `// @auto-generated
+import { createFileRoute } from '@tanstack/react-router';
+import { ${importName} } from '${moduleImport}';${typeImport}${extraTypeImport}${skeletonImport}
+${headImport}
+
+/**
+ * ${routeDescription}
+ * Loads page data via loader and renders the ${importName} component.
+ */
+export const Route = createFileRoute('${tanstackRoutePath}')({
+  loader: ${typedLoaderCall},
+  head: ${headCallback},${pendingLine}
+  component: ${importName}Component,
+});
+
+/**
+ * ${importName} page component.
+ * Uses Route.useLoaderData() to access the data loaded by the route loader,
+ * following React best practices for data fetching in route components.
+ */
+${componentFn}
+`;
+  }
+  return `// @auto-generated
+import { createFileRoute } from '@tanstack/react-router';
+import { ${route.factory} } from '${baseImport}';
+
+const config = ${route.factory}();
+export const Route = createFileRoute('${tanstackRoutePath}')({
+  loader: config.Loader,
+  component: () => { const data = Route.useLoaderData(); return <config.Component {...data} />; },
+});
+`;
+}
+function getEngineTwilightRelPath(routesDir) {
+  let dir = dirname(fileURLToPath(import.meta.url));
+  while (dir !== dirname(dir)) {
+    if (existsSync(join(dir, "package.json"))) break;
+    dir = dirname(dir);
+  }
+  const twilightDir = join(dir, ".twilight");
+  const absRoutes = resolve(routesDir);
+  return relative(absRoutes, twilightDir).split(sep).join("/");
+}
+function resolveProjectPkg(projectRoot, pkg, subpath) {
+  const pkgJsonPath = join(projectRoot, "node_modules", pkg, "package.json");
+  const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+  const key = subpath ? `./${subpath}` : ".";
+  const exportEntry = pkgJson.exports?.[key];
+  const rel = typeof exportEntry === "string" ? exportEntry : exportEntry?.import?.default ?? exportEntry?.default ?? exportEntry?.require?.default ?? pkgJson.main;
+  if (!rel)
+    throw new Error(`[twilight-react] Cannot resolve ${pkg}${subpath ? `/${subpath}` : ""}`);
+  return join(projectRoot, "node_modules", pkg, rel);
+}
+function buildVirtualRouteConfig(routes, rootRouteFile, routesDir) {
+  try {
+    const projectRequire = createRequire(resolve(process.cwd(), "package.json"));
+    const { rootRoute, index, route } = projectRequire("@tanstack/virtual-file-routes");
+    const accountPrefix = "/account/";
+    const accountLayout = routes.find((r) => r.isLayout && r.path === "/account");
+    const accountChildren = routes.filter((r) => !r.isLayout && r.path.startsWith(accountPrefix));
+    const nonAccountRoutes = routes.filter((r) => !r.isLayout && !r.path.startsWith(accountPrefix));
+    const langChildren = nonAccountRoutes.map((r) => {
+      if (r.isIndex) return index(r.file);
+      const relativePath = r.path.replace(/^\//, "");
+      return route(relativePath, r.file);
+    });
+    if (accountLayout) {
+      const twilightRel2 = getEngineTwilightRelPath(routesDir);
+      const accChildren = accountChildren.map((r) => {
+        const relativePath = r.path.replace(/^\/account\/?/, "");
+        return route(relativePath, r.file);
+      });
+      langChildren.push(route("account", `${twilightRel2}/account.tsx`, accChildren));
+    }
+    const twilightRel = getEngineTwilightRelPath(routesDir);
+    return rootRoute(rootRouteFile, [
+      route("{-$locale}", `${twilightRel}/$locale.tsx`, [
+        ...langChildren,
+        // Redirect route - handles /{-$locale}/redirect/{type}/{id} URLs
+        route("redirect/$type/$id", `${twilightRel}/redirect.$type.$id.tsx`)
+      ])
+    ]);
+  } catch (_error) {
+    console.warn(
+      "[twilight-react:tanstack] @tanstack/virtual-file-routes not found. Please install it."
+    );
+    return void 0;
+  }
+}
+var tanstackAdapter = {
+  name: "tanstack",
+  generateRouteFiles({
+    projectRoot,
+    baseRoutes,
+    baseRoutesImport
+  }) {
+    const routesDir = DEFAULT_ROUTES_DIR;
+    const routesFilePath = resolve(projectRoot, DEFAULT_ROUTES_FILE);
+    const customRoutes = loadRoutesFile(routesFilePath);
+    const routeMap = /* @__PURE__ */ new Map();
+    (baseRoutes ?? DEFAULT_BASE_ROUTES).forEach((r) => routeMap.set(r.path, r));
+    customRoutes.forEach((r) => routeMap.set(r.path, r));
+    const allRoutes = Array.from(routeMap.values());
+    const routesDirPath = resolve(projectRoot, routesDir);
+    if (!existsSync(routesDirPath)) {
+      mkdirSync(routesDirPath, { recursive: true });
+    }
+    const engineRouteFiles = [
+      {
+        name: "$locale.tsx",
+        content: getLocaleWrapperTemplate(baseRoutesImport)
+      },
+      {
+        name: "redirect.$type.$id.tsx",
+        content: getRedirectTemplate(baseRoutesImport)
+      },
+      {
+        name: "account.tsx",
+        content: getAccountLayoutTemplate(baseRoutesImport)
+      }
+    ];
+    let engineRoot = dirname(fileURLToPath(import.meta.url));
+    while (engineRoot !== dirname(engineRoot)) {
+      if (existsSync(join(engineRoot, "package.json"))) break;
+      engineRoot = dirname(engineRoot);
+    }
+    const twilightDir = join(engineRoot, ".twilight");
+    if (!existsSync(twilightDir)) {
+      mkdirSync(twilightDir, { recursive: true });
+    }
+    for (const { name, content } of engineRouteFiles) {
+      const filePath = join(twilightDir, name);
+      if (!existsSync(filePath)) {
+        writeFileSync(filePath, content);
+      } else {
+        const existing = readFileSync(filePath, "utf-8");
+        if (existing !== content) {
+          writeFileSync(filePath, content);
+        }
+      }
+    }
+    for (const route of allRoutes) {
+      if (route.isLayout) continue;
+      const filePath = join(routesDirPath, route.file);
+      const content = generateRouteFileContent(route, baseRoutesImport);
+      if (!existsSync(filePath)) {
+        writeFileSync(filePath, content);
+        console.log(`[twilight-react:tanstack] Created: ${route.file}`);
+      } else {
+        const existing = readFileSync(filePath, "utf-8");
+        if (existing.startsWith("// @auto-generated") && existing !== content) {
+          writeFileSync(filePath, content);
+          console.log(`[twilight-react:tanstack] Updated: ${route.file}`);
+        }
+      }
+    }
+    return allRoutes;
+  },
+  async createPlugins(options) {
+    const {
+      srcDirectory = "app",
+      baseRoutesImport = "@salla.sa/twilight-theme-engine/routes",
+      localesDir
+    } = options;
+    const projectRoot = process.cwd();
+    const allRoutes = tanstackAdapter.generateRouteFiles({ projectRoot, baseRoutesImport });
+    const virtualRouteConfig = buildVirtualRouteConfig(
+      allRoutes,
+      DEFAULT_ROOT_ROUTE,
+      resolve(projectRoot, srcDirectory, "routes")
+    );
+    const routeGeneratorPlugin = {
+      name: "twilight:react",
+      enforce: "pre",
+      config(config) {
+        tanstackAdapter.generateRouteFiles({
+          projectRoot: config.root || projectRoot,
+          baseRoutesImport
+        });
+        return config;
+      }
+      // configureServer(server) {
+      //   // Proactively warm up the Cloudflare Worker module graph so the user's
+      //   // first browser request is served promptly. Without this, Worker
+      //   // compilation is triggered lazily on the first navigation request,
+      //   // causing a ~10-15 second blank-page window on cold starts.
+      //   server.httpServer?.on('listening', () => {
+      //     const address = server.httpServer?.address();
+      //     const port =
+      //       address && typeof address === 'object' && 'port' in address
+      //         ? (address as { port: number }).port
+      //         : null;
+      //     if (!port) return;
+      //     void (async () => {
+      //       // Give TanStack Start + Cloudflare plugin time to finish registering
+      //       // their middleware before we make the warmup request.
+      //       await new Promise<void>((r) => setTimeout(r, 1500));
+      //       for (let attempt = 0; attempt < 10; attempt++) {
+      //         try {
+      //           const ctrl = new AbortController();
+      //           const tid = setTimeout(() => ctrl.abort(), 12000);
+      //           const resp = await fetch(`http://localhost:${port}/ar`, {
+      //             signal: ctrl.signal,
+      //           });
+      //           clearTimeout(tid);
+      //           const text = await resp.text();
+      //           // A substantial response means the Worker is compiled and SSR works.
+      //           if (text.length > 500) return;
+      //         } catch {
+      //           // Worker not ready yet — retry
+      //         }
+      //         await new Promise<void>((r) => setTimeout(r, 2000));
+      //       }
+      //     })();
+      //   });
+      // },
+    };
+    const { tanstackStart } = await import(pathToFileURL(resolveProjectPkg(projectRoot, "@tanstack/react-start", "plugin/vite")).href);
+    const reactMod = await import(pathToFileURL(resolveProjectPkg(projectRoot, "@vitejs/plugin-react")).href);
+    return [
+      tanstackStart({ srcDirectory, router: { virtualRouteConfig } }),
+      reactMod.default(),
+      packageAliasesPlugin(),
+      routeGeneratorPlugin,
+      webHydrationPlugin(),
+      themeTranslationsPlugin(localesDir),
+      bestPracticesPlugin()
+    ];
+  }
+};
+
+// src/vite/adapters/nextjs.adapter.ts
+var nextjsAdapter = {
+  name: "nextjs",
+  generateRouteFiles(_options) {
+    throw new Error("[twilight-react:nextjs] Next.js framework support is not yet implemented");
+  },
+  async createPlugins(_options) {
+    throw new Error("[twilight-react:nextjs] Next.js framework support is not yet implemented");
+  }
+};
+
+// src/vite/adapters/index.ts
+var frameworkAdapters = {
+  tanstack: tanstackAdapter,
+  nextjs: nextjsAdapter
+};
+function getFrameworkAdapter(framework) {
+  const adapter = frameworkAdapters[framework];
+  if (!adapter) {
+    throw new Error(`[twilight-react] Unsupported framework: ${framework}`);
+  }
+  return adapter;
+}
+
+// src/vite/twilight-react.ts
+async function twilightReact(options = {}) {
+  const { framework = "tanstack" } = options;
+  if (framework === "tanstack") setHeadAdapter(tanstackHeadAdapter);
+  else if (framework === "nextjs") setHeadAdapter(nextjsHeadAdapter);
+  return getFrameworkAdapter(framework).createPlugins(options);
+}
+var twilight_react_default = twilightReact;
+
+export { bestPracticesPlugin, twilight_react_default as default, getFrameworkAdapter, nextjsAdapter as nextjs, tanstackAdapter as tanstack, twilightReact };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map