@plannotator/ui 0.40.0 → 0.41.1

package/utils/graphviz.ts

@@ -0,0 +1,93 @@
+/**
+ * Graphviz runtime slot — the same shape as `./mermaid`, one per engine so
+ * a host fills either independently.
+ *
+ * ONE code path feeds the renderer slot (`./diagram-render`):
+ * `loadGraphvizRuntime()`. It resolves at once from a filled slot and
+ * otherwise imports the engine lazily: `@viz-js/viz` (about 1.2 MB of
+ * Emscripten JS with the wasm inlined) is fetched on the first dot fence, a
+ * failed import is dropped from the memo so the next call issues a fresh
+ * `import()`, and the block re-attempts once and offers Retry. In
+ * Plannotator's single-file builds the import is inlined and resolves from
+ * the bundle; a host that bundles by route fetches it on demand.
+ *
+ * This module has NO static import of `@viz-js/viz`; the only place the
+ * dependency is named at runtime is the default loader's `import()`.
+ */
+import type { Viz } from '@viz-js/viz';
+
+export type GraphvizRuntime = Viz;
+
+/** Who filled the slot. */
+export type GraphvizRuntimeSource = 'loader' | 'host';
+
+export type GraphvizRuntimeLoader = () => Promise<Viz>;
+
+/** Default lazy loader: import the engine and instantiate its wasm once. */
+const defaultGraphvizLoader: GraphvizRuntimeLoader = () => import('@viz-js/viz').then((m) => m.instance());
+
+let runtime: Viz | null = null;
+let runtimeSource: GraphvizRuntimeSource | null = null;
+let loader: GraphvizRuntimeLoader = defaultGraphvizLoader;
+let pending: Promise<Viz> | null = null;
+
+/** Delay before the one automatic re-attempt after a failed lazy import. */
+let retryDelayMs = 750;
+
+/** Current runtime, or `null` while the slot is empty. */
+export function getGraphvizRuntime(): Viz | null {
+  return runtime;
+}
+
+/** How the current runtime was registered, or `null` while the slot is empty. */
+export function getGraphvizRuntimeSource(): GraphvizRuntimeSource | null {
+  return runtimeSource;
+}
+
+/** Register an already-instantiated engine (a host with its own import). */
+export function setGraphvizRuntime(next: Viz, source: GraphvizRuntimeSource = 'host'): void {
+  runtime = next;
+  runtimeSource = source;
+  pending = null;
+}
+
+/** The renderer's retry delay for the lazy path. */
+export function getGraphvizRetryDelayMs(): number {
+  return retryDelayMs;
+}
+
+/**
+ * Resolve the engine: at once from a filled slot, otherwise through the
+ * loader. A rejected load is dropped from the memo so the next call (the
+ * automatic re-attempt, a later mount, or the Retry button) issues a fresh
+ * `import()` instead of replaying the cached rejection.
+ */
+export function loadGraphvizRuntime(): Promise<Viz> {
+  if (runtime) return Promise.resolve(runtime);
+  if (!pending) {
+    const attempt = loader().then(
+      (loaded) => {
+        setGraphvizRuntime(loaded, 'loader');
+        return loaded;
+      },
+      (err: unknown) => {
+        if (pending === attempt) pending = null;
+        throw err;
+      },
+    );
+    pending = attempt;
+  }
+  return pending;
+}
+
+/** Test hook: empty the slot, stand in for the lazy import, shorten the retry delay. */
+export function __setGraphvizRuntimeLoaderForTests(
+  next: GraphvizRuntimeLoader | undefined,
+  options?: { retryDelayMs?: number },
+): void {
+  runtime = null;
+  runtimeSource = null;
+  pending = null;
+  loader = next ?? defaultGraphvizLoader;
+  retryDelayMs = options?.retryDelayMs ?? 750;
+}

package/utils/parser.ts

@@ -1,6 +1,7 @@
 import type { Block, Annotation, CodeAnnotation, EditorAnnotation, ImageAttachment } from '../types';
 import { planDenyFeedback } from '@plannotator/core/feedback-templates';
 import { resolveReplyParents } from '@plannotator/core/annotation-threads';
+import { diagramAnchorLocationLine, parseDiagramAnchor } from '@plannotator/core/diagram-anchor';
 import { skillReferenceExportBlock } from './skillReferences';
 
 /**
@@ -1249,7 +1250,7 @@ export const exportAnnotationEntry = (ann: any, opts: ElementContextExportOption
         output += `[${ann.text}] ${commentHeadingLine(ann)}\n`;
         if (ann.quickLabelTip) output += `> ${ann.quickLabelTip}\n`;
       } else {
-        output += `${commentHeadingLine(ann)}\n> ${ann?.text ?? ''}\n`;
+        output += `${commentHeadingLine(ann)}\n${diagramLocationExportLine(ann)}> ${ann?.text ?? ''}\n`;
       }
   }
   const resolvedOpts: ElementContextExportOptions = {
@@ -1267,6 +1268,16 @@ export const exportAnnotationEntry = (ann: any, opts: ElementContextExportOption
   return output;
 };
 
+/** The location line under a comment made on a rendered diagram part:
+ *  `Diagram node Approve? (D), line 4` — the part's own id (what the agent
+ *  greps the fence for) and the DOCUMENT line that declares it. Emits
+ *  nothing for every other annotation, keeping their output byte-identical;
+ *  a malformed anchor (an older or foreign writer) is skipped, never thrown. */
+const diagramLocationExportLine = (ann: any): string => {
+  const anchor = ann?.diagramAnchor === undefined ? null : parseDiagramAnchor(ann.diagramAnchor);
+  return anchor === null ? '' : `${safeInline(diagramAnchorLocationLine(anchor), 600)}\n`;
+};
+
 const lineLabelForAnnotation = (blocks: Block[], ann: any): string | null => {
   if (!ann.blockId || ann.type === 'GLOBAL_COMMENT') return null;
   if (typeof ann.blockId === 'string' && ann.blockId.startsWith('diff-block-')) return null;
@@ -1435,11 +1446,13 @@ export const exportAnnotations = (
       case 'COMMENT':
         if (ann.isQuickLabel) {
           output += `[${ann.text}] ${commentHeadingLine(ann)}\n`;
+          output += diagramLocationExportLine(ann);
           if (ann.quickLabelTip) {
             output += `> ${ann.quickLabelTip}\n`;
           }
         } else {
           output += `${commentHeadingLine(ann)}\n`;
+          output += diagramLocationExportLine(ann);
           output += `> ${ann.text}\n`;
         }
         break;
@@ -1554,6 +1567,7 @@ export const exportLinkedDocAnnotations = (
 
         case 'COMMENT':
           output += `${commentHeadingLine(ann)}\n`;
+          output += diagramLocationExportLine(ann);
           output += `> ${ann.text}\n`;
           break;
 

package/components/mermaidSvg.ts

@@ -1,33 +0,0 @@
-// Pure SVG-markup helpers for MermaidBlock. Kept free of React and the
-// mermaid library so they can be unit-tested without loading mermaid's
-// browser-only `initialize()` (which throws in headless test environments).
-
-// Bake sizing attrs into the SVG markup so they survive repeated
-// dangerouslySetInnerHTML re-injection — imperative setAttribute gets wiped.
-export function normalizeMermaidSvgMarkup(markup: string): string {
-  return markup.replace(/<svg\b([^>]*)>/i, (_match, attrs: string) => {
-    let next = attrs;
-
-    if (/\bstyle\s*=\s*"/i.test(next)) {
-      next = next.replace(/\bstyle\s*=\s*"([^"]*)"/i, (_m, styleVal: string) => {
-        const rules = styleVal
-          .split(';')
-          .map((s) => s.trim())
-          .filter((s) => s.length > 0 && !/^max-width\s*:/i.test(s));
-        rules.push('max-width: none');
-        return `style="${rules.join('; ')}"`;
-      });
-    } else {
-      next += ' style="max-width: none"';
-    }
-
-    if (!/\bpreserveAspectRatio\s*=/i.test(next)) {
-      next += ' preserveAspectRatio="xMidYMid meet"';
-    }
-    if (!/\bheight\s*=/i.test(next)) {
-      next += ' height="100%"';
-    }
-
-    return `<svg${next}>`;
-  });
-}