@mercurjs/dashboard-sdk 2.0.0-canary.0

package/dist/index.cjs

@@ -0,0 +1,584 @@
+"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)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  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, {
+  dashboardPlugin: () => dashboardPlugin,
+  defineConfig: () => defineConfig
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/plugin.ts
+var import_path5 = __toESM(require("path"), 1);
+
+// src/utils.ts
+function resolveExports(moduleExports) {
+  if ("default" in moduleExports && moduleExports.default && "default" in moduleExports.default) {
+    return resolveExports(moduleExports.default);
+  }
+  return moduleExports;
+}
+async function getFileExports(path6) {
+  const { unregister } = await safeRegister();
+  const module2 = require(path6);
+  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 normalizePath(filePath) {
+  return filePath.replace(/\\/g, "/");
+}
+
+// src/constants.ts
+var VALID_FILE_EXTENSIONS = [".tsx", ".ts", ".jsx", ".js"];
+var CONFIG_NAME = "mercur.config.ts";
+var CONFIG_VIRTUAL_MODULE = "virtual:mercur/config";
+var ROUTES_VIRTUAL_MODULE = "virtual:mercur/routes";
+var COMPONENTS_VIRTUAL_MODULE = "virtual:mercur/components";
+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, 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 (!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(...crawlPages(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 hasDefaultExport(filePath) {
+  try {
+    const content = import_fs.default.readFileSync(filePath, "utf-8");
+    return /export\s+default\s+/.test(content) || /export\s*\{\s*[^}]*\s+as\s+default\s*[,}]/.test(content);
+  } catch {
+    return false;
+  }
+}
+function getNamedExports(filePath) {
+  try {
+    const content = import_fs.default.readFileSync(filePath, "utf-8");
+    const hasHandle = /export\s+(const|function|async\s+function)\s+handle\b/.test(content) || /export\s*\{[^}]*\bhandle\b[^}]*\}/.test(content);
+    const hasLoader = /export\s+(const|function|async\s+function)\s+loader\b/.test(content) || /export\s*\{[^}]*\bloader\b[^}]*\}/.test(content);
+    return { hasHandle, hasLoader };
+  } catch {
+    return { hasHandle: false, hasLoader: false };
+  }
+}
+function 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) {
+  return {
+    Component: generateRouteComponentName(index),
+    path: routePath,
+    handle: hasHandle ? generateHandleName(index) : void 0,
+    loader: hasLoader ? generateLoaderName(index) : void 0
+  };
+}
+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.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) {
+  if (!hasDefaultExport(file)) {
+    return null;
+  }
+  const { hasHandle, hasLoader } = getNamedExports(file);
+  const routePath = getRoute(file, pagesDir);
+  const imports = generateImports(file, index, hasHandle, hasLoader);
+  const route = generateRouteObject(routePath, index, hasHandle, hasLoader);
+  return {
+    imports,
+    route
+  };
+}
+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 }) {
+  const pagesDir = import_path.default.join(srcDir, "pages");
+  const files = crawlPages(pagesDir);
+  if (files.length === 0) {
+    return `export const customRoutes = []`;
+  }
+  let index = 0;
+  const results = [];
+  for (const file of files) {
+    const result = parseFile(file, pagesDir, index);
+    if (result) {
+      results.push(result);
+      index++;
+    }
+  }
+  if (results.length === 0) {
+    return `export const customRoutes = []`;
+  }
+  const routeTree = buildRouteTree(results);
+  const imports = routeTree.flatMap((result) => result.imports);
+  const routes = routeTree.map((result) => formatRoute(result.route));
+  return `${imports.join("\n")}
+
+export const customRoutes = [
+${routes.join(",\n")}
+]`;
+}
+
+// src/menu-items.ts
+var import_fs2 = __toESM(require("fs"), 1);
+var import_path2 = __toESM(require("path"), 1);
+function crawlPages2(dir, pattern = "page") {
+  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(...crawlPages2(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, 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 hasConfigExport(filePath) {
+  try {
+    const content = import_fs2.default.readFileSync(filePath, "utf-8");
+    return /export\s+(const|let|var)\s+config\b/.test(content) || /export\s*\{[^}]*\bconfig\b[^}]*\}/.test(content);
+  } catch {
+    return false;
+  }
+}
+function getConfigProperties(filePath) {
+  try {
+    const content = import_fs2.default.readFileSync(filePath, "utf-8");
+    const hasLabel = /\blabel\s*[:=]/.test(content);
+    if (!hasLabel) {
+      return null;
+    }
+    const hasIcon = /\bicon\s*[:=]/.test(content);
+    const rankMatch = content.match(/\brank\s*:\s*(\d+)/);
+    const rank = rankMatch ? parseInt(rankMatch[1], 10) : void 0;
+    const nestedMatch = content.match(/\bnested\s*:\s*["']([^"']+)["']/);
+    const nested = nestedMatch ? nestedMatch[1] : void 0;
+    const translationNsMatch = content.match(/\btranslationNs\s*:\s*["']([^"']+)["']/);
+    const translationNs = translationNsMatch ? translationNsMatch[1] : void 0;
+    return { label: hasLabel, icon: hasIcon, rank, nested, translationNs };
+  } 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) {
+  if (!hasConfigExport(file)) {
+    return null;
+  }
+  const config = getConfigProperties(file);
+  if (!config) {
+    return null;
+  }
+  return {
+    import: generateImport(file, index),
+    menuItem: generateMenuItem(config, file, pagesDir, index)
+  };
+}
+function generateMenuItems({ srcDir }) {
+  const pagesDir = import_path2.default.join(srcDir, "pages");
+  const files = crawlPages2(pagesDir);
+  if (files.length === 0) {
+    return `export default { menuItems: [] }`;
+  }
+  let index = 0;
+  const results = [];
+  for (const file of files) {
+    const result = parseFile2(file, pagesDir, index);
+    if (result) {
+      results.push(result);
+      index++;
+    }
+  }
+  if (results.length === 0) {
+    return `export default { menuItems: [] }`;
+  }
+  const imports = results.map((r) => r.import);
+  const menuItems = results.map((r) => formatMenuItem(r.menuItem));
+  return `${imports.join("\n")}
+
+export default {
+    menuItems: [
+${menuItems.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 { components, ...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 "${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 buildConfig(config, root) {
+  const srcDir = import_path5.default.join(root, "src");
+  return {
+    ...config,
+    backendUrl: config.backendUrl ?? "http://localhost:9000",
+    root,
+    srcDir,
+    configPath: import_path5.default.resolve(root, CONFIG_NAME)
+  };
+}
+async function loadMercurConfig(root) {
+  const configPath = import_path5.default.resolve(root, CONFIG_NAME);
+  try {
+    const mod = await getFileExports(configPath);
+    const content = mod.default ?? mod;
+    return buildConfig(content, root);
+  } catch (error) {
+    console.error(error);
+    throw new Error(
+      `[@mercurjs/dashboard-sdk] Could not find or load ${CONFIG_NAME} in ${root}`
+    );
+  }
+}
+function isPageFile(file) {
+  const basename = import_path5.default.basename(file, import_path5.default.extname(file));
+  return basename === "page";
+}
+function dashboardPlugin() {
+  let root;
+  let config;
+  return {
+    name: "@mercurjs/dashboard-sdk",
+    async config(viteConfig) {
+      root = viteConfig.root || process.cwd();
+      config = await loadMercurConfig(root);
+      return {
+        define: {
+          "__BACKEND_URL__": JSON.stringify(config.backendUrl)
+        }
+      };
+    },
+    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 }) {
+      const configPath = import_path5.default.resolve(root, CONFIG_NAME);
+      if (file === configPath) {
+        server.restart();
+        return;
+      }
+      if (isPageFile(file)) {
+        const mod = server.moduleGraph.getModuleById(RESOLVED_ROUTES_MODULE);
+        if (mod) {
+          server.moduleGraph.invalidateModule(mod);
+        }
+      }
+    }
+  };
+}
+
+// src/define-config.ts
+function defineConfig(config) {
+  return config;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  dashboardPlugin,
+  defineConfig
+});

package/dist/index.d.cts

@@ -0,0 +1,34 @@
+import * as Vite from 'vite';
+import { ComponentType } from 'react';
+
+declare function dashboardPlugin(): Vite.Plugin;
+
+interface MercurConfig {
+    name?: string;
+    logo?: string;
+    components?: {
+        MainSidebar?: string;
+        SettingsSidebar?: string;
+    };
+    i18n?: {
+        defaultLanguage: string;
+    };
+    backendUrl?: string;
+}
+interface BuiltMercurConfig extends MercurConfig {
+    backendUrl: string;
+    root: string;
+    srcDir: string;
+    configPath: string;
+}
+type RouteConfig = {
+    label: string;
+    icon?: ComponentType;
+    rank?: number;
+    nested?: string;
+    translationNs?: string;
+};
+
+declare function defineConfig(config: MercurConfig): MercurConfig;
+
+export { type BuiltMercurConfig, type MercurConfig, type RouteConfig, dashboardPlugin, defineConfig };

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@mercurjs/dashboard-sdk",
+  "version": "2.0.0-canary.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/mercurjs/mercur",
+    "directory": "packages/dashboard-sdk"
+  },
+  "type": "module",
+  "main": "./dist/index.cjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "require": "./dist/index.cjs",
+      "default": "./dist/index.cjs"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "dev": "tsup --watch",
+    "build": "tsup",
+    "lint": "eslint . --ext ts,tsx --report-unused-disable-directives --max-warnings 0"
+  },
+  "dependencies": {
+    "esbuild-register": "^3.6.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "tsup": "^8.0.2",
+    "typescript": "5.9.3",
+    "vite": "^5.4.21",
+    "@types/react": "^18.2.66"
+  }
+}