Beautiful, AI-native markdown IDE and LLM wiki
TypeScript 2nd-brainagent-skillsclaudecodexcompany-braindocsknowledge-knowledge-baseknowledge-managementllmllm-wikillm-wiki-karpathymarkdownmarkdown-editormdmdxnotespkmsecond-brainskills
import { cleanup, fireEvent, render, screen, waitFor, within } from '@testing-library/react';
import { afterEach, beforeEach, describe, expect, test, vi } from 'vitest';
import { renderLinguiTemplate } from '@/test-utils/lingui-mock';
type WindowGlobals = { NodeFilter?: typeof NodeFilter };
type GlobalWithDomShims = typeof globalThis &
WindowGlobals & { window?: WindowGlobals; ResizeObserver?: unknown };
const globalWithDomShims = globalThis as GlobalWithDomShims;
if (
globalWithDomShims.NodeFilter === undefined &&
globalWithDomShims.window?.NodeFilter !== undefined
) {
globalWithDomShims.NodeFilter = globalWithDomShims.window.NodeFilter;
}
if (globalWithDomShims.ResizeObserver === undefined) {
class NoopResizeObserver {
observe() {}
unobserve() {}
disconnect() {}
}
globalWithDomShims.ResizeObserver = NoopResizeObserver;
}
const renderMermaid = vi.fn(async (_id: string, _chart: string) => ({
svg: '<svg viewBox="0 0 100 100"><g><text>Graph</text></g></svg>',
}));
const initializeMermaid = vi.fn(() => {});
import * as actualLinguiMacro from '@lingui/react/macro';
vi.doMock('mermaid', () => ({
default: {
initialize: initializeMermaid,
render: renderMermaid,
},
}));
vi.doMock('@lingui/react/macro', () => ({
...actualLinguiMacro,
Trans: ({ children }: { children: React.ReactNode }) => <>{children}</>,
useLingui: () => ({ t: renderLinguiTemplate }),
}));
type MockPanzoomInstance = {
zoomIn: ReturnType<typeof vi.fn>;
zoomOut: ReturnType<typeof vi.fn>;
pan: ReturnType<typeof vi.fn>;
reset: ReturnType<typeof vi.fn>;
destroy: ReturnType<typeof vi.fn>;
zoomWithWheel: ReturnType<typeof vi.fn>;
getScale: ReturnType<typeof vi.fn>;
};
type MockPanzoomOptions = {
cursor?: string;
noBind?: boolean;
touchAction?: string;
};
const panzoomInstances: MockPanzoomInstance[] = [];
const panzoomOptions: MockPanzoomOptions[] = [];
const createPanzoom = vi.fn((_element: SVGElement, options?: MockPanzoomOptions) => {
const instance: MockPanzoomInstance = {
zoomIn: vi.fn(() => ({ scale: 1.25 })),
zoomOut: vi.fn(() => ({ scale: 0.75 })),
pan: vi.fn(() => ({ x: 0, y: 0, scale: 1 })),
reset: vi.fn(() => ({ x: 0, y: 0, scale: 1 })),
destroy: vi.fn(() => {}),
zoomWithWheel: vi.fn(() => ({ scale: 1 })),
getScale: vi.fn(() => 1),
};
panzoomInstances.push(instance);
panzoomOptions.push(options ?? {});
return instance;
});
vi.doMock('@panzoom/panzoom', () => ({
default: createPanzoom,
}));
const { MermaidLightbox, MermaidView } = await import('./Mermaid');
const { TooltipProvider } = await import('@/components/ui/tooltip');
function renderMermaidView(chart: string) {
return render(
<TooltipProvider>
<MermaidView chart={chart} />
</TooltipProvider>,
);
}
async function waitForPanzoomInstance(index = 0) {
await waitFor(() => {
expect(panzoomInstances.length).toBeGreaterThan(index);
});
return panzoomInstances[index];
}
describe('MermaidView controls', () => {
beforeEach(() => {
renderMermaid.mockClear();
initializeMermaid.mockClear();
createPanzoom.mockClear();
panzoomInstances.length = 0;
panzoomOptions.length = 0;
Object.defineProperty(globalThis.navigator, 'clipboard', {
configurable: true,
value: undefined,
});
});
afterEach(() => {
cleanup();
});
test('renders toolbar buttons for a ready diagram', async () => {
renderMermaidView('graph TD; A-->B;');
for (const label of [
'Zoom in',
'Zoom out',
'Pan up',
'Pan down',
'Pan left',
'Pan right',
'Reset view',
]) {
expect(await screen.findByRole('button', { name: label })).not.toBeNull();
}
});
test('labels the controls as a toolbar', async () => {
renderMermaidView('graph TD; A-->B;');
await waitForPanzoomInstance();
expect(screen.getByRole('toolbar', { name: 'Mermaid diagram controls' })).not.toBeNull();
});
test('toolbar controls call the Panzoom instance', async () => {
renderMermaidView('graph TD; A-->B;');
const panzoom = await waitForPanzoomInstance();
fireEvent.click(screen.getByRole('button', { name: 'Zoom in' }));
fireEvent.click(screen.getByRole('button', { name: 'Zoom out' }));
fireEvent.click(screen.getByRole('button', { name: 'Reset view' }));
fireEvent.click(screen.getByRole('button', { name: 'Pan up' }));
fireEvent.click(screen.getByRole('button', { name: 'Pan down' }));
fireEvent.click(screen.getByRole('button', { name: 'Pan left' }));
fireEvent.click(screen.getByRole('button', { name: 'Pan right' }));
expect(panzoom.zoomIn.mock.calls.length).toBe(1);
expect(panzoom.zoomOut.mock.calls.length).toBe(1);
expect(panzoom.reset.mock.calls.length).toBe(1);
const panOpts = {
animate: true,
duration: 200,
easing: 'ease-out',
relative: true,
};
expect(panzoom.pan.mock.calls).toEqual([
[0, 48, panOpts],
[0, -48, panOpts],
[48, 0, panOpts],
[-48, 0, panOpts],
]);
});
test('honors prefers-reduced-motion by skipping the pan animation', async () => {
const originalMatchMedia = window.matchMedia;
window.matchMedia = ((query: string) => ({
matches: query.includes('reduce'),
media: query,
onchange: null,
addEventListener: () => {},
removeEventListener: () => {},
dispatchEvent: () => false,
})) as typeof window.matchMedia;
try {
renderMermaidView('graph TD; A-->B;');
const panzoom = await waitForPanzoomInstance();
fireEvent.click(screen.getByRole('button', { name: 'Pan up' }));
expect(panzoom.pan.mock.calls[0]?.[2]).toEqual({
animate: false,
duration: 200,
easing: 'ease-out',
relative: true,
});
} finally {
window.matchMedia = originalMatchMedia;
}
});
test('does not register wheel zoom listeners inside the diagram', async () => {
const originalAddEventListener = EventTarget.prototype.addEventListener;
const addEventListenerCalls: Array<{ target: EventTarget; type: string }> = [];
EventTarget.prototype.addEventListener = function (
this: EventTarget,
type: string,
listener: EventListenerOrEventListenerObject,
options?: AddEventListenerOptions | boolean,
) {
addEventListenerCalls.push({ target: this, type });
return originalAddEventListener.call(this, type, listener, options);
};
try {
renderMermaidView('graph TD; A-->B;');
await waitForPanzoomInstance();
const mermaidWheelListeners = addEventListenerCalls.filter(
({ target, type }) =>
type === 'wheel' &&
target instanceof Element &&
target.closest('[data-component-type="mermaid"]'),
);
expect(mermaidWheelListeners).toHaveLength(0);
} finally {
EventTarget.prototype.addEventListener = originalAddEventListener;
}
});
test('logs when Panzoom setup fails', async () => {
const originalWarn = console.warn;
const warn = vi.fn(() => {});
console.warn = warn;
createPanzoom.mockImplementationOnce(() => {
throw new Error('panzoom unavailable');
});
try {
renderMermaidView('graph TD; A-->B;');
await waitFor(() => {
expect(warn.mock.calls.length).toBe(1);
});
expect(warn.mock.calls[0]?.[0]).toBe('[Mermaid] panzoom setup failed:');
expect(warn.mock.calls[0]?.[1]).toBeInstanceOf(Error);
} finally {
console.warn = originalWarn;
}
});
test('does not bind pointer drag gestures to the diagram', async () => {
renderMermaidView('graph TD; A-->B;');
await waitForPanzoomInstance();
expect(panzoomOptions[0]?.noBind).toBe(true);
expect(panzoomOptions[0]?.cursor).toBe('default');
expect(panzoomOptions[0]?.touchAction).toBe('auto');
});
test('standalone .mmd binding wires two-finger wheel to pan and ctrl/meta+wheel to zoom', async () => {
const editBinding = { canEdit: true, commitChart: vi.fn() };
const { container } = render(
<TooltipProvider>
<MermaidView chart="graph TD; A-->B;" editBinding={editBinding} />
</TooltipProvider>,
);
const panzoom = await waitForPanzoomInstance();
const scroller = container.querySelector('.ok-mermaid-svg') as HTMLElement;
expect(scroller).not.toBeNull();
const trackpad = new WheelEvent('wheel', {
deltaX: 30,
deltaY: 40,
bubbles: true,
cancelable: true,
});
scroller.dispatchEvent(trackpad);
expect(panzoom.pan).toHaveBeenCalledWith(-30, -40, { relative: true });
expect(panzoom.zoomWithWheel).not.toHaveBeenCalled();
expect(trackpad.defaultPrevented).toBe(true);
panzoom.pan.mockClear();
panzoom.getScale.mockReturnValueOnce(2);
const scaled = new WheelEvent('wheel', {
deltaX: 60,
deltaY: 0,
bubbles: true,
cancelable: true,
});
scroller.dispatchEvent(scaled);
expect(panzoom.pan).toHaveBeenCalledWith(-30, -0, { relative: true });
const zoom = new WheelEvent('wheel', {
deltaY: -10,
ctrlKey: true,
bubbles: true,
cancelable: true,
});
scroller.dispatchEvent(zoom);
expect(panzoom.zoomWithWheel).toHaveBeenCalledWith(zoom);
expect(zoom.defaultPrevented).toBe(true);
panzoom.zoomWithWheel.mockClear();
const cmdZoom = new WheelEvent('wheel', {
deltaY: -10,
metaKey: true,
bubbles: true,
cancelable: true,
});
scroller.dispatchEvent(cmdZoom);
expect(panzoom.zoomWithWheel).toHaveBeenCalledWith(cmdZoom);
expect(cmdZoom.defaultPrevented).toBe(true);
});
test('standalone wheel listener does not accumulate across re-renders', async () => {
const editBinding = { canEdit: true, commitChart: vi.fn() };
const { container, rerender } = render(
<TooltipProvider>
<MermaidView chart="graph TD; A-->B;" editBinding={editBinding} />
</TooltipProvider>,
);
const first = await waitForPanzoomInstance();
rerender(
<TooltipProvider>
<MermaidView chart="graph TD; B-->C;" editBinding={editBinding} />
</TooltipProvider>,
);
await waitFor(() => {
expect(panzoomInstances.length).toBe(2);
expect(first.destroy.mock.calls.length).toBe(1);
});
const current = panzoomInstances[1];
const scroller = container.querySelector('.ok-mermaid-svg') as HTMLElement;
const wheel = new WheelEvent('wheel', {
deltaX: 10,
deltaY: 20,
bubbles: true,
cancelable: true,
});
scroller.dispatchEvent(wheel);
expect(current.pan.mock.calls.length).toBe(1);
expect(first.pan.mock.calls.length).toBe(0);
});
test('re-rendering with a different chart destroys the old Panzoom instance', async () => {
const { rerender } = render(
<TooltipProvider>
<MermaidView chart="graph TD; A-->B;" />
</TooltipProvider>,
);
const firstPanzoom = await waitForPanzoomInstance();
rerender(
<TooltipProvider>
<MermaidView chart="graph TD; B-->C;" />
</TooltipProvider>,
);
await waitFor(() => {
expect(firstPanzoom.destroy.mock.calls.length).toBe(1);
expect(panzoomInstances.length).toBe(2);
});
});
test('ready diagram fills its preview host', async () => {
const { container } = renderMermaidView('graph TD; A-->B;');
await waitForPanzoomInstance();
const root = container.querySelector<HTMLElement>('[data-component-type="mermaid"]');
const svgHost = container.querySelector<HTMLElement>('.ok-mermaid-svg');
const stage = svgHost?.parentElement;
expect(root?.className).toContain('h-full');
expect(root?.className).toContain('w-full');
expect(svgHost?.className).toContain('flex-1');
expect(stage?.className).not.toContain('p-4');
});
test('action cluster is compact and anchored bottom-right', async () => {
const { container } = renderMermaidView('graph TD; A-->B;');
await waitForPanzoomInstance();
const cluster = screen.getByTestId('mermaid-actions');
const resetButton = screen.getByRole('button', { name: 'Reset view' });
const resetIcon = resetButton.querySelector('svg');
expect(cluster?.className).toContain('right-3');
expect(cluster?.className).toContain('bottom-3');
expect(resetButton.getAttribute('data-size')).toBe('icon-sm');
expect(resetIcon?.classList).toContain('size-4');
expect(container.querySelector('.top-1\\/2')).toBeNull();
});
test('error state does not render toolbar controls', async () => {
renderMermaid.mockImplementationOnce(async () => {
throw new Error('invalid mermaid');
});
renderMermaidView('graph TD; A-->');
expect(await screen.findByRole('alert')).not.toBeNull();
expect(screen.queryByRole('button', { name: 'Zoom in' })).toBeNull();
});
});
describe('MermaidView expand control', () => {
test('renders only when a host passes onExpand, and forwards the click', async () => {
const onExpand = vi.fn(() => {});
render(
<TooltipProvider>
<MermaidView chart="graph TD; A-->B;" onExpand={onExpand} />
</TooltipProvider>,
);
await waitForPanzoomInstance();
fireEvent.click(screen.getByRole('button', { name: 'Expand diagram' }));
expect(onExpand).toHaveBeenCalledTimes(1);
});
test('is absent when no host opts in', async () => {
renderMermaidView('graph TD; A-->B;');
await waitForPanzoomInstance();
expect(screen.queryByRole('button', { name: 'Expand diagram' })).toBeNull();
});
});
describe('MermaidLightbox', () => {
test('hosts a complete toolbar, a view-only cue, and no expand control', async () => {
render(
<TooltipProvider>
<MermaidLightbox chart="graph TD; A-->B;" open onOpenChange={() => {}} />
</TooltipProvider>,
);
const dialog = await screen.findByRole('dialog', { name: 'Mermaid diagram' });
await waitForPanzoomInstance();
expect(
within(dialog).getByRole('toolbar', { name: 'Mermaid diagram controls' }),
).not.toBeNull();
expect(within(dialog).queryByRole('button', { name: 'Expand diagram' })).toBeNull();
expect(within(dialog).getByText('View only')).not.toBeNull();
});
test('a chart edit while open reaches the canvas', async () => {
const { rerender } = render(
<TooltipProvider>
<MermaidLightbox chart="graph TD; A-->B;" open onOpenChange={() => {}} />
</TooltipProvider>,
);
await waitForPanzoomInstance();
rerender(
<TooltipProvider>
<MermaidLightbox chart="graph TD; C-->D;" open onOpenChange={() => {}} />
</TooltipProvider>,
);
await waitFor(() => {
const charts = renderMermaid.mock.calls.map((call) => call[1]);
expect(charts.some((chart) => chart.includes('C-->D'))).toBe(true);
});
});
test('the close control reports through onOpenChange and closing tears the canvas down', async () => {
const onOpenChange = vi.fn((_open: boolean) => {});
const { rerender } = render(
<TooltipProvider>
<MermaidLightbox chart="graph TD; A-->B;" open onOpenChange={onOpenChange} />
</TooltipProvider>,
);
await screen.findByRole('dialog', { name: 'Mermaid diagram' });
const panzoom = await waitForPanzoomInstance();
fireEvent.click(screen.getByRole('button', { name: 'Close' }));
expect(onOpenChange).toHaveBeenCalledWith(false);
rerender(
<TooltipProvider>
<MermaidLightbox chart="graph TD; A-->B;" open={false} onOpenChange={onOpenChange} />
</TooltipProvider>,
);
await waitFor(() => {
expect(screen.queryByRole('dialog')).toBeNull();
});
expect(panzoom.destroy.mock.calls.length).toBeGreaterThan(0);
});
});
describe('MermaidView editBinding (standalone .mmd path)', () => {
test('renders an editable diagram with no JSX host when an editBinding is supplied', async () => {
let committed: string | null = null;
render(
<TooltipProvider>
<MermaidView
chart="graph TD; A-->B;"
editBinding={{
canEdit: true,
commitChart: (next) => {
committed = next;
},
}}
/>
</TooltipProvider>,
);
await waitForPanzoomInstance();
expect(screen.getByRole('toolbar')).toBeDefined();
expect(committed).toBeNull();
});
});