@docfuse/plugins 0.1.0

package/dist/plantuml.js

@@ -0,0 +1,297 @@
+// src/plantuml/index.ts
+import { defineMarkdownPlugin } from "@docfuse/markdown";
+import { deflateSync, strToU8 } from "fflate";
+
+// 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/plantuml/index.ts
+var PLUGIN_VERSION = "3";
+function encode6Bit(value) {
+  const normalized = value & 63;
+  if (normalized < 10) return String.fromCharCode(48 + normalized);
+  if (normalized < 36) return String.fromCharCode(65 + normalized - 10);
+  if (normalized < 62) return String.fromCharCode(97 + normalized - 36);
+  return normalized === 62 ? "-" : "_";
+}
+function encodePlantUml(source) {
+  const normalized = /@start\w+/i.test(source) ? source : `@startuml
+${source}
+@enduml`;
+  const bytes = deflateSync(strToU8(normalized), { level: 9 });
+  let encoded = "";
+  for (let index = 0; index < bytes.length; index += 3) {
+    const first = bytes[index] ?? 0;
+    const second = bytes[index + 1] ?? 0;
+    const third = bytes[index + 2] ?? 0;
+    encoded += encode6Bit(first >> 2);
+    encoded += encode6Bit((first & 3) << 4 | second >> 4);
+    encoded += encode6Bit((second & 15) << 2 | third >> 6);
+    encoded += encode6Bit(third & 63);
+  }
+  return encoded;
+}
+function plantUml(options = {}) {
+  const server = options.server === false ? "" : options.server?.trim().replace(/\/+$/, "") ?? "";
+  return defineMarkdownPlugin({
+    name: "plantuml",
+    version: PLUGIN_VERSION,
+    cacheKey: { server },
+    browserCompiler: {
+      module: "@docfuse/plugins/plantuml",
+      exportName: "plantUml",
+      options: { server: server || false }
+    },
+    fenceLanguages: ["plantuml", "puml"],
+    appliesTo: ({ source }) => hasMarkdownFenceLanguage(source, /* @__PURE__ */ new Set(["plantuml", "puml"])),
+    assets: {
+      clients: [{ id: "plantuml", module: "@docfuse/plugins/client/plantuml" }],
+      styles: [{ id: "diagrams", module: "@docfuse/plugins/diagram.css" }]
+    },
+    rehypePlugins: [
+      diagramFence({
+        languages: /* @__PURE__ */ new Set(["plantuml", "puml"]),
+        kind: "plantuml",
+        filename: () => "diagram.puml",
+        ...server ? { imageUrl: (source) => `${server}/${encodePlantUml(source)}` } : {}
+      })
+    ]
+  });
+}
+export {
+  plantUml
+};

package/dist/reading-time.d.ts

@@ -0,0 +1,20 @@
+import { MarkdownPlugin } from '@docfuse/markdown';
+
+interface ReadingTimeOptions {
+    wordsPerMinute?: number;
+    cjkWordsPerMinute?: number;
+    includeCode?: boolean;
+    /** Fallback label template. English is built in. `{minutes}` is replaced with the calculated value. */
+    label?: string;
+    /** Locale-specific templates, merged over the built-in Chinese label. */
+    labels?: Readonly<Record<string, string>>;
+}
+interface ReadingTimeCounts {
+    latinWords: number;
+    cjkCharacters: number;
+    minutes: number;
+}
+declare function countReadingTime(text: string, wordsPerMinute: number, cjkWordsPerMinute: number): ReadingTimeCounts;
+declare function readingTime(options?: ReadingTimeOptions): MarkdownPlugin;
+
+export { type ReadingTimeCounts, type ReadingTimeOptions, countReadingTime, readingTime };

package/dist/reading-time.js

@@ -0,0 +1,90 @@
+// src/reading-time/index.ts
+import { defineMarkdownPlugin } from "@docfuse/markdown";
+import { SKIP, visit } from "unist-util-visit";
+
+// src/shared/hast.ts
+function element(tagName, properties = {}, children = []) {
+  return { type: "element", tagName, properties, children };
+}
+
+// src/reading-time/index.ts
+var PLUGIN_VERSION = "3";
+var CJK = /[\u4e00-\u9fff\u3400-\u4dbf\u3040-\u30ff\uac00-\ud7af]/g;
+var SKIP_TAGS = /* @__PURE__ */ new Set(["pre", "code", "script", "style", "svg"]);
+var DEFAULT_LABEL = "{minutes} min read";
+var DEFAULT_LABELS = { zh: "\u7EA6 {minutes} \u5206\u949F\u9605\u8BFB" };
+function positiveRate(value, name) {
+  if (!Number.isFinite(value) || value <= 0) throw new TypeError(`${name} must be a positive finite number`);
+  return value;
+}
+function countReadingTime(text, wordsPerMinute, cjkWordsPerMinute) {
+  positiveRate(wordsPerMinute, "wordsPerMinute");
+  positiveRate(cjkWordsPerMinute, "cjkWordsPerMinute");
+  const cjkCharacters = text.match(CJK)?.length ?? 0;
+  const latinWords = text.replace(CJK, " ").match(/[A-Za-z0-9]+(?:['’][A-Za-z0-9]+)*/g)?.length ?? 0;
+  const minutes = Math.max(1, Math.round(latinWords / wordsPerMinute + cjkCharacters / cjkWordsPerMinute));
+  return { latinWords, cjkCharacters, minutes };
+}
+function collectText(tree, includeCode) {
+  const chunks = [];
+  visit(tree, (node) => {
+    if (!includeCode && node.type === "element" && SKIP_TAGS.has(node.tagName)) return SKIP;
+    if (node.type === "text") chunks.push(node.value);
+  });
+  return chunks.join(" ");
+}
+function localeFromFile(file) {
+  if (!file || typeof file !== "object" || !("data" in file)) return void 0;
+  const data = file.data;
+  if (!data || typeof data !== "object" || !("docfuseLocale" in data)) return void 0;
+  const locale = data.docfuseLocale;
+  return typeof locale === "string" ? locale.trim().toLowerCase() || void 0 : void 0;
+}
+function normalizeLabels(labels) {
+  return Object.fromEntries(
+    Object.entries(labels ?? {}).map(([locale, value]) => [locale.trim().toLowerCase(), value]).filter(([locale]) => locale.length > 0)
+  );
+}
+function labelForLocale(fallback, labels, locale) {
+  if (!locale) return fallback;
+  return labels[locale] ?? labels[locale.split("-")[0] ?? ""] ?? fallback;
+}
+function readingTime(options = {}) {
+  const wordsPerMinute = positiveRate(options.wordsPerMinute ?? 220, "wordsPerMinute");
+  const cjkWordsPerMinute = positiveRate(options.cjkWordsPerMinute ?? 300, "cjkWordsPerMinute");
+  const includeCode = options.includeCode === true;
+  const label = options.label ?? DEFAULT_LABEL;
+  const labels = { ...DEFAULT_LABELS, ...normalizeLabels(options.labels) };
+  return defineMarkdownPlugin({
+    name: "reading-time",
+    version: PLUGIN_VERSION,
+    cacheKey: { wordsPerMinute, cjkWordsPerMinute, includeCode, label, labels },
+    browserCompiler: {
+      module: "@docfuse/plugins/reading-time",
+      exportName: "readingTime",
+      options: { wordsPerMinute, cjkWordsPerMinute, includeCode, label, labels }
+    },
+    rehypePlugins: [
+      () => (tree, file) => {
+        const counts = countReadingTime(collectText(tree, includeCode), wordsPerMinute, cjkWordsPerMinute);
+        if (counts.latinWords + counts.cjkCharacters === 0) return;
+        const resolvedLabel = labelForLocale(label, labels, localeFromFile(file));
+        const readingTimeNode = element(
+          "p",
+          {
+            className: ["df-reading-time"],
+            dataDfReadingMinutes: String(counts.minutes),
+            dataDfWordCount: String(counts.latinWords + counts.cjkCharacters)
+          },
+          [{ type: "text", value: resolvedLabel.replaceAll("{minutes}", String(counts.minutes)) }]
+        );
+        const titleIndex = tree.children.findIndex((node) => node.type === "element" && node.tagName === "h1");
+        tree.children.splice(titleIndex >= 0 ? titleIndex + 1 : 0, 0, readingTimeNode);
+      }
+    ]
+  });
+}
+export {
+  countReadingTime,
+  readingTime
+};

package/package.json

@@ -0,0 +1,122 @@
+{
+  "name": "@docfuse/plugins",
+  "version": "0.1.0",
+  "description": "Official plugins and providers for Docfuse and @docfuse/markdown.",
+  "license": "MIT",
+  "author": "Docfuse Contributors",
+  "homepage": "https://docfuse.dev",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jiangxinlei/docfuse.git",
+    "directory": "packages/plugins"
+  },
+  "bugs": {
+    "url": "https://github.com/jiangxinlei/docfuse/issues"
+  },
+  "keywords": [
+    "docfuse",
+    "markdown",
+    "plugin",
+    "remark",
+    "rehype",
+    "mermaid",
+    "plantuml"
+  ],
+  "type": "module",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    },
+    "./external-links": {
+      "types": "./dist/external-links.d.ts",
+      "import": "./dist/external-links.js"
+    },
+    "./reading-time": {
+      "types": "./dist/reading-time.d.ts",
+      "import": "./dist/reading-time.js"
+    },
+    "./link-card": {
+      "types": "./dist/link-card.d.ts",
+      "import": "./dist/link-card.js"
+    },
+    "./kroki": {
+      "types": "./dist/kroki.d.ts",
+      "import": "./dist/kroki.js"
+    },
+    "./mermaid": {
+      "types": "./dist/mermaid.d.ts",
+      "import": "./dist/mermaid.js"
+    },
+    "./plantuml": {
+      "types": "./dist/plantuml.d.ts",
+      "import": "./dist/plantuml.js"
+    },
+    "./math": {
+      "types": "./dist/math.d.ts",
+      "import": "./dist/math.js"
+    },
+    "./pagefind": {
+      "types": "./dist/pagefind.d.ts",
+      "import": "./dist/pagefind.js"
+    },
+    "./client/kroki": "./dist/client/kroki.js",
+    "./client/mermaid": "./dist/client/mermaid.js",
+    "./client/plantuml": "./dist/client/plantuml.js",
+    "./diagram.css": "./dist/diagram.css",
+    "./math.css": "./dist/math.css"
+  },
+  "files": [
+    "dist",
+    "README.zh-CN.md"
+  ],
+  "engines": {
+    "node": ">=22"
+  },
+  "publishConfig": {
+    "access": "public",
+    "provenance": true
+  },
+  "dependencies": {
+    "fflate": "^0.8.3",
+    "katex": "^0.17.0",
+    "rehype-katex": "^7.0.1",
+    "remark-math": "^6.0.0",
+    "unist-util-visit": "^5.1.0",
+    "@docfuse/markdown": "0.1.0"
+  },
+  "peerDependencies": {
+    "mermaid": "^11.12.0",
+    "pagefind": "^1.5.2"
+  },
+  "peerDependenciesMeta": {
+    "mermaid": {
+      "optional": true
+    },
+    "pagefind": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/hast": "^3.0.4",
+    "@types/mdast": "^4.0.4",
+    "@types/node": "^22.10.0",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "esbuild": "^0.28.1",
+    "mermaid": "^11.12.0",
+    "pagefind": "^1.5.2",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "tsup": "^8.3.5",
+    "typescript": "^6.0.3",
+    "docfuse": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsup && node scripts/verify-client-assets.mjs && node scripts/build-math-css.mjs",
+    "test:browser": "node scripts/test-browser-build.mjs",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run --root ../.. packages/plugins"
+  }
+}