@docfuse/plugins 0.1.0

package/dist/mermaid.js

@@ -0,0 +1,290 @@
+// src/mermaid/index.ts
+import { defineMarkdownPlugin } from "@docfuse/markdown";
+
+// src/shared/diagram.ts
+import { visit } from "unist-util-visit";
+function displayKind(kind) {
+  if (kind === "plantuml") return "PlantUML";
+  return kind.charAt(0).toUpperCase() + kind.slice(1);
+}
+var DIAGRAM_LABELS = {
+  en: {
+    copy: "Copy source",
+    source: "Show source",
+    preview: "Show preview",
+    expand: "Expand diagram",
+    close: "Close expanded diagram",
+    controls: "Diagram zoom controls",
+    zoomOut: "Zoom out",
+    zoomReset: "Reset zoom",
+    zoomIn: "Zoom in",
+    imageAlt: (kind) => `${displayKind(kind)} diagram`,
+    loadingPreview: "Diagram preview loads in the browser."
+  },
+  zh: {
+    copy: "\u590D\u5236\u56FE\u8868\u6E90\u7801",
+    source: "\u663E\u793A\u56FE\u8868\u6E90\u7801",
+    preview: "\u663E\u793A\u56FE\u8868\u9884\u89C8",
+    expand: "\u653E\u5927\u56FE\u8868",
+    close: "\u5173\u95ED\u56FE\u8868\u9884\u89C8",
+    controls: "\u56FE\u8868\u7F29\u653E\u63A7\u4EF6",
+    zoomOut: "\u7F29\u5C0F\u56FE\u8868",
+    zoomReset: "\u91CD\u7F6E\u56FE\u8868\u7F29\u653E",
+    zoomIn: "\u653E\u5927\u56FE\u8868",
+    imageAlt: (kind) => `${displayKind(kind)} \u56FE\u8868`,
+    loadingPreview: "\u56FE\u8868\u9884\u89C8\u5C06\u5728\u6D4F\u89C8\u5668\u4E2D\u52A0\u8F7D\u3002"
+  }
+};
+function labelsFromFile(file) {
+  if (!file || typeof file !== "object" || !("data" in file)) return DIAGRAM_LABELS.en;
+  const data = file.data;
+  if (!data || typeof data !== "object" || !("docfuseLocale" in data)) return DIAGRAM_LABELS.en;
+  const locale = typeof data.docfuseLocale === "string" ? data.docfuseLocale.toLowerCase() : "";
+  return locale === "zh" || locale.startsWith("zh-") ? DIAGRAM_LABELS.zh : DIAGRAM_LABELS.en;
+}
+function languageOf(node) {
+  const code = node.children.find(
+    (child) => child.type === "element" && child.tagName === "code"
+  );
+  if (!code) return void 0;
+  const classes = Array.isArray(code.properties.className) ? code.properties.className : [];
+  const language = classes.map(String).find((className) => className.startsWith("language-"))?.slice("language-".length).toLowerCase();
+  const source = code.children.filter((child) => child.type === "text").map((child) => child.value).join("");
+  return language ? { language, source } : void 0;
+}
+function action(name, label, properties = {}) {
+  return {
+    type: "element",
+    tagName: "button",
+    properties: { type: "button", dataDfDiagramAction: name, ariaLabel: label, ...properties },
+    children: [{ type: "text", value: label }]
+  };
+}
+function zoomControl(name, label) {
+  return {
+    type: "element",
+    tagName: "button",
+    properties: { type: "button", dataDfDiagramAction: name, ariaLabel: label, title: label },
+    children: [{ type: "text", value: label }]
+  };
+}
+function diagramFence(options) {
+  return () => (tree, file) => {
+    const labels = labelsFromFile(file);
+    visit(tree, "element", (node, index, parent) => {
+      if (!parent || index === void 0 || node.tagName !== "pre") return;
+      const fence = languageOf(node);
+      if (!fence || !options.languages.has(fence.language)) return;
+      const imageUrl = options.imageUrl?.(fence.source, fence.language);
+      const hasVisualPreview = Boolean(imageUrl || options.kind === "mermaid");
+      const preview = imageUrl ? {
+        type: "element",
+        tagName: "img",
+        properties: {
+          className: ["df-diagram-img"],
+          src: imageUrl,
+          alt: labels.imageAlt(options.kind),
+          loading: "lazy"
+        },
+        children: []
+      } : {
+        type: "element",
+        tagName: "div",
+        properties: { className: ["df-diagram-placeholder"] },
+        children: [{ type: "text", value: labels.loadingPreview }]
+      };
+      parent.children[index] = {
+        type: "element",
+        tagName: "figure",
+        properties: {
+          className: ["df-diagram-window"],
+          dataDfPluginDiagram: options.kind,
+          dataDfSource: fence.source,
+          ...options.moduleUrl ? { dataDfModuleUrl: options.moduleUrl } : {}
+        },
+        children: [
+          {
+            type: "element",
+            tagName: "figcaption",
+            properties: { className: ["df-diagram-toolbar"] },
+            children: [
+              {
+                type: "element",
+                tagName: "span",
+                properties: { className: ["df-diagram-title"] },
+                children: [{ type: "text", value: options.filename(fence.language) }]
+              },
+              {
+                type: "element",
+                tagName: "span",
+                properties: { className: ["df-diagram-actions"] },
+                children: [
+                  action("copy", labels.copy),
+                  action("source", labels.source, { dataDfDiagramPreviewLabel: labels.preview }),
+                  action("expand", labels.expand, { dataDfDiagramCloseLabel: labels.close })
+                ]
+              }
+            ]
+          },
+          {
+            type: "element",
+            tagName: "div",
+            properties: { className: ["df-diagram-stage"] },
+            children: [
+              {
+                type: "element",
+                tagName: "div",
+                properties: { className: ["df-diagram-preview"] },
+                children: [preview]
+              },
+              {
+                type: "element",
+                tagName: "pre",
+                properties: { className: ["df-diagram-source"], hidden: true },
+                children: [
+                  {
+                    type: "element",
+                    tagName: "code",
+                    properties: {},
+                    children: [{ type: "text", value: fence.source }]
+                  }
+                ]
+              },
+              ...hasVisualPreview ? [
+                {
+                  type: "element",
+                  tagName: "div",
+                  properties: {
+                    className: ["df-diagram-zoom-controls"],
+                    role: "group",
+                    ariaLabel: labels.controls
+                  },
+                  children: [
+                    zoomControl("zoom-out", labels.zoomOut),
+                    zoomControl("zoom-reset", labels.zoomReset),
+                    zoomControl("zoom-in", labels.zoomIn)
+                  ]
+                }
+              ] : []
+            ]
+          }
+        ]
+      };
+    });
+  };
+}
+
+// src/shared/markdownSource.ts
+function stripColumns(value, columns) {
+  let index = 0;
+  let consumed = 0;
+  while (index < value.length && consumed < columns) {
+    if (value[index] === " ") consumed += 1;
+    else if (value[index] === "	") consumed += 4 - consumed % 4;
+    else break;
+    index += 1;
+  }
+  return consumed >= columns ? value.slice(index) : void 0;
+}
+function containerContent(line, state) {
+  let value = line;
+  while (true) {
+    const quote = value.match(/^ {0,3}>[ \t]?/);
+    if (!quote) break;
+    value = value.slice(quote[0].length);
+  }
+  const continued = state.listIndent > 0 ? stripColumns(value, state.listIndent) : void 0;
+  const content = continued ?? value;
+  const item = content.match(/^ {0,3}(?:[-+*]|\d{1,9}[.)])([ \t]+)(.*)$/);
+  if (item) {
+    const body = item[2] ?? "";
+    state.listIndent = (continued === void 0 ? 0 : state.listIndent) + content.length - body.length;
+    return body;
+  }
+  if (continued !== void 0 || value.trim() === "") return content;
+  state.listIndent = 0;
+  return value;
+}
+function openingFence(line) {
+  const match = line.match(/^ {0,3}(`{3,}|~{3,})(.*)$/);
+  if (!match?.[1]) return void 0;
+  const marker = match[1][0];
+  const info = match[2]?.trim() ?? "";
+  if (marker === "`" && info.includes("`")) return void 0;
+  return {
+    marker,
+    size: match[1].length,
+    language: info.split(/\s+/, 1)[0]?.toLowerCase() ?? ""
+  };
+}
+function closesFence(line, fence) {
+  const match = line.match(/^ {0,3}(`+|~+)[ \t]*$/);
+  return Boolean(match?.[1]?.[0] === fence.marker && match[1].length >= fence.size);
+}
+function hasMarkdownFenceLanguage(source, languages) {
+  let open;
+  const container = { listIndent: 0 };
+  for (const line of source.split(/\r?\n/)) {
+    const content = containerContent(line, container);
+    if (open) {
+      if (closesFence(content, open)) open = void 0;
+      continue;
+    }
+    const fence = openingFence(content);
+    if (!fence) continue;
+    if (languages.has(fence.language)) return true;
+    open = fence;
+  }
+  return false;
+}
+
+// src/mermaid/index.ts
+var PLUGIN_VERSION = "3";
+function mermaid(options = {}) {
+  const moduleUrl = options.moduleUrl?.trim();
+  return defineMarkdownPlugin({
+    name: "mermaid",
+    version: PLUGIN_VERSION,
+    cacheKey: { moduleUrl: moduleUrl ?? null },
+    browserCompiler: {
+      module: "@docfuse/plugins/mermaid",
+      exportName: "mermaid",
+      options: moduleUrl ? { moduleUrl } : {}
+    },
+    fenceLanguages: ["mermaid"],
+    appliesTo: ({ source }) => hasMarkdownFenceLanguage(source, /* @__PURE__ */ new Set(["mermaid"])),
+    assets: {
+      clients: [
+        {
+          id: "mermaid",
+          module: "@docfuse/plugins/client/mermaid",
+          resources: [
+            {
+              module: "mermaid/dist/mermaid.esm.min.mjs",
+              output: "mermaid.esm.min.mjs",
+              directories: [
+                {
+                  source: "chunks/mermaid.esm.min",
+                  output: "chunks/mermaid.esm.min",
+                  extensions: [".mjs"]
+                }
+              ]
+            }
+          ]
+        }
+      ],
+      styles: [{ id: "diagrams", module: "@docfuse/plugins/diagram.css" }]
+    },
+    rehypePlugins: [
+      diagramFence({
+        languages: /* @__PURE__ */ new Set(["mermaid"]),
+        kind: "mermaid",
+        filename: () => "diagram.mmd",
+        ...moduleUrl ? { moduleUrl } : {}
+      })
+    ]
+  });
+}
+export {
+  mermaid
+};

package/dist/pagefind.d.ts

@@ -0,0 +1,66 @@
+interface PagefindOptions {
+    includeCharacters?: string;
+    keepIndexUrl?: boolean;
+    writePlayground?: boolean;
+}
+interface PagefindProviderPage {
+    search: boolean;
+    outputPath: string;
+    routePath: string;
+    sourceRelativePath: string;
+}
+interface PagefindProviderContext {
+    cwd?: string;
+    config?: unknown;
+    outputRoot: string;
+    graph: {
+        pages: PagefindProviderPage[];
+    };
+    publicPathFor(routePath: string): string;
+    resolveOutputPath(outputPath: string, label: string): string;
+}
+interface PagefindProvider {
+    readonly id: 'pagefind';
+    readonly client: 'pagefind';
+    readonly version: string;
+    readonly cacheKey: Readonly<Required<PagefindOptions>>;
+    write(context: PagefindProviderContext): Promise<void>;
+}
+interface PagefindIndex {
+    addHTMLFile(input: {
+        url: string;
+        content: string;
+    }): Promise<{
+        errors: string[];
+    }>;
+    writeFiles(input: {
+        outputPath: string;
+    }): Promise<{
+        errors: string[];
+    }>;
+    deleteIndex(): Promise<void>;
+}
+interface PagefindApi {
+    createIndex(options: {
+        includeCharacters: string;
+        keepIndexUrl: boolean;
+        writePlayground: boolean;
+    }): Promise<{
+        errors: string[];
+        index?: PagefindIndex;
+    }>;
+    close(): Promise<void>;
+}
+interface PagefindDependencies {
+    pagefindApi: PagefindApi;
+    readFile(path: string, encoding: 'utf8'): Promise<string>;
+    rm(path: string, options: {
+        recursive?: boolean;
+        force?: boolean;
+    }): Promise<void>;
+    join(...paths: string[]): string;
+}
+declare function writePagefindIndex(context: PagefindProviderContext, resolved: Required<PagefindOptions>, loadDependencies?: () => Promise<PagefindDependencies>): Promise<void>;
+declare function pagefind(options?: PagefindOptions): PagefindProvider;
+
+export { type PagefindOptions, type PagefindProvider, type PagefindProviderContext, pagefind, writePagefindIndex };

package/dist/pagefind.js

@@ -0,0 +1,84 @@
+// src/pagefind/index.ts
+var PLUGIN_VERSION = "1";
+var unusedPagefindUiFiles = [
+  "pagefind-ui.js",
+  "pagefind-ui.css",
+  "pagefind-modular-ui.js",
+  "pagefind-component-ui.js",
+  "pagefind-component-ui.css",
+  "pagefind-highlight.js"
+];
+function assertPagefind(errors, action) {
+  if (errors.length) throw new Error(`Pagefind ${action} failed:
+${errors.join("\n")}`);
+}
+async function loadPagefindDependencies() {
+  const filesystemModule = "node:fs/promises";
+  const pathModule = "node:path";
+  const pagefindModule = "pagefind";
+  const [filesystem, paths, pagefindApi] = await Promise.all([
+    import(filesystemModule),
+    import(pathModule),
+    import(pagefindModule)
+  ]);
+  return {
+    pagefindApi,
+    readFile: filesystem.readFile,
+    rm: filesystem.rm,
+    join: paths.join
+  };
+}
+async function writePagefindIndex(context, resolved, loadDependencies = loadPagefindDependencies) {
+  let pagefindApi;
+  let index;
+  try {
+    const dependencies = await loadDependencies();
+    pagefindApi = dependencies.pagefindApi;
+    const { join, readFile, rm } = dependencies;
+    const pagefindRoot = join(context.outputRoot, "pagefind");
+    await rm(pagefindRoot, { recursive: true, force: true });
+    await rm(join(context.outputRoot, "search"), { recursive: true, force: true });
+    const created = await pagefindApi.createIndex(resolved);
+    assertPagefind(created.errors, "initialization");
+    if (!created.index) throw new Error("Pagefind did not return an index");
+    index = created.index;
+    for (const page of context.graph.pages.filter((candidate) => candidate.search)) {
+      const htmlPath = context.resolveOutputPath(page.outputPath, `search page ${page.outputPath}`);
+      const result = await index.addHTMLFile({
+        url: context.publicPathFor(page.routePath),
+        content: await readFile(htmlPath, "utf8")
+      });
+      assertPagefind(result.errors, `indexing ${page.sourceRelativePath}`);
+    }
+    const written = await index.writeFiles({ outputPath: pagefindRoot });
+    assertPagefind(written.errors, "write");
+    await Promise.all(unusedPagefindUiFiles.map((file) => rm(join(pagefindRoot, file), { force: true })));
+  } finally {
+    try {
+      await index?.deleteIndex();
+    } finally {
+      await pagefindApi?.close();
+    }
+  }
+}
+function pagefind(options = {}) {
+  const resolved = {
+    includeCharacters: options.includeCharacters ?? "._-",
+    keepIndexUrl: options.keepIndexUrl ?? false,
+    writePlayground: options.writePlayground ?? false
+  };
+  const provider = Object.freeze({
+    id: "pagefind",
+    client: "pagefind",
+    version: PLUGIN_VERSION,
+    cacheKey: resolved,
+    async write(context) {
+      await writePagefindIndex(context, resolved);
+    }
+  });
+  return provider;
+}
+export {
+  pagefind,
+  writePagefindIndex
+};

package/dist/plantuml.d.ts

@@ -0,0 +1,10 @@
+import { MarkdownPlugin } from '@docfuse/markdown';
+
+interface PlantUmlOptions {
+    /** PlantUML server base URL. Set to false to keep source-only output. */
+    server?: string | false;
+}
+/** Enable PlantUML fenced code blocks as an opt-in official plugin. */
+declare function plantUml(options?: PlantUmlOptions): MarkdownPlugin;
+
+export { type PlantUmlOptions, plantUml };