@mercurjs/dashboard-sdk 2.2.0-rc.0 → 2.2.0-rc.1

package/dist/vite.js

@@ -0,0 +1,1180 @@
+import {
+  __require
+} from "./chunk-3RG5ZIWI.js";
+
+// src/plugin.ts
+import path8 from "path";
+import fs7 from "fs";
+
+// src/utils.ts
+import fs from "fs";
+import path from "path";
+
+// 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/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 MENU_ITEMS_VIRTUAL_MODULE = "virtual:mercur/menu-items";
+var I18N_VIRTUAL_MODULE = "virtual:mercur/i18n";
+var WIDGETS_VIRTUAL_MODULE = "virtual:mercur/widgets";
+var NAVIGATION_VIRTUAL_MODULE = "virtual:mercur/navigation";
+var CUSTOM_FIELDS_VIRTUAL_MODULE = "virtual:mercur/custom-fields";
+var RESOLVED_CONFIG_MODULE = "\0" + CONFIG_VIRTUAL_MODULE;
+var RESOLVED_ROUTES_MODULE = "\0" + ROUTES_VIRTUAL_MODULE;
+var RESOLVED_MENU_ITEMS_MODULE = "\0" + MENU_ITEMS_VIRTUAL_MODULE;
+var RESOLVED_I18N_MODULE = "\0" + I18N_VIRTUAL_MODULE;
+var RESOLVED_WIDGETS_MODULE = "\0" + WIDGETS_VIRTUAL_MODULE;
+var RESOLVED_NAVIGATION_MODULE = "\0" + NAVIGATION_VIRTUAL_MODULE;
+var RESOLVED_CUSTOM_FIELDS_MODULE = "\0" + CUSTOM_FIELDS_VIRTUAL_MODULE;
+var VIRTUAL_MODULES = [
+  CONFIG_VIRTUAL_MODULE,
+  ROUTES_VIRTUAL_MODULE,
+  MENU_ITEMS_VIRTUAL_MODULE,
+  I18N_VIRTUAL_MODULE,
+  WIDGETS_VIRTUAL_MODULE,
+  NAVIGATION_VIRTUAL_MODULE,
+  CUSTOM_FIELDS_VIRTUAL_MODULE
+];
+
+// src/utils.ts
+function normalizePath(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+function crawlModuleFiles(dir) {
+  const files = [];
+  if (!fs.existsSync(dir)) return files;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+    const full = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...crawlModuleFiles(full));
+    } else if (entry.isFile()) {
+      const ext = path.extname(entry.name);
+      const base = path.basename(entry.name, ext);
+      if (base.endsWith(".d")) continue;
+      if (base.startsWith("_") || base === "index") continue;
+      if (VALID_FILE_EXTENSIONS.includes(ext)) files.push(full);
+    }
+  }
+  return files;
+}
+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(path10) {
+  const { unregister } = await safeRegister();
+  const module = __require(path10);
+  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(path10) {
+      if (path10.node.left.type === "MemberExpression" && path10.node.left.object.type === "Identifier" && path10.node.left.object.name === "exports" && path10.node.left.property.type === "Identifier" && path10.node.left.property.name === "default") {
+        found = true;
+      }
+    },
+    ExportNamedDeclaration(path10) {
+      const specifiers = path10.node.specifiers;
+      if (specifiers?.some(
+        (s) => s.type === "ExportSpecifier" && s.exported.type === "Identifier" && s.exported.name === "default"
+      )) {
+        found = true;
+      }
+    }
+  });
+  return found;
+}
+
+// src/routes.ts
+import fs2 from "fs";
+import path2 from "path";
+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 (!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(...crawlRoutes(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 hasConfigPublic(ast) {
+  let found = false;
+  traverse(ast, {
+    ExportNamedDeclaration(path10) {
+      const declaration = path10.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(path10) {
+      const declaration = path10.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 = fs2.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, 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 = path2.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
+import fs3 from "fs";
+import path3 from "path";
+function crawlRoutes2(dir, pattern = "page") {
+  const files = [];
+  if (!fs3.existsSync(dir)) {
+    return files;
+  }
+  const entries = fs3.readdirSync(dir, { withFileTypes: true });
+  for (const entry of entries) {
+    const fullPath = path3.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      files.push(...crawlRoutes2(fullPath, pattern));
+    } else if (entry.isFile()) {
+      const ext = path3.extname(entry.name);
+      const baseName = path3.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(path10) {
+  if (isVariableDeclarator(path10.node)) {
+    const decl = isIdentifier(path10.node.id, { name: "config" }) ? path10.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 = path10.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 = fs3.readFileSync(file, "utf-8");
+    const ast = parse(code, getParserOptions(file));
+    let config = null;
+    let configFound = false;
+    traverse(ast, {
+      VariableDeclarator(path10) {
+        if (configFound) return;
+        const properties = getConfigObjectProperties(path10);
+        if (!properties) return;
+        config = processConfigProperties(properties);
+        if (config) configFound = true;
+      },
+      ExportNamedDeclaration(path10) {
+        if (configFound) return;
+        const properties = getConfigObjectProperties(path10);
+        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 = path3.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
+import fs4 from "fs";
+import path4 from "path";
+function findI18nIndex(srcDir) {
+  const i18nDir = path4.join(srcDir, "i18n");
+  if (!fs4.existsSync(i18nDir)) {
+    return null;
+  }
+  for (const ext of VALID_FILE_EXTENSIONS) {
+    const filePath = path4.join(i18nDir, `index${ext}`);
+    if (fs4.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/widgets.ts
+import fs5 from "fs";
+import path5 from "path";
+function extractZones(value, zones) {
+  if (isStringLiteral(value)) {
+    zones.push(value.value);
+  } else if (isArrayExpression(value)) {
+    for (const el of value.elements) {
+      if (isStringLiteral(el)) zones.push(el.value);
+    }
+  }
+}
+function readWidgetConfig(properties) {
+  const zones = [];
+  let id;
+  for (const prop of properties) {
+    if (!isObjectProperty(prop)) continue;
+    if (isIdentifier(prop.key, { name: "zone" })) {
+      extractZones(prop.value, zones);
+    }
+    if (isIdentifier(prop.key, { name: "id" }) && isStringLiteral(prop.value)) {
+      id = prop.value.value;
+    }
+  }
+  if (zones.length === 0) return null;
+  return { zones, id };
+}
+function getConfigProperties(node) {
+  if (isCallExpression(node) && node.arguments.length > 0 && isObjectExpression(node.arguments[0])) {
+    return node.arguments[0].properties;
+  }
+  if (isObjectExpression(node)) {
+    return node.properties;
+  }
+  return null;
+}
+function getWidgetConfig(file) {
+  try {
+    const code = fs5.readFileSync(file, "utf-8");
+    const ast = parse(code, getParserOptions(file));
+    if (!hasDefaultExport(ast)) return null;
+    let info = null;
+    const visit = (declaration) => {
+      if (info) return;
+      if (!isVariableDeclaration(declaration)) return;
+      for (const decl of declaration.declarations) {
+        if (isVariableDeclarator(decl) && isIdentifier(decl.id, { name: "config" })) {
+          const props = getConfigProperties(decl.init);
+          if (props) info = readWidgetConfig(props);
+        }
+      }
+    };
+    traverse(ast, {
+      ExportNamedDeclaration(p) {
+        visit(p.node.declaration);
+      },
+      VariableDeclaration(p) {
+        visit(p.node);
+      }
+    });
+    return info;
+  } catch {
+    return null;
+  }
+}
+function hashPath(relative) {
+  let hash = 0;
+  for (let i = 0; i < relative.length; i++) {
+    hash = (hash << 5) - hash + relative.charCodeAt(i);
+    hash |= 0;
+  }
+  return Math.abs(hash).toString(36).slice(0, 6);
+}
+function widgetId(info, file, widgetsDir) {
+  if (info.id) return info.id;
+  const relative = normalizePath(path5.relative(widgetsDir, file));
+  return `Widget-${hashPath(relative)}`;
+}
+function parseWidgetFile(file, widgetsDir, index) {
+  const info = getWidgetConfig(file);
+  if (!info) return null;
+  const name = `Widget${index}`;
+  const importPath = normalizePath(file);
+  const zonesLiteral = JSON.stringify(info.zones);
+  const id = widgetId(info, file, widgetsDir);
+  return {
+    import: `import ${name} from "${importPath}"`,
+    entry: `    { Component: ${name}, zone: ${zonesLiteral}, widgetId: ${JSON.stringify(
+      id
+    )} }`
+  };
+}
+function collectWidgets(srcDir, startIndex = 0) {
+  const widgetsDir = path5.join(srcDir, "widgets");
+  let index = startIndex;
+  const results = [];
+  for (const file of crawlModuleFiles(widgetsDir)) {
+    const result = parseWidgetFile(file, widgetsDir, index);
+    if (result) {
+      results.push(result);
+      index++;
+    }
+  }
+  return {
+    imports: results.map((r) => r.import),
+    entries: results.map((r) => r.entry)
+  };
+}
+function generateWidgets({
+  srcDir,
+  pluginExtensions
+}) {
+  const { imports, entries: widgetEntries } = collectWidgets(srcDir);
+  const pluginDeclarations = pluginExtensions.map(
+    (ext, i) => `const __plugin${i} = (await import("${normalizePath(ext)}")).default`
+  );
+  const pluginSpreads = pluginExtensions.map(
+    (_, i) => `    ...(__plugin${i}.widgetModule?.widgets ?? [])`
+  );
+  const entries = [...widgetEntries, ...pluginSpreads];
+  if (imports.length === 0 && pluginDeclarations.length === 0 && entries.length === 0) {
+    return `export default { widgets: [] }`;
+  }
+  return `${imports.join("\n")}
+
+${pluginDeclarations.join("\n")}
+
+export default {
+    widgets: [
+${entries.join(",\n")}
+    ]
+}`;
+}
+
+// src/navigation.ts
+import fs6 from "fs";
+import path6 from "path";
+function findNavigationFile(srcDir) {
+  for (const ext of VALID_FILE_EXTENSIONS) {
+    const filePath = path6.join(srcDir, `_navigation${ext}`);
+    if (fs6.existsSync(filePath)) return filePath;
+  }
+  return null;
+}
+function generateNavigation({ srcDir }) {
+  const file = findNavigationFile(srcDir);
+  if (!file) {
+    return `export default { items: [] }`;
+  }
+  return `import navigationConfig from "${normalizePath(file)}"
+export default navigationConfig`;
+}
+
+// src/custom-fields.ts
+import path7 from "path";
+function generateCustomFields({
+  srcDir,
+  pluginExtensions
+}) {
+  const dir = path7.join(srcDir, "custom-fields");
+  const files = crawlModuleFiles(dir);
+  const imports = files.map(
+    (file, i) => `import __cf${i} from "${normalizePath(file)}"`
+  );
+  const localRefs = files.map((_, i) => `__cf${i}`);
+  const pluginDeclarations = pluginExtensions.map(
+    (ext, i) => `const __plugin${i} = (await import("${normalizePath(ext)}")).default`
+  );
+  const pluginSpreads = pluginExtensions.map(
+    (_, i) => `    ...(__plugin${i}.customFieldsModule?.configs ?? [])`
+  );
+  const configs = [
+    ...localRefs.map((ref) => `    ${ref}`),
+    ...pluginSpreads
+  ];
+  if (configs.length === 0 && pluginDeclarations.length === 0) {
+    return `export default { configs: [] }`;
+  }
+  return `${imports.join("\n")}
+
+${pluginDeclarations.join("\n")}
+
+export default {
+    configs: [
+${configs.join(",\n")}
+    ]
+}`;
+}
+
+// src/virtual-modules.ts
+function isVirtualModule(id) {
+  return VIRTUAL_MODULES.includes(id);
+}
+function resolveVirtualModule(id) {
+  return "\0" + id;
+}
+function loadVirtualModule({
+  id,
+  mercurConfig
+}) {
+  if (id === RESOLVED_CONFIG_MODULE) {
+    return loadConfigModule(mercurConfig);
+  }
+  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);
+  }
+  if (id === RESOLVED_WIDGETS_MODULE) {
+    return generateWidgets(mercurConfig);
+  }
+  if (id === RESOLVED_NAVIGATION_MODULE) {
+    return generateNavigation(mercurConfig);
+  }
+  if (id === RESOLVED_CUSTOM_FIELDS_MODULE) {
+    return generateCustomFields(mercurConfig);
+  }
+  return null;
+}
+function loadConfigModule(mercurConfig) {
+  return `export default ${JSON.stringify(mercurConfig)}`;
+}
+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 = path8.basename(file, path8.extname(file));
+  return basename === "page";
+}
+function isWidgetFile(file) {
+  return normalizeSep(file).includes("/src/widgets/");
+}
+function isNavigationFile(file) {
+  const basename = path8.basename(file, path8.extname(file));
+  return basename === "_navigation";
+}
+function isCustomFieldFile(file) {
+  return normalizeSep(file).includes("/src/custom-fields/");
+}
+function normalizeSep(file) {
+  return file.replace(/\\/g, "/");
+}
+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 !== path8.dirname(dir)) {
+    const candidate = path8.join(dir, "node_modules");
+    if (fs7.existsSync(candidate) && fs7.statSync(candidate).isDirectory()) {
+      return candidate;
+    }
+    dir = path8.dirname(dir);
+  }
+  return path8.join(configDir, "node_modules");
+}
+function resolvePluginRoot(resolve, configDir, nodeModulesRoot) {
+  try {
+    if (resolve.startsWith(".")) {
+      const resolved = path8.resolve(configDir, resolve);
+      if (fs7.existsSync(resolved)) {
+        return fs7.realpathSync(resolved);
+      }
+      return null;
+    }
+    const packagePath = path8.join(nodeModulesRoot, resolve);
+    if (!fs7.existsSync(packagePath)) {
+      return null;
+    }
+    return fs7.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 = path8.join(
+      pluginRoot,
+      ".medusa/server/src",
+      appType,
+      "index.mjs"
+    );
+    if (fs7.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 = path8.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 = path8.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;
+  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 = path8.resolve(
+        root,
+        pluginConfig.medusaConfigPath
+      );
+      const { base, pluginExtensions, vendorAppUrl } = await loadMedusaConfig(
+        medusaConfigPath,
+        root,
+        {
+          isDevelopment,
+          vendorUrl: pluginConfig.vendorUrl
+        }
+      );
+      const srcDir = path8.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/menu-items",
+            "virtual:mercur/i18n",
+            "virtual:mercur/widgets",
+            "virtual:mercur/navigation",
+            "virtual:mercur/custom-fields",
+            ...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({ id, mercurConfig: config });
+    },
+    configureServer(server) {
+      const invalidate = (moduleId, reload) => {
+        const mod = server.moduleGraph.getModuleById(moduleId);
+        if (mod) {
+          server.moduleGraph.invalidateModule(mod);
+          if (reload) server.ws.send({ type: "full-reload" });
+        }
+      };
+      const handleChange = (file) => {
+        if (isRouteFile(file)) invalidate(RESOLVED_ROUTES_MODULE, true);
+        if (isWidgetFile(file)) invalidate(RESOLVED_WIDGETS_MODULE, true);
+        if (isNavigationFile(file)) invalidate(RESOLVED_NAVIGATION_MODULE, true);
+        if (isCustomFieldFile(file)) invalidate(RESOLVED_CUSTOM_FIELDS_MODULE, true);
+      };
+      server.watcher.on("add", handleChange);
+      server.watcher.on("unlink", handleChange);
+    },
+    handleHotUpdate({ file, server }) {
+      const invalidate = (moduleId) => {
+        const mod = server.moduleGraph.getModuleById(moduleId);
+        if (mod) server.moduleGraph.invalidateModule(mod);
+      };
+      if (isRouteFile(file)) invalidate(RESOLVED_ROUTES_MODULE);
+      if (isWidgetFile(file)) invalidate(RESOLVED_WIDGETS_MODULE);
+      if (isNavigationFile(file)) invalidate(RESOLVED_NAVIGATION_MODULE);
+      if (isCustomFieldFile(file)) invalidate(RESOLVED_CUSTOM_FIELDS_MODULE);
+    }
+  };
+}
+
+// src/generate-plugin-entry.ts
+import path9 from "path";
+import fs8 from "fs";
+function findI18nIndex2(srcDir) {
+  const i18nDir = path9.join(srcDir, "i18n");
+  if (!fs8.existsSync(i18nDir)) return null;
+  for (const ext of VALID_FILE_EXTENSIONS) {
+    const filePath = path9.join(i18nDir, `index${ext}`);
+    if (fs8.existsSync(filePath)) return filePath;
+  }
+  return null;
+}
+function generatePluginEntryModule(srcDir) {
+  const routesDir = path9.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 { imports: widgetImports, entries: widgetEntries } = collectWidgets(
+    srcDir,
+    index
+  );
+  const cfFiles = crawlModuleFiles(path9.join(srcDir, "custom-fields"));
+  const cfImports = cfFiles.map(
+    (file, i) => `import __cf${i} from "${normalizePath(file)}"`
+  );
+  const cfRefs = cfFiles.map((_, i) => `    __cf${i}`);
+  const i18nFile = findI18nIndex2(srcDir);
+  const i18nImport = i18nFile ? `import i18nResources from "${normalizePath(i18nFile)}"` : "";
+  const i18nValue = i18nFile ? "i18nResources" : "{}";
+  const allImports = [
+    ...routeImports,
+    ...menuItemImports,
+    ...widgetImports,
+    ...cfImports
+  ];
+  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 widgetModule = {
+    widgets: [
+${widgetEntries.join(",\n")}
+    ]
+}
+
+const customFieldsModule = {
+    configs: [
+${cfRefs.join(",\n")}
+    ]
+}
+
+const plugin = {
+    routeModule,
+    menuItemModule,
+    widgetModule,
+    customFieldsModule,
+    i18nModule: ${i18nValue},
+}
+
+export default plugin
+`;
+}
+export {
+  generatePluginEntryModule,
+  mercurDashboardPlugin
+};