The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
import { beforeEach, describe, expect, it, vi } from "vitest";
import { renderMarkdown } from "./render";
import { subscribeTheme, themeKey } from "@/platform/themeWatch";
import { hasMermaid, renderMermaidIn, resetMermaidForTests } from "./mermaid";
const m = vi.hoisted(() => ({
loads: 0,
initialize: vi.fn(),
render: vi.fn(async (id: string, text: string) => {
// Like mermaid: a measuring node under <body> while rendering.
const tmp = document.createElement("div");
tmp.id = `d${id}`;
document.body.append(tmp);
if (text.includes("bad")) throw new Error("Parse error on line 2:\nbad\n^");
return {
svg:
`<svg id="${id}"><style>#${id}{fill:#dad;}#${id} .cluster rect{fill:#2e2f30;}#${id} .flowchart-link{fill:none;}#${id} [id$="-arrow"] path{fill:#9fa2a8;}</style>` +
`<defs><marker id="${id}-arrow" orient="auto"><path d="M0,0L8,4"/></marker></defs>` +
`<g class="cluster" id="dad"><rect/></g>` +
`<path class="flowchart-link" d="M0,4" marker-end="url(#${id}-arrow)"/><text>${text.split("\n")[0]}</text></svg>`,
};
}),
}));
vi.mock("mermaid", () => {
m.loads++;
return { default: { initialize: m.initialize, render: m.render } };
});
function preview(md: string): HTMLElement {
const root = document.createElement("div");
root.innerHTML = renderMarkdown(md);
document.body.append(root);
return root;
}
const SEQ = "```mermaid\nsequenceDiagram\n A->B:test\n```\n";
async function renderedSvg(svg: string): Promise<SVGSVGElement> {
m.render.mockResolvedValueOnce({ svg });
const root = preview(SEQ);
await renderMermaidIn(root).done;
return root.querySelector("svg")!;
}
describe("mermaid in the markdown preview", () => {
beforeEach(() => {
resetMermaidForTests();
m.render.mockClear();
m.initialize.mockClear();
document.body.innerHTML = "";
});
it("emits a placeholder holding the escaped source, other code blocks unchanged", () => {
const root = preview(
`# T\n\n${SEQ}\n\`\`\`js\nlet a = 1;\n\`\`\`\n\n\`\`\`Mermaid title\ngraph TD\n a["<b>x</b>"]-->b\n\`\`\`\n`,
);
const blocks = root.querySelectorAll<HTMLElement>("[data-mermaid]");
expect(blocks).toHaveLength(2);
expect(blocks[0]!.parentElement?.dataset.line).toBe("2");
expect(blocks[0]!.querySelector("pre > code.language-mermaid")?.textContent).toBe("sequenceDiagram\n A->B:test");
expect(blocks[1]!.querySelector("code")?.textContent).toContain('a["<b>x</b>"]');
expect(blocks[1]!.querySelector("b")).toBeNull();
expect(root.querySelector("code.language-js")?.closest("[data-mermaid]")).toBeNull();
});
it("loads mermaid only for previews with a diagram", async () => {
const plain = preview("# Plain\n\n```js\n1\n```\n");
expect(hasMermaid(plain)).toBe(false);
const pass = renderMermaidIn(plain);
expect(pass.async).toBe(false);
await pass.done;
expect(m.loads).toBe(0);
const root = preview(SEQ);
expect(hasMermaid(root)).toBe(true);
await renderMermaidIn(root).done;
expect(m.loads).toBe(1);
expect(m.initialize).toHaveBeenCalledWith(
expect.objectContaining({ startOnLoad: false, securityLevel: "strict", theme: "base", look: "classic" }),
);
const block = root.querySelector<HTMLElement>("[data-mermaid]")!;
expect(block.getAttribute("data-mermaid-state")).toBe("ok");
expect(block.querySelector(".mermaid-output svg")).not.toBeNull();
// Temporary nodes mermaid leaves under <body> are removed.
expect(document.body.querySelector(":scope > [id^='d']")).toBeNull();
});
it("shows syntax errors inline next to the source without throwing", async () => {
const root = preview("```mermaid\nsequenceDiagram\nbad\n```\n");
await expect(renderMermaidIn(root).done).resolves.toBeUndefined();
const block = root.querySelector<HTMLElement>("[data-mermaid]")!;
expect(block.getAttribute("data-mermaid-state")).toBe("error");
expect(block.querySelector("pre code")?.textContent).toContain("bad");
const error = block.querySelector(".mermaid-output")!;
expect(error.getAttribute("role")).toBe("alert");
expect(error.textContent).toContain("Parse error on line 2");
expect(error.querySelector("svg")).toBeNull();
});
it("renders with unique ids, reuses results and keeps the old diagram while a new one renders", async () => {
const first = preview(SEQ);
await renderMermaidIn(first, []).done;
const ids = new Set(m.render.mock.calls.map(([id]) => id));
// Same source again (e.g. an edit elsewhere): drawn synchronously from the cache.
const previous: Node[] = [];
const again = preview(SEQ);
const pass = renderMermaidIn(again, previous);
expect(pass.async).toBe(false);
expect(again.querySelector("[data-mermaid-state='ok'] svg")).not.toBeNull();
expect(m.render).toHaveBeenCalledTimes(1);
// Edited diagram: the previous drawing stands in until the new one is ready.
const edited = preview(SEQ.replace("test", "edited"));
const next = renderMermaidIn(edited, previous);
expect(next.async).toBe(true);
expect(edited.querySelector(".mermaid-output svg text")?.textContent).toBe("sequenceDiagram");
await next.done;
expect(m.render).toHaveBeenCalledTimes(2);
ids.add(m.render.mock.calls[1]![0]);
expect(ids.size).toBe(2);
});
it("applies a cached diagram with fresh SVG ids so copies don't share markers", async () => {
const first = preview(SEQ);
await renderMermaidIn(first, []).done;
// Like the first copy sitting in a hidden host: a closed details, another tab.
first.style.display = "none";
const second = preview(SEQ);
const pass = renderMermaidIn(second, []);
expect(pass.async).toBe(false); // drawn from the cache, no new render
await pass.done;
expect(m.render).toHaveBeenCalledTimes(1);
const idsOf = (svg: Element) => [svg, ...svg.querySelectorAll("[id]")].map((el) => el.getAttribute("id"));
const a = first.querySelector("svg")!;
const b = second.querySelector("svg")!;
const idsA = idsOf(a);
const idsB = idsOf(b);
expect(idsA).toHaveLength(3);
expect(idsB).toHaveLength(3);
expect(idsA.filter((id) => idsB.includes(id))).toEqual([]);
// Every marker reference, `<style>#<svg-id>` rule and `[id$="-arrow"]` suffix rule
// resolves within its own copy without touching hex colours (`#dad`) in `<style>`.
for (const svg of [a, b]) {
const own = new Set(idsOf(svg));
const rootId = svg.getAttribute("id")!;
const ref = svg.querySelector("[marker-end]")!.getAttribute("marker-end")!;
expect(own.has(/url\(#(.+)\)/.exec(ref)![1]!)).toBe(true);
const css = svg.querySelector("style")!.textContent!;
expect(css).toContain(`#${rootId}{fill:#dad;}`);
expect(css).toContain(`#${rootId} .cluster rect{fill:#2e2f30;}`);
expect(css).toContain(`#${rootId} .flowchart-link{fill:none;}`);
expect(svg.querySelector("defs [id$='-arrow'] path")).not.toBeNull();
}
});
it.each(["", ".node", ":hover", ">g", "+g", "~g", "[role]", ", rect", " .cluster rect", "\nrect"])(
"rewrites style selectors followed by %j",
async (tail) => {
const svg = await renderedSvg(
`<svg id="openidea-mermaid-1"><style>#openidea-mermaid-1${tail}{fill:none;}</style></svg>`,
);
expect(svg.querySelector("style")!.textContent).toBe(`#${svg.id}${tail}{fill:none;}`);
},
);
it("rewrites fragment links, quoted URLs and marker ids while preserving suffix selectors", async () => {
const id = "openidea-mermaid-1";
const marker = `${id}_flowchart-pointEnd`;
const svg = await renderedSvg(
`<svg id="${id}" aria-labelledby="title desc" aria-describedby="desc">` +
`<style>#${id} [id$="-pointEnd"]{fill:#dad;}#${marker}{stroke:#dad;}</style>` +
`<title id="title">Title</title><desc id="desc">Description</desc>` +
`<marker id="${marker}"/><g id="dad"/>` +
`<use href="#${marker}"/><use xlink:href="#${marker}"/>` +
`<path marker-end="url(#${marker})"/>` +
`<path marker-end="url('#${marker}')"/>` +
`<path marker-end='url("#${marker}")'/>` +
`<path style="marker-end: url( '#${marker}' );"/>` +
`<style>#${id} path{marker-end:url("#${marker}");}</style></svg>`,
);
const markerId = svg.querySelector("marker")!.id;
expect(markerId).toBe(`${svg.id}_flowchart-pointEnd`);
expect(svg.querySelector("[id$='-pointEnd']")).not.toBeNull();
expect(
[...svg.querySelectorAll("use")].map((el) => el.getAttribute("href") ?? el.getAttribute("xlink:href")),
).toEqual([`#${markerId}`, `#${markerId}`]);
expect([...svg.querySelectorAll("path[marker-end]")].map((el) => el.getAttribute("marker-end"))).toEqual([
`url(#${markerId})`,
`url('#${markerId}')`,
`url("#${markerId}")`,
]);
expect(svg.querySelector("path[style]")!.getAttribute("style")).toBe(`marker-end: url( '#${markerId}' );`);
expect([...svg.querySelectorAll("style")].map((el) => el.textContent)).toEqual([
`#${svg.id} [id$="-pointEnd"]{fill:#dad;}#${markerId}{stroke:#dad;}`,
`#${svg.id} path{marker-end:url("#${markerId}");}`,
]);
expect(svg.getAttribute("aria-labelledby")).toBe(
`${svg.querySelector("title")!.id} ${svg.querySelector("desc")!.id}`,
);
expect(svg.getAttribute("aria-describedby")).toBe(svg.querySelector("desc")!.id);
});
it("keeps ids with a shared prefix distinct and leaves unknown references unchanged", async () => {
const short = "openidea-mermaid-1";
const long = "openidea-mermaid-10";
const svg = await renderedSvg(
`<svg id="${short}"><g id="${long}"/>` +
`<style>#${short}>g,#${long}:hover{fill:none;}#${long}0{fill:none;}</style>` +
`<use href="#${short}"/><use href="#${long}"/><use href="#${long}0"/>` +
`<path marker-end="url('#${long}')"/></svg>`,
);
const longId = svg.querySelector("g")!.id;
expect(longId).toBe(`${svg.id}0`);
expect([...svg.querySelectorAll("use")].map((el) => el.getAttribute("href"))).toEqual([
`#${svg.id}`,
`#${longId}`,
`#${long}0`,
]);
expect(svg.querySelector("style")!.textContent).toBe(
`#${svg.id}>g,#${longId}:hover{fill:none;}#${long}0{fill:none;}`,
);
expect(svg.querySelector("path")!.getAttribute("marker-end")).toBe(`url('#${longId}')`);
});
it("leaves ids in ordinary labels and unrelated attributes untouched", async () => {
const id = "openidea-mermaid-1";
const label = `#${id} ${id} id="${id}" href="#${id}" url(#${id})`;
const svg = await renderedSvg(
`<svg id="${id}"><text>${label}</text>` +
`<g data-id="${id}" data-label="#${id}" title="url(#${id})"/>` +
`<a href="https://example.com/#${id}">Link</a></svg>`,
);
expect(svg.querySelector("text")!.textContent).toBe(label);
expect(svg.querySelector("g")!.getAttribute("data-id")).toBe(id);
expect(svg.querySelector("g")!.getAttribute("data-label")).toBe(`#${id}`);
expect(svg.querySelector("g")!.getAttribute("title")).toBe(`url(#${id})`);
expect(svg.querySelector("a")!.getAttribute("href")).toBe(`https://example.com/#${id}`);
});
it("re-renders when switching between built-in palette themes of the same light / dark base", async () => {
const root = document.documentElement;
const previous = root.dataset.colorTheme;
const changed = vi.fn();
const off = subscribeTheme(changed);
try {
root.dataset.colorTheme = "one-dark";
const firstKey = themeKey();
await renderMermaidIn(preview(SEQ)).done;
root.dataset.colorTheme = "solarized-dark";
await Promise.resolve();
expect(changed).toHaveBeenCalled();
expect(themeKey()).not.toBe(firstKey);
await renderMermaidIn(preview(SEQ)).done;
expect(m.render).toHaveBeenCalledTimes(2);
} finally {
off();
if (previous === undefined) delete root.dataset.colorTheme;
else root.dataset.colorTheme = previous;
}
});
it("re-renders when switching between plugin themes of the same light / dark base", async () => {
const root = document.documentElement;
const changed = vi.fn();
const off = subscribeTheme(changed);
try {
root.dataset.theme = "dark";
root.dataset.pluginTheme = "acme-themes/night";
const firstKey = themeKey();
await renderMermaidIn(preview(SEQ)).done;
root.dataset.pluginTheme = "acme-themes/dusk";
await Promise.resolve();
expect(changed).toHaveBeenCalled();
expect(themeKey()).not.toBe(firstKey);
await renderMermaidIn(preview(SEQ)).done;
expect(m.render).toHaveBeenCalledTimes(2);
} finally {
off();
delete root.dataset.pluginTheme;
}
});
it("lifts dark-theme shapes off the editor background and paints labels with the foreground", async () => {
const root = document.documentElement;
const previous = root.dataset.theme;
root.dataset.theme = "dark";
const values: Record<string, string> = {
"--bg-editor": "#191a1c",
"--bg-elev": "#212326",
"--bg-floating-toolbar": "#33353b",
"--bg-selected": "#2a4371",
"--border-strong": "#40434a",
"--fg-strong": "#dfe1e5",
"--fg": "#d1d3d9",
"--fg-secondary": "#9fa2a8",
"--accent": "#3871e1",
"--chart-series": "#e07a7c",
"--danger": "#f57e84",
};
const computed = vi
.spyOn(globalThis, "getComputedStyle")
.mockImplementation(
() => ({ getPropertyValue: (n: string) => values[n] ?? "" }) as unknown as CSSStyleDeclaration,
);
try {
await renderMermaidIn(preview(SEQ)).done;
expect(m.initialize).toHaveBeenCalledWith(
expect.objectContaining({
look: "classic",
themeVariables: expect.objectContaining({
darkMode: true,
useGradient: false,
background: "#191a1c",
mainBkg: "#33353b",
nodeBorder: "#dfe1e5",
primaryBorderColor: "#dfe1e5",
primaryColor: "#3871e1",
cScale0: "#3871e1",
lineColor: "#9fa2a8",
classText: "#dfe1e5",
}),
}),
);
} finally {
computed.mockRestore();
if (previous === undefined) delete root.dataset.theme;
else root.dataset.theme = previous;
}
});
it("passes colours a theme writes as hsl() or color-mix() to mermaid as RGB", async () => {
const values: Record<string, string> = {
"--bg-editor": "hsl(220, 13%, 18%)",
"--fg": "color-mix(in srgb, hsl(220, 14%, 71%) 90%, black)",
"--danger": "#e06c75",
};
const resolved: Record<string, string> = {
"--bg-editor": "rgb(40, 44, 52)",
"--fg": "color(srgb 0.6 0.62 0.66)",
};
let probe = "";
const computed = vi.spyOn(globalThis, "getComputedStyle").mockImplementation(
(el) =>
(el === document.documentElement
? { getPropertyValue: (n: string) => values[n] ?? "" }
: {
color: resolved[(probe = (el as HTMLElement).style.color.slice(4, -1))] ?? "",
}) as unknown as CSSStyleDeclaration,
);
try {
await renderMermaidIn(preview(SEQ)).done;
expect(probe).not.toBe("");
expect(m.initialize).toHaveBeenCalledWith(
expect.objectContaining({
themeVariables: expect.objectContaining({
background: "rgb(40, 44, 52)",
textColor: "rgb(153, 158, 168)",
errorTextColor: "#e06c75",
}),
}),
);
expect(document.querySelector("span[hidden]")).toBeNull();
} finally {
computed.mockRestore();
}
});
it("skips superseded renders", async () => {
const root = preview(SEQ.replace("test", "stale"));
const pass = renderMermaidIn(root);
pass.cancel();
await pass.done;
expect(m.render).not.toHaveBeenCalled();
expect(root.querySelector("[data-mermaid]")?.getAttribute("data-mermaid-state")).toBe("pending");
});
});