@matfsw/docusaurus-plantuml-plugin 1.1.2 → 1.3.0

package/dist/stdlibShared.js

@@ -0,0 +1,54 @@
+/**
+ * What the Node side and the browser side of standard library support both need: the shape
+ * of the manifest, and the one definition of what a `<namespace/…>` include looks like.
+ *
+ * Deliberately free of `node:` imports. `stdlibBundle.ts` reads the file system and
+ * `stdlib.ts` resolves paths; neither may be pulled into a theme component's bundle, and
+ * keeping the shared half here is what stops that from happening by accident.
+ */
+/** Directory holding a namespace's includable examples, which upstream keeps in the bundle. */
+export const STDLIB_EXAMPLES_DIRECTORY = '_examples_';
+/**
+ * `<namespace/path>` in an `!include` and its variants.
+ *
+ * Anchored to the start of a line because `!include` is only a directive there. Applied to
+ * stdlib sources when bundling and to author sources when rendering — one syntax, one place
+ * to correct it.
+ */
+export const STDLIB_INCLUDE_PATTERN = /^[^\S\r\n]*!include(?:sub|url|_many)?[^\S\r\n]+<([^>\r\n]+)>/gim;
+/**
+ * Extracts the `<namespace/…>` includes of a PlantUML source.
+ *
+ * Includes whose path is computed (`!include <material2.1.19/$icon>`, as DomainStory does
+ * inside an `!if`) are skipped: the namespace is knowable but the file is not, so treating it
+ * as a hard dependency would make every DomainStory diagram drag in 6.8 MB of icons for a
+ * branch it will probably not take.
+ */
+export function findStdlibIncludes(source) {
+    const found = [];
+    const seen = new Set();
+    // `matchAll` on a shared global regex is safe: it clones the regex rather than advancing
+    // `lastIndex` on the original.
+    for (const match of source.matchAll(STDLIB_INCLUDE_PATTERN)) {
+        const raw = match[1]?.trim() ?? '';
+        if (raw.includes('$') || raw.includes('%'))
+            continue;
+        const slash = raw.indexOf('/');
+        if (slash <= 0)
+            continue;
+        const namespace = raw.slice(0, slash).toLowerCase();
+        const target = raw.slice(slash + 1).toLowerCase();
+        if (target === '')
+            continue;
+        const key = `${namespace}/${target}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        found.push({
+            namespace,
+            target,
+            fromExamples: target.startsWith(`${STDLIB_EXAMPLES_DIRECTORY}/`),
+        });
+    }
+    return found;
+}

package/dist/theme/MDXComponents/Code/index.js

@@ -29,7 +29,7 @@ export default function Code(props) {
     if (engine === null || source === null) {
         return _jsx(OriginalCode, { ...props });
     }
-    return (_jsx(PlantUmlDiagram, { source: source, title: parseTitle(props), language: language, engine: engine, layout: engine === 'graphviz' ? parseStringMeta(props, 'engine') : undefined, zoom: parseBooleanMeta(props, 'zoom') }));
+    return (_jsx(PlantUmlDiagram, { source: source, title: parseTitle(props), language: language, engine: engine, layout: engine === 'graphviz' ? parseStringMeta(props, 'engine') : undefined, zoom: parseBooleanMeta(props, 'zoom'), showSource: parseBooleanMeta(props, 'showSource') }));
 }
 /**
  * Decides which engine — if either — owns this fence.

package/dist/theme/PlantUmlDiagram/index.d.ts

@@ -19,6 +19,11 @@ export interface PlantUmlDiagramProps {
      * Set from the fence metastring: `zoom` or `zoom=false`.
      */
     zoom?: boolean;
+    /**
+     * Overrides the `showSource` plugin option for this diagram. `undefined` follows the option.
+     * Set from the fence metastring: `showSource` or `showSource=false`.
+     */
+    showSource?: boolean;
 }
 /**
  * Renders one diagram in the browser, with either engine.
@@ -30,4 +35,4 @@ export interface PlantUmlDiagramProps {
  * Nothing happens during server-side rendering: the markup emitted on the server is the
  * same deferred placeholder the client renders first, so hydration never mismatches.
  */
-export default function PlantUmlDiagram({ source, title, language, engine, layout, zoom: zoomProp, }: PlantUmlDiagramProps): ReactNode;
+export default function PlantUmlDiagram({ source, title, language, engine, layout, zoom: zoomProp, showSource: showSourceProp, }: PlantUmlDiagramProps): ReactNode;

package/dist/theme/PlantUmlDiagram/index.js

@@ -1,5 +1,5 @@
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useEffect, useId, useRef, useState } from 'react';
+import { useCallback, useEffect, useId, useRef, useState } from 'react';
 import { useColorMode } from '@docusaurus/theme-common';
 import { DATA_ATTR } from '../../constants.js';
 import { getSharedCache } from '../../runtime/cache.js';
@@ -19,6 +19,8 @@ const ENGINE_LABEL = {
 };
 /** Margin large enough that a diagram is usually ready by the time it is scrolled into view. */
 const LAZY_ROOT_MARGIN = '300px';
+/** How long the copy result stays on screen before the control goes quiet again. */
+const COPY_FEEDBACK_MS = 2_000;
 const INITIAL_STATE = { status: 'idle', svg: null, error: null };
 function escapeHtml(value) {
     return value
@@ -44,11 +46,12 @@ function messageFor(error) {
  * Nothing happens during server-side rendering: the markup emitted on the server is the
  * same deferred placeholder the client renders first, so hydration never mismatches.
  */
-export default function PlantUmlDiagram({ source, title, language, engine = 'plantuml', layout, zoom: zoomProp, }) {
+export default function PlantUmlDiagram({ source, title, language, engine = 'plantuml', layout, zoom: zoomProp, showSource: showSourceProp, }) {
     const config = usePlantUmlConfig();
     const { colorMode } = useColorMode();
     const containerRef = useRef(null);
     const hintId = useId();
+    const sourcePanelId = useId();
     const themeOption = config?.options.theme ?? 'auto';
     const dark = themeOption === 'auto' ? colorMode === 'dark' : themeOption === 'dark';
     const lazy = config?.options.lazy ?? true;
@@ -62,8 +65,39 @@ export default function PlantUmlDiagram({ source, title, language, engine = 'pla
     const renderDark = engine === 'graphviz' ? false : dark;
     // A fence flag wins over the plugin option, which in turn wins over the built-in default.
     const interactive = zoomProp ?? config?.options.zoom ?? true;
+    const sourceAvailable = showSourceProp ?? config?.options.showSource ?? true;
     const [state, setState] = useState(INITIAL_STATE);
     const [inView, setInView] = useState(!lazy);
+    const [sourceOpen, setSourceOpen] = useState(false);
+    const [copyState, setCopyState] = useState('idle');
+    const copyTimer = useRef(undefined);
+    // A pending "Copied" message must not fire into an unmounted component.
+    useEffect(() => () => clearTimeout(copyTimer.current), []);
+    /**
+     * Copies the source, and says whether it worked.
+     *
+     * `navigator.clipboard` is undefined outside a secure context, which a documentation site
+     * served over plain HTTP genuinely is. Reporting that plainly is better than a control that
+     * silently does nothing — the panel is open, so the reader can still select the text.
+     */
+    const copySource = useCallback(() => {
+        const settle = (next) => {
+            setCopyState(next);
+            clearTimeout(copyTimer.current);
+            copyTimer.current = setTimeout(() => setCopyState('idle'), COPY_FEEDBACK_MS);
+        };
+        const clipboard = typeof navigator === 'undefined' ? undefined : navigator.clipboard;
+        if (typeof clipboard?.writeText !== 'function') {
+            settle('failed');
+            return;
+        }
+        void clipboard.writeText(source).then(() => settle('copied'), () => settle('failed'));
+    }, [source]);
+    // A diagram whose source changed is a different diagram: an open panel would otherwise keep
+    // showing the old text's copy result, and the reader would have no idea it was stale.
+    useEffect(() => {
+        setCopyState('idle');
+    }, [source]);
     // Called unconditionally, as hooks must be; it attaches nothing when not interactive.
     const zoom = useZoomPan({
         enabled: interactive && state.status === 'ready',
@@ -136,7 +170,7 @@ export default function PlantUmlDiagram({ source, title, language, engine = 'pla
                 transparentBackground: options.graphviz.transparentBackground,
                 maxSourceBytes: options.graphviz.maxSourceBytes,
             })
-            : renderDiagram({ ...shared, dark: renderDark });
+            : renderDiagram({ ...shared, dark: renderDark, stdlib: config.stdlib });
         void pending
             .then((svg) => commit({ status: 'ready', svg, error: null }))
             .catch((error) => {
@@ -156,6 +190,7 @@ export default function PlantUmlDiagram({ source, title, language, engine = 'pla
         config,
         config?.assetsBaseUrl,
         config?.coreVersion,
+        config?.stdlib,
         config?.options.sanitizeSvg,
         config?.options.renderTimeoutMs,
         config?.options.cache,
@@ -167,16 +202,29 @@ export default function PlantUmlDiagram({ source, title, language, engine = 'pla
     const busy = state.status === 'loading' || state.status === 'rendering';
     // The sanitized SVG always lives in this element, zoomable or not, so `role="img" > svg`
     // stays a stable contract for tests and for author CSS.
-    const canvas = state.svg !== null && (_jsx("div", { className: styles.canvas, role: "img", "aria-label": label, 
+    const canvas = state.svg !== null && (_jsx("div", { className: !interactive && sourceOpen ? `${styles.canvas} ${styles.hiddenView}` : styles.canvas, role: "img", "aria-label": label, 
         // Sanitized above unless `sanitizeSvg: false` was explicitly opted into.
         dangerouslySetInnerHTML: { __html: state.svg } }));
+    const copyControl = sourceAvailable && sourceOpen && state.status === 'ready' && (_jsx("button", { type: "button", className: `${styles.toolbarButton} ${styles.toolbarTextButton}`, "aria-label": `Copy ${engineName} source to clipboard`, onClick: copySource, children: "Copy" }));
+    const sourceToggle = sourceAvailable && (_jsx("button", { type: "button", className: styles.toolbarButton, "aria-label": sourceOpen ? 'Hide diagram source' : 'Show diagram source', "aria-expanded": sourceOpen, "aria-controls": sourcePanelId, onClick: () => setSourceOpen((open) => !open), children: _jsx("span", { "aria-hidden": "true", children: '</>' }) }));
+    /**
+     * The source *replaces the diagram in its own frame* rather than appearing beneath it.
+     *
+     * Below the diagram it had two failure modes that the frame removes by construction: a
+     * diagram taller than the window pushed the panel off-screen, so the control looked broken;
+     * and while maximized the panel was painted behind the `position: fixed` overlay, so it was
+     * invisible however far you scrolled. Living in the same box as the picture, it is visible
+     * exactly when and where the picture was.
+     */
+    const sourceView = sourceAvailable && sourceOpen && state.status === 'ready' && (_jsxs("div", { className: styles.sourceView, id: sourcePanelId, children: [_jsxs("div", { className: styles.sourceViewBar, children: [_jsxs("span", { className: styles.sourceViewTitle, children: [engineName, " source"] }), _jsxs("span", { className: styles.copyStatus, role: "status", children: [copyState === 'copied' ? 'Copied to clipboard' : null, copyState === 'failed' ? 'Could not copy — select the text instead' : null] })] }), _jsx("pre", { className: styles.sourceCode, children: source })] }));
     return (_jsxs("figure", { ref: containerRef, className: styles.figure, "aria-busy": busy || undefined, [DATA_ATTR.diagram]: language ?? engine,
         [DATA_ATTR.engine]: engine,
         ...(engine === 'graphviz' ? { [DATA_ATTR.layout]: resolvedLayout } : {}),
         [DATA_ATTR.status]: state.status,
         [DATA_ATTR.theme]: dark ? 'dark' : 'light',
         ...(interactive ? { [DATA_ATTR.interactive]: 'true' } : {}),
-        ...(zoom.maximized ? { [DATA_ATTR.maximized]: 'true' } : {}), children: [state.status === 'ready' && state.svg !== null && !interactive && canvas, state.status === 'ready' && state.svg !== null && interactive && (_jsxs("div", { ref: zoom.stageRef, className: zoom.maximized ? `${styles.stage} ${styles.maximized}` : styles.stage, children: [_jsx("div", { ref: zoom.viewportRef, className: styles.viewport, tabIndex: 0, "aria-describedby": hintId, "aria-keyshortcuts": "Plus Minus 0 ArrowUp ArrowDown ArrowLeft ArrowRight", onKeyDown: zoom.onKeyDown, [DATA_ATTR.zoom]: '1', children: _jsx("div", { ref: zoom.layerRef, className: styles.layer, children: canvas }) }), _jsxs("div", { className: styles.toolbar, role: "group", "aria-label": `${label} zoom controls`, children: [_jsx("button", { type: "button", className: styles.toolbarButton, "aria-label": "Zoom out", onClick: zoom.zoomOut, children: _jsx("span", { "aria-hidden": "true", children: "\u2212" }) }), _jsx("button", { type: "button", className: styles.toolbarButton, "aria-label": "Zoom in", onClick: zoom.zoomIn, children: _jsx("span", { "aria-hidden": "true", children: "+" }) }), _jsx("button", { type: "button", className: styles.toolbarButton, "aria-label": "Reset zoom", onClick: zoom.reset, children: _jsx("span", { "aria-hidden": "true", children: "\u27F2" }) }), _jsx("button", { type: "button", className: styles.toolbarButton, "aria-label": "Maximize diagram", "aria-pressed": zoom.maximized, onClick: zoom.toggleMaximize, children: _jsx("span", { "aria-hidden": "true", children: zoom.maximized ? '✕' : '⛶' }) }), _jsx("span", { ref: zoom.readoutRef, className: styles.readout, "aria-hidden": "true", children: "100%" })] })] })), state.status === 'ready' && state.svg !== null && interactive && (_jsx("p", { id: hintId, className: styles.visuallyHidden, children: "Zoomable diagram. Use the zoom controls, or press plus and minus to zoom, the arrow keys to pan, and zero to reset." })), state.status !== 'ready' && state.status !== 'error' && (
+        ...(zoom.maximized ? { [DATA_ATTR.maximized]: 'true' } : {}),
+        ...(sourceOpen ? { [DATA_ATTR.sourceOpen]: 'true' } : {}), children: [state.status === 'ready' && state.svg !== null && !interactive && canvas, state.status === 'ready' && state.svg !== null && !interactive && sourceView, state.status === 'ready' && state.svg !== null && !interactive && sourceAvailable && (_jsxs("div", { className: styles.plainToolbar, role: "group", "aria-label": `${label} source controls`, children: [sourceToggle, copyControl] })), state.status === 'ready' && state.svg !== null && interactive && (_jsxs("div", { ref: zoom.stageRef, className: zoom.maximized ? `${styles.stage} ${styles.maximized}` : styles.stage, children: [_jsxs("div", { className: styles.stageBody, children: [_jsx("div", { ref: zoom.viewportRef, className: sourceOpen ? `${styles.viewport} ${styles.invisibleView}` : styles.viewport, tabIndex: sourceOpen ? -1 : 0, "aria-describedby": hintId, "aria-keyshortcuts": "Plus Minus 0 ArrowUp ArrowDown ArrowLeft ArrowRight", onKeyDown: zoom.onKeyDown, [DATA_ATTR.zoom]: '1', children: _jsx("div", { ref: zoom.layerRef, className: styles.layer, children: canvas }) }), sourceView] }), _jsxs("div", { className: styles.toolbar, role: "group", "aria-label": `${label} zoom controls`, children: [!sourceOpen && (_jsx("button", { type: "button", className: styles.toolbarButton, "aria-label": "Zoom out", onClick: zoom.zoomOut, children: _jsx("span", { "aria-hidden": "true", children: "\u2212" }) })), !sourceOpen && (_jsx("button", { type: "button", className: styles.toolbarButton, "aria-label": "Zoom in", onClick: zoom.zoomIn, children: _jsx("span", { "aria-hidden": "true", children: "+" }) })), !sourceOpen && (_jsx("button", { type: "button", className: styles.toolbarButton, "aria-label": "Reset zoom", onClick: zoom.reset, children: _jsx("span", { "aria-hidden": "true", children: "\u27F2" }) })), _jsx("button", { type: "button", className: styles.toolbarButton, "aria-label": "Maximize diagram", "aria-pressed": zoom.maximized, onClick: zoom.toggleMaximize, children: _jsx("span", { "aria-hidden": "true", children: zoom.maximized ? '✕' : '⛶' }) }), sourceToggle, copyControl, _jsx("span", { ref: zoom.readoutRef, className: sourceOpen ? `${styles.readout} ${styles.hiddenView}` : styles.readout, "aria-hidden": "true", children: "100%" })] })] })), state.status === 'ready' && state.svg !== null && interactive && (_jsx("p", { id: hintId, className: styles.visuallyHidden, children: "Zoomable diagram. Use the zoom controls, or press plus and minus to zoom, the arrow keys to pan, and zero to reset." })), state.status !== 'ready' && state.status !== 'error' && (
             // `aria-busy` on the figure already conveys progress; announcing every phase change
             // would make a page with several diagrams unusable with a screen reader.
             _jsxs("div", { className: styles.placeholder, children: [_jsx("span", { className: styles.spinner, "aria-hidden": "true" }), _jsxs("span", { children: [state.status === 'loading' ? `Loading ${engineName} runtime…` : null, state.status === 'rendering' ? `Rendering ${label}…` : null, state.status === 'idle' ? `${label} (waiting to render)` : null] })] })), state.status === 'error' && (_jsxs("div", { className: styles.error, role: "alert", children: [_jsxs("p", { className: styles.errorHeading, children: [_jsx("span", { className: styles.errorIcon, "aria-hidden": "true", children: "\u26A0" }), _jsxs("span", { children: ["Error: ", engineName, " diagram could not be rendered"] })] }), _jsx("pre", { className: styles.errorMessage, children: state.error }), config?.options.showSourceOnError !== false && (_jsxs("details", { className: styles.errorDetails, children: [_jsx("summary", { children: "Show diagram source" }), _jsx("pre", { className: styles.source, children: source })] }))] })), title !== undefined && _jsx("figcaption", { className: styles.caption, children: title }), _jsx("noscript", { dangerouslySetInnerHTML: {

package/dist/theme/PlantUmlDiagram/styles.module.css

@@ -291,3 +291,120 @@
   overflow-x: auto;
   font-size: 0.8125rem;
 }
+
+/*
+ * Source view.
+ *
+ * The source takes the diagram's place inside the same frame rather than appearing beneath it.
+ * Below the diagram it had two failure modes this removes by construction: a diagram taller
+ * than the window pushed it off-screen, and while maximized it was painted behind the
+ * `position: fixed` overlay. In the frame it is visible exactly where the picture was.
+ */
+
+/* One grid cell shared by the viewport and the source view, so they occupy the same box. */
+.stageBody {
+  position: relative;
+  display: grid;
+}
+
+.stageBody > * {
+  grid-area: 1 / 1;
+  /* Without this a wide <pre> would stretch the grid column instead of scrolling. */
+  min-width: 0;
+}
+
+/*
+ * `visibility`, not `display`: the hidden viewport keeps contributing its height, so the frame
+ * does not resize when flipping, and the zoom hook's layout measurements stay valid for the
+ * flip back. A `visibility: hidden` subtree is also not focusable and takes no pointer events,
+ * so the invisible diagram cannot be tabbed into or dragged.
+ */
+.invisibleView {
+  visibility: hidden;
+}
+
+/* Collapses entirely — used where there is no frame height worth preserving. */
+.hiddenView {
+  display: none;
+}
+
+/*
+ * Inside a zoom frame the source is taken out of flow so that it cannot size the grid row: the
+ * row stays exactly as tall as the (hidden but still laid-out) viewport, and a long source
+ * scrolls within it. Left in flow it grew the frame from the diagram's height to the source's —
+ * on a long diagram that pushed the text back off the bottom of the window, which is the very
+ * problem moving it into the frame was meant to solve.
+ */
+.stageBody .sourceView {
+  position: absolute;
+  inset: 0;
+}
+
+.sourceView {
+  display: flex;
+  flex-direction: column;
+  min-height: 0;
+  border: 1px solid var(--ifm-color-emphasis-300);
+  border-radius: var(--ifm-global-radius);
+  background: var(--ifm-background-surface-color);
+  overflow: hidden;
+}
+
+.sourceViewBar {
+  display: flex;
+  align-items: center;
+  flex-wrap: wrap;
+  gap: 0.5rem;
+  /* Clears the toolbar, which floats over the top-right of the same frame. */
+  padding: 0.5rem 12rem 0.25rem 0.75rem;
+}
+
+.sourceViewTitle {
+  color: var(--ifm-color-emphasis-700);
+  font-size: 0.8125rem;
+  font-weight: 600;
+}
+
+.copyStatus {
+  flex: 1;
+  color: var(--ifm-color-emphasis-700);
+  font-size: 0.75rem;
+  text-align: right;
+}
+
+/*
+ * The copy control is a toolbar button like the rest, just carrying a word instead of a glyph,
+ * so it needs width where the icon buttons are square.
+ */
+.toolbarTextButton {
+  width: auto;
+  padding: 0 0.5rem;
+  font-size: 0.8125rem;
+}
+
+.sourceCode {
+  flex: 1;
+  min-height: 0;
+  margin: 0;
+  padding: 0.75rem;
+  overflow: auto;
+  background: transparent;
+  font-size: 0.8125rem;
+  /* Wraps rather than scrolls sideways: diagram source is read, not just copied. */
+  white-space: pre-wrap;
+  word-break: break-word;
+}
+
+/*
+ * Without a zoom frame the source has no box to fill, so it needs a floor of its own — and a
+ * ceiling, so a long diagram cannot produce an endless wall of text.
+ */
+.figure:not([data-plantuml-interactive]) .sourceView {
+  max-height: 30rem;
+}
+
+.plainToolbar {
+  display: flex;
+  justify-content: flex-end;
+  margin-top: 0.25rem;
+}

package/dist/theme/usePlantUmlConfig.d.ts

@@ -1,9 +1,17 @@
 import { type ResolvedPlantUmlOptions } from '../options.js';
+import type { StdlibRuntimeManifest } from '../stdlibShared.js';
+/** The standard library as the browser sees it: a URL to fetch bundles from, and an index. */
+export interface StdlibRuntimeConfig {
+    baseUrl: string;
+    manifest: StdlibRuntimeManifest;
+}
 export interface PlantUmlRuntimeConfig {
     options: ResolvedPlantUmlOptions;
     /** Absolute, `baseUrl`-prefixed URL of the directory holding the runtime assets. */
     assetsBaseUrl: string;
     coreVersion: string;
+    /** `null` when the standard library is switched off for this site. */
+    stdlib: StdlibRuntimeConfig | null;
 }
 /**
  * Reads the plugin's configuration from Docusaurus global data.

package/dist/theme/usePlantUmlConfig.js

@@ -2,7 +2,7 @@ import { useMemo } from 'react';
 import useBaseUrl from '@docusaurus/useBaseUrl';
 import { useAllPluginInstancesData } from '@docusaurus/useGlobalData';
 import { PLUGIN_NAME } from '../constants.js';
-import { DEFAULT_GRAPHVIZ_OPTIONS } from '../options.js';
+import { DEFAULT_GRAPHVIZ_OPTIONS, DEFAULT_STDLIB_OPTIONS, } from '../options.js';
 function isGlobalData(value) {
     if (typeof value !== 'object' || value === null)
         return false;
@@ -23,26 +23,32 @@ export function usePlantUmlConfig() {
     const first = instances ? Object.values(instances).find(isGlobalData) : undefined;
     // `useBaseUrl` must be called unconditionally; the placeholder path is discarded below.
     const assetsBaseUrl = useBaseUrl(first ? first.assetsDir : '/');
+    const stdlibBaseUrl = useBaseUrl(first?.stdlib ? first.stdlib.dir : '/');
     // Memoized because consumers use this object as an effect dependency. Returning a fresh
     // object on every render would restart the render effect on every state update, which
     // re-enters rendering forever.
     return useMemo(() => first
         ? {
-            options: withGraphvizDefaults(first.options),
+            options: withDefaults(first.options),
             assetsBaseUrl,
             coreVersion: first.coreVersion,
+            stdlib: first.stdlib ? { baseUrl: stdlibBaseUrl, manifest: first.stdlib.manifest } : null,
         }
-        : null, [first, assetsBaseUrl]);
+        : null, [first, assetsBaseUrl, stdlibBaseUrl]);
 }
 /**
- * Fills in the `graphviz` group when it is missing from global data.
+ * Fills in the nested option groups when they are missing from global data.
  *
- * `resolveOptions` always produces it, so this only matters for data written by an older
+ * `resolveOptions` always produces them, so this only matters for data written by an older
  * version of the plugin — a stale `.docusaurus` cache surviving an upgrade, most plausibly.
  * Substituting the defaults keeps such a site rendering instead of failing on a missing key.
  */
-function withGraphvizDefaults(options) {
-    if (options.graphviz)
+function withDefaults(options) {
+    if (options.graphviz && options.stdlib)
         return options;
-    return { ...options, graphviz: DEFAULT_GRAPHVIZ_OPTIONS };
+    return {
+        ...options,
+        graphviz: options.graphviz ?? DEFAULT_GRAPHVIZ_OPTIONS,
+        stdlib: options.stdlib ?? DEFAULT_STDLIB_OPTIONS,
+    };
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@matfsw/docusaurus-plantuml-plugin",
-  "version": "1.1.2",
+  "version": "1.3.0",
   "description": "Render PlantUML diagrams in Docusaurus 3 entirely in the browser - no Java, no PlantUML server, no CDN.",
   "keywords": [
     "docusaurus",
@@ -35,6 +35,7 @@
     "./package.json": "./package.json"
   },
   "files": [
+    "assets",
     "dist",
     "README.md",
     "LICENSE",
@@ -62,6 +63,7 @@
     "verify:tag": "node scripts/verify-tag-version.mjs",
     "sync:meta": "node scripts/sync-project-metadata.mjs",
     "sync:check": "node scripts/sync-project-metadata.mjs --check",
+    "stdlib:update": "node scripts/update-stdlib.mjs",
     "example:install": "npm --prefix examples/docusaurus install",
     "example:build": "npm --prefix examples/docusaurus run build",
     "example:serve": "npm --prefix examples/docusaurus run serve",