Open source website builder and Webflow alternative. Webstudio is an advanced visual builder that connects to any headless CMS, supports all CSS properties, and can be hosted anywhere, including with us.
TypeScript accessibilityalternativecloudflarecloudflare-workersdesignfreefrontendopen-sourceradix-uireactremixweb-developmentwebflowwebsite-builderwebsite-developmentwebsiteswebstudio
import { createRef } from "react";
import { renderToStaticMarkup, renderToString } from "react-dom/server";
import { hydrateRoot } from "react-dom/client";
import { act, render, waitFor } from "@testing-library/react";
import { expect, test, vi } from "vitest";
import css from "@shikijs/langs/css";
import javascript from "@shikijs/langs/javascript";
import githubLight from "@shikijs/themes/github-light";
import nord from "@shikijs/themes/nord";
import { createCodeText } from ".";
import { CodeText } from "./base";
const HighlightedCodeText = createCodeText({
languages: [javascript],
themes: [githubLight, nord],
});
test("renders highlighted HAST inside the semantic code root", () => {
const markup = renderToStaticMarkup(
<HighlightedCodeText
className="custom-code"
language="javascript"
theme="github-light"
>
const answer = 42;
</HighlightedCodeText>
);
expect(markup).toMatch(/^<code/);
expect(markup).not.toContain("<pre");
expect(markup).toContain("<span");
expect(markup).not.toContain('language="javascript"');
const container = document.createElement("div");
container.innerHTML = markup;
const codeElement = container.querySelector("code");
expect(codeElement?.className).toBe("custom-code");
expect(codeElement?.getAttribute("tabindex")).toBeNull();
});
test("uses the implicit theme for a language-only code fence", () => {
const markup = renderToStaticMarkup(
<HighlightedCodeText language="javascript">
const answer = 42;
</HighlightedCodeText>
);
expect(markup).toContain("<span");
expect(markup).not.toContain('theme="github-light"');
});
test("keeps theme colors without changing typography", () => {
const markup = renderToStaticMarkup(
<HighlightedCodeText language="javascript" theme="nord">
// answer
</HighlightedCodeText>
);
const container = document.createElement("div");
container.innerHTML = markup;
const codeElement = container.querySelector("code");
expect(
codeElement?.style.getPropertyValue("--w-code-text-theme-background")
).toBe("#2e3440ff");
expect(codeElement?.style.getPropertyValue("--w-code-text-theme-color")).toBe(
"#d8dee9ff"
);
expect(markup).not.toContain("font-style");
expect(markup).not.toContain("font-weight");
});
test("preserves an author-provided tab index", () => {
const markup = renderToStaticMarkup(
<HighlightedCodeText
code="const answer = 42;"
language="javascript"
theme="github-light"
tabIndex={0}
/>
);
expect(markup).toContain('tabindex="0"');
});
test("allows a failed asset load to retry after remount", async () => {
let languageAttempts = 0;
const AsyncCodeText = createCodeText({
loaders: {
language: async () => {
languageAttempts += 1;
return languageAttempts === 1 ? undefined : javascript;
},
theme: async () => githubLight,
},
});
const props = {
children: "const answer = 42;",
language: "javascript",
theme: "github-light",
} as const;
const firstRender = render(<AsyncCodeText {...props} />);
await waitFor(() => expect(languageAttempts).toBe(1));
firstRender.unmount();
const secondRender = render(<AsyncCodeText {...props} />);
await waitFor(() => expect(languageAttempts).toBe(2));
await waitFor(() =>
expect(secondRender.container.querySelector("code span")).not.toBeNull()
);
});
test("keeps source code escaped", () => {
const source = '<img src=x onerror="unsafe()">';
const markup = renderToStaticMarkup(
<HighlightedCodeText language="javascript" theme="github-light">
{source}
</HighlightedCodeText>
);
expect(markup).toContain("<");
expect(markup).toContain("img");
expect(markup).not.toContain("<img");
expect(markup).not.toContain("onerror=");
const container = document.createElement("div");
container.innerHTML = markup;
expect(container.textContent).toBe(source);
expect(container.querySelector("img")).toBeNull();
});
test("uses default highlighting without authored props", () => {
const markup = renderToStaticMarkup(
<HighlightedCodeText>const ready = true;</HighlightedCodeText>
);
expect(markup).toContain("<span");
expect(markup).not.toContain('language="javascript"');
expect(markup).not.toContain('theme="github-light"');
});
test("falls back to plain code for an unavailable selection", () => {
expect(
renderToStaticMarkup(
<HighlightedCodeText code="puts :hello" language="ruby" theme="nord" />
)
).toBe("<code>puts :hello</code>");
});
test("renders empty text content without inserting authored text", () => {
expect(
renderToStaticMarkup(
<HighlightedCodeText language="javascript" theme="github-light">
{" "}
</HighlightedCodeText>
)
).toBe("<code> </code>");
});
test("prefers text content over the legacy code property", () => {
expect(
renderToStaticMarkup(
<HighlightedCodeText
code="legacy"
language="javascript"
theme="github-light"
>
current
</HighlightedCodeText>
)
).toContain("current");
});
test("hydrates the server markup without changing the DOM", async () => {
const element = (
<HighlightedCodeText language="javascript" theme="github-light">
const answer = 42;
</HighlightedCodeText>
);
const container = document.createElement("div");
container.innerHTML = renderToString(element);
const serverMarkup = container.innerHTML;
let root: ReturnType<typeof hydrateRoot>;
await act(async () => {
root = hydrateRoot(container, element);
});
expect(container.innerHTML).toBe(serverMarkup);
await act(async () => root.unmount());
});
test("preserves server highlighting while client assets load", async () => {
let resolveLanguage: (language: typeof javascript) => void = () => {};
const language = new Promise<typeof javascript>((resolve) => {
resolveLanguage = resolve;
});
const ServerCodeText = createCodeText({
languages: [javascript],
themes: [githubLight],
suspense: true,
});
const ClientCodeText = createCodeText({
loaders: {
language: () => language,
theme: async () => githubLight,
},
suspense: true,
});
const props = {
children: "const answer = 42;",
language: "javascript",
theme: "github-light",
} as const;
const container = document.createElement("div");
container.innerHTML = renderToString(<ServerCodeText {...props} />);
const serverMarkup = container.innerHTML;
const consoleError = vi.spyOn(console, "error").mockImplementation(() => {});
let root: ReturnType<typeof hydrateRoot>;
await act(async () => {
root = hydrateRoot(container, <ClientCodeText {...props} />);
});
expect(container.innerHTML).toBe(serverMarkup);
expect(consoleError).not.toHaveBeenCalled();
await act(async () => resolveLanguage(javascript));
await waitFor(() =>
expect(container.querySelector("code span")).not.toBeNull()
);
expect(container.innerHTML).toBe(serverMarkup);
expect(consoleError).not.toHaveBeenCalled();
await act(async () => root.unmount());
consoleError.mockRestore();
});
test("keeps the code element mounted when a bound selection changes", async () => {
let resolveLanguage: (language: typeof css) => void = () => {};
const language = new Promise<typeof css>((resolve) => {
resolveLanguage = resolve;
});
let resolveTheme: (theme: typeof nord) => void = () => {};
const theme = new Promise<typeof nord>((resolve) => {
resolveTheme = resolve;
});
const DynamicCodeText = createCodeText({
languages: [javascript],
themes: [githubLight],
loaders: {
language: () => language,
theme: () => theme,
},
suspense: true,
});
const view = render(
<DynamicCodeText
code="const answer = 42;"
language="javascript"
theme="github-light"
tabIndex={0}
/>
);
const codeElement = view.container.querySelector("code");
codeElement?.focus();
view.rerender(
<DynamicCodeText
code=".answer { color: red; }"
language="css"
theme="nord"
tabIndex={0}
/>
);
expect(view.container.querySelector("code")).toBe(codeElement);
expect(document.activeElement).toBe(codeElement);
await act(async () => {
resolveLanguage(css);
resolveTheme(nord);
});
await waitFor(() =>
expect(view.container.querySelector("code span")).not.toBeNull()
);
expect(view.container.querySelector("code")).toBe(codeElement);
expect(document.activeElement).toBe(codeElement);
expect(
codeElement?.style.getPropertyValue("--w-code-text-theme-background")
).toBe("#2e3440ff");
});
test("forwards the code element ref", async () => {
const ref = createRef<HTMLElement>();
const container = document.createElement("div");
document.body.append(container);
let root: ReturnType<typeof hydrateRoot>;
const element = (
<HighlightedCodeText
ref={ref}
code="const answer = 42;"
language="javascript"
theme="github-light"
/>
);
container.innerHTML = renderToString(element);
await act(async () => {
root = hydrateRoot(container, element);
});
expect(ref.current?.tagName).toBe("CODE");
await act(async () => root.unmount());
container.remove();
});
test("preserves the HTML language of legacy plain Code Text", () => {
expect(renderToStaticMarkup(<CodeText lang="en">legacy code</CodeText>)).toBe(
'<code lang="en">legacy code</code>'
);
});