@xyd-js/documan 0.0.0-build-ba549ac-20251203173500 → 0.0.0-build-83b15db-20251213220910

package/dist/index.js

@@ -259,6 +259,40 @@ var package_default4 = {
   }
 };
 
+// ../xyd-plugin-extra-diagram/package.json
+var package_default5 = {
+  name: "@xyd-js/plugin-extra-diagram",
+  version: "0.0.0",
+  author: "",
+  description: "",
+  license: "MIT",
+  main: "./dist/index.js",
+  type: "module",
+  exports: {
+    "./package.json": "./package.json",
+    ".": {
+      import: "./dist/index.js"
+    }
+  },
+  scripts: {
+    clean: "rimraf build",
+    prebuild: "pnpm clean",
+    build: "tsup",
+    test: "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  dependencies: {
+    "unist-util-visit": "^5.0.0"
+  },
+  devDependencies: {
+    "@vitest/coverage-v8": "^1.6.1",
+    rimraf: "^3.0.2",
+    tsup: "^8.4.0",
+    vite: "^7.0.0",
+    vitest: "^1.6.1"
+  }
+};
+
 // src/const.ts
 var XYD_FOLDER_PATH = ".xyd";
 var HOST_FOLDER_PATH = `${XYD_FOLDER_PATH}/host`;
@@ -722,11 +756,39 @@ var ANALYTICS_INTEGRATION_DEPENDENCIES = {
     "@pluganalytics/provider-livesession": "0.0.0-pre.7"
   }
 };
+var resolveComponentDist = (dist) => {
+  if (!dist || typeof dist !== "string") {
+    return { resolvedDist: dist, exists: false };
+  }
+  const looksLikePath = /^([./]|[A-Za-z]:)/.test(dist);
+  if (looksLikePath) {
+    const candidates = [
+      dist,
+      `${dist}.js`,
+      `${dist}.ts`,
+      `${dist}.tsx`,
+      path2.join(dist, "index.js"),
+      path2.join(dist, "index.ts"),
+      path2.join(dist, "index.tsx")
+    ];
+    for (const candidate of candidates) {
+      try {
+        if (fs.existsSync(candidate)) {
+          return { resolvedDist: candidate, exists: true };
+        }
+      } catch {
+      }
+    }
+    return { resolvedDist: dist, exists: false };
+  }
+  return { resolvedDist: dist, exists: true };
+};
 var EXTERNAL_XYD_PLUGINS = {
   "@xyd-js/plugin-supademo": package_default.version,
   "@xyd-js/plugin-chatwoot": package_default2.version,
   "@xyd-js/plugin-intercom": package_default3.version,
-  "@xyd-js/plugin-livechat": package_default4.version
+  "@xyd-js/plugin-livechat": package_default4.version,
+  "@xyd-js/plugin-extra-diagram": package_default5.version
 };
 function isLLMsTxtPath(settings) {
   const aiLlms = settings?.ai?.llmsTxt;
@@ -737,6 +799,24 @@ function isLLMsTxtPath(settings) {
   }
   return false;
 }
+function cloneComponentsPreservingReferences(componentPlugins) {
+  return componentPlugins.map((comp) => {
+    const cloned = { ...comp };
+    for (const key in cloned) {
+      if (cloned.hasOwnProperty(key)) {
+        const value = cloned[key];
+        if (typeof value === "function" || key === "component") {
+          cloned[key] = value;
+        } else if (Array.isArray(value)) {
+          cloned[key] = [...value];
+        } else if (value && typeof value === "object" && value.constructor === Object) {
+          cloned[key] = { ...value };
+        }
+      }
+    }
+    return cloned;
+  });
+}
 async function appInit(options) {
   const readPreloadSettings = await readSettings2();
   if (!readPreloadSettings) {
@@ -763,8 +843,26 @@ async function appInit(options) {
   {
     resolvedPlugins = await loadPlugins(preloadSettings, options) || [];
     const userUniformVitePlugins = [];
+    const userMarkdownPlugins = {
+      rehype: [],
+      remark: [],
+      remarkRehypeHandlers: {}
+    };
     const componentPlugins = [];
+    const userHooks = {};
     resolvedPlugins?.forEach((p) => {
+      if (p.hooks) {
+        Object.keys(p.hooks).map((hookKey) => {
+          if (!p.hooks) {
+            return;
+          }
+          const hook = p.hooks[hookKey];
+          if (!userHooks[hookKey]) {
+            userHooks[hookKey] = [];
+          }
+          userHooks[hookKey].push(hook);
+        });
+      }
       if (p.uniform) {
         userUniformVitePlugins.push(...p.uniform);
       }
@@ -793,14 +891,23 @@ async function appInit(options) {
             if (!component.name) {
               component.name = component.component.name;
             }
-            if (!component.dist) {
-              component.dist = p._pluginPkg + "/" + component.name;
-              continue;
-            }
             if (!component.name) {
               console.error("No component name");
               continue;
             }
+            if (!component.dist) {
+              const pluginPkg = p._pluginPkg || "";
+              const looksLikeFilePath = /\.[tj]sx?$/.test(path2.basename(pluginPkg));
+              const pluginPkgBase = looksLikeFilePath ? path2.dirname(pluginPkg) : pluginPkg.replace(/\/[^\/]+\.(ts|js|tsx|jsx|mjs|cjs)$/, "");
+              const componentFunctionName = component.component.name;
+              const distName = componentFunctionName || component.name;
+              component.dist = `${pluginPkgBase}/${distName}`;
+            }
+            const { resolvedDist, exists } = resolveComponentDist(component.dist);
+            component.dist = resolvedDist;
+            if (!component.isInline) {
+              component.isInline = !exists;
+            }
           }
           components.push(...p.components);
         }
@@ -810,9 +917,24 @@ async function appInit(options) {
       if (head?.length && preloadSettings?.theme?.head) {
         preloadSettings.theme.head.push(...head);
       }
+      if (p.markdown?.rehype) {
+        userMarkdownPlugins.rehype.push(...p.markdown?.rehype || []);
+      }
+      if (p.markdown?.remark) {
+        userMarkdownPlugins.remark.push(...p.markdown?.remark || []);
+      }
+      if (p.markdown?.remarkRehypeHandlers) {
+        userMarkdownPlugins.remarkRehypeHandlers = {
+          ...userMarkdownPlugins.remarkRehypeHandlers,
+          ...p.markdown?.remarkRehypeHandlers || {}
+        };
+      }
     });
     globalThis.__xydUserUniformVitePlugins = userUniformVitePlugins;
+    globalThis.__xydUserMarkdownPlugins = userMarkdownPlugins;
     globalThis.__xydUserComponents = componentPlugins;
+    globalThis.__xydUserHooks = userHooks;
+    globalThis.__xydUserComponentsSERVER = cloneComponentsPreservingReferences(componentPlugins);
   }
   const respPluginDocs = await pluginDocs({
     ...options,
@@ -864,19 +986,61 @@ function virtualComponentsPlugin() {
     },
     async load(id) {
       if (id === "virtual:xyd-user-components.jsx") {
-        const userComponents = globalThis.__xydUserComponents || [];
-        if (userComponents.length > 0 && userComponents[0]?.component) {
-          const imports = userComponents.map(
-            (component, index) => `import Component${index} from '${component.dist}';`
-          ).join("\n");
-          const componentObjects = userComponents.map(
-            (component, index) => `{
+        const userComponents = globalThis.__xydUserComponentsSERVER || [];
+        const resolveExistingDist = (dist) => {
+          if (!dist || typeof dist !== "string") return null;
+          const looksLikePath = /^([./]|[A-Za-z]:)/.test(dist);
+          if (!looksLikePath) return dist;
+          const candidates = [dist, `${dist}.js`, `${dist}.ts`, `${dist}.tsx`];
+          for (const candidate of candidates) {
+            if (fs.existsSync(candidate)) {
+              const stat2 = fs.statSync(candidate);
+              if (stat2.isDirectory()) {
+                const indexCandidates = [
+                  path2.join(candidate, "index.js"),
+                  path2.join(candidate, "index.ts"),
+                  path2.join(candidate, "index.tsx")
+                ];
+                for (const idx of indexCandidates) {
+                  if (fs.existsSync(idx)) return idx;
+                }
+              } else {
+                return candidate;
+              }
+            }
+          }
+          return null;
+        };
+        const imports = userComponents.map((component, index) => {
+          const dist = component?.dist;
+          const explicitInline = component?.isInline === true;
+          const looksLikePath = typeof dist === "string" && /^([./]|[A-Za-z]:)/.test(dist);
+          const resolvedDist = resolveExistingDist(dist);
+          const missingLocalFile = looksLikePath && !resolvedDist;
+          const shouldInline = explicitInline || !dist || missingLocalFile;
+          const importTarget = resolvedDist || dist;
+          if (!shouldInline && importTarget) {
+            return `import Component${index} from '${importTarget}';`;
+          }
+          return `const Component${index} = ${component?.component?.toString()}`;
+        }).join("\n");
+        const componentObjects = userComponents.map((component, index) => {
+          const dist = component?.dist;
+          const explicitInline = component?.isInline === true;
+          const looksLikePath = typeof dist === "string" && /^([./]|[A-Za-z]:)/.test(dist);
+          const resolvedDist = resolveExistingDist(dist);
+          const missingLocalFile = looksLikePath && !resolvedDist;
+          const shouldInline = explicitInline || !dist || missingLocalFile;
+          const finalDist = shouldInline ? "" : resolvedDist || dist || "";
+          return `{
                                 component: Component${index},
                                 name: '${component.name}',
-                                dist: '${component.dist}'
-                            }`
-          ).join(",\n                            ");
-          return `
+                                dist: '${finalDist}'
+                            }`;
+        }).join(",\n                            ");
+        const resp = `
+                        import React from 'react';
+
                         // Pre-bundled at build time - no async loading needed
                         ${imports}
                         
@@ -884,10 +1048,7 @@ function virtualComponentsPlugin() {
                             ${componentObjects}
                         ];
                     `;
-        }
-        return `
-                    export const components = globalThis.__xydUserComponents || []
-                `;
+        return resp;
       }
       return null;
     }
@@ -925,6 +1086,30 @@ function virtualProvidersPlugin(settings) {
     }
   };
 }
+function virtualScriptsPlugin(settings) {
+  return {
+    name: "xyd-plugin-virtual-scripts",
+    enforce: "pre",
+    resolveId(id) {
+      if (id === "virtual:xyd-scripts") {
+        return id;
+      }
+    },
+    async load(id) {
+      if (id === "virtual:xyd-scripts") {
+        const scripts = settings?.theme?.scripts || [];
+        if (scripts.length === 0) {
+          return `// No scripts configured`;
+        }
+        const imports = scripts.map((script) => `import '${script}';`).join("\n");
+        return `
+// Auto-generated imports from settings.theme.scripts
+${imports}
+        `;
+      }
+    }
+  };
+}
 async function commonVitePlugins(respPluginDocs, resolvedPlugins) {
   const userVitePlugins = resolvedPlugins.map((p) => p.vite).flat() || [];
   return [
@@ -938,6 +1123,7 @@ async function commonVitePlugins(respPluginDocs, resolvedPlugins) {
     reactRouter(),
     virtualComponentsPlugin(),
     virtualProvidersPlugin(respPluginDocs.settings),
+    virtualScriptsPlugin(respPluginDocs.settings),
     pluginIconSet(respPluginDocs.settings),
     ...userVitePlugins
   ];
@@ -1235,20 +1421,33 @@ async function loadPlugins(settings, options) {
       return [];
     }
     let mod;
-    try {
-      mod = await import(pluginName);
-    } catch (e) {
-      pluginName = path2.join(
-        process.cwd(),
-        ".xyd/host/node_modules",
-        pluginName
-      );
-      const pluginPreview = await createServer({
-        optimizeDeps: {
-          include: []
-        }
-      });
-      mod = await pluginPreview.ssrLoadModule(pluginName);
+    if (pluginName?.startsWith("./")) {
+      try {
+        pluginName = path2.join(process.cwd(), pluginName);
+        const pluginPreview = await createServer({
+          optimizeDeps: {
+            include: []
+          }
+        });
+        mod = await pluginPreview.ssrLoadModule(pluginName);
+      } catch (e) {
+      }
+    } else {
+      try {
+        mod = await import(pluginName);
+      } catch (e) {
+        pluginName = path2.join(
+          process.cwd(),
+          ".xyd/host/node_modules",
+          pluginName
+        );
+        const pluginPreview = await createServer({
+          optimizeDeps: {
+            include: []
+          }
+        });
+        mod = await pluginPreview.ssrLoadModule(pluginName);
+      }
     }
     if (!mod.default) {
       console.error(`Plugin ${plugin} has no default export`);
@@ -1310,6 +1509,12 @@ function integrationsToPlugins(integrations) {
   if (integrations?.support?.livechat) {
     plugins.push(["@xyd-js/plugin-livechat", integrations.support.livechat]);
   }
+  if (integrations?.diagrams && typeof integrations?.diagrams === "object" && ".config" in integrations?.diagrams) {
+    const diagramCfg = integrations?.diagrams[".config"];
+    if (diagramCfg?.interactive) {
+      plugins.push(["@xyd-js/plugin-extra-diagram", {}]);
+    }
+  }
   return plugins;
 }
 async function preWorkspaceSetup(options = {}) {