ui: full-screen diagram preview that zooms around what is on screen, inert diagrams (#32591)

* ui: keep Pele diagrams inert

Pele turns a node with `click ... href` into a live link, where Mermaid's
strict security level left diagrams without links. Unwrap every link in
Pele's output, keeping its children, so the inline block, the live-preview
editor, the preview dialog and the downloaded svg stay inert. The Diagrams
story's flowchart now carries click directives and its play test checks
that no link or href is left.

Assisted-by: Claude (Opus 5.5 Medium)

* ui: open diagrams full screen, zoom around what is on screen

The diagram preview dialog fills the window on every device. The preview
places the diagram from its top left corner, so a zoom keeps a screen point
fixed: the wheel and a trackpad pinch zoom around the pointer, the buttons
and +/- keys around the middle of the screen, wherever the diagram has been
panned to. Two-finger pinch, double-click and arrow keys work too. The
diagram opens fitted and keeps fitting until panned or zoomed; Reset view
fits it again.

Adds MermaidPreview and DialogMermaidPreview stories with play tests and a
unit test for the zoom math.

Assisted-by: Claude (Opus 5.5 Medium)

* ui: add a diagrams trace to the demo fixtures

Assisted-by: Claude (Opus 5.5 Medium)
This commit is contained in:
Aleksander Grygier authored and GitHub committed 2026-11-20 09:57:44 +01:00
1 parent 4c4a0f0a42
commit 55b8d8d898
14 files changed
+673 -87

No files matched your search

+30
View File
@@ -301,9 +301,39 @@ function agenticDebugging(): Trace {
return trace;
}
/** A reply with a diagram, for diagram preview demos. */
function diagrams(): Trace {
const trace = new Trace('How a request flows through llama-server');
trace.user('Can you draw how a chat request flows through llama-server?');
trace.assistant(
[
'Here is the path a request takes:',
'',
'```mermaid',
'flowchart LR',
' U[Browser] -->|POST /v1/chat/completions| S(llama-server)',
' S --> Q{Slot free?}',
' Q -->|yes| P[Prompt processing]',
' Q -->|no| W[Queue]',
' W --> P',
' P --> G[Sample token]',
' G -->|more| G',
' G -->|SSE tokens| U',
' click S href "https://github.com/ggml-org/llama.cpp" "llama.cpp on GitHub" _blank',
'```',
'',
'Requests wait in the queue until a slot is free, then tokens stream back as they are sampled.'
].join('\n')
);
return trace;
}
/** Built-in traces, by name. */
export const DEMO_TRACES: Record<string, () => Trace> = {
'agentic-debugging': agenticDebugging,
diagrams,
'long-chat': longChat
};
@@ -43,6 +43,13 @@ function diagramWidth(node: HTMLElement): number | undefined {
return width > 0 ? width : undefined;
}
// Pele wraps a node with a `click ... href` directive in a link. Diagrams come from model
// output, so they stay inert, as they were under Mermaid's strict security level: each link
// gives way to its children. The preview dialog and the downloaded file copy this svg.
function unwrapLinks(root: HTMLElement) {
for (const link of root.querySelectorAll('a')) link.replaceWith(...link.childNodes);
}
/**
* Renders the mermaid diagrams in `container` that haven't been rendered yet, with Pele.
* Marks nodes immediately to prevent duplicate renders during streaming. Colors come
@@ -77,6 +84,7 @@ export async function renderMermaidDiagrams(container: HTMLElement) {
});
node.innerHTML = svg;
unwrapLinks(node);
} catch (error) {
// the message quotes the diagram source, so it goes in as text
const message = document.createElement('div');
@@ -1,7 +1,16 @@
<script lang="ts">
import MermaidPreviewControls from './MermaidPreviewControls.svelte';
import { SVG } from '#lib/constants/index.ts';
import {
DIAGRAM_ZOOM_FACTOR,
type DiagramView,
fitView,
wheelZoomFactor,
zoomAt,
zoomAtCenter
} from '#lib/utils/diagram-viewport.ts';
import { mountSvgShadow } from '#lib/utils/svg-shadow.ts';
import { SvelteMap } from 'svelte/reactivity';
interface Props {
svgHtml: string;
@@ -9,61 +18,105 @@
let { svgHtml }: Props = $props();
// room kept clear around a fitted diagram, and below it for the controls
const FIT_PADDING_PX = 24;
const CONTROLS_SPACE_PX = 96;
// how far an arrow key pans, and with Shift held
const PAN_STEP_PX = 48;
const PAN_STEP_LARGE_PX = 192;
let viewport = $state<HTMLDivElement | null>(null);
let diagram = $state<HTMLDivElement | null>(null);
let svgHost = $state<HTMLDivElement | null>(null);
let view = $state<DiagramView>({ scale: 1, x: 0, y: 0 });
// Until the user pans or zooms, the diagram keeps fitting the viewport: as the window
// resizes, and as a streaming svg grows
let touched = $state(false);
let fitted = $state(false);
// Pointers down on the viewport: one pans, two pinch
const pointers = new SvelteMap<number, { x: number; y: number }>();
let isDragging = $state(false);
// Re-mount on every svgHtml change so a live streaming svg keeps rendering while zoomed
$effect(() => {
if (svgHost) mountSvgShadow(svgHost, svgHtml, SVG.DIALOG_SHADOW_STYLE);
});
// Zoom and pan state
let scale = $state(1);
let translateX = $state(0);
let translateY = $state(0);
let isDragging = $state(false);
const containerRef = { current: null as HTMLDivElement | null };
function viewportSize() {
return { height: viewport?.clientHeight ?? 0, width: viewport?.clientWidth ?? 0 };
}
// Drag start position
let dragStartX = 0;
let dragStartY = 0;
let dragStartTranslateX = 0;
let dragStartTranslateY = 0;
function fit() {
if (!viewport || !diagram) return;
const MIN_SCALE = 0.1;
const MAX_SCALE = 10;
const ZOOM_STEP = 0.15;
const { height, width } = viewportSize();
const content = { height: diagram.offsetHeight, width: diagram.offsetWidth };
if (!width || !height || !content.width || !content.height) return;
view = fitView(
content,
{ height: Math.max(height - CONTROLS_SPACE_PX, 0), width },
FIT_PADDING_PX
);
fitted = true;
}
$effect(() => {
if (!viewport || !diagram) return;
const observer = new ResizeObserver(() => {
if (!touched) fit();
});
observer.observe(viewport);
observer.observe(diagram);
return () => observer.disconnect();
});
function setView(next: DiagramView) {
view = next;
touched = true;
}
function resetView() {
scale = 1;
translateX = 0;
translateY = 0;
touched = false;
fit();
}
function zoomIn() {
scale = Math.min(scale + ZOOM_STEP, MAX_SCALE);
function zoomBy(factor: number) {
setView(zoomAtCenter(view, factor, viewportSize()));
}
function zoomOut() {
scale = Math.max(scale - ZOOM_STEP, MIN_SCALE);
// a point of the page in the viewport's own coordinates
function localPoint(clientX: number, clientY: number) {
const rect = viewport!.getBoundingClientRect();
return { x: clientX - rect.left, y: clientY - rect.top };
}
function handleWheel(event: WheelEvent) {
event.preventDefault();
const delta = event.deltaY > 0 ? -ZOOM_STEP : ZOOM_STEP;
scale = Math.min(Math.max(scale + delta, MIN_SCALE), MAX_SCALE);
function isOnControls(target: EventTarget | null) {
return target instanceof Element && Boolean(target.closest('.mermaid-preview-controls'));
}
// Imperatively attach a non-passive wheel listener so preventDefault() actually works
// (Svelte 5 wheel listeners are passive by default, making preventDefault() a no-op)
// Attached imperatively: Svelte's wheel listeners are passive, so preventDefault() would
// not stop the page (or a pinch, the browser) from zooming
$effect(() => {
const el = containerRef.current;
const el = viewport;
if (!el) return;
function onWheel(e: WheelEvent) {
handleWheel(e);
function onWheel(event: WheelEvent) {
if (isOnControls(event.target)) return;
event.preventDefault();
const point = localPoint(event.clientX, event.clientY);
setView(zoomAt(view, wheelZoomFactor(event), point.x, point.y));
}
el.addEventListener('wheel', onWheel, { passive: false });
@@ -72,53 +125,137 @@
});
function handlePointerDown(event: PointerEvent) {
if (event.button !== 0 && event.pointerType === 'mouse') return;
if (event.pointerType === 'mouse' && event.button !== 0) return;
if (isOnControls(event.target)) return;
pointers.set(event.pointerId, { x: event.clientX, y: event.clientY });
isDragging = true;
dragStartX = event.clientX;
dragStartY = event.clientY;
dragStartTranslateX = translateX;
dragStartTranslateY = translateY;
(event.currentTarget as HTMLElement).setPointerCapture(event.pointerId);
viewport?.setPointerCapture(event.pointerId);
}
function handlePointerMove(event: PointerEvent) {
if (!isDragging) return;
const last = pointers.get(event.pointerId);
translateX = dragStartTranslateX + (event.clientX - dragStartX);
translateY = dragStartTranslateY + (event.clientY - dragStartY);
if (!last) return;
if (pointers.size === 1) {
pointers.set(event.pointerId, { x: event.clientX, y: event.clientY });
setView({
...view,
x: view.x + event.clientX - last.x,
y: view.y + event.clientY - last.y
});
return;
}
// Two fingers: zoom around their midpoint by how much they spread, and move with it
const [a, b] = [...pointers.values()];
const before = { x: (a.x + b.x) / 2, y: (a.y + b.y) / 2 };
const spreadBefore = Math.hypot(a.x - b.x, a.y - b.y);
pointers.set(event.pointerId, { x: event.clientX, y: event.clientY });
const [c, d] = [...pointers.values()];
const after = { x: (c.x + d.x) / 2, y: (c.y + d.y) / 2 };
const spreadAfter = Math.hypot(c.x - d.x, c.y - d.y);
if (!spreadBefore) return;
const point = localPoint(before.x, before.y);
const zoomed = zoomAt(view, spreadAfter / spreadBefore, point.x, point.y);
setView({ ...zoomed, x: zoomed.x + after.x - before.x, y: zoomed.y + after.y - before.y });
}
function handlePointerUp() {
isDragging = false;
function handlePointerUp(event: PointerEvent) {
pointers.delete(event.pointerId);
isDragging = pointers.size > 0;
}
function handleDoubleClick(event: MouseEvent) {
if (isOnControls(event.target)) return;
const point = localPoint(event.clientX, event.clientY);
setView(zoomAt(view, 2, point.x, point.y));
}
function handleKeydown(event: KeyboardEvent) {
if (event.ctrlKey || event.metaKey || event.altKey) return;
const step = event.shiftKey ? PAN_STEP_LARGE_PX : PAN_STEP_PX;
switch (event.key) {
case '+':
case '=':
zoomBy(DIAGRAM_ZOOM_FACTOR);
break;
case '-':
case '_':
zoomBy(1 / DIAGRAM_ZOOM_FACTOR);
break;
case '0':
resetView();
break;
case 'ArrowLeft':
setView({ ...view, x: view.x + step });
break;
case 'ArrowRight':
setView({ ...view, x: view.x - step });
break;
case 'ArrowUp':
setView({ ...view, y: view.y + step });
break;
case 'ArrowDown':
setView({ ...view, y: view.y - step });
break;
default:
return;
}
event.preventDefault();
}
</script>
<svelte:window onkeydown={handleKeydown} />
<!-- svelte-ignore a11y_no_static_element_interactions -->
<div
bind:this={containerRef.current}
class="mermaid-preview relative flex items-center justify-center overflow-hidden bg-muted/20"
bind:this={viewport}
class="mermaid-preview relative size-full touch-none overflow-hidden bg-muted/20 select-none {isDragging
? 'cursor-grabbing'
: 'cursor-grab'}"
ondblclick={handleDoubleClick}
onlostpointercapture={handlePointerUp}
onpointercancel={handlePointerUp}
onpointerdown={handlePointerDown}
onpointermove={handlePointerMove}
onpointerup={handlePointerUp}
>
<!-- svelte-ignore a11y_no_static_element_interactions -->
<div
class="mermaid-preview-diagram transform-origin-center inline-block min-h-fit min-w-fit will-change-transform {isDragging &&
'select-none'}"
onpointerdown={handlePointerDown}
onpointerleave={handlePointerUp}
onpointermove={handlePointerMove}
onpointerup={handlePointerUp}
style="transform: translate({translateX}px, {translateY}px) scale({scale}); cursor: {isDragging
? 'grabbing'
: 'grab'};"
bind:this={diagram}
class="mermaid-preview-diagram absolute top-0 left-0 w-max origin-top-left will-change-transform {fitted
? ''
: 'invisible'}"
style="transform: translate({view.x}px, {view.y}px) scale({view.scale});"
>
<div bind:this={svgHost}></div>
</div>
<MermaidPreviewControls
onResetView={resetView}
onZoomIn={zoomIn}
onZoomOut={zoomOut}
{scale}
onZoomIn={() => zoomBy(DIAGRAM_ZOOM_FACTOR)}
onZoomOut={() => zoomBy(1 / DIAGRAM_ZOOM_FACTOR)}
scale={view.scale}
{svgHtml}
/>
</div>
@@ -31,7 +31,7 @@
</script>
<div
class="mermaid-preview-controls absolute bottom-8 flex shrink-0 items-center justify-center p-3"
class="mermaid-preview-controls absolute bottom-8 left-1/2 flex shrink-0 -translate-x-1/2 cursor-auto items-center justify-center p-3"
>
<div class="mermaid-preview-controls-inner flex items-center gap-1 rounded-lg bg-muted p-1">
<button
@@ -123,16 +123,18 @@ export { default as CollapsibleContentBlock } from './CollapsibleContentBlock.sv
export { default as CollapsibleTerminalBlock } from './CollapsibleTerminalBlock.svelte';
/**
* **MermaidPreview** - Interactive Mermaid diagram viewer
* **MermaidPreview** - Pan and zoom viewer for a diagram's svg
*
* Renders Mermaid-generated SVG diagrams with zoom, pan, and fit-to-view controls.
* Shows a diagram (a Pele-drawn Mermaid block or an svg block) fitted to its box, with
* zoom, pan and download controls.
*
* **Features:**
* - Mouse wheel zoom in/out
* - Click-drag panning with pointer capture
* - Fit to view and reset view controls
* - Download as SVG
* - Responsive scaling with viewBox detection
* - Fits the diagram until the user pans or zooms, also as the box resizes
* - Wheel and trackpad pinch zoom around the pointer; zoom buttons and +/- keys zoom
* around the middle of the box, wherever the diagram has been panned to
* - Drag to pan, two-finger pinch on touch, double-click to zoom in, arrow keys to pan
* - Reset view (0) fits the diagram again
* - Download as SVG with the theme colors written in
*
* @example
* ```svelte
@@ -11,9 +11,10 @@
let { onOpenChange, open = $bindable(), svgHtml }: Props = $props();
</script>
<!-- Full screen on every device, so a large diagram has the whole window to pan and zoom in -->
<Dialog.Root bind:open {onOpenChange}>
<Dialog.Content
class="z-999999 grid max-h-full max-w-full! grid-rows-[1fr_auto] overflow-hidden p-0 md:h-[90vh] md:max-w-[90vw]!"
class="top-0! left-0! z-999999 block h-dvh! max-h-none! w-screen! max-w-none! translate-x-0! translate-y-0! overflow-hidden rounded-none! border-x-0! border-t-(length:--safe-area-top)! border-b-(length:--safe-area-bottom)! border-transparent! p-0 data-[state=closed]:zoom-out-100 data-[state=open]:zoom-in-100"
showCloseButton
>
<MermaidPreview {svgHtml} />
@@ -502,26 +502,16 @@ export { default as DialogMcpResourcesBrowser } from './DialogMcpResourcesBrowse
export { default as DialogMcpResourcePreview } from './DialogMcpResourcePreview.svelte';
/**
* **DialogMermaidPreview** - Full-screen Mermaid diagram preview with zoom and pan
* **DialogMermaidPreview** - Full-screen diagram preview with zoom and pan
*
* Full-screen dialog for previewing Mermaid diagrams with interactive controls.
* Supports mouse wheel zoom, drag-to-pan, and toolbar buttons for zoom in/out,
* fit to view, and reset.
*
* **Architecture:**
* - Uses UI dialog components (`Dialog.Root`, `Dialog.Overlay`, `Dialog.Content`)
* for consistent styling, animations, and accessibility
* - CSS transform-based zoom and pan (no external dependencies)
* - Pointer events for cross-device drag support (mouse + touch)
* - Wheel events for zoom-to-cursor functionality
* Opens a diagram in a dialog that fills the window on every device, with
* `MermaidPreview` inside it for zooming and panning.
*
* **Features:**
* - Scroll wheel zoom centered on cursor position
* - Click and drag to pan the diagram
* - Toolbar with zoom in, zoom out, fit to view, reset controls
* - Zoom percentage indicator
* - Keyboard accessible close button
* - Dark/light theme support
* - Full screen, keeping clear of the status bar and home indicator on phones
* - Zoom around the pointer or the middle of the screen, pan by drag or pinch
* - Zoom percentage, reset (fit) and download controls
* - Keyboard accessible close button, Escape closes
*
* @example
* ```svelte
@@ -0,0 +1,75 @@
// Pan and zoom for the diagram preview. The diagram sits at the top left of its viewport
// with `transform-origin: 0 0`, so a point (x, y) of the diagram shows on screen at
// (x * scale + x0, y * scale + y0), and every zoom keeps one screen point fixed.
export interface DiagramView {
scale: number;
x: number;
y: number;
}
export interface Size {
width: number;
height: number;
}
export const DIAGRAM_MIN_SCALE = 0.1;
export const DIAGRAM_MAX_SCALE = 10;
// a fitted diagram may grow, but not so much that a two-node flowchart fills the screen
export const DIAGRAM_MAX_FIT_SCALE = 2;
// one click of a zoom button, or one key press
export const DIAGRAM_ZOOM_FACTOR = 1.25;
function clampScale(scale: number): number {
return Math.min(Math.max(scale, DIAGRAM_MIN_SCALE), DIAGRAM_MAX_SCALE);
}
/**
* Scales the view by `factor` around the viewport point (`px`, `py`): what is under that
* point stays there. The scale is clamped, and the point stays fixed at the clamped scale.
*/
export function zoomAt(view: DiagramView, factor: number, px: number, py: number): DiagramView {
const scale = clampScale(view.scale * factor);
const ratio = scale / view.scale;
return { scale, x: px - (px - view.x) * ratio, y: py - (py - view.y) * ratio };
}
/** Scales the view by `factor` around the middle of the viewport. */
export function zoomAtCenter(view: DiagramView, factor: number, viewport: Size): DiagramView {
return zoomAt(view, factor, viewport.width / 2, viewport.height / 2);
}
/**
* The view that shows the whole diagram centered in the viewport, less `padding` on every
* side. A small diagram grows up to DIAGRAM_MAX_FIT_SCALE.
*/
export function fitView(content: Size, viewport: Size, padding = 0): DiagramView {
if (content.width <= 0 || content.height <= 0) return { scale: 1, x: 0, y: 0 };
const scale = clampScale(
Math.min(
(viewport.width - 2 * padding) / content.width,
(viewport.height - 2 * padding) / content.height,
DIAGRAM_MAX_FIT_SCALE
)
);
return {
scale,
x: (viewport.width - content.width * scale) / 2,
y: (viewport.height - content.height * scale) / 2
};
}
/**
* How much a wheel event zooms by. A trackpad pinch arrives as a wheel event with ctrlKey
* and small deltas, so it is scaled up to feel like the fingers; line and page deltas
* (mouse wheels on some systems) are turned into pixels first.
*/
export function wheelZoomFactor(event: Pick<WheelEvent, 'ctrlKey' | 'deltaMode' | 'deltaY'>) {
const unit = event.deltaMode === 1 ? 16 : event.deltaMode === 2 ? 400 : 1;
const speed = event.ctrlKey ? 0.01 : 0.002;
return Math.exp(-event.deltaY * unit * speed);
}
@@ -3,7 +3,7 @@
import { MERMAID_DIAGRAMS_MD } from '../fixtures/mermaid-diagrams.js';
import { defineMeta } from '@storybook/addon-svelte-csf';
import { MarkdownContent } from '#lib/components/app/index.ts';
import { expect, waitFor } from 'storybook/test';
import { expect, userEvent, waitFor } from 'storybook/test';
const { Story } = defineMeta({
component: MarkdownContent,
@@ -36,5 +36,31 @@
await expect(error?.textContent).toContain('line 2');
await expect(error?.closest('pre')).toBeVisible();
// `click ... href` must not turn a node into a live link, as under Mermaid's strict mode
const flowchart = canvasElement.querySelector('pre.mermaid svg.pele');
await expect(flowchart?.textContent).toContain('llama-server');
await expect(canvasElement.querySelector('pre.mermaid a')).toBeNull();
await expect(
canvasElement.querySelector('pre.mermaid [href], pre.mermaid [*|href]')
).toBeNull();
// The preview button opens the diagram in a dialog that fills the window
await userEvent.click(canvasElement.querySelector<HTMLElement>('.preview-code-btn')!);
const preview = await waitFor(() => {
const el = document.querySelector<HTMLElement>('.mermaid-preview');
expect(el).not.toBeNull();
return el!;
});
await expect(preview.getBoundingClientRect().width).toBeCloseTo(window.innerWidth, 0);
await expect(preview.getBoundingClientRect().height).toBeCloseTo(window.innerHeight, 0);
await userEvent.keyboard('{Escape}');
await waitFor(() => expect(document.querySelector('.mermaid-preview')).toBeNull());
}}
/>
@@ -0,0 +1,132 @@
<script lang="ts" module>
import {
FLOWCHART_SVG,
PIPELINE_SVG,
SEQUENCE_SVG,
SMALL_SVG
} from '../fixtures/mermaid-preview.js';
import { defineMeta } from '@storybook/addon-svelte-csf';
import { MermaidPreview } from '#lib/components/app/index.ts';
import { expect, userEvent, waitFor } from 'storybook/test';
// the pan and zoom viewer of the diagram preview dialog, here in a box of its own
const { Story } = defineMeta({
component: MermaidPreview,
parameters: {
layout: 'fullscreen'
},
title: 'Llama Chat/Content/MermaidPreview'
});
// the diagram's transform: where its top left corner is, and its scale
function readView(canvas: HTMLElement) {
const diagram = canvas.querySelector<HTMLElement>('.mermaid-preview-diagram')!;
const m = new DOMMatrix(getComputedStyle(diagram).transform);
return { scale: m.a, x: m.e, y: m.f };
}
// which point of the diagram is under the viewport point (x, y), and where it is now
function pointUnder(view: ReturnType<typeof readView>, x: number, y: number) {
return { x: (x - view.x) / view.scale, y: (y - view.y) / view.scale };
}
function screenOf(view: ReturnType<typeof readView>, p: { x: number; y: number }) {
return { x: p.x * view.scale + view.x, y: p.y * view.scale + view.y };
}
</script>
<Story
asChild
name="Flowchart"
play={async ({ canvasElement }) => {
const viewport = await waitFor(() => {
const el = canvasElement.querySelector<HTMLElement>('.mermaid-preview');
expect(el?.querySelector('.mermaid-preview-diagram')).toBeVisible();
return el!;
});
const rect = viewport.getBoundingClientRect();
const middle = { x: rect.width / 2, y: rect.height / 2 };
const fitted = readView(canvasElement);
// the wheel zooms around the pointer
const pointer = { x: rect.width * 0.7, y: rect.height * 0.35 };
const underPointer = pointUnder(fitted, pointer.x, pointer.y);
viewport.dispatchEvent(
new WheelEvent('wheel', {
bubbles: true,
cancelable: true,
clientX: rect.left + pointer.x,
clientY: rect.top + pointer.y,
deltaY: -200
})
);
await waitFor(() => expect(readView(canvasElement).scale).toBeGreaterThan(fitted.scale));
await expect(screenOf(readView(canvasElement), underPointer).x).toBeCloseTo(pointer.x, 0);
await expect(screenOf(readView(canvasElement), underPointer).y).toBeCloseTo(pointer.y, 0);
// after a pan, the zoom buttons zoom around the middle of the viewport
const zoomed = readView(canvasElement);
const drag = (type: string, x: number, y: number) =>
viewport.dispatchEvent(
new PointerEvent(type, {
bubbles: true,
button: 0,
clientX: rect.left + x,
clientY: rect.top + y,
pointerId: 1
})
);
drag('pointerdown', 100, 100);
drag('pointermove', 260, 180);
drag('pointerup', 260, 180);
await waitFor(() => expect(readView(canvasElement).x).toBeCloseTo(zoomed.x + 160, 0));
const panned = readView(canvasElement);
const underMiddle = pointUnder(panned, middle.x, middle.y);
await userEvent.click(canvasElement.querySelector<HTMLElement>('[aria-label="Zoom out"]')!);
await waitFor(() => expect(readView(canvasElement).scale).toBeLessThan(panned.scale));
await expect(screenOf(readView(canvasElement), underMiddle).x).toBeCloseTo(middle.x, 0);
await expect(screenOf(readView(canvasElement), underMiddle).y).toBeCloseTo(middle.y, 0);
// reset fits the diagram again
await userEvent.click(canvasElement.querySelector<HTMLElement>('[aria-label="Reset view"]')!);
await waitFor(() => expect(readView(canvasElement)).toEqual(fitted));
await expect(canvasElement.querySelector('.mermaid-preview-zoom-label')?.textContent).toBe(
`${Math.round(fitted.scale * 100)}%`
);
}}
>
<div class="h-dvh w-screen">
<MermaidPreview svgHtml={FLOWCHART_SVG} />
</div>
</Story>
<Story
asChild
name="Wide diagram"
play={async ({ canvasElement }) => {
// fitting shrinks a diagram wider than the screen so all of it shows
await waitFor(() => expect(readView(canvasElement).scale).toBeLessThan(1));
}}
>
<div class="h-dvh w-screen">
<MermaidPreview svgHtml={PIPELINE_SVG} />
</div>
</Story>
<Story asChild name="Small diagram">
<div class="h-dvh w-screen">
<MermaidPreview svgHtml={SMALL_SVG} />
</div>
</Story>
<Story asChild name="Sequence diagram">
<div class="h-dvh w-screen">
<MermaidPreview svgHtml={SEQUENCE_SVG} />
</div>
</Story>
@@ -0,0 +1,41 @@
<script lang="ts" module>
import { FLOWCHART_SVG } from '../fixtures/mermaid-preview.js';
import { defineMeta } from '@storybook/addon-svelte-csf';
import { DialogMermaidPreview } from '#lib/components/app/index.ts';
import { expect, waitFor } from 'storybook/test';
// the preview a diagram block's preview button opens; it fills the window on every device
const { Story } = defineMeta({
component: DialogMermaidPreview,
parameters: {
layout: 'fullscreen'
},
title: 'Llama Chat/Dialogs/DialogMermaidPreview'
});
</script>
<script lang="ts">
let open = $state(true);
</script>
<Story
asChild
name="Default"
play={async () => {
const content = await waitFor(() => {
const el = document.querySelector<HTMLElement>('[data-slot="dialog-content"]');
expect(el?.querySelector('.mermaid-preview')).not.toBeNull();
return el!;
});
const rect = content.getBoundingClientRect();
await expect(rect.left).toBe(0);
await expect(rect.top).toBe(0);
await expect(rect.width).toBeCloseTo(window.innerWidth, 0);
await expect(rect.height).toBeCloseTo(window.innerHeight, 0);
}}
>
<DialogMermaidPreview bind:open svgHtml={FLOWCHART_SVG} />
</Story>
@@ -1,4 +1,5 @@
// Mermaid blocks of several diagram types, and one that can't be drawn
// Mermaid blocks of several diagram types, and one that can't be drawn. The flowchart's
// click directives must leave it inert.
const fence = '```';
export const MERMAID_DIAGRAMS_MD = String.raw`
@@ -12,6 +13,8 @@ flowchart LR
Q -->|no| W[Queue]
W --> D
D -->|SSE tokens| U
click S href "https://github.com/ggml-org/llama.cpp" "llama.cpp on GitHub" _blank
click D call alert(1)
${fence}
The same exchange over time:
@@ -0,0 +1,30 @@
// Diagrams drawn with Pele, as renderMermaidDiagrams() draws them, for the preview stories
import { render } from 'pele';
export const FLOWCHART_SVG = render(`flowchart LR
U[Browser] -->|POST /v1/chat/completions| S(llama-server)
S --> Q{Slot free?}
Q -->|yes| D[Decode]
Q -->|no| W[Queue]
W --> D
D -->|SSE tokens| U`).svg;
// wider than any screen, so fitting it shrinks it
export const PIPELINE_SVG = render(`flowchart LR
A[Download GGUF] --> B[Read metadata] --> C[Load tensors] --> D[Build graph]
D --> E[Tokenize prompt] --> F[Prompt processing] --> G[Sample token]
G --> H[Detokenize] --> I[Stream to client] --> J{Stop?}
J -->|no| G
J -->|yes| K[Free slot]`).svg;
// small enough that fitting it grows it, up to the fit cap
export const SMALL_SVG = render(`flowchart TD
A[Prompt] --> B[Answer]`).svg;
export const SEQUENCE_SVG = render(`sequenceDiagram
participant C as Llama Chat
participant S as llama-server
C->>S: POST /v1/chat/completions
S-->>C: data: {"choices":[...]}
S-->>C: data: [DONE]
Note over C,S: the stream ends with DONE`).svg;
@@ -0,0 +1,111 @@
import {
DIAGRAM_MAX_FIT_SCALE,
DIAGRAM_MAX_SCALE,
DIAGRAM_MIN_SCALE,
type DiagramView,
fitView,
wheelZoomFactor,
zoomAt,
zoomAtCenter
} from '#lib/utils/diagram-viewport.ts';
import { describe, expect, it } from 'vitest';
// where the diagram point (x, y) shows on screen
function onScreen(view: DiagramView, x: number, y: number) {
return { x: x * view.scale + view.x, y: y * view.scale + view.y };
}
// the diagram point under the screen point (x, y)
function underScreen(view: DiagramView, x: number, y: number) {
return { x: (x - view.x) / view.scale, y: (y - view.y) / view.scale };
}
describe('zoomAt', () => {
it('keeps the diagram point under the zoom point in place', () => {
const view = { scale: 1.5, x: -120, y: 40 };
const under = underScreen(view, 300, 200);
const zoomed = zoomAt(view, 2, 300, 200);
expect(zoomed.scale).toBe(3);
expect(onScreen(zoomed, under.x, under.y).x).toBeCloseTo(300);
expect(onScreen(zoomed, under.x, under.y).y).toBeCloseTo(200);
});
it('clamps the scale and still keeps the point in place', () => {
const view = { scale: 8, x: 10, y: 10 };
const under = underScreen(view, 50, 60);
const zoomed = zoomAt(view, 4, 50, 60);
expect(zoomed.scale).toBe(DIAGRAM_MAX_SCALE);
expect(onScreen(zoomed, under.x, under.y).x).toBeCloseTo(50);
expect(zoomAt({ scale: 0.2, x: 0, y: 0 }, 0.1, 0, 0).scale).toBe(DIAGRAM_MIN_SCALE);
});
});
describe('zoomAtCenter', () => {
it('zooms around the middle of the viewport after a pan, not the diagram origin', () => {
const viewport = { height: 600, width: 800 };
// zoomed in and panned away from where the diagram started
const panned = { scale: 2, x: -500, y: -300 };
const under = underScreen(panned, 400, 300);
const out = zoomAtCenter(panned, 0.5, viewport);
expect(out.scale).toBe(1);
expect(onScreen(out, under.x, under.y).x).toBeCloseTo(400);
expect(onScreen(out, under.x, under.y).y).toBeCloseTo(300);
});
it('zooming in and out again returns to the same view', () => {
const viewport = { height: 600, width: 800 };
const view = { scale: 1.3, x: 25, y: -70 };
const back = zoomAtCenter(zoomAtCenter(view, 1.25, viewport), 1 / 1.25, viewport);
expect(back.scale).toBeCloseTo(view.scale);
expect(back.x).toBeCloseTo(view.x);
expect(back.y).toBeCloseTo(view.y);
});
});
describe('fitView', () => {
it('shrinks a large diagram to fit and centers it', () => {
const view = fitView({ height: 500, width: 2000 }, { height: 800, width: 1000 }, 50);
expect(view.scale).toBeCloseTo(0.45);
expect(view.x).toBeCloseTo(50);
expect(view.y).toBeCloseTo((800 - 500 * 0.45) / 2);
});
it('grows a small diagram no more than the fit cap', () => {
expect(fitView({ height: 50, width: 100 }, { height: 800, width: 1000 }).scale).toBe(
DIAGRAM_MAX_FIT_SCALE
);
});
it('leaves an unmeasured diagram at its own size', () => {
expect(fitView({ height: 0, width: 0 }, { height: 800, width: 1000 })).toEqual({
scale: 1,
x: 0,
y: 0
});
});
});
describe('wheelZoomFactor', () => {
it('zooms in on a wheel up and out on a wheel down', () => {
expect(wheelZoomFactor({ ctrlKey: false, deltaMode: 0, deltaY: -100 })).toBeGreaterThan(1);
expect(wheelZoomFactor({ ctrlKey: false, deltaMode: 0, deltaY: 100 })).toBeLessThan(1);
});
it('a wheel step up and back down cancel out', () => {
const up = wheelZoomFactor({ ctrlKey: false, deltaMode: 1, deltaY: -3 });
const down = wheelZoomFactor({ ctrlKey: false, deltaMode: 1, deltaY: 3 });
expect(up * down).toBeCloseTo(1);
});
it('a trackpad pinch zooms faster per pixel than a wheel', () => {
expect(wheelZoomFactor({ ctrlKey: true, deltaMode: 0, deltaY: -10 })).toBeGreaterThan(
wheelZoomFactor({ ctrlKey: false, deltaMode: 0, deltaY: -10 })
);
});
});