@mercurjs/dashboard-sdk 2.0.0-canary.76 → 2.0.0-canary.78

package/dist/index.cjs

@@ -38,9 +38,6 @@ module.exports = __toCommonJS(index_exports);
 var import_path5 = __toESM(require("path"), 1);
 var import_fs4 = __toESM(require("fs"), 1);
 
-// src/utils.ts
-var import_node_module = require("module");
-
 // src/babel.ts
 var import_parser = require("@babel/parser");
 var import_traverse = __toESM(require("@babel/traverse"), 1);
@@ -53,7 +50,6 @@ if (typeof import_traverse.default === "function") {
 }
 
 // src/utils.ts
-var import_meta = {};
 function normalizePath(filePath) {
   return filePath.replace(/\\/g, "/");
 }
@@ -73,10 +69,9 @@ function resolveExports(moduleExports) {
   }
   return moduleExports;
 }
-var esmRequire = typeof require !== "undefined" ? require : (0, import_node_module.createRequire)(import_meta.url);
-async function getFileExports(filePath) {
+async function getFileExports(path6) {
   const { unregister } = await safeRegister();
-  const module2 = esmRequire(filePath);
+  const module2 = require(path6);
   unregister();
   return resolveExports(module2);
 }
@@ -696,7 +691,7 @@ function resolvePluginExtensions(plugins, configDir) {
     const pluginRoot = resolvePluginRoot(resolve, configDir, nodeModulesRoot);
     if (!pluginRoot) continue;
     for (const appType of appTypes) {
-      const extFile = import_path5.default.join(pluginRoot, ".medusa/server/src", appType, "index.js");
+      const extFile = import_path5.default.join(pluginRoot, ".medusa/server/src", appType, "index.mjs");
       if (import_fs4.default.existsSync(extFile)) {
         extensions.push(extFile);
       }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mercurjs/dashboard-sdk",
-  "version": "2.0.0-canary.76",
+  "version": "2.0.0-canary.78",
   "repository": {
     "type": "git",
     "url": "https://github.com/mercurjs/mercur",
@@ -12,8 +12,8 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js",
-      "require": "./dist/index.cjs"
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.cjs"
     }
   },
   "files": [

package/dist/index.d.ts

@@ -1,37 +0,0 @@
-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

@@ -1,779 +0,0 @@
-var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
-  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
-}) : x)(function(x) {
-  if (typeof require !== "undefined") return require.apply(this, arguments);
-  throw Error('Dynamic require of "' + x + '" is not supported');
-});
-
-// src/plugin.ts
-import path5 from "path";
-import fs4 from "fs";
-
-// src/utils.ts
-import { createRequire } from "module";
-
-// 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 resolveExports(moduleExports) {
-  if ("default" in moduleExports && moduleExports.default && "default" in moduleExports.default) {
-    return resolveExports(moduleExports.default);
-  }
-  return moduleExports;
-}
-var esmRequire = typeof __require !== "undefined" ? __require : createRequire(import.meta.url);
-async function getFileExports(filePath) {
-  const { unregister } = await safeRegister();
-  const module = esmRequire(filePath);
-  unregister();
-  return resolveExports(module);
-}
-var safeRegister = async () => {
-  const { register } = await import("esbuild-register/dist/node");
-  let res;
-  try {
-    res = register({
-      format: "cjs",
-      loader: "ts"
-    });
-  } catch {
-    res = {
-      unregister: () => {
-      }
-    };
-  }
-  return res;
-};
-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 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 = []`;
-  }
-  return `${allImports.join("\n")}
-
-${pluginDeclarations.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 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: [] }`;
-  }
-  return `${allImports.join("\n")}
-
-${pluginDeclarations.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;
-}
-async function loadMedusaConfig(medusaConfigPath, root) {
-  try {
-    const mod = await getFileExports(medusaConfigPath);
-    const medusaConfig = mod.default ?? mod;
-    const modules = medusaConfig?.modules ?? {};
-    const configDir = path5.dirname(medusaConfigPath);
-    let base;
-    for (const key of UI_MODULE_KEYS) {
-      const value = modules[key];
-      if (!value || typeof value !== "object" || !value.options?.appDir) continue;
-      const appDir = path5.resolve(configDir, value.options.appDir);
-      if (appDir === root) {
-        base = value.options.path;
-        break;
-      }
-    }
-    const plugins = medusaConfig?.plugins ?? [];
-    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: {
-          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
-};