@xyd-js/documan 0.1.0-xyd.10 → 0.1.0-xyd.115

package/dist/index.js

@@ -1,238 +1,1206 @@
-// src/run/build.ts
-import path from "node:path";
-import fs from "node:fs";
-import { fileURLToPath } from "node:url";
+// src/build.ts
+import path2 from "path";
+import fs2 from "fs";
 import { build as viteBuild } from "vite";
 import tsconfigPaths from "vite-tsconfig-paths";
-import { reactRouter } from "@xyd-js/react-router-dev/vite";
-import { vitePlugins as xydContentVitePlugins } from "@xyd-js/content";
-import { pluginZero } from "@xyd-js/plugin-zero";
+
+// src/utils.ts
+import path from "path";
+import fs from "fs";
+import { fileURLToPath } from "url";
+import { execSync } from "child_process";
+import crypto from "crypto";
+import { createServer } from "vite";
+import { reactRouter } from "@react-router/dev/vite";
+import { IconSet } from "@iconify/tools";
+import { readSettings, pluginDocs } from "@xyd-js/plugin-docs";
+import { vitePlugins as xydContentVitePlugins } from "@xyd-js/content/vite";
+
+// src/const.ts
+var XYD_FOLDER_PATH = ".xyd";
+var HOST_FOLDER_PATH = `${XYD_FOLDER_PATH}/host`;
+var CACHE_FOLDER_PATH = `${XYD_FOLDER_PATH}/.cache`;
+var BUILD_FOLDER_PATH = `${XYD_FOLDER_PATH}/build`;
+var SUPPORTED_SETTINGS_FILES = [
+  "docs.json",
+  "docs.ts",
+  "docs.tsx"
+];
+var SUPPORTED_CONTENT_FILES = [
+  ".md",
+  ".mdx"
+];
+
+// src/cli.ts
+import readline from "readline";
+import cliSpinners from "cli-spinners";
+var CLI = class {
+  spinner;
+  spinnerInterval = null;
+  currentFrame = 0;
+  currentMessage = "";
+  isSpinning = false;
+  constructor(spinnerType = "dots") {
+    this.spinner = cliSpinners[spinnerType];
+  }
+  startSpinner(message) {
+    if (this.isSpinning) {
+      this.stopSpinner();
+    }
+    this.currentMessage = message;
+    this.isSpinning = true;
+    this.currentFrame = 0;
+    this.write(`${this.spinner.frames[0]} ${this.currentMessage}`);
+    this.spinnerInterval = setInterval(() => {
+      const frame = this.spinner.frames[this.currentFrame];
+      this.write(`${frame} ${this.currentMessage}`);
+      this.currentFrame = (this.currentFrame + 1) % this.spinner.frames.length;
+    }, this.spinner.interval);
+  }
+  stopSpinner() {
+    if (this.spinnerInterval) {
+      clearInterval(this.spinnerInterval);
+      this.spinnerInterval = null;
+    }
+    this.isSpinning = false;
+    this.clearLine();
+  }
+  clearLine() {
+    readline.clearLine(process.stdout, 0);
+    readline.cursorTo(process.stdout, 0);
+  }
+  write(message) {
+    this.clearLine();
+    process.stdout.write(message);
+  }
+  log(message) {
+    if (this.isSpinning) {
+      this.stopSpinner();
+    }
+    console.log(message);
+  }
+  error(message) {
+    if (this.isSpinning) {
+      this.stopSpinner();
+    }
+    console.error(message);
+  }
+  updateMessage(message) {
+    this.currentMessage = message;
+  }
+};
+var cli = new CLI();
+
+// src/utils.ts
 var __filename = fileURLToPath(import.meta.url);
 var __dirname = path.dirname(__filename);
-async function build() {
-  const resp = await pluginZero();
-  if (!resp) {
-    throw new Error("PluginZero not found");
+async function appInit(options) {
+  const readPreloadSettings = await readSettings();
+  if (!readPreloadSettings) {
+    return null;
   }
-  const buildDir = path.join(process.cwd(), ".xyd/build");
+  const preloadSettings = typeof readPreloadSettings === "string" ? JSON.parse(readPreloadSettings) : readPreloadSettings;
   {
-    const packageJsonPath = path.join(buildDir, "package.json");
-    const packageJsonContent = {
-      type: "module",
-      scripts: {},
-      dependencies: {},
-      devDependencies: {}
+    if (!preloadSettings.integrations?.search) {
+      preloadSettings.integrations = {
+        ...preloadSettings.integrations || {},
+        search: {
+          orama: true
+        }
+      };
+    }
+    const plugins = integrationsToPlugins(preloadSettings.integrations);
+    if (preloadSettings.plugins) {
+      preloadSettings.plugins = [...plugins, ...preloadSettings.plugins];
+    } else {
+      preloadSettings.plugins = plugins;
+    }
+  }
+  let resolvedPlugins = [];
+  {
+    resolvedPlugins = await loadPlugins(preloadSettings) || [];
+    const userUniformVitePlugins = [];
+    const componentPlugins = [];
+    resolvedPlugins?.forEach((p) => {
+      if (p.uniform) {
+        userUniformVitePlugins.push(...p.uniform);
+      }
+      if (p.components) {
+        componentPlugins.push(...p.components);
+      }
+    });
+    globalThis.__xydUserUniformVitePlugins = userUniformVitePlugins;
+    globalThis.__xydUserComponents = componentPlugins;
+  }
+  const respPluginDocs = await pluginDocs(options);
+  if (!respPluginDocs) {
+    throw new Error("PluginDocs not found");
+  }
+  if (!respPluginDocs.settings) {
+    throw new Error("Settings not found in respPluginDocs");
+  }
+  respPluginDocs.settings.plugins = [
+    ...respPluginDocs.settings?.plugins || [],
+    ...preloadSettings.plugins || []
+  ];
+  globalThis.__xydBasePath = respPluginDocs.basePath;
+  globalThis.__xydSettings = respPluginDocs.settings;
+  globalThis.__xydPagePathMapping = respPluginDocs.pagePathMapping;
+  return {
+    respPluginDocs,
+    resolvedPlugins
+  };
+}
+function virtualComponentsPlugin() {
+  return {
+    name: "xyd-plugin-virtual-components",
+    resolveId(id) {
+      if (id === "virtual:xyd-user-components") {
+        return id + ".jsx";
+      }
+      return null;
+    },
+    async load(id) {
+      if (id === "virtual:xyd-user-components.jsx") {
+        const userComponents = globalThis.__xydUserComponents || [];
+        if (userComponents.length > 0 && userComponents[0]?.dist) {
+          const imports = userComponents.map(
+            (component, index) => `import Component${index} from '${component.dist}';`
+          ).join("\n");
+          const componentObjects = userComponents.map(
+            (component, index) => `{
+                                component: Component${index},
+                                name: '${component.name}',
+                                dist: '${component.dist}'
+                            }`
+          ).join(",\n                            ");
+          return `
+                        // Pre-bundled at build time - no async loading needed
+                        ${imports}
+                        
+                        export const components = [
+                            ${componentObjects}
+                        ];
+                    `;
+        }
+        return `
+                    export const components = globalThis.__xydUserComponents || {}
+                `;
+      }
+      return null;
+    }
+  };
+}
+function virtualProvidersPlugin(settings) {
+  return {
+    name: "xyd-plugin-virtual-providers",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === "virtual:xyd-analytics-providers") {
+        return id;
+      }
+    },
+    async load(id) {
+      if (id === "virtual:xyd-analytics-providers") {
+        const providers = Object.keys(settings?.integrations?.analytics || {});
+        const imports = providers.map(
+          (provider) => `import { default as ${provider}Provider } from '@pluganalytics/provider-${provider}'`
+        ).join("\n");
+        const cases = providers.map(
+          (provider) => `case '${provider}': return ${provider}Provider`
+        ).join("\n");
+        return `
+                    ${imports}
+
+                    export const loadProvider = async (provider) => {
+                        switch (provider) {
+                            ${cases}
+                            default:
+                                console.error(\`Provider \${provider} not found\`)
+                                return null
+                        }
+                    }
+                `;
+      }
+    }
+  };
+}
+function commonVitePlugins(respPluginDocs, resolvedPlugins) {
+  const userVitePlugins = resolvedPlugins.map((p) => p.vite).flat() || [];
+  return [
+    ...xydContentVitePlugins({
+      toc: {
+        maxDepth: respPluginDocs.settings.theme?.maxTocDepth || 2
+      },
+      settings: respPluginDocs.settings
+    }),
+    ...respPluginDocs.vitePlugins,
+    reactRouter(),
+    virtualComponentsPlugin(),
+    virtualProvidersPlugin(respPluginDocs.settings),
+    pluginIconSet(respPluginDocs.settings),
+    ...userVitePlugins
+  ];
+}
+function pluginIconSet(settings) {
+  const DEFAULT_ICON_SET = "lucide";
+  async function fetchIconSet(name, version) {
+    if (name.startsWith("http://") || name.startsWith("https://")) {
+      try {
+        const iconsResp = await fetch(name);
+        const iconsData = await iconsResp.json();
+        const iconSet = new IconSet(iconsData);
+        return { icons: iconsData, iconSet };
+      } catch (error) {
+        console.warn(`Failed to fetch from URL ${name}:`, error);
+      }
+    }
+    const tryReadFile = (filePath) => {
+      try {
+        if (!fs.existsSync(filePath)) {
+          console.warn(`File does not exist: ${filePath}`);
+          return null;
+        }
+        const fileContent = fs.readFileSync(filePath, "utf-8");
+        try {
+          const iconsData = JSON.parse(fileContent);
+          const iconSet = new IconSet(iconsData);
+          return { icons: iconsData, iconSet };
+        } catch (parseError) {
+          console.warn(`Invalid JSON in file ${filePath}:`, parseError);
+          return null;
+        }
+      } catch (error) {
+        console.warn(`Failed to read file ${filePath}:`, error);
+        return null;
+      }
     };
-    if (!fs.existsSync(buildDir)) {
-      fs.mkdirSync(buildDir, { recursive: true });
+    if (path.isAbsolute(name)) {
+      const result = tryReadFile(name);
+      if (result) return result;
+    }
+    if (name.startsWith(".")) {
+      const fullPath = path.join(process.cwd(), name);
+      const result = tryReadFile(fullPath);
+      if (result) return result;
+    }
+    const cdnUrl = version ? `https://cdn.jsdelivr.net/npm/@iconify-json/${name}@${version}/icons.json` : `https://cdn.jsdelivr.net/npm/@iconify-json/${name}/icons.json`;
+    try {
+      const iconsResp = await fetch(cdnUrl);
+      const iconsData = await iconsResp.json();
+      const iconSet = new IconSet(iconsData);
+      return { icons: iconsData, iconSet };
+    } catch (error) {
+      throw new Error(`Failed to load icon set from any source (file or CDN): ${name}`);
+    }
+  }
+  async function processIconSet(iconSet, icons, noPrefix) {
+    const resp = /* @__PURE__ */ new Map();
+    for (const icon of Object.keys(icons.icons)) {
+      const svg = iconSet.toSVG(icon);
+      if (!svg) continue;
+      let prefix = noPrefix ? void 0 : iconSet.prefix;
+      const iconName = prefix ? `${prefix}:${icon}` : icon;
+      resp.set(iconName, { svg: svg.toString() });
+    }
+    return resp;
+  }
+  async function addIconsToMap(resp, name, version, noPrefix) {
+    const { icons, iconSet } = await fetchIconSet(name, version);
+    const newIcons = await processIconSet(iconSet, icons, noPrefix);
+    newIcons.forEach((value, key) => resp.set(key, value));
+  }
+  async function processIconLibrary(library) {
+    const resp = /* @__PURE__ */ new Map();
+    if (typeof library === "string") {
+      await addIconsToMap(resp, library);
+    } else if (Array.isArray(library)) {
+      for (const item of library) {
+        if (typeof item === "string") {
+          await addIconsToMap(resp, item);
+        } else {
+          const { name, version, default: isDefault, noprefix } = item;
+          const noPrefix = isDefault || noprefix === true;
+          await addIconsToMap(resp, name, version, noPrefix);
+        }
+      }
+    } else {
+      const { name, version, default: isDefault, noprefix } = library;
+      const noPrefix = isDefault || noprefix === true;
+      await addIconsToMap(resp, name, version, noPrefix);
+    }
+    return resp;
+  }
+  return {
+    name: "xyd-plugin-icon-set",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === "virtual:xyd-icon-set") {
+        return id;
+      }
+    },
+    async load(id) {
+      if (id === "virtual:xyd-icon-set") {
+        let resp;
+        if (settings.theme?.icons?.library) {
+          resp = await processIconLibrary(settings.theme.icons.library);
+        } else {
+          resp = await processIconLibrary([
+            {
+              name: DEFAULT_ICON_SET,
+              default: true
+            }
+          ]);
+        }
+        return `
+                    export const iconSet = ${JSON.stringify(Object.fromEntries(resp))};
+                `;
+      }
+    }
+  };
+}
+function getXydFolderPath() {
+  return path.join(
+    process.cwd(),
+    XYD_FOLDER_PATH
+  );
+}
+function getHostPath() {
+  if (process.env.XYD_DEV_MODE) {
+    if (process.env.XYD_HOST) {
+      return path.resolve(process.env.XYD_HOST);
+    }
+    return path.join(__dirname, "../../../", HOST_FOLDER_PATH);
+  }
+  return path.join(process.cwd(), HOST_FOLDER_PATH);
+}
+function getAppRoot() {
+  return getHostPath();
+}
+function getPublicPath() {
+  return path.join(process.cwd(), "public");
+}
+function getBuildPath() {
+  return path.join(
+    process.cwd(),
+    BUILD_FOLDER_PATH
+  );
+}
+function getDocsPluginBasePath() {
+  return path.join(getHostPath(), "./plugins/xyd-plugin-docs");
+}
+async function loadPlugins(settings) {
+  const resolvedPlugins = [];
+  for (const plugin of settings.plugins || []) {
+    let pluginName;
+    let pluginArgs = [];
+    if (typeof plugin === "string") {
+      pluginName = plugin;
+      pluginArgs = [];
+    } else if (Array.isArray(plugin)) {
+      pluginName = plugin[0];
+      pluginArgs = plugin.slice(1);
+    } else {
+      console.error(`Currently only string and array plugins are supported, got: ${plugin}`);
+      return [];
+    }
+    let mod;
+    try {
+      mod = await import(pluginName);
+    } catch (e) {
+      pluginName = path.join(process.cwd(), pluginName);
+      const pluginPreview = await createServer({
+        optimizeDeps: {
+          include: []
+        }
+      });
+      mod = await pluginPreview.ssrLoadModule(pluginName);
+    }
+    if (!mod.default) {
+      console.error(`Plugin ${plugin} has no default export`);
+      continue;
+    }
+    let pluginInstance = mod.default(...pluginArgs);
+    if (typeof pluginInstance === "function") {
+      const plug = pluginInstance(settings);
+      resolvedPlugins.push(plug);
+      continue;
+    }
+    resolvedPlugins.push(pluginInstance);
+  }
+  return resolvedPlugins;
+}
+function integrationsToPlugins(integrations) {
+  const plugins = [];
+  let foundSearchIntegation = 0;
+  if (integrations?.search?.orama) {
+    if (typeof integrations.search.orama === "boolean") {
+      plugins.push("@xyd-js/plugin-orama");
+    } else {
+      plugins.push(["@xyd-js/plugin-orama", integrations.search.orama]);
+    }
+    foundSearchIntegation++;
+  }
+  if (integrations?.search?.algolia) {
+    plugins.push(["@xyd-js/plugin-algolia", integrations.search.algolia]);
+    foundSearchIntegation++;
+  }
+  if (foundSearchIntegation > 1) {
+    throw new Error("Only one search integration is allowed");
+  }
+  return plugins;
+}
+async function preWorkspaceSetup(options = {}) {
+  await ensureFoldersExist();
+  if (!options.force) {
+    if (await shouldSkipHostSetup()) {
+      return true;
+    }
+  }
+  const hostTemplate = process.env.XYD_DEV_MODE ? path.resolve(__dirname, "../../xyd-host") : path.resolve(__dirname, "../../host");
+  const hostPath = getHostPath();
+  await copyHostTemplate(hostTemplate, hostPath);
+  let pluginDocsPath;
+  if (process.env.XYD_DEV_MODE) {
+    pluginDocsPath = path.resolve(__dirname, "../../xyd-plugin-docs");
+  } else {
+    pluginDocsPath = path.resolve(__dirname, "../../plugin-docs");
+  }
+  const pagesSourcePath = path.join(pluginDocsPath, "src/pages");
+  const pagesTargetPath = path.join(hostPath, "plugins/xyd-plugin-docs/src/pages");
+  if (fs.existsSync(pagesSourcePath)) {
+    await copyHostTemplate(pagesSourcePath, pagesTargetPath);
+  } else {
+    console.warn(`Pages source path does not exist: ${pagesSourcePath}`);
+  }
+}
+function calculateFolderChecksum(folderPath) {
+  const hash = crypto.createHash("sha256");
+  const ignorePatterns = [...getGitignorePatterns(folderPath), ".xydchecksum", "node_modules", "dist", ".react-router", "package-lock.json", "pnpm-lock.yaml"];
+  function processFile(filePath) {
+    const relativePath = path.relative(folderPath, filePath);
+    const content = fs.readFileSync(filePath);
+    hash.update(relativePath);
+    hash.update(content);
+  }
+  function processDirectory(dirPath) {
+    const entries = fs.readdirSync(dirPath, { withFileTypes: true });
+    entries.sort((a, b) => a.name.localeCompare(b.name));
+    for (const entry of entries) {
+      const sourceEntry = path.join(dirPath, entry.name);
+      if (shouldIgnoreEntry(entry.name, ignorePatterns)) {
+        continue;
+      }
+      if (entry.name === ".git") {
+        continue;
+      }
+      if (entry.isDirectory()) {
+        processDirectory(sourceEntry);
+      } else {
+        processFile(sourceEntry);
+      }
+    }
+  }
+  processDirectory(folderPath);
+  return hash.digest("hex");
+}
+function getGitignorePatterns(folderPath) {
+  const gitignorePath = path.join(folderPath, ".gitignore");
+  if (fs.existsSync(gitignorePath)) {
+    const gitignoreContent = fs.readFileSync(gitignorePath, "utf-8");
+    return gitignoreContent.split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
+  }
+  return [];
+}
+function shouldIgnoreEntry(entryName, ignorePatterns) {
+  return ignorePatterns.some((pattern) => {
+    const regex = new RegExp(pattern.replace(/\*/g, ".*"));
+    return regex.test(entryName);
+  });
+}
+async function copyHostTemplate(sourcePath, targetPath) {
+  if (!fs.existsSync(sourcePath)) {
+    throw new Error(`Host template source path does not exist: ${sourcePath}`);
+  }
+  if (fs.existsSync(targetPath)) {
+    fs.rmSync(targetPath, { recursive: true, force: true });
+  }
+  fs.mkdirSync(targetPath, { recursive: true });
+  const ignorePatterns = getGitignorePatterns(sourcePath);
+  const entries = fs.readdirSync(sourcePath, { withFileTypes: true });
+  for (const entry of entries) {
+    const sourceEntry = path.join(sourcePath, entry.name);
+    const targetEntry = path.join(targetPath, entry.name);
+    if (shouldIgnoreEntry(entry.name, ignorePatterns)) {
+      continue;
+    }
+    if (entry.name === ".git") {
+      continue;
+    }
+    if (entry.isDirectory()) {
+      await copyHostTemplate(sourceEntry, targetEntry);
+    } else {
+      fs.copyFileSync(sourceEntry, targetEntry);
+      if (entry.name === "package.json" && process.env.XYD_DEV_MODE) {
+        const packageJsonPath = targetEntry;
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+        packageJson.name = "xyd-host-dev";
+        fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+      }
     }
-    fs.writeFileSync(packageJsonPath, JSON.stringify(packageJsonContent, null, 2), "utf8");
+  }
+}
+async function ensureFoldersExist() {
+  const folders = [CACHE_FOLDER_PATH];
+  for (const folder of folders) {
+    const fullPath = path.resolve(process.cwd(), folder);
+    if (!fs.existsSync(fullPath)) {
+      fs.mkdirSync(fullPath, { recursive: true });
+    }
+  }
+}
+async function postWorkspaceSetup(settings) {
+  const spinner = new CLI("dots");
+  try {
+    spinner.startSpinner("Installing xyd framework...");
+    const hostPath = getHostPath();
+    const packageJsonPath = path.join(hostPath, "package.json");
+    if (!fs.existsSync(packageJsonPath)) {
+      console.warn("No package.json found in host path");
+      return;
+    }
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, "utf-8"));
+    if (!packageJson.dependencies) {
+      packageJson.dependencies = {};
+    }
+    for (const plugin of settings.plugins || []) {
+      let pluginName;
+      if (typeof plugin === "string") {
+        pluginName = plugin;
+      } else if (Array.isArray(plugin)) {
+        pluginName = plugin[0];
+      } else {
+        continue;
+      }
+      if (pluginName.startsWith("@xyd-js/")) {
+        continue;
+      }
+      const isValidNpmPackage = /^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/.test(pluginName);
+      if (isValidNpmPackage) {
+        const hostPackageJsonPath = path.join(hostPath, "package.json");
+        if (fs.existsSync(hostPackageJsonPath)) {
+          const hostPackageJson = JSON.parse(fs.readFileSync(hostPackageJsonPath, "utf-8"));
+          const deps = hostPackageJson.dependencies || {};
+          const matchingDep = Object.entries(deps).find(([depName]) => {
+            return depName === pluginName;
+          });
+          if (matchingDep) {
+            packageJson.dependencies[pluginName] = matchingDep[1];
+          } else {
+            console.warn(`no matching dependency found for: ${pluginName} in: ${hostPackageJsonPath}`);
+          }
+        } else {
+          console.warn(`no host package.json found in: ${hostPath}`);
+        }
+      } else if (!pluginName.startsWith(".") && !pluginName.startsWith("/")) {
+        console.warn(`invalid plugin name: ${pluginName}`);
+      }
+    }
+    fs.writeFileSync(packageJsonPath, JSON.stringify(packageJson, null, 2));
+    await nodeInstallPackages(hostPath);
+    spinner.stopSpinner();
+    spinner.log("\u2714 Local xyd framework installed successfully");
+  } catch (error) {
+    spinner.stopSpinner();
+    spinner.error("\u274C Failed to install xyd framework");
+    throw error;
+  }
+}
+function nodeInstallPackages(hostPath) {
+  const cmdInstall = pmInstall();
+  const execOptions = {
+    cwd: hostPath,
+    env: {
+      ...process.env,
+      NODE_ENV: ""
+      // since 'production' does not install it well,
+    }
+  };
+  const customRegistry = process.env.XYD_NPM_REGISTRY || process.env.npm_config_registry;
+  if (customRegistry) {
+    if (!execOptions.env) {
+      execOptions.env = {};
+    }
+    execOptions.env["npm_config_registry"] = customRegistry;
+  }
+  if (process.env.XYD_VERBOSE) {
+    execOptions.stdio = "inherit";
+  }
+  execSync(cmdInstall, execOptions);
+}
+function pmInstall() {
+  if (process.env.XYD_NODE_PM) {
+    switch (process.env.XYD_NODE_PM) {
+      case "npm": {
+        return npmInstall();
+      }
+      case "pnpm": {
+        return pnpmInstall();
+      }
+      case "bun": {
+        return bunInstall();
+      }
+      default: {
+        console.warn(`Unknown package manager: ${process.env.XYD_NODE_PM}, falling back to npm`);
+        return npmInstall();
+      }
+    }
+  }
+  if (hasBun()) {
+    return bunInstall();
+  }
+  const { pnpm } = runningPm();
+  console.log("\u2139\uFE0F consider install `bun` for better performance \n");
+  if (pnpm) {
+    return pnpmInstall();
+  }
+  return npmInstall();
+}
+function hasBun() {
+  try {
+    execSync("bun --version", { stdio: "ignore" });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function runningPm() {
+  let pnpm = false;
+  let bun = false;
+  if (process.env.npm_execpath) {
+    if (process.env.npm_execpath.includes("pnpm")) {
+      pnpm = true;
+    } else if (process.env.npm_execpath.includes("bun")) {
+      bun = true;
+    }
+  }
+  if (process.env.NODE_PATH) {
+    const nodePath = process.env.NODE_PATH;
+    if (nodePath.includes(".pnpm")) {
+      pnpm = true;
+    } else if (nodePath.includes(".bun")) {
+      bun = true;
+    }
+  }
+  if (process.execPath.includes("bun") || path.dirname(process.argv?.[1] || "").includes("bun")) {
+    bun = true;
+  }
+  return {
+    pnpm,
+    bun
+  };
+}
+function pnpmInstall() {
+  return "pnpm install";
+}
+function bunInstall() {
+  return "bun install";
+}
+function npmInstall() {
+  return "npm install";
+}
+async function shouldSkipHostSetup() {
+  const hostPath = getHostPath();
+  if (!fs.existsSync(hostPath)) {
+    return false;
+  }
+  const currentChecksum = calculateFolderChecksum(hostPath);
+  const storedChecksum = getStoredChecksum();
+  if (!storedChecksum || storedChecksum !== currentChecksum) {
+    return false;
+  }
+  return true;
+}
+function getStoredChecksum() {
+  const checksumPath = path.join(getHostPath(), ".xydchecksum");
+  if (!fs.existsSync(checksumPath)) {
+    return null;
+  }
+  try {
+    return fs.readFileSync(checksumPath, "utf-8").trim();
+  } catch (error) {
+    console.error("Error reading checksum file:", error);
+    return null;
+  }
+}
+function storeChecksum(checksum) {
+  const checksumPath = path.join(getHostPath(), ".xydchecksum");
+  try {
+    fs.writeFileSync(checksumPath, checksum);
+  } catch (error) {
+    console.error("Error writing checksum file:", error);
+  }
+}
+
+// src/build.ts
+async function build() {
+  const skip = await preWorkspaceSetup({
+    force: true
+  });
+  const inited = await appInit();
+  if (!inited) {
+    return;
+  }
+  const { respPluginDocs, resolvedPlugins } = inited;
+  const commonRunVitePlugins = commonVitePlugins(respPluginDocs, resolvedPlugins);
+  const appRoot = getAppRoot();
+  if (!skip) {
+    await postWorkspaceSetup(respPluginDocs.settings);
+    const newChecksum = calculateFolderChecksum(getHostPath());
+    storeChecksum(newChecksum);
+  }
+  {
+    await setupInstallableEnvironmentV2();
   }
   try {
     await viteBuild({
-      root: process.env.XYD_CLI ? __dirname : process.env.XYD_DOCUMAN_HOST || path.join(__dirname, "../host"),
-      // @ts-ignore
+      mode: "production",
+      root: appRoot,
       plugins: [
-        ...xydContentVitePlugins({
-          toc: {
-            minDepth: 2
-          }
-        }),
-        reactRouter({
-          outDir: buildDir,
-          routes: resp.routes
-        }),
-        tsconfigPaths(),
-        ...resp.vitePlugins
+        ...commonRunVitePlugins,
+        tsconfigPaths()
       ],
       optimizeDeps: {
         include: ["react/jsx-runtime"]
+      },
+      define: {
+        "process.env.NODE_ENV": JSON.stringify("production"),
+        "process.env": {}
+      },
+      resolve: {
+        alias: {
+          process: "process/browser"
+        }
       }
+      // ssr: {
+      //     noExternal: ["react", "react-dom", "react-router"]
+      // }
     });
     await viteBuild({
-      root: process.env.XYD_CLI ? __dirname : process.env.XYD_DOCUMAN_HOST || path.join(__dirname, "../host"),
+      mode: "production",
+      root: appRoot,
       build: {
         ssr: true
+        // rollupOptions: {
+        //     external: ["@xyd-js/framework/hydration", "fs"]
+        // }
       },
-      // @ts-ignore
       plugins: [
-        ...xydContentVitePlugins({
-          toc: {
-            minDepth: 2
-          }
-        }),
-        reactRouter({
-          outDir: buildDir,
-          routes: resp.routes
-        }),
-        tsconfigPaths(),
-        ...resp.vitePlugins
+        fixManifestPlugin(appRoot),
+        ...commonRunVitePlugins,
+        tsconfigPaths()
       ],
       optimizeDeps: {
         include: ["react/jsx-runtime"]
+        // include: ["react", "react-dom", "react/jsx-runtime", "react-router"],
+        // force: true
+      },
+      define: {
+        "process.env.NODE_ENV": JSON.stringify("production"),
+        "process.env": {}
+      },
+      resolve: {
+        alias: {
+          process: "process/browser"
+          // react: path.resolve(workspaceNodeModulesPath, "react"),
+          // "react-dom": path.resolve(workspaceNodeModulesPath, "react-dom")
+        }
       }
+      // ssr: {
+      //     noExternal: ["react", "react-dom", "react-router"]
+      // }
     });
-    console.log("Build completed successfully.");
   } catch (error) {
     console.error("Build failed:", error);
   }
 }
+function setupInstallableEnvironmentV2() {
+  const symbolicXydNodeModules = path2.join(getXydFolderPath(), "node_modules");
+  const hostNodeModules = path2.join(getHostPath(), "node_modules");
+  if (fs2.existsSync(symbolicXydNodeModules)) {
+    if (fs2.lstatSync(symbolicXydNodeModules).isSymbolicLink()) {
+      fs2.unlinkSync(symbolicXydNodeModules);
+    } else {
+      fs2.rmSync(symbolicXydNodeModules, { recursive: true, force: true });
+    }
+  }
+  fs2.symlinkSync(hostNodeModules, symbolicXydNodeModules, "dir");
+}
+function fixManifestPlugin(appRoot) {
+  const manifestPath = path2.join(
+    getBuildPath(),
+    // getAppRoot(),
+    "./server/.vite/manifest.json"
+  );
+  return {
+    name: "xyd-fix-rr-manifest",
+    apply: "build",
+    // run after manifest is generated
+    // 2) after bundle is written, compute prefix and strip it
+    writeBundle(_, bundle) {
+      const cwdDir = process.cwd();
+      let prefix = path2.relative(appRoot, cwdDir).replace(/\\/g, "/");
+      if (prefix) prefix += "/";
+      const esc = prefix.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+      const stripRe = new RegExp(`^${esc}`);
+      for (const fileName in bundle) {
+        const asset = bundle[fileName];
+        if (asset.type !== "asset") continue;
+        if (fileName.endsWith("manifest.json")) {
+          const manifest = JSON.parse(asset.source.toString());
+          const fixed = {};
+          for (const key of Object.keys(manifest)) {
+            const entry = manifest[key];
+            const newKey = key.replace(stripRe, "");
+            if (typeof entry.src === "string") {
+              entry.src = entry.src.replace(stripRe, "");
+            }
+            fixed[newKey] = entry;
+          }
+          asset.source = JSON.stringify(fixed, null, 2);
+          fs2.writeFileSync(manifestPath, asset.source, "utf8");
+        }
+      }
+    }
+  };
+}
 
-// src/run/dev.ts
-import path2 from "node:path";
-import { fileURLToPath as fileURLToPath2 } from "node:url";
-import { createServer, searchForWorkspaceRoot } from "vite";
-import { reactRouter as reactRouter2 } from "@xyd-js/react-router-dev/vite";
-import { vitePlugins as xydContentVitePlugins2 } from "@xyd-js/content";
-import { pluginZero as pluginZero2 } from "@xyd-js/plugin-zero";
-var __filename2 = fileURLToPath2(import.meta.url);
-var __dirname2 = path2.dirname(__filename2);
-var port = process.env.XYD_PORT ? parseInt(process.env.XYD_PORT) : 5175;
-async function dev() {
-  const resp = await pluginZero2();
-  if (!resp) {
-    throw new Error("PluginZero not found");
+// src/dev.ts
+import path3 from "path";
+import fs3 from "fs";
+import { createServer as createServer2, searchForWorkspaceRoot } from "vite";
+import { readSettings as readSettings2 } from "@xyd-js/plugin-docs";
+if (!process.env.ENABLE_TIMERS) {
+  ["time", "timeLog", "timeEnd"].forEach((method) => {
+    console[method] = () => {
+    };
+  });
+}
+var RELOADING = false;
+async function dev(options) {
+  const spinner = new CLI("dots");
+  spinner.startSpinner("Preparing local xyd instance...");
+  const skip = await preWorkspaceSetup();
+  const inited = await appInit();
+  if (!inited) {
+    return;
   }
+  const { respPluginDocs, resolvedPlugins } = inited;
   const allowCwd = searchForWorkspaceRoot(process.cwd());
-  const preview = await createServer({
-    // any valid user config options, plus `mode` and `configFile`
-    // configFile: path.join(__dirname, "../src/vite/empty-config.ts"), // TODO: bundler??
-    // configFile: path.join(__dirname, "../"), // TODO: bundler??
-    // root: path.join(__dirname, "../"), // TODO: bundler?
-    root: process.env.XYD_CLI ? __dirname2 : process.env.XYD_DOCUMAN_HOST || path2.join(__dirname2, "../host"),
-    // TODO: bundler?
+  const appRoot = getAppRoot();
+  const commonRunVitePlugins = commonVitePlugins(respPluginDocs, resolvedPlugins);
+  spinner.stopSpinner();
+  if (!skip) {
+    await postWorkspaceSetup(respPluginDocs.settings);
+    const newChecksum = calculateFolderChecksum(getHostPath());
+    storeChecksum(newChecksum);
+  }
+  spinner.log("\u2714 Local xyd instance is ready");
+  let server = null;
+  const port = options?.port ?? parseInt(process.env.XYD_PORT ?? "5175");
+  let USE_CONTEXT_ISSUE_PACKAGES = [];
+  {
+    if (process.env.XYD_DEV_MODE) {
+      USE_CONTEXT_ISSUE_PACKAGES = [
+        "react-github-btn",
+        "radix-ui",
+        "@code-hike/lighter",
+        "lucide-react",
+        "openux-js",
+        "pluganalytics"
+      ];
+    } else {
+      USE_CONTEXT_ISSUE_PACKAGES = [
+        "@xyd-js/theme-cosmo",
+        "@xyd-js/theme-opener",
+        "@xyd-js/theme-picasso",
+        "@xyd-js/theme-poetry"
+      ];
+    }
+  }
+  const preview = await createServer2({
+    root: appRoot,
+    publicDir: "/public",
     server: {
+      allowedHosts: [],
       port,
       fs: {
         allow: [
           allowCwd,
-          process.env.XYD_CLI ? path2.join(__dirname2, "../../") : ""
-          // path.join(__dirname, "../node_modules") // Ensure node_modules from xyd-documan is included
+          appRoot
         ]
       }
     },
+    define: {
+      "process.env.NODE_ENV": JSON.stringify(process.env.NODE_ENV),
+      "process.env": {}
+    },
+    resolve: {
+      alias: {
+        process: "process/browser"
+      }
+      // preserveSymlinks: true
+    },
     build: {
       rollupOptions: {
-        // Exclude package `B` from the client-side bundle
-        external: ["@xyd-js/uniform", "@xyd-js/uniform/content", "@xyd-js/plugin-zero"]
+        external: []
       }
     },
     ssr: {
-      external: ["@xyd-js/uniform", "@xyd-js/uniform/content", "@xyd-js/plugin-zero"]
-      // noExternal: [
-      //     "@xyd-js/uniform",
-      //     "@xyd-js/uniform/content",
-      //     "@xyd-js/plugin-zero"
-      // ],
+      external: []
     },
     optimizeDeps: {
-      include: ["react/jsx-runtime"]
+      include: [
+        "react/jsx-runtime",
+        ...USE_CONTEXT_ISSUE_PACKAGES
+      ]
+      // exclude: ["react", "react-dom"]
     },
-    // @ts-ignore
     plugins: [
-      // TODO: fix plugin ts
-      ...xydContentVitePlugins2({
-        toc: {
-          minDepth: 2
+      ...commonRunVitePlugins,
+      {
+        name: "xyd-configureServer",
+        configureServer(s) {
+          server = s;
         }
-      }),
-      reactRouter2({
-        routes: resp.routes
-      }),
-      ...resp.vitePlugins
+      }
     ]
   });
+  const watcher = fs3.watch(allowCwd, { recursive: true }, async (eventType, filename) => {
+    if (RELOADING) {
+      return;
+    }
+    if (!filename) {
+      console.log("[xyd:dev-watcher] Received empty filename");
+      return;
+    }
+    if (!server) {
+      console.log("[xyd:dev-watcher] Server not ready");
+      return;
+    }
+    const filePath = path3.join(allowCwd, filename);
+    if (filePath.includes(CACHE_FOLDER_PATH)) {
+      return;
+    }
+    const publicPathReload = filePath.includes(getPublicPath());
+    if (publicPathReload) {
+      const relativePath = path3.relative(allowCwd, filePath);
+      const urlPath = "/" + relativePath.replace(/\\/g, "/");
+      preview.ws.send({
+        type: "full-reload",
+        path: urlPath
+      });
+      return;
+    }
+    let apiPaths = {};
+    if (respPluginDocs?.settings?.api) {
+      apiPaths = resolveApiFilePaths(process.cwd(), respPluginDocs.settings.api);
+    }
+    const apiChanged = !!apiPaths[filePath];
+    const isSettingsFile = SUPPORTED_SETTINGS_FILES.some((ext) => filePath.endsWith(ext));
+    const isContentFile = SUPPORTED_CONTENT_FILES.some((ext) => filePath.endsWith(ext));
+    const isWatchFile = isSettingsFile || isContentFile || apiChanged;
+    if (!isWatchFile) {
+      return;
+    }
+    if (isContentFile && eventType !== "rename") {
+      console.log("\u{1F504} Content file changed, refresh...", eventType);
+      invalidateSettings(server);
+      await touchLayoutPage();
+      return;
+    }
+    const renameContentFile = isContentFile && eventType === "rename";
+    if (isSettingsFile || renameContentFile) {
+      if (renameContentFile) {
+        console.log("\u{1F504} Content file renamed, refresh...");
+      } else {
+        console.log("\u{1F504} Settings file changed, refresh...");
+      }
+      if (respPluginDocs?.settings.engine?.uniform?.store) {
+        await appInit({
+          disableFSWrite: true
+        });
+      } else {
+        await appInit();
+      }
+      const newSettings = await readSettings2();
+      if (typeof newSettings !== "object") {
+        console.log("[xyd:dev-watcher] Settings is not an object");
+        return;
+      }
+      invalidateSettings(server);
+      await touchReactRouterConfig();
+      await touchLayoutPage();
+      server.ws.send({ type: "full-reload" });
+    }
+  });
+  watcher.on("error", (error) => {
+    console.error("[xyd:dev] File watcher error:", error);
+  });
   await preview.listen(port);
+  if (respPluginDocs.settings.navigation) {
+    await optimizeDepsFix(port, respPluginDocs.settings.navigation);
+  }
   preview.printUrls();
   preview.bindCLIShortcuts({ print: true });
+  preview.httpServer?.once("close", () => {
+    watcher.close();
+  });
 }
-
-// src/run/serve.ts
-import fs2 from "node:fs";
-import os from "node:os";
-import path3 from "node:path";
-import url from "node:url";
-import { createRequestHandler } from "@react-router/express";
-import compression from "compression";
-import express from "express";
-import morgan from "morgan";
-import sourceMapSupport from "source-map-support";
-import getPort from "get-port";
-function parseNumber(raw) {
-  if (raw === void 0) return void 0;
-  let maybe = Number(raw);
-  if (Number.isNaN(maybe)) return void 0;
-  return maybe;
-}
-async function serve() {
-  process.env.NODE_ENV = process.env.NODE_ENV ?? "production";
-  sourceMapSupport.install({
-    retrieveSourceMap: function(source) {
-      let match = source.startsWith("file://");
-      if (match) {
-        let filePath = url.fileURLToPath(source);
-        let sourceMapPath = `${filePath}.map`;
-        if (fs2.existsSync(sourceMapPath)) {
-          return {
-            url: source,
-            map: fs2.readFileSync(sourceMapPath, "utf8")
-          };
+function resolveApiFilePaths(basePath, api) {
+  const result = {};
+  const apis = [api.openapi, api.graphql, api.sources].filter((s) => s !== void 0);
+  apis.forEach((section) => {
+    flattenApiFile(section).forEach((p) => {
+      const apiAbsPath = path3.resolve(basePath, p);
+      result[apiAbsPath] = true;
+    });
+  });
+  return result;
+}
+function flattenApiFile(file) {
+  if (!file) return [];
+  if (typeof file === "string") {
+    return [file];
+  }
+  if (Array.isArray(file)) {
+    return file.flatMap(flattenApiFile);
+  }
+  if (typeof file === "object") {
+    const obj = file;
+    if (typeof obj.source === "string") {
+      return [obj.source];
+    }
+    return Object.values(obj).flatMap(flattenApiFile);
+  }
+  return [];
+}
+function getFirstPageFromNavigation(navigation) {
+  if (!navigation?.sidebar?.length) {
+    return null;
+  }
+  function extractFirstPage(pages) {
+    for (const page of pages) {
+      if (typeof page === "string") {
+        return normalizePagePath(page);
+      }
+      if (typeof page === "object") {
+        if ("route" in page && page.pages) {
+          const firstPage = extractFirstPage(page.pages);
+          if (firstPage) return firstPage;
+        }
+        if ("pages" in page && page.pages) {
+          const firstPage = extractFirstPage(page.pages);
+          if (firstPage) return firstPage;
+        }
+        if ("page" in page && typeof page.page === "string") {
+          return normalizePagePath(page.page);
         }
       }
-      return null;
     }
-  });
-  let port2 = parseNumber(process.env.PORT) ?? await getPort({ port: 3e3 });
-  let buildPathArg = path3.join(process.cwd(), ".xyd/build/server/index.js");
-  if (!buildPathArg) {
-    console.error(`
-  Usage: react-router-serve <server-build-path> - e.g. react-router-serve build/server/index.js`);
-    process.exit(1);
-  }
-  let buildPath = path3.resolve(buildPathArg);
-  let build2 = await import(url.pathToFileURL(buildPath).href);
-  let onListen = () => {
-    let address = process.env.HOST || Object.values(os.networkInterfaces()).flat().find((ip) => String(ip?.family).includes("4") && !ip?.internal)?.address;
-    if (!address) {
-      console.log(`[xyd-serve] http://localhost:${port2}`);
-    } else {
-      console.log(
-        `[xyd-serve] http://localhost:${port2} (http://${address}:${port2})`
-      );
+    return null;
+  }
+  return extractFirstPage(navigation.sidebar);
+}
+function normalizePagePath(pagePath) {
+  let normalized = pagePath.replace(/\.(md|mdx)$/, "");
+  if (normalized.endsWith("/index") || normalized === "index") {
+    normalized = normalized.replace(/\/?index$/, "");
+  }
+  if (normalized.startsWith("/")) {
+    normalized = normalized.slice(1);
+  }
+  return normalized;
+}
+async function fetchFirstPage(firstPage, port) {
+  const urlsToTry = [
+    `http://localhost:${port}/${firstPage}`,
+    `http://localhost:${port}/${firstPage}/`,
+    `http://localhost:${port}/${firstPage}.html`,
+    `http://localhost:${port}/${firstPage}/index.html`
+  ];
+  for (const url of urlsToTry) {
+    try {
+      const response = await fetch(url);
+      if (response.ok) {
+        return;
+      }
+    } catch (error) {
+      continue;
     }
-  };
-  build2 = {
-    ...build2,
-    assetsBuildDirectory: path3.join(process.cwd(), ".xyd/build/client")
-  };
-  let app = express();
-  app.disable("x-powered-by");
-  app.use(compression());
-  app.use(
-    path3.posix.join(build2.publicPath, "assets"),
-    express.static(path3.join(build2.assetsBuildDirectory, "assets"), {
-      immutable: true,
-      maxAge: "1y"
-    })
-  );
-  app.use(build2.publicPath, express.static(build2.assetsBuildDirectory));
-  app.use(express.static("public", { maxAge: "1h" }));
-  app.use(morgan("tiny"));
-  app.all(
-    "*",
-    createRequestHandler({
-      build: build2,
-      mode: process.env.NODE_ENV
-    })
-  );
-  let server = process.env.HOST ? app.listen(port2, process.env.HOST, onListen) : app.listen(port2, onListen);
-  ["SIGTERM", "SIGINT"].forEach((signal) => {
-    process.once(signal, () => server?.close(console.error));
+  }
+}
+function invalidateSettings(server) {
+  const virtualId = "virtual:xyd-settings";
+  const resolvedId = virtualId + ".jsx";
+  const mod = server.moduleGraph.getModuleById(resolvedId);
+  if (!mod) {
+    console.log("[xyd:dev-watcher] Settings module not found");
+    return;
+  }
+  server.moduleGraph.invalidateModule(mod);
+  server.ws.send({
+    type: "update",
+    updates: [
+      {
+        type: "js-update",
+        path: `/@id/${resolvedId}`,
+        acceptedPath: `/@id/${resolvedId}`,
+        timestamp: Date.now()
+      }
+    ]
+  });
+}
+async function touchReactRouterConfig() {
+  const hostPath = getHostPath();
+  const hostReactRouterConfig = path3.join(hostPath, "react-router.config.ts");
+  await fs3.promises.utimes(hostReactRouterConfig, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date());
+}
+async function touchLayoutPage() {
+  const docsPluginBasePath = getDocsPluginBasePath();
+  const layoutPath = path3.join(docsPluginBasePath, "./src/pages/layout.tsx");
+  await fs3.promises.utimes(layoutPath, /* @__PURE__ */ new Date(), /* @__PURE__ */ new Date());
+}
+async function optimizeDepsFix(port, navigation) {
+  const firstPage = getFirstPageFromNavigation(navigation);
+  if (firstPage) {
+    await fetchFirstPage(firstPage, port);
+  }
+}
+
+// src/install.ts
+import fs4 from "fs";
+import { readSettings as readSettings3 } from "@xyd-js/plugin-docs";
+async function install() {
+  const settings = await readSettings3();
+  if (!settings) {
+    throw new Error("cannot preload settings");
+  }
+  if (typeof settings === "string") {
+    throw new Error("install does not support string settings");
+  }
+  const hostPath = getHostPath();
+  if (fs4.existsSync(hostPath)) {
+    fs4.rmSync(hostPath, { recursive: true, force: true });
+  }
+  await preWorkspaceSetup({
+    force: true
   });
+  await postWorkspaceSetup(settings);
 }
 export {
   build,
   dev,
-  serve
+  install
 };
 //# sourceMappingURL=index.js.map