@matfsw/docusaurus-plantuml-plugin 0.1.0

package/dist/assets.d.ts

@@ -0,0 +1,15 @@
+export interface PlantUmlCoreLocation {
+    /** Absolute directory of the installed `@plantuml/core` package. */
+    packageDir: string;
+    /** Installed `@plantuml/core` version, used to namespace emitted asset URLs. */
+    version: string;
+    /** Absolute paths of the runtime files that must be served from the site origin. */
+    files: string[];
+}
+/**
+ * Locates the installed `@plantuml/core` package on disk.
+ *
+ * Resolution goes through `@plantuml/core/package.json`, which the package lists in its
+ * `exports` map — resolving the bare specifier would give the ES module entry instead.
+ */
+export declare function locatePlantUmlCore(): PlantUmlCoreLocation;

package/dist/assets.js

@@ -0,0 +1,32 @@
+import fs from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { PLANTUML_MODULE_FILENAME, PLUGIN_NAME, VIZ_SCRIPT_FILENAME } from './constants.js';
+const require = createRequire(import.meta.url);
+/**
+ * Locates the installed `@plantuml/core` package on disk.
+ *
+ * Resolution goes through `@plantuml/core/package.json`, which the package lists in its
+ * `exports` map — resolving the bare specifier would give the ES module entry instead.
+ */
+export function locatePlantUmlCore() {
+    let packageJsonPath;
+    try {
+        packageJsonPath = require.resolve('@plantuml/core/package.json');
+    }
+    catch (cause) {
+        throw new Error(`[${PLUGIN_NAME}] Could not resolve '@plantuml/core'. It is a dependency of this plugin; ` +
+            'reinstall your site dependencies to fix a broken or deduplicated install.', { cause });
+    }
+    const packageDir = path.dirname(packageJsonPath);
+    const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+    const version = typeof packageJson.version === 'string' ? packageJson.version : '0.0.0';
+    return {
+        packageDir,
+        version,
+        files: [
+            path.join(packageDir, VIZ_SCRIPT_FILENAME),
+            path.join(packageDir, PLANTUML_MODULE_FILENAME),
+        ],
+    };
+}

package/dist/constants.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Identifiers shared by the Node-side plugin and the browser-side theme components.
+ *
+ * `PLUGIN_NAME` is the Docusaurus plugin name and therefore the key used for global data,
+ * so it must stay stable and identical on both sides of the SSR boundary. It is deliberately
+ * independent of the npm package name so that renaming the package cannot break global-data
+ * lookups in already-built sites.
+ */
+export declare const PLUGIN_ID = "plantuml-client";
+/** Docusaurus' own default plugin instance id, mirrored to avoid a runtime import. */
+export declare const DEFAULT_PLUGIN_ID = "default";
+export declare const PLUGIN_NAME = "docusaurus-plugin-plantuml-client";
+/** Directory (relative to `baseUrl`) that the PlantUML runtime assets are emitted into. */
+export declare function assetsDirForVersion(coreVersion: string): string;
+export declare const VIZ_SCRIPT_FILENAME = "viz-global.js";
+export declare const PLANTUML_MODULE_FILENAME = "plantuml.js";
+/** `data-*` attribute names, kept in one place because tests and docs depend on them. */
+export declare const DATA_ATTR: {
+    readonly diagram: "data-plantuml-diagram";
+    readonly status: "data-plantuml-status";
+    readonly theme: "data-plantuml-theme";
+};

package/dist/constants.js

@@ -0,0 +1,24 @@
+/**
+ * Identifiers shared by the Node-side plugin and the browser-side theme components.
+ *
+ * `PLUGIN_NAME` is the Docusaurus plugin name and therefore the key used for global data,
+ * so it must stay stable and identical on both sides of the SSR boundary. It is deliberately
+ * independent of the npm package name so that renaming the package cannot break global-data
+ * lookups in already-built sites.
+ */
+export const PLUGIN_ID = 'plantuml-client';
+/** Docusaurus' own default plugin instance id, mirrored to avoid a runtime import. */
+export const DEFAULT_PLUGIN_ID = 'default';
+export const PLUGIN_NAME = `docusaurus-plugin-${PLUGIN_ID}`;
+/** Directory (relative to `baseUrl`) that the PlantUML runtime assets are emitted into. */
+export function assetsDirForVersion(coreVersion) {
+    return `assets/${PLUGIN_ID}-${coreVersion}`;
+}
+export const VIZ_SCRIPT_FILENAME = 'viz-global.js';
+export const PLANTUML_MODULE_FILENAME = 'plantuml.js';
+/** `data-*` attribute names, kept in one place because tests and docs depend on them. */
+export const DATA_ATTR = {
+    diagram: 'data-plantuml-diagram',
+    status: 'data-plantuml-status',
+    theme: 'data-plantuml-theme',
+};

package/dist/index.cjs

@@ -0,0 +1,288 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DEFAULT_OPTIONS: () => DEFAULT_OPTIONS,
+  PLUGIN_ID: () => PLUGIN_ID,
+  PLUGIN_NAME: () => PLUGIN_NAME,
+  PlantUmlOptionsError: () => PlantUmlOptionsError,
+  createCopyPlugin: () => createCopyPlugin,
+  default: () => plantumlPlugin,
+  resolveOptions: () => resolveOptions,
+  validateOptions: () => validateOptions
+});
+module.exports = __toCommonJS(src_exports);
+
+// node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/index.ts
+var import_node_path2 = __toESM(require("path"), 1);
+var import_node_url = require("url");
+var import_copy_webpack_plugin = __toESM(require("copy-webpack-plugin"), 1);
+
+// src/assets.ts
+var import_node_fs = __toESM(require("fs"), 1);
+var import_node_module = require("module");
+var import_node_path = __toESM(require("path"), 1);
+
+// src/constants.ts
+var PLUGIN_ID = "plantuml-client";
+var DEFAULT_PLUGIN_ID = "default";
+var PLUGIN_NAME = `docusaurus-plugin-${PLUGIN_ID}`;
+function assetsDirForVersion(coreVersion) {
+  return `assets/${PLUGIN_ID}-${coreVersion}`;
+}
+var VIZ_SCRIPT_FILENAME = "viz-global.js";
+var PLANTUML_MODULE_FILENAME = "plantuml.js";
+
+// src/assets.ts
+var require2 = (0, import_node_module.createRequire)(importMetaUrl);
+function locatePlantUmlCore() {
+  let packageJsonPath;
+  try {
+    packageJsonPath = require2.resolve("@plantuml/core/package.json");
+  } catch (cause) {
+    throw new Error(
+      `[${PLUGIN_NAME}] Could not resolve '@plantuml/core'. It is a dependency of this plugin; reinstall your site dependencies to fix a broken or deduplicated install.`,
+      { cause }
+    );
+  }
+  const packageDir = import_node_path.default.dirname(packageJsonPath);
+  const packageJson = JSON.parse(import_node_fs.default.readFileSync(packageJsonPath, "utf8"));
+  const version = typeof packageJson.version === "string" ? packageJson.version : "0.0.0";
+  return {
+    packageDir,
+    version,
+    files: [
+      import_node_path.default.join(packageDir, VIZ_SCRIPT_FILENAME),
+      import_node_path.default.join(packageDir, PLANTUML_MODULE_FILENAME)
+    ]
+  };
+}
+
+// src/options.ts
+var DEFAULT_OPTIONS = {
+  languages: ["plantuml", "puml"],
+  theme: "auto",
+  lazy: true,
+  cache: "memory",
+  sanitizeSvg: true,
+  showSourceOnError: true,
+  renderTimeoutMs: 2e4,
+  cacheMaxEntries: 50
+};
+var CACHE_MODES = ["none", "memory", "session"];
+var THEMES = ["auto", "light", "dark"];
+var MIN_RENDER_TIMEOUT_MS = 100;
+var MAX_RENDER_TIMEOUT_MS = 6e5;
+var PlantUmlOptionsError = class extends Error {
+  constructor(message) {
+    super(`[${PLUGIN_NAME}] ${message}`);
+    this.name = "PlantUmlOptionsError";
+  }
+};
+function fail(message) {
+  throw new PlantUmlOptionsError(message);
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function quoteList(values) {
+  return values.map((value) => `'${value}'`).join(", ");
+}
+function validateBoolean(value, key, fallback) {
+  if (value === void 0) return fallback;
+  if (typeof value !== "boolean") {
+    fail(`options.${key} must be a boolean, received ${JSON.stringify(value)}.`);
+  }
+  return value;
+}
+function validateLanguages(value) {
+  if (value === void 0) return [...DEFAULT_OPTIONS.languages];
+  if (!Array.isArray(value)) {
+    fail(`options.languages must be an array of strings, received ${JSON.stringify(value)}.`);
+  }
+  if (value.length === 0) {
+    fail("options.languages must contain at least one language.");
+  }
+  const normalized = value.map((entry, index) => {
+    if (typeof entry !== "string" || entry.trim() === "") {
+      fail(
+        `options.languages[${index}] must be a non-empty string, received ${JSON.stringify(entry)}.`
+      );
+    }
+    return entry.trim().toLowerCase();
+  });
+  const duplicates = normalized.filter((entry, index) => normalized.indexOf(entry) !== index);
+  if (duplicates.length > 0) {
+    fail(`options.languages contains duplicate entries: ${quoteList([...new Set(duplicates)])}.`);
+  }
+  return normalized;
+}
+function validateRenderTimeout(value) {
+  if (value === void 0) return DEFAULT_OPTIONS.renderTimeoutMs;
+  if (typeof value !== "number" || !Number.isFinite(value)) {
+    fail(`options.renderTimeoutMs must be a finite number, received ${JSON.stringify(value)}.`);
+  }
+  if (!Number.isInteger(value)) {
+    fail(`options.renderTimeoutMs must be an integer, received ${value}.`);
+  }
+  if (value < MIN_RENDER_TIMEOUT_MS || value > MAX_RENDER_TIMEOUT_MS) {
+    fail(
+      `options.renderTimeoutMs must be between ${MIN_RENDER_TIMEOUT_MS} and ${MAX_RENDER_TIMEOUT_MS} milliseconds, received ${value}.`
+    );
+  }
+  return value;
+}
+function validateCacheMaxEntries(value) {
+  if (value === void 0) return DEFAULT_OPTIONS.cacheMaxEntries;
+  if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+    fail(`options.cacheMaxEntries must be a positive integer, received ${JSON.stringify(value)}.`);
+  }
+  return value;
+}
+function resolveOptions(rawOptions) {
+  if (rawOptions === void 0 || rawOptions === null) {
+    return { ...DEFAULT_OPTIONS, languages: [...DEFAULT_OPTIONS.languages] };
+  }
+  if (!isPlainObject(rawOptions)) {
+    fail(`options must be an object, received ${JSON.stringify(rawOptions)}.`);
+  }
+  const allowedKeys = /* @__PURE__ */ new Set([
+    "languages",
+    "theme",
+    "lazy",
+    "cache",
+    "sanitizeSvg",
+    "showSourceOnError",
+    "renderTimeoutMs",
+    "cacheMaxEntries",
+    // Docusaurus injects `id` for multi-instance plugins.
+    "id"
+  ]);
+  const unknownKeys = Object.keys(rawOptions).filter((key) => !allowedKeys.has(key));
+  if (unknownKeys.length > 0) {
+    fail(
+      `Unknown option${unknownKeys.length > 1 ? "s" : ""} ${quoteList(unknownKeys)}. Supported options: ${quoteList([...allowedKeys].filter((key) => key !== "id"))}.`
+    );
+  }
+  const { theme, cache } = rawOptions;
+  if (theme !== void 0 && !THEMES.includes(theme)) {
+    fail(`options.theme must be one of ${quoteList(THEMES)}, received ${JSON.stringify(theme)}.`);
+  }
+  if (cache !== void 0 && !CACHE_MODES.includes(cache)) {
+    fail(
+      `options.cache must be one of ${quoteList(CACHE_MODES)}, received ${JSON.stringify(cache)}.`
+    );
+  }
+  return {
+    languages: validateLanguages(rawOptions.languages),
+    theme: theme ?? DEFAULT_OPTIONS.theme,
+    lazy: validateBoolean(rawOptions.lazy, "lazy", DEFAULT_OPTIONS.lazy),
+    cache: cache ?? DEFAULT_OPTIONS.cache,
+    sanitizeSvg: validateBoolean(
+      rawOptions.sanitizeSvg,
+      "sanitizeSvg",
+      DEFAULT_OPTIONS.sanitizeSvg
+    ),
+    showSourceOnError: validateBoolean(
+      rawOptions.showSourceOnError,
+      "showSourceOnError",
+      DEFAULT_OPTIONS.showSourceOnError
+    ),
+    renderTimeoutMs: validateRenderTimeout(rawOptions.renderTimeoutMs),
+    cacheMaxEntries: validateCacheMaxEntries(rawOptions.cacheMaxEntries)
+  };
+}
+
+// src/index.ts
+var currentDir = import_node_path2.default.dirname((0, import_node_url.fileURLToPath)(importMetaUrl));
+function createCopyPlugin(currentBundler, patterns) {
+  if (currentBundler?.name === "rspack") {
+    const { CopyRspackPlugin } = currentBundler.instance;
+    if (!CopyRspackPlugin) {
+      throw new Error(
+        `[${PLUGIN_NAME}] The Rspack bundler is active but 'CopyRspackPlugin' is unavailable, so the PlantUML runtime assets cannot be emitted. Upgrade @docusaurus/faster, or disable \`future.v4\` to use the webpack bundler.`
+      );
+    }
+    return new CopyRspackPlugin({ patterns });
+  }
+  return new import_copy_webpack_plugin.default({ patterns });
+}
+function plantumlPlugin(_context, options = {}) {
+  const resolved = resolveOptions(options);
+  const core = locatePlantUmlCore();
+  const assetsDir = assetsDirForVersion(core.version);
+  return {
+    name: PLUGIN_NAME,
+    getThemePath() {
+      return import_node_path2.default.join(currentDir, "theme");
+    },
+    contentLoaded({ actions }) {
+      const globalData = {
+        options: resolved,
+        assetsDir,
+        coreVersion: core.version
+      };
+      actions.setGlobalData(globalData);
+    },
+    configureWebpack(_config, isServer, utils) {
+      if (isServer) {
+        return {};
+      }
+      const patterns = core.files.map((absolutePath) => ({
+        from: absolutePath,
+        to: `${assetsDir}/[name][ext]`,
+        // These files are already minified upstream; re-processing 8 MB is wasted work.
+        info: { minimized: true }
+      }));
+      return { plugins: [createCopyPlugin(utils?.currentBundler, patterns)] };
+    }
+  };
+}
+function validateOptions({
+  options
+}) {
+  resolveOptions(options);
+  return { ...options, id: options.id ?? DEFAULT_PLUGIN_ID };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_OPTIONS,
+  PLUGIN_ID,
+  PLUGIN_NAME,
+  PlantUmlOptionsError,
+  createCopyPlugin,
+  resolveOptions,
+  validateOptions
+});

package/dist/index.d.cts

@@ -0,0 +1,97 @@
+import { ConfigureWebpackUtils, LoadContext, Plugin, PluginOptions } from '@docusaurus/types';
+import { WebpackPluginInstance } from 'webpack';
+
+/** Cache backing store for rendered SVG output. */
+type CacheMode = 'none' | 'memory' | 'session';
+/** Which PlantUML colour scheme to render. `auto` follows the Docusaurus colour mode. */
+type DiagramTheme = 'auto' | 'light' | 'dark';
+/**
+ * Options accepted by the plugin in `docusaurus.config.*`.
+ *
+ * Every field is optional; see {@link DEFAULT_OPTIONS} for the defaults.
+ */
+interface PlantUmlPluginOptions {
+    /** Fenced-code languages treated as PlantUML. Matched case-insensitively. */
+    languages?: string[];
+    /** Diagram colour scheme. `auto` follows the Docusaurus light/dark colour mode. */
+    theme?: DiagramTheme;
+    /** Render a diagram only once it scrolls near the viewport. */
+    lazy?: boolean;
+    /** Where to cache rendered SVG output. */
+    cache?: CacheMode;
+    /** Sanitize rendered SVG before inserting it into the page. Disable at your own risk. */
+    sanitizeSvg?: boolean;
+    /** Include the PlantUML source in a `<details>` block when rendering fails. */
+    showSourceOnError?: boolean;
+    /** Abort a single render after this many milliseconds. */
+    renderTimeoutMs?: number;
+    /** Maximum number of cached SVG entries kept per browsing session. */
+    cacheMaxEntries?: number;
+    /** Docusaurus plugin instance id, used when the plugin is registered more than once. */
+    id?: string;
+}
+/** Plugin options after validation, with every default applied. */
+type ResolvedPlantUmlOptions = Required<Omit<PlantUmlPluginOptions, 'id' | 'languages'>> & {
+    /** Normalized to lower case; matching is case-insensitive. */
+    languages: string[];
+};
+declare const DEFAULT_OPTIONS: ResolvedPlantUmlOptions;
+/** Thrown for invalid plugin options so Docusaurus fails the build with a useful message. */
+declare class PlantUmlOptionsError extends Error {
+    constructor(message: string);
+}
+/**
+ * Validates raw plugin options and applies defaults.
+ *
+ * Unknown keys are rejected rather than ignored: a typo in `docusaurus.config.ts` would
+ * otherwise silently disable the option the author meant to set.
+ */
+declare function resolveOptions(rawOptions: unknown): ResolvedPlantUmlOptions;
+
+/**
+ * Identifiers shared by the Node-side plugin and the browser-side theme components.
+ *
+ * `PLUGIN_NAME` is the Docusaurus plugin name and therefore the key used for global data,
+ * so it must stay stable and identical on both sides of the SSR boundary. It is deliberately
+ * independent of the npm package name so that renaming the package cannot break global-data
+ * lookups in already-built sites.
+ */
+declare const PLUGIN_ID = "plantuml-client";
+declare const PLUGIN_NAME = "docusaurus-plugin-plantuml-client";
+
+/** Shape of the data this plugin publishes to the browser through Docusaurus global data. */
+interface PlantUmlGlobalData {
+    options: ResolvedPlantUmlOptions;
+    /** `baseUrl`-relative directory holding `viz-global.js` and `plantuml.js`. */
+    assetsDir: string;
+    /** Installed `@plantuml/core` version; part of the cache key. */
+    coreVersion: string;
+}
+/** One copy pattern per runtime file, shared by the webpack and Rspack code paths. */
+interface CopyPattern {
+    from: string;
+    to: string;
+    info: {
+        minimized: true;
+    };
+}
+/**
+ * Selects the copy plugin for the bundler in use.
+ *
+ * `currentBundler` only exists from Docusaurus 3.6, where Rspack support was added. On 3.5.x
+ * it is `undefined` and webpack is the only bundler, so an absent value is not an error.
+ */
+declare function createCopyPlugin(currentBundler: ConfigureWebpackUtils['currentBundler'] | undefined, patterns: CopyPattern[]): WebpackPluginInstance;
+declare function plantumlPlugin(_context: LoadContext, options?: PlantUmlPluginOptions): Plugin<void>;
+/**
+ * Docusaurus option validation hook. Runs before the plugin function so configuration
+ * mistakes fail the build immediately with an actionable message.
+ *
+ * Docusaurus relies on the returned options carrying a plugin instance `id`; it normally
+ * comes from the Joi helper's default, so opting out of Joi means supplying it here.
+ */
+declare function validateOptions({ options, }: {
+    options: PlantUmlPluginOptions & Partial<PluginOptions>;
+}): PlantUmlPluginOptions & PluginOptions;
+
+export { type CacheMode, DEFAULT_OPTIONS, type DiagramTheme, PLUGIN_ID, PLUGIN_NAME, type PlantUmlGlobalData, PlantUmlOptionsError, type PlantUmlPluginOptions, type ResolvedPlantUmlOptions, createCopyPlugin, plantumlPlugin as default, resolveOptions, validateOptions };

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+import type { ConfigureWebpackUtils, LoadContext, Plugin, PluginOptions as DocusaurusPluginOptions } from '@docusaurus/types';
+import type { WebpackPluginInstance } from 'webpack';
+import { type PlantUmlPluginOptions, type ResolvedPlantUmlOptions } from './options.js';
+export type { CacheMode, DiagramTheme, PlantUmlPluginOptions, ResolvedPlantUmlOptions, } from './options.js';
+export { DEFAULT_OPTIONS, PlantUmlOptionsError, resolveOptions } from './options.js';
+export { PLUGIN_ID, PLUGIN_NAME } from './constants.js';
+/** Shape of the data this plugin publishes to the browser through Docusaurus global data. */
+export interface PlantUmlGlobalData {
+    options: ResolvedPlantUmlOptions;
+    /** `baseUrl`-relative directory holding `viz-global.js` and `plantuml.js`. */
+    assetsDir: string;
+    /** Installed `@plantuml/core` version; part of the cache key. */
+    coreVersion: string;
+}
+/** One copy pattern per runtime file, shared by the webpack and Rspack code paths. */
+interface CopyPattern {
+    from: string;
+    to: string;
+    info: {
+        minimized: true;
+    };
+}
+/**
+ * Selects the copy plugin for the bundler in use.
+ *
+ * `currentBundler` only exists from Docusaurus 3.6, where Rspack support was added. On 3.5.x
+ * it is `undefined` and webpack is the only bundler, so an absent value is not an error.
+ */
+export declare function createCopyPlugin(currentBundler: ConfigureWebpackUtils['currentBundler'] | undefined, patterns: CopyPattern[]): WebpackPluginInstance;
+export default function plantumlPlugin(_context: LoadContext, options?: PlantUmlPluginOptions): Plugin<void>;
+/**
+ * Docusaurus option validation hook. Runs before the plugin function so configuration
+ * mistakes fail the build immediately with an actionable message.
+ *
+ * Docusaurus relies on the returned options carrying a plugin instance `id`; it normally
+ * comes from the Joi helper's default, so opting out of Joi means supplying it here.
+ */
+export declare function validateOptions({ options, }: {
+    options: PlantUmlPluginOptions & Partial<DocusaurusPluginOptions>;
+}): PlantUmlPluginOptions & DocusaurusPluginOptions;

package/dist/index.js

@@ -0,0 +1,74 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import CopyWebpackPlugin from 'copy-webpack-plugin';
+import { locatePlantUmlCore } from './assets.js';
+import { assetsDirForVersion, DEFAULT_PLUGIN_ID, PLUGIN_NAME } from './constants.js';
+import { resolveOptions, } from './options.js';
+export { DEFAULT_OPTIONS, PlantUmlOptionsError, resolveOptions } from './options.js';
+export { PLUGIN_ID, PLUGIN_NAME } from './constants.js';
+const currentDir = path.dirname(fileURLToPath(import.meta.url));
+/**
+ * Selects the copy plugin for the bundler in use.
+ *
+ * `currentBundler` only exists from Docusaurus 3.6, where Rspack support was added. On 3.5.x
+ * it is `undefined` and webpack is the only bundler, so an absent value is not an error.
+ */
+export function createCopyPlugin(currentBundler, patterns) {
+    if (currentBundler?.name === 'rspack') {
+        const { CopyRspackPlugin } = currentBundler.instance;
+        if (!CopyRspackPlugin) {
+            throw new Error(`[${PLUGIN_NAME}] The Rspack bundler is active but 'CopyRspackPlugin' is unavailable, ` +
+                'so the PlantUML runtime assets cannot be emitted. Upgrade @docusaurus/faster, or ' +
+                'disable `future.v4` to use the webpack bundler.');
+        }
+        return new CopyRspackPlugin({ patterns });
+    }
+    return new CopyWebpackPlugin({ patterns });
+}
+export default function plantumlPlugin(_context, options = {}) {
+    // Docusaurus already ran `validateOptions`, but the plugin function is also callable
+    // directly (and from JS configs that skip validation), so normalize defensively.
+    const resolved = resolveOptions(options);
+    const core = locatePlantUmlCore();
+    const assetsDir = assetsDirForVersion(core.version);
+    return {
+        name: PLUGIN_NAME,
+        getThemePath() {
+            return path.join(currentDir, 'theme');
+        },
+        contentLoaded({ actions }) {
+            const globalData = {
+                options: resolved,
+                assetsDir,
+                coreVersion: core.version,
+            };
+            actions.setGlobalData(globalData);
+        },
+        configureWebpack(_config, isServer, utils) {
+            // The PlantUML runtime is browser-only; emitting it from the server compilation
+            // would duplicate ~8 MB into the SSR bundle output for no benefit.
+            if (isServer) {
+                return {};
+            }
+            const patterns = core.files.map((absolutePath) => ({
+                from: absolutePath,
+                to: `${assetsDir}/[name][ext]`,
+                // These files are already minified upstream; re-processing 8 MB is wasted work.
+                info: { minimized: true },
+            }));
+            // Optional chaining, not laziness: `currentBundler` is absent on Docusaurus 3.5.x.
+            return { plugins: [createCopyPlugin(utils?.currentBundler, patterns)] };
+        },
+    };
+}
+/**
+ * Docusaurus option validation hook. Runs before the plugin function so configuration
+ * mistakes fail the build immediately with an actionable message.
+ *
+ * Docusaurus relies on the returned options carrying a plugin instance `id`; it normally
+ * comes from the Joi helper's default, so opting out of Joi means supplying it here.
+ */
+export function validateOptions({ options, }) {
+    resolveOptions(options);
+    return { ...options, id: options.id ?? DEFAULT_PLUGIN_ID };
+}

package/dist/options.d.ts

@@ -0,0 +1,46 @@
+/** Cache backing store for rendered SVG output. */
+export type CacheMode = 'none' | 'memory' | 'session';
+/** Which PlantUML colour scheme to render. `auto` follows the Docusaurus colour mode. */
+export type DiagramTheme = 'auto' | 'light' | 'dark';
+/**
+ * Options accepted by the plugin in `docusaurus.config.*`.
+ *
+ * Every field is optional; see {@link DEFAULT_OPTIONS} for the defaults.
+ */
+export interface PlantUmlPluginOptions {
+    /** Fenced-code languages treated as PlantUML. Matched case-insensitively. */
+    languages?: string[];
+    /** Diagram colour scheme. `auto` follows the Docusaurus light/dark colour mode. */
+    theme?: DiagramTheme;
+    /** Render a diagram only once it scrolls near the viewport. */
+    lazy?: boolean;
+    /** Where to cache rendered SVG output. */
+    cache?: CacheMode;
+    /** Sanitize rendered SVG before inserting it into the page. Disable at your own risk. */
+    sanitizeSvg?: boolean;
+    /** Include the PlantUML source in a `<details>` block when rendering fails. */
+    showSourceOnError?: boolean;
+    /** Abort a single render after this many milliseconds. */
+    renderTimeoutMs?: number;
+    /** Maximum number of cached SVG entries kept per browsing session. */
+    cacheMaxEntries?: number;
+    /** Docusaurus plugin instance id, used when the plugin is registered more than once. */
+    id?: string;
+}
+/** Plugin options after validation, with every default applied. */
+export type ResolvedPlantUmlOptions = Required<Omit<PlantUmlPluginOptions, 'id' | 'languages'>> & {
+    /** Normalized to lower case; matching is case-insensitive. */
+    languages: string[];
+};
+export declare const DEFAULT_OPTIONS: ResolvedPlantUmlOptions;
+/** Thrown for invalid plugin options so Docusaurus fails the build with a useful message. */
+export declare class PlantUmlOptionsError extends Error {
+    constructor(message: string);
+}
+/**
+ * Validates raw plugin options and applies defaults.
+ *
+ * Unknown keys are rejected rather than ignored: a typo in `docusaurus.config.ts` would
+ * otherwise silently disable the option the author meant to set.
+ */
+export declare function resolveOptions(rawOptions: unknown): ResolvedPlantUmlOptions;