@mercurjs/dashboard-sdk 2.2.0-canary.40 → 2.2.0-canary.41

package/dist/index.cjs

@@ -1,9 +1,7 @@
 "use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -17,935 +15,36 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
-  generatePluginEntryModule: () => generatePluginEntryModule,
-  mercurDashboardPlugin: () => mercurDashboardPlugin
+  defineCustomFieldsConfig: () => defineCustomFieldsConfig,
+  defineNavigationConfig: () => defineNavigationConfig,
+  defineWidgetConfig: () => defineWidgetConfig
 });
 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(path7) {
-  const { unregister } = await safeRegister();
-  const module2 = require(path7);
-  unregister();
-  return resolveExports(module2);
-}
-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(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_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
-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, routesDir) {
-  const importPath = normalizePath(file);
-  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 crawlRoutes(dir, pattern = "page") {
-  const files = [];
-  if (!import_fs.default.existsSync(dir)) {
-    return files;
-  }
-  const entries = import_fs.default.readdirSync(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = import_path.default.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      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);
-      if (baseName === pattern && VALID_FILE_EXTENSIONS.includes(ext)) {
-        files.push(fullPath);
-      }
-    }
-  }
-  return files;
-}
-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}`;
-}
-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, 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;
-  }
-}
-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 routesDir = import_path.default.join(srcDir, "routes");
-  let index = 0;
-  const results = [];
-  for (const file of crawlRoutes(routesDir)) {
-    const result = parseFile(file, routesDir, 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
-var import_fs2 = __toESM(require("fs"), 1);
-var import_path2 = __toESM(require("path"), 1);
-function crawlRoutes2(dir, pattern = "page") {
-  const files = [];
-  if (!import_fs2.default.existsSync(dir)) {
-    return files;
-  }
-  const entries = import_fs2.default.readdirSync(dir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = import_path2.default.join(dir, entry.name);
-    if (entry.isDirectory()) {
-      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);
-      if (baseName === pattern && VALID_FILE_EXTENSIONS.includes(ext)) {
-        files.push(fullPath);
-      }
-    }
-  }
-  return files;
-}
-function getRoute2(file, routesDir) {
-  const importPath = normalizePath(file);
-  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 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 getRouteConfig(file) {
-  try {
-    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;
-  }
-}
-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, routesDir, index) {
-  const configName = generateRouteConfigName(index);
-  return {
-    label: `${configName}.label`,
-    icon: config.icon ? `${configName}.icon` : void 0,
-    path: getRoute2(file, routesDir),
-    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 parseMenuItemFile(file, routesDir, index) {
-  const config = getRouteConfig(file);
-  if (!config) {
-    return null;
-  }
-  return {
-    import: generateImport(file, index),
-    menuItem: generateMenuItem(config, file, routesDir, index)
-  };
-}
-function generateMenuItems({ srcDir, pluginExtensions }) {
-  const routesDir = import_path2.default.join(srcDir, "routes");
-  let index = 0;
-  const results = [];
-  for (const file of crawlRoutes2(routesDir)) {
-    const result = parseMenuItemFile(file, routesDir, 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
-var import_fs3 = __toESM(require("fs"), 1);
-var import_path3 = __toESM(require("path"), 1);
-function findI18nIndex(srcDir) {
-  const i18nDir = import_path3.default.join(srcDir, "i18n");
-  if (!import_fs3.default.existsSync(i18nDir)) {
-    return null;
-  }
-  for (const ext of VALID_FILE_EXTENSIONS) {
-    const filePath = import_path3.default.join(i18nDir, `index${ext}`);
-    if (import_fs3.default.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 { ...configWithoutComponents } = mercurConfig;
-  return `export default ${JSON.stringify(configWithoutComponents)}`;
-}
-function loadComponentsModule(mercurConfig, cwd) {
-  const components = mercurConfig.components ?? {};
-  const imports = [];
-  const exports2 = [];
-  Object.entries(components).forEach(([name, componentPath]) => {
-    const resolvedPath = import_path4.default.resolve(cwd, "src", componentPath);
-    imports.push(`import _${name} from "${JSON.stringify(resolvedPath)}"`);
-    exports2.push(`${name}: _${name}`);
-  });
-  return `
-${imports.join("\n")}
-
-export default {
-    ${exports2.join(",\n    ")}
-}
-`;
-}
-function loadRoutesModule(mercurConfig) {
-  return generateRoutes(mercurConfig);
-}
-function loadMenuItemsModule(mercurConfig) {
-  return generateMenuItems(mercurConfig);
-}
-function loadI18nModule(mercurConfig) {
-  return generateI18n(mercurConfig);
-}
-
-// src/plugin.ts
-function isRouteFile(file) {
-  const basename = import_path5.default.basename(file, import_path5.default.extname(file));
-  return basename === "page";
-}
-var UI_MODULE_KEYS = ["admin_ui", "vendor_ui"];
-var MEDUSA_VIRTUAL_MODULES = [
-  "virtual:medusa/displays",
-  "virtual:medusa/forms",
-  "virtual:medusa/i18n",
-  "virtual:medusa/menu-items",
-  "virtual:medusa/routes",
-  "virtual:medusa/widgets",
-  "virtual:medusa/links"
-];
-function isMedusaVirtualModule(id) {
-  return MEDUSA_VIRTUAL_MODULES.includes(id);
-}
-function resolveMedusaVirtualModule(id) {
-  return "\0" + id;
-}
-function isResolvedMedusaVirtualModule(id) {
-  return id.startsWith("\0virtual:medusa/");
-}
-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 {
-    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 trimTrailingSlashes(value) {
-  let end = value.length;
-  while (end > 0 && value.charCodeAt(end - 1) === 47) {
-    end -= 1;
-  }
-  return end === value.length ? value : value.slice(0, end);
-}
-async function loadMedusaConfig(medusaConfigPath, root, options) {
-  const configDir = import_path5.default.dirname(medusaConfigPath);
-  try {
-    const previousCwd = process.cwd();
-    let mod;
-    process.chdir(configDir);
-    try {
-      mod = await getFileExports(medusaConfigPath);
-    } finally {
-      process.chdir(previousCwd);
-    }
-    const medusaConfig = mod.default ?? mod;
-    const modules = medusaConfig?.modules ?? {};
-    let base;
-    let appType = "admin";
-    let vendorAppUrl;
-    const vendorModule = modules.vendor_ui;
-    const vendorPath = vendorModule?.options?.path ?? "/seller";
-    if (options.vendorUrl) {
-      vendorAppUrl = trimTrailingSlashes(options.vendorUrl);
-    } else if (options.isDevelopment) {
-      const vendorHost = vendorModule?.options?.viteDevServerHost ?? "localhost";
-      const vendorPort = vendorModule?.options?.viteDevServerPort ?? 7001;
-      vendorAppUrl = `http://${vendorHost}:${vendorPort}${vendorPath}`;
-    } else {
-      vendorAppUrl = vendorPath;
-    }
-    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, vendorAppUrl };
-  } catch (error) {
-    console.warn(
-      `[@mercurjs/dashboard-sdk] Could not load the Medusa config from "${medusaConfigPath}": ${error instanceof Error ? error.message : String(error)}. Building with base "/" and no plugin extensions \u2014 if this panel is served under a sub-path (e.g. /dashboard), its assets will not resolve.`
-    );
-    return { pluginExtensions: [] };
-  }
-}
-function mercurDashboardPlugin(pluginConfig) {
-  let root;
-  let config;
+// src/config/utils.ts
+function createConfigHelper(config) {
   return {
-    name: "@mercurjs/dashboard-sdk",
-    async config(viteConfig) {
-      root = viteConfig.root || process.cwd();
-      const isDevelopment = (viteConfig.mode || process.env.NODE_ENV || "development") !== "production";
-      const medusaConfigPath = import_path5.default.resolve(
-        root,
-        pluginConfig.medusaConfigPath
-      );
-      const { base, pluginExtensions, vendorAppUrl } = await loadMedusaConfig(
-        medusaConfigPath,
-        root,
-        {
-          isDevelopment,
-          vendorUrl: pluginConfig.vendorUrl
-        }
-      );
-      const srcDir = import_path5.default.join(root, "src");
-      const backendUrl = pluginConfig.backendUrl ?? "http://localhost:9000";
-      const imageLimit = pluginConfig.imageLimit ?? 2 * 1024 * 1024;
-      config = {
-        ...pluginConfig,
-        backendUrl,
-        base,
-        root,
-        srcDir,
-        pluginExtensions,
-        imageLimit
-      };
-      return {
-        base: config.base,
-        define: {
-          __BACKEND_URL__: JSON.stringify(config.backendUrl),
-          __BASE__: JSON.stringify(config.base || "/"),
-          __VENDOR_URL__: JSON.stringify(vendorAppUrl || "")
-        },
-        resolve: {
-          dedupe: ["i18next", "react-i18next", "react", "react-dom"]
-        },
-        optimizeDeps: {
-          exclude: [
-            "virtual:mercur/config",
-            "virtual:mercur/routes",
-            "virtual:mercur/components",
-            "virtual:mercur/menu-items",
-            "virtual:mercur/i18n",
-            ...MEDUSA_VIRTUAL_MODULES
-          ],
-          include: [
-            "react",
-            "react/jsx-runtime",
-            "react-dom/client",
-            "react-router-dom",
-            "react-i18next",
-            "i18next",
-            "@medusajs/ui",
-            "@medusajs/dashboard",
-            "@mercurjs/client",
-            "@tanstack/react-query"
-          ]
-        }
-      };
-    },
-    configResolved(resolvedConfig) {
-      root = resolvedConfig.root;
-    },
-    resolveId(id) {
-      if (isVirtualModule(id)) {
-        return resolveVirtualModule(id);
-      }
-      if (isMedusaVirtualModule(id)) {
-        return resolveMedusaVirtualModule(id);
-      }
-      return null;
-    },
-    load(id) {
-      if (isResolvedMedusaVirtualModule(id)) {
-        return "export default {}";
-      }
-      return loadVirtualModule({ cwd: root, id, mercurConfig: config });
-    },
-    configureServer(server) {
-      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", handleRouteChange);
-      server.watcher.on("unlink", handleRouteChange);
-    },
-    handleHotUpdate({ file, server }) {
-      if (isRouteFile(file)) {
-        const mod = server.moduleGraph.getModuleById(RESOLVED_ROUTES_MODULE);
-        if (mod) {
-          server.moduleGraph.invalidateModule(mod);
-        }
-      }
-    }
+    ...config,
+    $$typeof: /* @__PURE__ */ Symbol.for("react.memo")
   };
 }
-
-// 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 defineWidgetConfig(config) {
+  return createConfigHelper(config);
 }
-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")}
-    ]
+function defineNavigationConfig(config) {
+  return createConfigHelper(config);
 }
-
-const plugin = {
-    routeModule,
-    menuItemModule,
-    i18nModule: ${i18nValue},
-}
-
-export default plugin
-`;
+function defineCustomFieldsConfig(config) {
+  return createConfigHelper(config);
 }
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  generatePluginEntryModule,
-  mercurDashboardPlugin
+  defineCustomFieldsConfig,
+  defineNavigationConfig,
+  defineWidgetConfig
 });