@mercurjs/dashboard-sdk 2.0.0-canary.9 → 2.0.0-canary.90

package/dist/index.cjs

@@ -30,24 +30,49 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  dashboardPlugin: () => dashboardPlugin,
-  defineConfig: () => defineConfig
+  generatePluginEntryModule: () => generatePluginEntryModule,
+  mercurDashboardPlugin: () => mercurDashboardPlugin
 });
 module.exports = __toCommonJS(index_exports);
 
 // src/plugin.ts
 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 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 resolveExports(moduleExports) {
   if ("default" in moduleExports && moduleExports.default && "default" in moduleExports.default) {
     return resolveExports(moduleExports.default);
   }
   return moduleExports;
 }
-async function getFileExports(path6) {
+async function getFileExports(path7) {
   const { unregister } = await safeRegister();
-  const module2 = require(path6);
+  const module2 = require(path7);
   unregister();
   return resolveExports(module2);
 }
@@ -67,13 +92,31 @@ var safeRegister = async () => {
   }
   return res;
 };
-function normalizePath(filePath) {
-  return filePath.replace(/\\/g, "/");
+function hasDefaultExport(ast) {
+  let found = false;
+  traverse(ast, {
+    ExportDefaultDeclaration() {
+      found = true;
+    },
+    AssignmentExpression(path7) {
+      if (path7.node.left.type === "MemberExpression" && path7.node.left.object.type === "Identifier" && path7.node.left.object.name === "exports" && path7.node.left.property.type === "Identifier" && path7.node.left.property.name === "default") {
+        found = true;
+      }
+    },
+    ExportNamedDeclaration(path7) {
+      const specifiers = path7.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_NAME = "mercur.config.ts";
 var CONFIG_VIRTUAL_MODULE = "virtual:mercur/config";
 var ROUTES_VIRTUAL_MODULE = "virtual:mercur/routes";
 var COMPONENTS_VIRTUAL_MODULE = "virtual:mercur/components";
@@ -98,17 +141,17 @@ var import_path4 = __toESM(require("path"), 1);
 // src/routes.ts
 var import_fs = __toESM(require("fs"), 1);
 var import_path = __toESM(require("path"), 1);
-function getRoute(file, pagesDir) {
+function getRoute(file, routesDir) {
   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(
+  const normalizedRoutesDir = normalizePath(routesDir);
+  return importPath.replace(normalizedRoutesDir, "").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") {
+function crawlRoutes(dir, pattern = "page") {
   const files = [];
   if (!import_fs.default.existsSync(dir)) {
     return files;
@@ -117,7 +160,7 @@ function crawlPages(dir, pattern = "page") {
   for (const entry of entries) {
     const fullPath = import_path.default.join(dir, entry.name);
     if (entry.isDirectory()) {
-      files.push(...crawlPages(fullPath, pattern));
+      files.push(...crawlRoutes(fullPath, pattern));
     } else if (entry.isFile()) {
       const ext = import_path.default.extname(entry.name);
       const baseName = import_path.default.basename(entry.name, ext);
@@ -128,31 +171,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(path7) {
+      const declaration = path7.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(path7) {
+      const declaration = path7.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,19 +280,25 @@ ${indent}    ]`;
 ${indent}}`;
   return result;
 }
-function parseFile(file, pagesDir, index) {
-  if (!hasDefaultExport(file)) {
+function parseFile(file, routesDir, index) {
+  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, routesDir);
+    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();
@@ -243,7 +312,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("/@", "/")
@@ -258,38 +327,44 @@ function buildRouteTree(results) {
   }
   return Array.from(routeMap.values());
 }
-function generateRoutes({ srcDir }) {
-  const pagesDir = import_path.default.join(srcDir, "pages");
-  const files = crawlPages(pagesDir);
-  if (files.length === 0) {
-    return `export const customRoutes = []`;
-  }
+function generateRoutes({ srcDir, pluginExtensions }) {
+  const routesDir = import_path.default.join(srcDir, "routes");
   let index = 0;
   const results = [];
-  for (const file of files) {
-    const result = parseFile(file, pagesDir, index);
+  for (const file of crawlRoutes(routesDir)) {
+    const result = parseFile(file, routesDir, index);
     if (result) {
       results.push(result);
       index++;
     }
   }
-  if (results.length === 0) {
+  const pluginDeclarations = pluginExtensions.map(
+    (ext, i) => `const __plugin${i} = (await import("${normalizePath(ext)}")).default`
+  );
+  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];
+  const allRoutes = [...appRoutes, ...pluginSpreads];
+  if (allImports.length === 0 && pluginDeclarations.length === 0 && allRoutes.length === 0) {
     return `export const customRoutes = []`;
   }
-  const routeTree = buildRouteTree(results);
-  const imports = routeTree.flatMap((result) => result.imports);
-  const routes = routeTree.map((result) => formatRoute(result.route));
-  return `${imports.join("\n")}
+  return `${allImports.join("\n")}
+
+${pluginDeclarations.join("\n")}
 
 export const customRoutes = [
-${routes.join(",\n")}
+${allRoutes.join(",\n")}
 ]`;
 }
 
 // src/menu-items.ts
 var import_fs2 = __toESM(require("fs"), 1);
 var import_path2 = __toESM(require("path"), 1);
-function crawlPages2(dir, pattern = "page") {
+function crawlRoutes2(dir, pattern = "page") {
   const files = [];
   if (!import_fs2.default.existsSync(dir)) {
     return files;
@@ -298,7 +373,7 @@ function crawlPages2(dir, pattern = "page") {
   for (const entry of entries) {
     const fullPath = import_path2.default.join(dir, entry.name);
     if (entry.isDirectory()) {
-      files.push(...crawlPages2(fullPath, pattern));
+      files.push(...crawlRoutes2(fullPath, pattern));
     } else if (entry.isFile()) {
       const ext = import_path2.default.extname(entry.name);
       const baseName = import_path2.default.basename(entry.name, ext);
@@ -309,39 +384,100 @@ function crawlPages2(dir, pattern = "page") {
   }
   return files;
 }
-function getRoute2(file, pagesDir) {
+function getRoute2(file, routesDir) {
   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(
+  const normalizedRoutesDir = normalizePath(routesDir);
+  return importPath.replace(normalizedRoutesDir, "").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 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(path7) {
+  if ((0, import_types.isVariableDeclarator)(path7.node)) {
+    const decl = (0, import_types.isIdentifier)(path7.node.id, { name: "config" }) ? path7.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 = path7.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 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 getConfigProperties(filePath) {
+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(path7) {
+        if (configFound) return;
+        const properties = getConfigObjectProperties(path7);
+        if (!properties) return;
+        config = processConfigProperties(properties);
+        if (config) configFound = true;
+      },
+      ExportNamedDeclaration(path7) {
+        if (configFound) return;
+        const properties = getConfigObjectProperties(path7);
+        if (!properties) return;
+        config = processConfigProperties(properties);
+        if (config) configFound = true;
+      }
+    });
+    return config;
   } catch {
     return null;
   }
@@ -353,12 +489,12 @@ function generateImport(file, index) {
   const importPath = normalizePath(file);
   return `import { config as ${generateRouteConfigName(index)} } from "${importPath}"`;
 }
-function generateMenuItem(config, file, pagesDir, index) {
+function generateMenuItem(config, file, routesDir, index) {
   const configName = generateRouteConfigName(index);
   return {
     label: `${configName}.label`,
     icon: config.icon ? `${configName}.icon` : void 0,
-    path: getRoute2(file, pagesDir),
+    path: getRoute2(file, routesDir),
     rank: config.rank,
     nested: config.nested,
     translationNs: config.translationNs ? `${configName}.translationNs` : void 0
@@ -377,44 +513,47 @@ function formatMenuItem(menuItem) {
 ${parts.join(",\n")}
     }`;
 }
-function parseFile2(file, pagesDir, index) {
-  if (!hasConfigExport(file)) {
-    return null;
-  }
-  const config = getConfigProperties(file);
+function parseMenuItemFile(file, routesDir, index) {
+  const config = getRouteConfig(file);
   if (!config) {
     return null;
   }
   return {
     import: generateImport(file, index),
-    menuItem: generateMenuItem(config, file, pagesDir, index)
+    menuItem: generateMenuItem(config, file, routesDir, index)
   };
 }
-function generateMenuItems({ srcDir }) {
-  const pagesDir = import_path2.default.join(srcDir, "pages");
-  const files = crawlPages2(pagesDir);
-  if (files.length === 0) {
-    return `export default { menuItems: [] }`;
-  }
+function generateMenuItems({ srcDir, pluginExtensions }) {
+  const routesDir = import_path2.default.join(srcDir, "routes");
   let index = 0;
   const results = [];
-  for (const file of files) {
-    const result = parseFile2(file, pagesDir, index);
+  for (const file of crawlRoutes2(routesDir)) {
+    const result = parseMenuItemFile(file, routesDir, index);
     if (result) {
       results.push(result);
       index++;
     }
   }
-  if (results.length === 0) {
+  const pluginDeclarations = pluginExtensions.map(
+    (ext, i) => `const __plugin${i} = (await import("${normalizePath(ext)}")).default`
+  );
+  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];
+  const allMenuItems = [...appMenuItems, ...pluginSpreads];
+  if (allImports.length === 0 && pluginDeclarations.length === 0 && allMenuItems.length === 0) {
     return `export default { menuItems: [] }`;
   }
-  const imports = results.map((r) => r.import);
-  const menuItems = results.map((r) => formatMenuItem(r.menuItem));
-  return `${imports.join("\n")}
+  return `${allImports.join("\n")}
+
+${pluginDeclarations.join("\n")}
 
 export default {
     menuItems: [
-${menuItems.join(",\n")}
+${allMenuItems.join(",\n")}
     ]
 }`;
 }
@@ -506,47 +645,138 @@ function loadI18nModule(mercurConfig) {
 }
 
 // src/plugin.ts
-function buildConfig(config, root) {
-  const srcDir = import_path5.default.join(root, "src");
-  return {
-    ...config,
-    backendUrl: config.backendUrl ?? "http://localhost:9000",
-    root,
-    srcDir,
-    configPath: import_path5.default.resolve(root, CONFIG_NAME)
-  };
+function isRouteFile(file) {
+  const basename = import_path5.default.basename(file, import_path5.default.extname(file));
+  return basename === "page";
 }
-async function loadMercurConfig(root) {
-  const configPath = import_path5.default.resolve(root, CONFIG_NAME);
+var UI_MODULE_KEYS = ["admin_ui", "vendor_ui"];
+function findNodeModulesRoot(configDir) {
+  let dir = configDir;
+  while (dir !== import_path5.default.dirname(dir)) {
+    const candidate = import_path5.default.join(dir, "node_modules");
+    if (import_fs4.default.existsSync(candidate) && import_fs4.default.statSync(candidate).isDirectory()) {
+      return candidate;
+    }
+    dir = import_path5.default.dirname(dir);
+  }
+  return import_path5.default.join(configDir, "node_modules");
+}
+function resolvePluginRoot(resolve, configDir, nodeModulesRoot) {
   try {
-    const mod = await getFileExports(configPath);
-    const content = mod.default ?? mod;
-    return buildConfig(content, root);
-  } catch (error) {
-    console.error(error);
-    throw new Error(
-      `[@mercurjs/dashboard-sdk] Could not find or load ${CONFIG_NAME} in ${root}`
+    if (resolve.startsWith(".")) {
+      const resolved = import_path5.default.resolve(configDir, resolve);
+      if (import_fs4.default.existsSync(resolved)) {
+        return import_fs4.default.realpathSync(resolved);
+      }
+      return null;
+    }
+    const packagePath = import_path5.default.join(nodeModulesRoot, resolve);
+    if (!import_fs4.default.existsSync(packagePath)) {
+      return null;
+    }
+    return import_fs4.default.realpathSync(packagePath);
+  } catch {
+    return null;
+  }
+}
+function resolvePluginExtensions(plugins, configDir, appType) {
+  const nodeModulesRoot = findNodeModulesRoot(configDir);
+  const extensions = [];
+  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;
+    const extFile = import_path5.default.join(
+      pluginRoot,
+      ".medusa/server/src",
+      appType,
+      "index.mjs"
     );
+    if (import_fs4.default.existsSync(extFile)) {
+      extensions.push(extFile);
+    }
   }
+  return extensions;
 }
-function isPageFile(file) {
-  const basename = import_path5.default.basename(file, import_path5.default.extname(file));
-  return basename === "page";
+async function loadMedusaConfig(medusaConfigPath, root) {
+  try {
+    const mod = await getFileExports(medusaConfigPath);
+    const medusaConfig = mod.default ?? mod;
+    const modules = medusaConfig?.modules ?? {};
+    const configDir = import_path5.default.dirname(medusaConfigPath);
+    let base;
+    let appType = "admin";
+    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;
+        appType = key === "vendor_ui" ? "vendor" : "admin";
+        break;
+      }
+    }
+    const plugins = medusaConfig?.plugins?.filter(
+      (plugin) => plugin.resolve !== "@medusajs/draft-order"
+    ) ?? [];
+    const pluginExtensions = resolvePluginExtensions(plugins, configDir, appType);
+    return { base, pluginExtensions };
+  } catch {
+    return { pluginExtensions: [] };
+  }
 }
-function dashboardPlugin() {
+function mercurDashboardPlugin(pluginConfig) {
   let root;
   let config;
   return {
     name: "@mercurjs/dashboard-sdk",
     async config(viteConfig) {
       root = viteConfig.root || process.cwd();
-      config = await loadMercurConfig(root);
+      const medusaConfigPath = import_path5.default.resolve(
+        root,
+        pluginConfig.medusaConfigPath
+      );
+      const { base, pluginExtensions } = await loadMedusaConfig(
+        medusaConfigPath,
+        root
+      );
+      const srcDir = import_path5.default.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)
+          __BACKEND_URL__: JSON.stringify(config.backendUrl),
+          __BASE__: JSON.stringify(config.base || "/")
         },
         optimizeDeps: {
-          exclude: ["@mercurjs/vendor", "virtual:mercur/config"]
+          exclude: [
+            "virtual:mercur/config",
+            "virtual:mercur/routes",
+            "virtual:mercur/components",
+            "virtual:mercur/menu-items",
+            "virtual:mercur/i18n"
+          ],
+          include: [
+            "react",
+            "react/jsx-runtime",
+            "react-dom/client",
+            "react-router-dom",
+            "react-i18next",
+            "@medusajs/ui",
+            "@medusajs/dashboard",
+            "@medusajs/js-sdk",
+            "@tanstack/react-query"
+          ]
         }
       };
     },
@@ -563,24 +793,19 @@ function dashboardPlugin() {
       return loadVirtualModule({ cwd: root, id, mercurConfig: config });
     },
     configureServer(server) {
-      const handlePageChange = (file) => {
-        if (!isPageFile(file)) return;
+      const handleRouteChange = (file) => {
+        if (!isRouteFile(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);
+      server.watcher.on("add", handleRouteChange);
+      server.watcher.on("unlink", handleRouteChange);
     },
     handleHotUpdate({ file, server }) {
-      const configPath = import_path5.default.resolve(root, CONFIG_NAME);
-      if (file === configPath) {
-        server.restart();
-        return;
-      }
-      if (isPageFile(file)) {
+      if (isRouteFile(file)) {
         const mod = server.moduleGraph.getModuleById(RESOLVED_ROUTES_MODULE);
         if (mod) {
           server.moduleGraph.invalidateModule(mod);
@@ -590,12 +815,71 @@ function dashboardPlugin() {
   };
 }
 
-// src/define-config.ts
-function defineConfig(config) {
-  return config;
+// src/generate-plugin-entry.ts
+var import_path6 = __toESM(require("path"), 1);
+var import_fs5 = __toESM(require("fs"), 1);
+function findI18nIndex2(srcDir) {
+  const i18nDir = import_path6.default.join(srcDir, "i18n");
+  if (!import_fs5.default.existsSync(i18nDir)) return null;
+  for (const ext of VALID_FILE_EXTENSIONS) {
+    const filePath = import_path6.default.join(i18nDir, `index${ext}`);
+    if (import_fs5.default.existsSync(filePath)) return filePath;
+  }
+  return null;
+}
+function generatePluginEntryModule(srcDir) {
+  const routesDir = import_path6.default.join(srcDir, "routes");
+  const files = crawlRoutes(routesDir);
+  let index = 0;
+  const routeResults = [];
+  const menuItemResults = [];
+  for (const file of files) {
+    const route = parseFile(file, routesDir, index);
+    if (route) {
+      routeResults.push(route);
+    }
+    const menuItem = parseMenuItemFile(file, routesDir, index);
+    if (menuItem) {
+      menuItemResults.push(menuItem);
+    }
+    index++;
+  }
+  const routeTree = buildRouteTree(routeResults.filter(Boolean));
+  const routeImports = routeTree.flatMap((r) => r.imports);
+  const routes = routeTree.map((r) => formatRoute(r.route));
+  const menuItemImports = menuItemResults.filter(Boolean).map((r) => r.import);
+  const menuItems = menuItemResults.filter(Boolean).map((r) => formatMenuItem(r.menuItem));
+  const i18nFile = findI18nIndex2(srcDir);
+  const i18nImport = i18nFile ? `import i18nResources from "${normalizePath(i18nFile)}"` : "";
+  const i18nValue = i18nFile ? "i18nResources" : "{}";
+  const allImports = [...routeImports, ...menuItemImports];
+  if (i18nImport) allImports.push(i18nImport);
+  return `// Auto-generated plugin extensions entry
+${allImports.join("\n")}
+
+const routeModule = {
+    routes: [
+${routes.join(",\n")}
+    ]
+}
+
+const menuItemModule = {
+    menuItems: [
+${menuItems.join(",\n")}
+    ]
+}
+
+const plugin = {
+    routeModule,
+    menuItemModule,
+    i18nModule: ${i18nValue},
+}
+
+export default plugin
+`;
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  dashboardPlugin,
-  defineConfig
+  generatePluginEntryModule,
+  mercurDashboardPlugin
 });

package/dist/index.d.cts

@@ -1,9 +1,9 @@
 import * as Vite from 'vite';
 import { ComponentType } from 'react';
 
-declare function dashboardPlugin(): Vite.Plugin;
-
 interface MercurConfig {
+    medusaConfigPath: string;
+    backendUrl?: string;
     name?: string;
     logo?: string;
     components?: {
@@ -14,13 +14,14 @@ interface MercurConfig {
     i18n?: {
         defaultLanguage: string;
     };
-    backendUrl?: string;
+    enableSellerRegistration?: boolean;
 }
 interface BuiltMercurConfig extends MercurConfig {
     backendUrl: string;
+    base?: string;
     root: string;
     srcDir: string;
-    configPath: string;
+    pluginExtensions: string[];
 }
 type RouteConfig = {
     label: string;
@@ -31,6 +32,13 @@ type RouteConfig = {
     public?: boolean;
 };
 
-declare function defineConfig(config: MercurConfig): MercurConfig;
+declare function mercurDashboardPlugin(pluginConfig: MercurConfig): Vite.Plugin;
+
+/**
+ * Generates a plugin entry module for a given source directory (e.g. src/vendor).
+ * Scans routes, menu items, and i18n — outputs a single module string
+ * that exports default `{ routeModule, menuItemModule, i18nModule }`.
+ */
+declare function generatePluginEntryModule(srcDir: string): string;
 
-export { type BuiltMercurConfig, type MercurConfig, type RouteConfig, dashboardPlugin, defineConfig };
+export { type BuiltMercurConfig, type MercurConfig, type RouteConfig, generatePluginEntryModule, mercurDashboardPlugin };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mercurjs/dashboard-sdk",
-  "version": "2.0.0-canary.9",
+  "version": "2.0.0-canary.90",
   "repository": {
     "type": "git",
     "url": "https://github.com/mercurjs/mercur",
@@ -25,6 +25,9 @@
     "lint": "eslint . --ext ts,tsx --report-unused-disable-directives --max-warnings 0"
   },
   "dependencies": {
+    "@babel/parser": "7.25.6",
+    "@babel/traverse": "7.25.6",
+    "@babel/types": "7.25.6",
     "esbuild-register": "^3.6.0"
   },
   "devDependencies": {