@mercurjs/dashboard-sdk 2.0.0-canary.73 → 2.0.0-canary.74

package/dist/index.cjs

@@ -38,37 +38,52 @@ module.exports = __toCommonJS(index_exports);
 var import_path5 = __toESM(require("path"), 1);
 var import_fs4 = __toESM(require("fs"), 1);
 
+// src/babel.ts
+var import_parser = require("@babel/parser");
+var import_traverse = __toESM(require("@babel/traverse"), 1);
+var import_types = require("@babel/types");
+var traverse;
+if (typeof import_traverse.default === "function") {
+  traverse = import_traverse.default;
+} else {
+  traverse = import_traverse.default.default;
+}
+
 // src/utils.ts
-function resolveExports(moduleExports) {
-  if ("default" in moduleExports && moduleExports.default && "default" in moduleExports.default) {
-    return resolveExports(moduleExports.default);
-  }
-  return moduleExports;
+function normalizePath(filePath) {
+  return filePath.replace(/\\/g, "/");
 }
-async function getFileExports(path6) {
-  const { unregister } = await safeRegister();
-  const module2 = require(path6);
-  unregister();
-  return resolveExports(module2);
+function getParserOptions(file) {
+  const options = {
+    sourceType: "module",
+    plugins: ["jsx"]
+  };
+  if (file.endsWith(".ts") || file.endsWith(".tsx")) {
+    options.plugins.push("typescript");
+  }
+  return options;
 }
-var safeRegister = async () => {
-  const { register } = await import("esbuild-register/dist/node");
-  let res;
-  try {
-    res = register({
-      format: "cjs",
-      loader: "ts"
-    });
-  } catch {
-    res = {
-      unregister: () => {
+function hasDefaultExport(ast) {
+  let found = false;
+  traverse(ast, {
+    ExportDefaultDeclaration() {
+      found = true;
+    },
+    AssignmentExpression(path6) {
+      if (path6.node.left.type === "MemberExpression" && path6.node.left.object.type === "Identifier" && path6.node.left.object.name === "exports" && path6.node.left.property.type === "Identifier" && path6.node.left.property.name === "default") {
+        found = true;
       }
-    };
-  }
-  return res;
-};
-function normalizePath(filePath) {
-  return filePath.replace(/\\/g, "/");
+    },
+    ExportNamedDeclaration(path6) {
+      const specifiers = path6.node.specifiers;
+      if (specifiers?.some(
+        (s) => s.type === "ExportSpecifier" && s.exported.type === "Identifier" && s.exported.name === "default"
+      )) {
+        found = true;
+      }
+    }
+  });
+  return found;
 }
 
 // src/constants.ts
@@ -127,31 +142,51 @@ function crawlPages(dir, pattern = "page") {
   }
   return files;
 }
-function hasDefaultExport(filePath) {
-  try {
-    const content = import_fs.default.readFileSync(filePath, "utf-8");
-    return /export\s+default\s+/.test(content) || /export\s*\{\s*[^}]*\s+as\s+default\s*[,}]/.test(content);
-  } catch {
-    return false;
-  }
-}
-function hasConfigPublic(filePath) {
-  try {
-    const content = import_fs.default.readFileSync(filePath, "utf-8");
-    return /export\s+const\s+config\s*=\s*\{[^}]*public\s*:\s*true/.test(content);
-  } catch {
-    return false;
-  }
-}
-function getNamedExports(filePath) {
-  try {
-    const content = import_fs.default.readFileSync(filePath, "utf-8");
-    const hasHandle = /export\s+(const|function|async\s+function)\s+handle\b/.test(content) || /export\s*\{[^}]*\bhandle\b[^}]*\}/.test(content);
-    const hasLoader = /export\s+(const|function|async\s+function)\s+loader\b/.test(content) || /export\s*\{[^}]*\bloader\b[^}]*\}/.test(content);
-    return { hasHandle, hasLoader };
-  } catch {
-    return { hasHandle: false, hasLoader: false };
-  }
+function hasConfigPublic(ast) {
+  let found = false;
+  traverse(ast, {
+    ExportNamedDeclaration(path6) {
+      const declaration = path6.node.declaration;
+      if (!(0, import_types.isVariableDeclaration)(declaration)) return;
+      for (const decl of declaration.declarations) {
+        if ((0, import_types.isVariableDeclarator)(decl) && (0, import_types.isIdentifier)(decl.id, { name: "config" }) && decl.init?.type === "ObjectExpression") {
+          const publicProp = decl.init.properties.find(
+            (prop) => (0, import_types.isObjectProperty)(prop) && (0, import_types.isIdentifier)(prop.key, { name: "public" }) && (0, import_types.isBooleanLiteral)(prop.value, { value: true })
+          );
+          if (publicProp) {
+            found = true;
+          }
+        }
+      }
+    }
+  });
+  return found;
+}
+function getNamedExports(ast) {
+  let hasHandle = false;
+  let hasLoader = false;
+  traverse(ast, {
+    ExportNamedDeclaration(path6) {
+      const declaration = path6.node.declaration;
+      if (declaration?.type === "VariableDeclaration") {
+        declaration.declarations.forEach((decl) => {
+          if (decl.id.type === "Identifier" && decl.id.name === "handle") {
+            hasHandle = true;
+          }
+          if (decl.id.type === "Identifier" && decl.id.name === "loader") {
+            hasLoader = true;
+          }
+        });
+      }
+      if (declaration?.type === "FunctionDeclaration" && declaration.id?.name === "loader") {
+        hasLoader = true;
+      }
+      if (declaration?.type === "FunctionDeclaration" && declaration.id?.name === "handle") {
+        hasHandle = true;
+      }
+    }
+  });
+  return { hasHandle, hasLoader };
 }
 function generateRouteComponentName(index) {
   return `RouteComponent${index}`;
@@ -217,18 +252,24 @@ ${indent}}`;
   return result;
 }
 function parseFile(file, pagesDir, index) {
-  if (!hasDefaultExport(file)) {
+  try {
+    const code = import_fs.default.readFileSync(file, "utf-8");
+    const ast = (0, import_parser.parse)(code, getParserOptions(file));
+    if (!hasDefaultExport(ast)) {
+      return null;
+    }
+    const { hasHandle, hasLoader } = getNamedExports(ast);
+    const isPublic = hasConfigPublic(ast);
+    const routePath = getRoute(file, pagesDir);
+    const imports = generateImports(file, index, hasHandle, hasLoader);
+    const route = generateRouteObject(routePath, index, hasHandle, hasLoader, isPublic);
+    return {
+      imports,
+      route
+    };
+  } catch {
     return null;
   }
-  const { hasHandle, hasLoader } = getNamedExports(file);
-  const isPublic = hasConfigPublic(file);
-  const routePath = getRoute(file, pagesDir);
-  const imports = generateImports(file, index, hasHandle, hasLoader);
-  const route = generateRouteObject(routePath, index, hasHandle, hasLoader, isPublic);
-  return {
-    imports,
-    route
-  };
 }
 function buildRouteTree(results) {
   const routeMap = /* @__PURE__ */ new Map();
@@ -242,7 +283,7 @@ function buildRouteTree(results) {
       const parentPath = routePath.split("/@")[0];
       const parent = routeMap.get(parentPath);
       if (parent) {
-        parent.route.children = parent.route.children || [];
+        parent.route.children = parent.route.children ?? [];
         parent.route.children.push({
           ...result.route,
           path: result.route.path.replace("/@", "/")
@@ -325,29 +366,90 @@ function getRoute2(file, pagesDir) {
     ""
   ) || "/";
 }
-function hasConfigExport(filePath) {
-  try {
-    const content = import_fs2.default.readFileSync(filePath, "utf-8");
-    return /export\s+(const|let|var)\s+config\b/.test(content) || /export\s*\{[^}]*\bconfig\b[^}]*\}/.test(content);
-  } catch {
-    return false;
+function getConfigObjectProperties(path6) {
+  if ((0, import_types.isVariableDeclarator)(path6.node)) {
+    const decl = (0, import_types.isIdentifier)(path6.node.id, { name: "config" }) ? path6.node : null;
+    if (!decl) return null;
+    if ((0, import_types.isCallExpression)(decl.init) && decl.init.arguments.length > 0 && (0, import_types.isObjectExpression)(decl.init.arguments[0])) {
+      return decl.init.arguments[0].properties;
+    }
+    if ((0, import_types.isObjectExpression)(decl.init)) {
+      return decl.init.properties;
+    }
+    return null;
+  }
+  const declaration = path6.node.declaration;
+  if ((0, import_types.isVariableDeclaration)(declaration)) {
+    const configDecl = declaration.declarations.find(
+      (d) => (0, import_types.isVariableDeclarator)(d) && (0, import_types.isIdentifier)(d.id, { name: "config" })
+    );
+    if (configDecl && (0, import_types.isCallExpression)(configDecl.init) && configDecl.init.arguments.length > 0 && (0, import_types.isObjectExpression)(configDecl.init.arguments[0])) {
+      return configDecl.init.arguments[0].properties;
+    }
+    const directDecl = declaration.declarations.find(
+      (d) => (0, import_types.isVariableDeclarator)(d) && (0, import_types.isIdentifier)(d.id, { name: "config" })
+    );
+    if (directDecl && (0, import_types.isObjectExpression)(directDecl.init)) {
+      return directDecl.init.properties;
+    }
   }
+  return null;
 }
-function getConfigProperties(filePath) {
+function processConfigProperties(properties) {
+  const hasProperty = (name) => properties.some(
+    (prop) => (0, import_types.isObjectProperty)(prop) && (0, import_types.isIdentifier)(prop.key, { name })
+  );
+  const hasLabel = hasProperty("label");
+  if (!hasLabel) {
+    return null;
+  }
+  const hasIcon = hasProperty("icon");
+  const nested = properties.find(
+    (prop) => (0, import_types.isObjectProperty)(prop) && (0, import_types.isIdentifier)(prop.key, { name: "nested" })
+  );
+  let nestedValue;
+  if (nested && (0, import_types.isObjectProperty)(nested) && (0, import_types.isStringLiteral)(nested.value)) {
+    nestedValue = nested.value.value;
+  }
+  const translationNs = properties.find(
+    (prop) => (0, import_types.isObjectProperty)(prop) && (0, import_types.isIdentifier)(prop.key, { name: "translationNs" })
+  );
+  let translationNsValue;
+  if (translationNs && (0, import_types.isObjectProperty)(translationNs) && (0, import_types.isStringLiteral)(translationNs.value)) {
+    translationNsValue = translationNs.value.value;
+  }
+  const rank = properties.find(
+    (prop) => (0, import_types.isObjectProperty)(prop) && (0, import_types.isIdentifier)(prop.key, { name: "rank" })
+  );
+  let rankValue;
+  if (rank && (0, import_types.isObjectProperty)(rank) && (0, import_types.isNumericLiteral)(rank.value)) {
+    rankValue = rank.value.value;
+  }
+  return { label: hasLabel, icon: hasIcon, rank: rankValue, nested: nestedValue, translationNs: translationNsValue };
+}
+function getRouteConfig(file) {
   try {
-    const content = import_fs2.default.readFileSync(filePath, "utf-8");
-    const hasLabel = /\blabel\s*[:=]/.test(content);
-    if (!hasLabel) {
-      return null;
-    }
-    const hasIcon = /\bicon\s*[:=]/.test(content);
-    const rankMatch = content.match(/\brank\s*:\s*(\d+)/);
-    const rank = rankMatch ? parseInt(rankMatch[1], 10) : void 0;
-    const nestedMatch = content.match(/\bnested\s*:\s*["']([^"']+)["']/);
-    const nested = nestedMatch ? nestedMatch[1] : void 0;
-    const translationNsMatch = content.match(/\btranslationNs\s*:\s*["']([^"']+)["']/);
-    const translationNs = translationNsMatch ? translationNsMatch[1] : void 0;
-    return { label: hasLabel, icon: hasIcon, rank, nested, translationNs };
+    const code = import_fs2.default.readFileSync(file, "utf-8");
+    const ast = (0, import_parser.parse)(code, getParserOptions(file));
+    let config = null;
+    let configFound = false;
+    traverse(ast, {
+      VariableDeclarator(path6) {
+        if (configFound) return;
+        const properties = getConfigObjectProperties(path6);
+        if (!properties) return;
+        config = processConfigProperties(properties);
+        if (config) configFound = true;
+      },
+      ExportNamedDeclaration(path6) {
+        if (configFound) return;
+        const properties = getConfigObjectProperties(path6);
+        if (!properties) return;
+        config = processConfigProperties(properties);
+        if (config) configFound = true;
+      }
+    });
+    return config;
   } catch {
     return null;
   }
@@ -384,10 +486,7 @@ ${parts.join(",\n")}
     }`;
 }
 function parseFile2(file, pagesDir, index) {
-  if (!hasConfigExport(file)) {
-    return null;
-  }
-  const config = getConfigProperties(file);
+  const config = getRouteConfig(file);
   if (!config) {
     return null;
   }
@@ -574,23 +673,109 @@ function resolvePluginExtensions(plugins, configDir) {
   }
   return extensions;
 }
+function extractStringFromNode(node, configDir) {
+  if ((0, import_types.isStringLiteral)(node)) {
+    return node.value;
+  }
+  if ((0, import_types.isCallExpression)(node) && (0, import_types.isMemberExpression)(node.callee) && (0, import_types.isIdentifier)(node.callee.object, { name: "path" }) && (0, import_types.isIdentifier)(node.callee.property) && (node.callee.property.name === "join" || node.callee.property.name === "resolve")) {
+    const args = node.arguments;
+    if (args.length >= 2 && (0, import_types.isIdentifier)(args[0], { name: "__dirname" })) {
+      const parts = args.slice(1).filter((a) => (0, import_types.isStringLiteral)(a)).map((a) => a.value);
+      if (parts.length > 0) {
+        return import_path5.default.resolve(configDir, ...parts);
+      }
+    }
+  }
+  return null;
+}
+function extractObjectProperties(node) {
+  if ((0, import_types.isObjectExpression)(node)) {
+    return node.properties;
+  }
+  return null;
+}
 async function loadMedusaConfig(medusaConfigPath, root) {
   try {
-    const mod = await getFileExports(medusaConfigPath);
-    const medusaConfig = mod.default ?? mod;
-    const modules = medusaConfig?.modules ?? {};
+    const code = import_fs4.default.readFileSync(medusaConfigPath, "utf-8");
+    const ast = (0, import_parser.parse)(code, getParserOptions(medusaConfigPath));
     const configDir = import_path5.default.dirname(medusaConfigPath);
+    const result = { properties: null };
+    traverse(ast, {
+      // Handle: export default defineConfig({ ... })
+      ExportDefaultDeclaration(nodePath) {
+        const decl = nodePath.node.declaration;
+        if ((0, import_types.isCallExpression)(decl) && decl.arguments.length > 0) {
+          result.properties = extractObjectProperties(decl.arguments[0]);
+        }
+      },
+      // Handle: module.exports = defineConfig({ ... }) or module.exports = { ... }
+      AssignmentExpression(nodePath) {
+        const left = nodePath.node.left;
+        if ((0, import_types.isMemberExpression)(left) && (0, import_types.isIdentifier)(left.object, { name: "module" }) && (0, import_types.isIdentifier)(left.property, { name: "exports" })) {
+          const right = nodePath.node.right;
+          if ((0, import_types.isCallExpression)(right) && right.arguments.length > 0) {
+            result.properties = extractObjectProperties(right.arguments[0]);
+          } else if ((0, import_types.isObjectExpression)(right)) {
+            result.properties = right.properties;
+          }
+        }
+      }
+    });
+    const configObjectProperties = result.properties;
+    if (!configObjectProperties) {
+      return { pluginExtensions: [] };
+    }
     let base;
-    for (const key of UI_MODULE_KEYS) {
-      const value = modules[key];
-      if (!value || typeof value !== "object" || !value.options?.appDir) continue;
-      const appDir = import_path5.default.resolve(configDir, value.options.appDir);
-      if (appDir === root) {
-        base = value.options.path;
-        break;
+    const modulesProp = configObjectProperties.find(
+      (p) => (0, import_types.isObjectProperty)(p) && (0, import_types.isIdentifier)(p.key, { name: "modules" })
+    );
+    if (modulesProp && (0, import_types.isObjectProperty)(modulesProp) && (0, import_types.isObjectExpression)(modulesProp.value)) {
+      for (const key of UI_MODULE_KEYS) {
+        const uiProp = modulesProp.value.properties.find(
+          (p) => (0, import_types.isObjectProperty)(p) && (0, import_types.isIdentifier)(p.key, { name: key })
+        );
+        if (!uiProp || !(0, import_types.isObjectProperty)(uiProp) || !(0, import_types.isObjectExpression)(uiProp.value)) continue;
+        const optionsProp = uiProp.value.properties.find(
+          (p) => (0, import_types.isObjectProperty)(p) && (0, import_types.isIdentifier)(p.key, { name: "options" })
+        );
+        if (!optionsProp || !(0, import_types.isObjectProperty)(optionsProp) || !(0, import_types.isObjectExpression)(optionsProp.value)) continue;
+        const appDirProp = optionsProp.value.properties.find(
+          (p) => (0, import_types.isObjectProperty)(p) && (0, import_types.isIdentifier)(p.key, { name: "appDir" })
+        );
+        if (!appDirProp || !(0, import_types.isObjectProperty)(appDirProp)) continue;
+        const appDir = extractStringFromNode(appDirProp.value, configDir);
+        if (!appDir) continue;
+        const resolvedAppDir = import_path5.default.isAbsolute(appDir) ? appDir : import_path5.default.resolve(configDir, appDir);
+        if (resolvedAppDir === root) {
+          const pathProp = optionsProp.value.properties.find(
+            (p) => (0, import_types.isObjectProperty)(p) && (0, import_types.isIdentifier)(p.key, { name: "path" })
+          );
+          if (pathProp && (0, import_types.isObjectProperty)(pathProp) && (0, import_types.isStringLiteral)(pathProp.value)) {
+            base = pathProp.value.value;
+          }
+          break;
+        }
+      }
+    }
+    const plugins = [];
+    const pluginsProp = configObjectProperties.find(
+      (p) => (0, import_types.isObjectProperty)(p) && (0, import_types.isIdentifier)(p.key, { name: "plugins" })
+    );
+    if (pluginsProp && (0, import_types.isObjectProperty)(pluginsProp) && (0, import_types.isArrayExpression)(pluginsProp.value)) {
+      for (const element of pluginsProp.value.elements) {
+        if (!element) continue;
+        if ((0, import_types.isObjectExpression)(element)) {
+          const resolveProp = element.properties.find(
+            (p) => (0, import_types.isObjectProperty)(p) && (0, import_types.isIdentifier)(p.key, { name: "resolve" })
+          );
+          if (resolveProp && (0, import_types.isObjectProperty)(resolveProp) && (0, import_types.isStringLiteral)(resolveProp.value)) {
+            plugins.push({ resolve: resolveProp.value.value });
+          }
+        } else if ((0, import_types.isStringLiteral)(element)) {
+          plugins.push({ resolve: element.value });
+        }
       }
     }
-    const plugins = medusaConfig?.plugins ?? [];
     const pluginExtensions = resolvePluginExtensions(plugins, configDir);
     return { base, pluginExtensions };
   } catch {

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+import * as Vite from 'vite';
+import { ComponentType } from 'react';
+
+interface MercurConfig {
+    medusaConfigPath: string;
+    backendUrl?: string;
+    name?: string;
+    logo?: string;
+    components?: {
+        MainSidebar?: string;
+        SettingsSidebar?: string;
+        TopbarActions?: string;
+    };
+    i18n?: {
+        defaultLanguage: string;
+    };
+    enableSellerRegistration?: boolean;
+}
+interface BuiltMercurConfig extends MercurConfig {
+    backendUrl: string;
+    base?: string;
+    root: string;
+    srcDir: string;
+    pluginExtensions: string[];
+}
+type RouteConfig = {
+    label: string;
+    icon?: ComponentType;
+    rank?: number;
+    nested?: string;
+    translationNs?: string;
+    public?: boolean;
+};
+
+declare function mercurDashboardPlugin(pluginConfig: MercurConfig): Vite.Plugin;
+
+export { type BuiltMercurConfig, type MercurConfig, type RouteConfig, mercurDashboardPlugin };

package/dist/index.js

@@ -0,0 +1,829 @@
+// src/plugin.ts
+import path5 from "path";
+import fs4 from "fs";
+
+// src/babel.ts
+import { parse } from "@babel/parser";
+import _traverse from "@babel/traverse";
+import {
+  isBooleanLiteral,
+  isCallExpression,
+  isFunctionDeclaration,
+  isIdentifier,
+  isMemberExpression,
+  isNumericLiteral,
+  isObjectExpression,
+  isObjectProperty,
+  isStringLiteral,
+  isVariableDeclaration,
+  isVariableDeclarator,
+  isArrayExpression
+} from "@babel/types";
+var traverse;
+if (typeof _traverse === "function") {
+  traverse = _traverse;
+} else {
+  traverse = _traverse.default;
+}
+
+// src/utils.ts
+function normalizePath(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+function getParserOptions(file) {
+  const options = {
+    sourceType: "module",
+    plugins: ["jsx"]
+  };
+  if (file.endsWith(".ts") || file.endsWith(".tsx")) {
+    options.plugins.push("typescript");
+  }
+  return options;
+}
+function hasDefaultExport(ast) {
+  let found = false;
+  traverse(ast, {
+    ExportDefaultDeclaration() {
+      found = true;
+    },
+    AssignmentExpression(path6) {
+      if (path6.node.left.type === "MemberExpression" && path6.node.left.object.type === "Identifier" && path6.node.left.object.name === "exports" && path6.node.left.property.type === "Identifier" && path6.node.left.property.name === "default") {
+        found = true;
+      }
+    },
+    ExportNamedDeclaration(path6) {
+      const specifiers = path6.node.specifiers;
+      if (specifiers?.some(
+        (s) => s.type === "ExportSpecifier" && s.exported.type === "Identifier" && s.exported.name === "default"
+      )) {
+        found = true;
+      }
+    }
+  });
+  return found;
+}
+
+// src/constants.ts
+var VALID_FILE_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
+var CONFIG_VIRTUAL_MODULE = "virtual:mercur/config";
+var ROUTES_VIRTUAL_MODULE = "virtual:mercur/routes";
+var COMPONENTS_VIRTUAL_MODULE = "virtual:mercur/components";
+var MENU_ITEMS_VIRTUAL_MODULE = "virtual:mercur/menu-items";
+var I18N_VIRTUAL_MODULE = "virtual:mercur/i18n";
+var RESOLVED_CONFIG_MODULE = "\0" + CONFIG_VIRTUAL_MODULE;
+var RESOLVED_ROUTES_MODULE = "\0" + ROUTES_VIRTUAL_MODULE;
+var RESOLVED_COMPONENTS_MODULE = "\0" + COMPONENTS_VIRTUAL_MODULE;
+var RESOLVED_MENU_ITEMS_MODULE = "\0" + MENU_ITEMS_VIRTUAL_MODULE;
+var RESOLVED_I18N_MODULE = "\0" + I18N_VIRTUAL_MODULE;
+var VIRTUAL_MODULES = [
+  CONFIG_VIRTUAL_MODULE,
+  ROUTES_VIRTUAL_MODULE,
+  COMPONENTS_VIRTUAL_MODULE,
+  MENU_ITEMS_VIRTUAL_MODULE,
+  I18N_VIRTUAL_MODULE
+];
+
+// src/virtual-modules.ts
+import path4 from "path";
+
+// src/routes.ts
+import fs from "fs";
+import path from "path";
+function getRoute(file, pagesDir) {
+  const importPath = normalizePath(file);
+  const normalizedPagesDir = normalizePath(pagesDir);
+  return importPath.replace(normalizedPagesDir, "").replace(/\[\[\*\]\]/g, "*?").replace(/\[\*\]/g, "*").replace(/\(([^\[\]\)]+)\)/g, "$1?").replace(/\[\[([^\]]+)\]\]/g, ":$1?").replace(/\[([^\]]+)\]/g, ":$1").replace(
+    new RegExp(
+      `/page\\.(${VALID_FILE_EXTENSIONS.map((ext) => ext.slice(1)).join("|")})$`
+    ),
+    ""
+  ) || "/";
+}
+function crawlPages(dir, pattern = "page") {
+  const files = [];
+  if (!fs.existsSync(dir)) {
+    return files;
+  }
+  const entries = fs.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...crawlPages(fullPath, pattern));
+    } else if (entry.isFile()) {
+      const ext = path.extname(entry.name);
+      const baseName = path.basename(entry.name, ext);
+      if (baseName === pattern && VALID_FILE_EXTENSIONS.includes(ext)) {
+        files.push(fullPath);
+      }
+    }
+  }
+  return files;
+}
+function hasConfigPublic(ast) {
+  let found = false;
+  traverse(ast, {
+    ExportNamedDeclaration(path6) {
+      const declaration = path6.node.declaration;
+      if (!isVariableDeclaration(declaration)) return;
+      for (const decl of declaration.declarations) {
+        if (isVariableDeclarator(decl) && isIdentifier(decl.id, { name: "config" }) && decl.init?.type === "ObjectExpression") {
+          const publicProp = decl.init.properties.find(
+            (prop) => isObjectProperty(prop) && isIdentifier(prop.key, { name: "public" }) && isBooleanLiteral(prop.value, { value: true })
+          );
+          if (publicProp) {
+            found = true;
+          }
+        }
+      }
+    }
+  });
+  return found;
+}
+function getNamedExports(ast) {
+  let hasHandle = false;
+  let hasLoader = false;
+  traverse(ast, {
+    ExportNamedDeclaration(path6) {
+      const declaration = path6.node.declaration;
+      if (declaration?.type === "VariableDeclaration") {
+        declaration.declarations.forEach((decl) => {
+          if (decl.id.type === "Identifier" && decl.id.name === "handle") {
+            hasHandle = true;
+          }
+          if (decl.id.type === "Identifier" && decl.id.name === "loader") {
+            hasLoader = true;
+          }
+        });
+      }
+      if (declaration?.type === "FunctionDeclaration" && declaration.id?.name === "loader") {
+        hasLoader = true;
+      }
+      if (declaration?.type === "FunctionDeclaration" && declaration.id?.name === "handle") {
+        hasHandle = true;
+      }
+    }
+  });
+  return { hasHandle, hasLoader };
+}
+function generateRouteComponentName(index) {
+  return `RouteComponent${index}`;
+}
+function generateHandleName(index) {
+  return `RouteHandle${index}`;
+}
+function generateLoaderName(index) {
+  return `RouteLoader${index}`;
+}
+function generateImports(file, index, hasHandle, hasLoader) {
+  const imports = [];
+  const componentName = generateRouteComponentName(index);
+  const importPath = normalizePath(file);
+  if (!hasHandle && !hasLoader) {
+    imports.push(`import ${componentName} from "${importPath}"`);
+  } else {
+    const namedImports = [
+      hasHandle && `handle as ${generateHandleName(index)}`,
+      hasLoader && `loader as ${generateLoaderName(index)}`
+    ].filter(Boolean).join(", ");
+    imports.push(`import ${componentName}, { ${namedImports} } from "${importPath}"`);
+  }
+  return imports;
+}
+function generateRouteObject(routePath, index, hasHandle, hasLoader, isPublic) {
+  return {
+    Component: generateRouteComponentName(index),
+    path: routePath,
+    handle: hasHandle ? generateHandleName(index) : void 0,
+    loader: hasLoader ? generateLoaderName(index) : void 0,
+    isPublic
+  };
+}
+function formatRoute(route, indent = "    ") {
+  let result = `${indent}{
+`;
+  result += `${indent}    Component: ${route.Component},
+`;
+  result += `${indent}    path: "${route.path}"`;
+  if (route.handle) {
+    result += `,
+${indent}    handle: ${route.handle}`;
+  }
+  if (route.loader) {
+    result += `,
+${indent}    loader: ${route.loader}`;
+  }
+  if (route.isPublic) {
+    result += `,
+${indent}    isPublic: true`;
+  }
+  if (route.children?.length) {
+    result += `,
+${indent}    children: [
+`;
+    result += route.children.map((child) => formatRoute(child, indent + "        ")).join(",\n");
+    result += `
+${indent}    ]`;
+  }
+  result += `
+${indent}}`;
+  return result;
+}
+function parseFile(file, pagesDir, index) {
+  try {
+    const code = fs.readFileSync(file, "utf-8");
+    const ast = parse(code, getParserOptions(file));
+    if (!hasDefaultExport(ast)) {
+      return null;
+    }
+    const { hasHandle, hasLoader } = getNamedExports(ast);
+    const isPublic = hasConfigPublic(ast);
+    const routePath = getRoute(file, pagesDir);
+    const imports = generateImports(file, index, hasHandle, hasLoader);
+    const route = generateRouteObject(routePath, index, hasHandle, hasLoader, isPublic);
+    return {
+      imports,
+      route
+    };
+  } catch {
+    return null;
+  }
+}
+function buildRouteTree(results) {
+  const routeMap = /* @__PURE__ */ new Map();
+  const sortedResults = [...results].sort(
+    (a, b) => a.route.path.split("/").length - b.route.path.split("/").length
+  );
+  for (const result of sortedResults) {
+    const routePath = result.route.path;
+    const isParallel = routePath.includes("/@");
+    if (isParallel) {
+      const parentPath = routePath.split("/@")[0];
+      const parent = routeMap.get(parentPath);
+      if (parent) {
+        parent.route.children = parent.route.children ?? [];
+        parent.route.children.push({
+          ...result.route,
+          path: result.route.path.replace("/@", "/")
+        });
+        parent.imports.push(...result.imports);
+      } else {
+        routeMap.set(routePath, result);
+      }
+    } else {
+      routeMap.set(routePath, result);
+    }
+  }
+  return Array.from(routeMap.values());
+}
+function generateRoutes({ srcDir, pluginExtensions }) {
+  const pagesDir = path.join(srcDir, "pages");
+  let index = 0;
+  const results = [];
+  for (const file of crawlPages(pagesDir)) {
+    const result = parseFile(file, pagesDir, index);
+    if (result) {
+      results.push(result);
+      index++;
+    }
+  }
+  const pluginImports = pluginExtensions.map(
+    (ext, i) => `import * as __pluginRaw${i} from "${normalizePath(ext)}"`
+  );
+  const pluginUnwraps = pluginExtensions.map(
+    (_, i) => `const __plugin${i} = __pluginRaw${i}.default ?? __pluginRaw${i}`
+  );
+  const pluginSpreads = pluginExtensions.map(
+    (_, i) => `    ...(__plugin${i}.routeModule?.routes ?? [])`
+  );
+  const routeTree = buildRouteTree(results);
+  const appImports = routeTree.flatMap((r) => r.imports);
+  const appRoutes = routeTree.map((r) => formatRoute(r.route));
+  const allImports = [...appImports, ...pluginImports, ...pluginUnwraps];
+  const allRoutes = [...appRoutes, ...pluginSpreads];
+  if (allImports.length === 0 && allRoutes.length === 0) {
+    return `export const customRoutes = []`;
+  }
+  return `${allImports.join("\n")}
+
+export const customRoutes = [
+${allRoutes.join(",\n")}
+]`;
+}
+
+// src/menu-items.ts
+import fs2 from "fs";
+import path2 from "path";
+function crawlPages2(dir, pattern = "page") {
+  const files = [];
+  if (!fs2.existsSync(dir)) {
+    return files;
+  }
+  const entries = fs2.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path2.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...crawlPages2(fullPath, pattern));
+    } else if (entry.isFile()) {
+      const ext = path2.extname(entry.name);
+      const baseName = path2.basename(entry.name, ext);
+      if (baseName === pattern && VALID_FILE_EXTENSIONS.includes(ext)) {
+        files.push(fullPath);
+      }
+    }
+  }
+  return files;
+}
+function getRoute2(file, pagesDir) {
+  const importPath = normalizePath(file);
+  const normalizedPagesDir = normalizePath(pagesDir);
+  return importPath.replace(normalizedPagesDir, "").replace(/\[\[\*\]\]/g, "*?").replace(/\[\*\]/g, "*").replace(/\(([^\[\]\)]+)\)/g, "$1?").replace(/\[\[([^\]]+)\]\]/g, ":$1?").replace(/\[([^\]]+)\]/g, ":$1").replace(
+    new RegExp(
+      `/page\\.(${VALID_FILE_EXTENSIONS.map((ext) => ext.slice(1)).join("|")})$`
+    ),
+    ""
+  ) || "/";
+}
+function getConfigObjectProperties(path6) {
+  if (isVariableDeclarator(path6.node)) {
+    const decl = isIdentifier(path6.node.id, { name: "config" }) ? path6.node : null;
+    if (!decl) return null;
+    if (isCallExpression(decl.init) && decl.init.arguments.length > 0 && isObjectExpression(decl.init.arguments[0])) {
+      return decl.init.arguments[0].properties;
+    }
+    if (isObjectExpression(decl.init)) {
+      return decl.init.properties;
+    }
+    return null;
+  }
+  const declaration = path6.node.declaration;
+  if (isVariableDeclaration(declaration)) {
+    const configDecl = declaration.declarations.find(
+      (d) => isVariableDeclarator(d) && isIdentifier(d.id, { name: "config" })
+    );
+    if (configDecl && isCallExpression(configDecl.init) && configDecl.init.arguments.length > 0 && isObjectExpression(configDecl.init.arguments[0])) {
+      return configDecl.init.arguments[0].properties;
+    }
+    const directDecl = declaration.declarations.find(
+      (d) => isVariableDeclarator(d) && isIdentifier(d.id, { name: "config" })
+    );
+    if (directDecl && isObjectExpression(directDecl.init)) {
+      return directDecl.init.properties;
+    }
+  }
+  return null;
+}
+function processConfigProperties(properties) {
+  const hasProperty = (name) => properties.some(
+    (prop) => isObjectProperty(prop) && isIdentifier(prop.key, { name })
+  );
+  const hasLabel = hasProperty("label");
+  if (!hasLabel) {
+    return null;
+  }
+  const hasIcon = hasProperty("icon");
+  const nested = properties.find(
+    (prop) => isObjectProperty(prop) && isIdentifier(prop.key, { name: "nested" })
+  );
+  let nestedValue;
+  if (nested && isObjectProperty(nested) && isStringLiteral(nested.value)) {
+    nestedValue = nested.value.value;
+  }
+  const translationNs = properties.find(
+    (prop) => isObjectProperty(prop) && isIdentifier(prop.key, { name: "translationNs" })
+  );
+  let translationNsValue;
+  if (translationNs && isObjectProperty(translationNs) && isStringLiteral(translationNs.value)) {
+    translationNsValue = translationNs.value.value;
+  }
+  const rank = properties.find(
+    (prop) => isObjectProperty(prop) && isIdentifier(prop.key, { name: "rank" })
+  );
+  let rankValue;
+  if (rank && isObjectProperty(rank) && isNumericLiteral(rank.value)) {
+    rankValue = rank.value.value;
+  }
+  return { label: hasLabel, icon: hasIcon, rank: rankValue, nested: nestedValue, translationNs: translationNsValue };
+}
+function getRouteConfig(file) {
+  try {
+    const code = fs2.readFileSync(file, "utf-8");
+    const ast = parse(code, getParserOptions(file));
+    let config = null;
+    let configFound = false;
+    traverse(ast, {
+      VariableDeclarator(path6) {
+        if (configFound) return;
+        const properties = getConfigObjectProperties(path6);
+        if (!properties) return;
+        config = processConfigProperties(properties);
+        if (config) configFound = true;
+      },
+      ExportNamedDeclaration(path6) {
+        if (configFound) return;
+        const properties = getConfigObjectProperties(path6);
+        if (!properties) return;
+        config = processConfigProperties(properties);
+        if (config) configFound = true;
+      }
+    });
+    return config;
+  } catch {
+    return null;
+  }
+}
+function generateRouteConfigName(index) {
+  return `RouteConfig${index}`;
+}
+function generateImport(file, index) {
+  const importPath = normalizePath(file);
+  return `import { config as ${generateRouteConfigName(index)} } from "${importPath}"`;
+}
+function generateMenuItem(config, file, pagesDir, index) {
+  const configName = generateRouteConfigName(index);
+  return {
+    label: `${configName}.label`,
+    icon: config.icon ? `${configName}.icon` : void 0,
+    path: getRoute2(file, pagesDir),
+    rank: config.rank,
+    nested: config.nested,
+    translationNs: config.translationNs ? `${configName}.translationNs` : void 0
+  };
+}
+function formatMenuItem(menuItem) {
+  const parts = [
+    `        label: ${menuItem.label}`,
+    `        icon: ${menuItem.icon || "undefined"}`,
+    `        path: "${menuItem.path}"`,
+    `        rank: ${menuItem.rank !== void 0 ? menuItem.rank : "undefined"}`,
+    `        nested: ${menuItem.nested ? `"${menuItem.nested}"` : "undefined"}`,
+    `        translationNs: ${menuItem.translationNs || "undefined"}`
+  ];
+  return `    {
+${parts.join(",\n")}
+    }`;
+}
+function parseFile2(file, pagesDir, index) {
+  const config = getRouteConfig(file);
+  if (!config) {
+    return null;
+  }
+  return {
+    import: generateImport(file, index),
+    menuItem: generateMenuItem(config, file, pagesDir, index)
+  };
+}
+function generateMenuItems({ srcDir, pluginExtensions }) {
+  const pagesDir = path2.join(srcDir, "pages");
+  let index = 0;
+  const results = [];
+  for (const file of crawlPages2(pagesDir)) {
+    const result = parseFile2(file, pagesDir, index);
+    if (result) {
+      results.push(result);
+      index++;
+    }
+  }
+  const pluginImports = pluginExtensions.map(
+    (ext, i) => `import * as __pluginRaw${i} from "${normalizePath(ext)}"`
+  );
+  const pluginUnwraps = pluginExtensions.map(
+    (_, i) => `const __plugin${i} = __pluginRaw${i}.default ?? __pluginRaw${i}`
+  );
+  const pluginSpreads = pluginExtensions.map(
+    (_, i) => `        ...(__plugin${i}.menuItemModule?.menuItems ?? [])`
+  );
+  const appImports = results.map((r) => r.import);
+  const appMenuItems = results.map((r) => formatMenuItem(r.menuItem));
+  const allImports = [...appImports, ...pluginImports, ...pluginUnwraps];
+  const allMenuItems = [...appMenuItems, ...pluginSpreads];
+  if (allImports.length === 0 && allMenuItems.length === 0) {
+    return `export default { menuItems: [] }`;
+  }
+  return `${allImports.join("\n")}
+
+export default {
+    menuItems: [
+${allMenuItems.join(",\n")}
+    ]
+}`;
+}
+
+// src/i18n.ts
+import fs3 from "fs";
+import path3 from "path";
+function findI18nIndex(srcDir) {
+  const i18nDir = path3.join(srcDir, "i18n");
+  if (!fs3.existsSync(i18nDir)) {
+    return null;
+  }
+  for (const ext of VALID_FILE_EXTENSIONS) {
+    const filePath = path3.join(i18nDir, `index${ext}`);
+    if (fs3.existsSync(filePath)) {
+      return filePath;
+    }
+  }
+  return null;
+}
+function generateI18n({ srcDir }) {
+  const indexFile = findI18nIndex(srcDir);
+  if (!indexFile) {
+    return `export default {}`;
+  }
+  const importPath = normalizePath(indexFile);
+  return `import i18nResources from "${importPath}"
+export default i18nResources`;
+}
+
+// src/virtual-modules.ts
+function isVirtualModule(id) {
+  return VIRTUAL_MODULES.includes(id);
+}
+function resolveVirtualModule(id) {
+  return "\0" + id;
+}
+function loadVirtualModule({
+  cwd,
+  id,
+  mercurConfig
+}) {
+  if (id === RESOLVED_CONFIG_MODULE) {
+    return loadConfigModule(mercurConfig);
+  }
+  if (id === RESOLVED_COMPONENTS_MODULE) {
+    return loadComponentsModule(mercurConfig, cwd);
+  }
+  if (id === RESOLVED_ROUTES_MODULE) {
+    return loadRoutesModule(mercurConfig);
+  }
+  if (id === RESOLVED_MENU_ITEMS_MODULE) {
+    return loadMenuItemsModule(mercurConfig);
+  }
+  if (id === RESOLVED_I18N_MODULE) {
+    return loadI18nModule(mercurConfig);
+  }
+  return null;
+}
+function loadConfigModule(mercurConfig) {
+  const { components, ...configWithoutComponents } = mercurConfig;
+  return `export default ${JSON.stringify(configWithoutComponents)}`;
+}
+function loadComponentsModule(mercurConfig, cwd) {
+  const components = mercurConfig.components ?? {};
+  const imports = [];
+  const exports = [];
+  Object.entries(components).forEach(([name, componentPath]) => {
+    const resolvedPath = path4.resolve(cwd, "src", componentPath);
+    imports.push(`import _${name} from "${resolvedPath}"`);
+    exports.push(`${name}: _${name}`);
+  });
+  return `
+${imports.join("\n")}
+
+export default {
+    ${exports.join(",\n    ")}
+}
+`;
+}
+function loadRoutesModule(mercurConfig) {
+  return generateRoutes(mercurConfig);
+}
+function loadMenuItemsModule(mercurConfig) {
+  return generateMenuItems(mercurConfig);
+}
+function loadI18nModule(mercurConfig) {
+  return generateI18n(mercurConfig);
+}
+
+// src/plugin.ts
+function isPageFile(file) {
+  const basename = path5.basename(file, path5.extname(file));
+  return basename === "page";
+}
+var UI_MODULE_KEYS = [
+  "admin_ui",
+  "vendor_ui"
+];
+function findNodeModulesRoot(configDir) {
+  let dir = configDir;
+  while (dir !== path5.dirname(dir)) {
+    const candidate = path5.join(dir, "node_modules");
+    if (fs4.existsSync(candidate) && fs4.statSync(candidate).isDirectory()) {
+      return candidate;
+    }
+    dir = path5.dirname(dir);
+  }
+  return path5.join(configDir, "node_modules");
+}
+function resolvePluginRoot(resolve, configDir, nodeModulesRoot) {
+  try {
+    if (resolve.startsWith(".")) {
+      const resolved = path5.resolve(configDir, resolve);
+      if (fs4.existsSync(resolved)) {
+        return fs4.realpathSync(resolved);
+      }
+      return null;
+    }
+    const packagePath = path5.join(nodeModulesRoot, resolve);
+    if (!fs4.existsSync(packagePath)) {
+      return null;
+    }
+    return fs4.realpathSync(packagePath);
+  } catch {
+    return null;
+  }
+}
+function resolvePluginExtensions(plugins, configDir) {
+  const nodeModulesRoot = findNodeModulesRoot(configDir);
+  const extensions = [];
+  const appTypes = ["admin", "vendor"];
+  for (const plugin of plugins) {
+    const resolve = typeof plugin === "string" ? plugin : plugin?.resolve;
+    if (!resolve || typeof resolve !== "string") continue;
+    const pluginRoot = resolvePluginRoot(resolve, configDir, nodeModulesRoot);
+    if (!pluginRoot) continue;
+    for (const appType of appTypes) {
+      const extFile = path5.join(pluginRoot, ".medusa/server/src", appType, "index.js");
+      if (fs4.existsSync(extFile)) {
+        extensions.push(extFile);
+      }
+    }
+  }
+  return extensions;
+}
+function extractStringFromNode(node, configDir) {
+  if (isStringLiteral(node)) {
+    return node.value;
+  }
+  if (isCallExpression(node) && isMemberExpression(node.callee) && isIdentifier(node.callee.object, { name: "path" }) && isIdentifier(node.callee.property) && (node.callee.property.name === "join" || node.callee.property.name === "resolve")) {
+    const args = node.arguments;
+    if (args.length >= 2 && isIdentifier(args[0], { name: "__dirname" })) {
+      const parts = args.slice(1).filter((a) => isStringLiteral(a)).map((a) => a.value);
+      if (parts.length > 0) {
+        return path5.resolve(configDir, ...parts);
+      }
+    }
+  }
+  return null;
+}
+function extractObjectProperties(node) {
+  if (isObjectExpression(node)) {
+    return node.properties;
+  }
+  return null;
+}
+async function loadMedusaConfig(medusaConfigPath, root) {
+  try {
+    const code = fs4.readFileSync(medusaConfigPath, "utf-8");
+    const ast = parse(code, getParserOptions(medusaConfigPath));
+    const configDir = path5.dirname(medusaConfigPath);
+    const result = { properties: null };
+    traverse(ast, {
+      // Handle: export default defineConfig({ ... })
+      ExportDefaultDeclaration(nodePath) {
+        const decl = nodePath.node.declaration;
+        if (isCallExpression(decl) && decl.arguments.length > 0) {
+          result.properties = extractObjectProperties(decl.arguments[0]);
+        }
+      },
+      // Handle: module.exports = defineConfig({ ... }) or module.exports = { ... }
+      AssignmentExpression(nodePath) {
+        const left = nodePath.node.left;
+        if (isMemberExpression(left) && isIdentifier(left.object, { name: "module" }) && isIdentifier(left.property, { name: "exports" })) {
+          const right = nodePath.node.right;
+          if (isCallExpression(right) && right.arguments.length > 0) {
+            result.properties = extractObjectProperties(right.arguments[0]);
+          } else if (isObjectExpression(right)) {
+            result.properties = right.properties;
+          }
+        }
+      }
+    });
+    const configObjectProperties = result.properties;
+    if (!configObjectProperties) {
+      return { pluginExtensions: [] };
+    }
+    let base;
+    const modulesProp = configObjectProperties.find(
+      (p) => isObjectProperty(p) && isIdentifier(p.key, { name: "modules" })
+    );
+    if (modulesProp && isObjectProperty(modulesProp) && isObjectExpression(modulesProp.value)) {
+      for (const key of UI_MODULE_KEYS) {
+        const uiProp = modulesProp.value.properties.find(
+          (p) => isObjectProperty(p) && isIdentifier(p.key, { name: key })
+        );
+        if (!uiProp || !isObjectProperty(uiProp) || !isObjectExpression(uiProp.value)) continue;
+        const optionsProp = uiProp.value.properties.find(
+          (p) => isObjectProperty(p) && isIdentifier(p.key, { name: "options" })
+        );
+        if (!optionsProp || !isObjectProperty(optionsProp) || !isObjectExpression(optionsProp.value)) continue;
+        const appDirProp = optionsProp.value.properties.find(
+          (p) => isObjectProperty(p) && isIdentifier(p.key, { name: "appDir" })
+        );
+        if (!appDirProp || !isObjectProperty(appDirProp)) continue;
+        const appDir = extractStringFromNode(appDirProp.value, configDir);
+        if (!appDir) continue;
+        const resolvedAppDir = path5.isAbsolute(appDir) ? appDir : path5.resolve(configDir, appDir);
+        if (resolvedAppDir === root) {
+          const pathProp = optionsProp.value.properties.find(
+            (p) => isObjectProperty(p) && isIdentifier(p.key, { name: "path" })
+          );
+          if (pathProp && isObjectProperty(pathProp) && isStringLiteral(pathProp.value)) {
+            base = pathProp.value.value;
+          }
+          break;
+        }
+      }
+    }
+    const plugins = [];
+    const pluginsProp = configObjectProperties.find(
+      (p) => isObjectProperty(p) && isIdentifier(p.key, { name: "plugins" })
+    );
+    if (pluginsProp && isObjectProperty(pluginsProp) && isArrayExpression(pluginsProp.value)) {
+      for (const element of pluginsProp.value.elements) {
+        if (!element) continue;
+        if (isObjectExpression(element)) {
+          const resolveProp = element.properties.find(
+            (p) => isObjectProperty(p) && isIdentifier(p.key, { name: "resolve" })
+          );
+          if (resolveProp && isObjectProperty(resolveProp) && isStringLiteral(resolveProp.value)) {
+            plugins.push({ resolve: resolveProp.value.value });
+          }
+        } else if (isStringLiteral(element)) {
+          plugins.push({ resolve: element.value });
+        }
+      }
+    }
+    const pluginExtensions = resolvePluginExtensions(plugins, configDir);
+    return { base, pluginExtensions };
+  } catch {
+    return { pluginExtensions: [] };
+  }
+}
+function mercurDashboardPlugin(pluginConfig) {
+  let root;
+  let config;
+  return {
+    name: "@mercurjs/dashboard-sdk",
+    async config(viteConfig) {
+      root = viteConfig.root || process.cwd();
+      const medusaConfigPath = path5.resolve(root, pluginConfig.medusaConfigPath);
+      const { base, pluginExtensions } = await loadMedusaConfig(medusaConfigPath, root);
+      const srcDir = path5.join(root, "src");
+      const backendUrl = pluginConfig.backendUrl ?? "http://localhost:9000";
+      config = {
+        ...pluginConfig,
+        backendUrl,
+        base,
+        root,
+        srcDir,
+        pluginExtensions
+      };
+      return {
+        base: config.base,
+        define: {
+          "__BACKEND_URL__": JSON.stringify(config.backendUrl),
+          "__BASE__": JSON.stringify(config.base || "/")
+        },
+        optimizeDeps: {
+          include: pluginExtensions,
+          exclude: ["virtual:mercur/config", "virtual:mercur/routes", "virtual:mercur/components", "virtual:mercur/menu-items", "virtual:mercur/i18n"]
+        }
+      };
+    },
+    configResolved(resolvedConfig) {
+      root = resolvedConfig.root;
+    },
+    resolveId(id) {
+      if (isVirtualModule(id)) {
+        return resolveVirtualModule(id);
+      }
+      return null;
+    },
+    load(id) {
+      return loadVirtualModule({ cwd: root, id, mercurConfig: config });
+    },
+    configureServer(server) {
+      const handlePageChange = (file) => {
+        if (!isPageFile(file)) return;
+        const mod = server.moduleGraph.getModuleById(RESOLVED_ROUTES_MODULE);
+        if (mod) {
+          server.moduleGraph.invalidateModule(mod);
+          server.ws.send({ type: "full-reload" });
+        }
+      };
+      server.watcher.on("add", handlePageChange);
+      server.watcher.on("unlink", handlePageChange);
+    },
+    handleHotUpdate({ file, server }) {
+      if (isPageFile(file)) {
+        const mod = server.moduleGraph.getModuleById(RESOLVED_ROUTES_MODULE);
+        if (mod) {
+          server.moduleGraph.invalidateModule(mod);
+        }
+      }
+    }
+  };
+}
+export {
+  mercurDashboardPlugin
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mercurjs/dashboard-sdk",
-  "version": "2.0.0-canary.73",
+  "version": "2.0.0-canary.74",
   "repository": {
     "type": "git",
     "url": "https://github.com/mercurjs/mercur",
@@ -12,8 +12,8 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "require": "./dist/index.cjs",
-      "default": "./dist/index.cjs"
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
     }
   },
   "files": [
@@ -25,7 +25,9 @@
     "lint": "eslint . --ext ts,tsx --report-unused-disable-directives --max-warnings 0"
   },
   "dependencies": {
-    "esbuild-register": "^3.6.0"
+    "@babel/parser": "7.25.6",
+    "@babel/traverse": "7.25.6",
+    "@babel/types": "7.25.6"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",