sailfork / t3code-github / apps/ web/ src/ components/ files/ AttachmentFilePreview.browser.test.tsx
import DocumentPages, { sanitizeDocumentHtml } from "./DocumentPages";
import { act, render, stubGlobal, type Screen } from "../../../test/render";
import { EnvironmentId, ThreadId } from "@t3tools/contracts";
import { describe, expect, it, vi } from "vite-plus/test";
import { page, userEvent } from "vite-plus/test/browser";
import "~/index.css";
// Prepare the real worker before tests; Vite's worker transform adds a large inline source map.
const { refresh, assetUrlState, pdfOpens, pdfWorkerUrl } = await vi.hoisted(async () => {
const { default: source } = await import("pdfjs-dist/build/pdf.worker.min.mjs?raw");
return {
refresh: vi.fn<() => Promise<string | null>>(),
assetUrlState: vi.fn<() => import("~/assets/assetUrls").AssetUrlState>(),
pdfOpens: [] as Array<(task: import("pdfjs-dist").PDFDocumentLoadingTask) => void>,
pdfWorkerUrl: URL.createObjectURL(new Blob([source], { type: "text/javascript" })),
};
});
vi.mock(import("pdfjs-dist/build/pdf.worker.min.mjs?url"), () => ({
default: pdfWorkerUrl,
}));
vi.mock(import("~/assets/assetUrls"), async (original) => ({
...(await original()),
useAssetUrlRefresh: () => refresh,
useAssetUrlState: assetUrlState,
}));
// Hands each document pdf.js opens to the PDF test, which awaits its load instead of a poll window.
vi.mock(import("./pdfDocument"), async (original) => {
const actual = await original();
return {
...actual,
openPdf: (bytes) => {
const task = actual.openPdf(bytes);
pdfOpens.shift()?.(task);
return task;
},
};
});
// The real source view highlights through a worker pool; the text it receives is what matters here.
// Never load the original: its highlighter graph can outlast waitFor on a cold CI browser.
vi.mock(import("./ReadOnlySourcePreview"), () => ({
default: ({ text, wordWrap }: { text: string; wordWrap?: boolean }) => (
<pre data-word-wrap={String(wordWrap)}>{text}</pre>
),
}));
// The Word engine compiles about 30 MB of WebAssembly in a fresh worker per document, which took
// 10-17 s per test on loaded CI runners. These tests cover fetching, preparation and remounts, so
// the stand-in shows the prepared body's text instead of laying it out.
vi.mock(import("./office/WordDocument"), async () => {
const { use } = await import("react");
const { default: Zip } = await import("jszip");
const texts = new WeakMap<ArrayBuffer, Promise<string>>();
const read = (bytes: ArrayBuffer) =>
Zip.loadAsync(bytes)
.then((zip) => zip.file("word/document.xml")!.async("string"))
.then((xml) => xml.replace(/<[^>]+>/g, " "));
return {
default: ({ bytes }: { bytes: ArrayBuffer }) => {
let text = texts.get(bytes);
if (!text) texts.set(bytes, (text = read(bytes)));
return <pre>{use(text)}</pre>;
},
};
});
import { getClientSettings } from "~/hooks/useSettings";
import { AttachmentFilePreview } from "./AttachmentFilePreview";
import LargeTextViewer from "./LargeTextViewer";
import VirtualTablePreview from "./VirtualTablePreview";
import { OfficeFilePreview } from "./OfficeFilePreview";
import { MermaidFilePreview } from "./MermaidFilePreview";
import JSZip from "jszip";
import { boundedZip } from "@t3tools/client-runtime/zip/bounded-zip";
import BinaryViewer from "./BinaryViewer";
import { decodeImagePreview } from "./decodeImagePreview";
import type { BinaryWorkerResult } from "./binaryPreviewProtocol";
import type { TextPreviewResult } from "./largeTextProtocol";
import type { ReactElement } from "react";
// Real worker imports and WASM initialization can exceed waitFor's default second
// when the full browser project runs concurrently on CI.
describe("bounded binary previews", () => {
it("preserves length-delimited local and global PAX attributes", async () => {
const encode = (value: string) => new TextEncoder().encode(value);
const block = (name: string, content: Uint8Array, type = "0", size = content.length) => {
const bytes = new Uint8Array(512 + Math.ceil(content.length / 512) * 512);
const write = (offset: number, value: string) => bytes.set(encode(value), offset);
write(0, name);
write(124, size.toString(8).padStart(11, "0") + "\0");
bytes.fill(32, 148, 156);
write(156, type);
write(
148,
bytes
.subarray(0, 512)
.reduce((sum, byte) => sum + byte, 0)
.toString(8)
.padStart(6, "0") + "\0 ",
);
bytes.set(content, 512);
return bytes;
};
const attributes = (values: Record<string, string>) =>
encode(
Object.entries(values)
.map(([key, value]) => {
const payload = ` ${key}=${value}\n`;
let record = `${encode(payload).length + 1}${payload}`;
while (encode(record).length !== Number.parseInt(record, 10))
record = `${encode(record).length}${payload}`;
return record;
})
.join(""),
);
const chunks = [
block("Global", attributes({ size: "5", mtime: "-86400" }), "g"),
block("Local", attributes({ path: "café\n9 size=1\nname.txt" }), "x"),
block("first.txt", encode("hello"), "0", 0),
block("world.txt", encode("world"), "0", 0),
block("Local", attributes({ size: "3", mtime: "-172800" }), "x"),
block("short.txt", encode("bye"), "0", 0),
block("again.txt", encode("again"), "0", 0),
new Uint8Array(1024),
];
const bytes = new Uint8Array(chunks.reduce((size, chunk) => size + chunk.length, 0));
let offset = 0;
for (const chunk of chunks) {
bytes.set(chunk, offset);
offset += chunk.length;
}
const worker = new Worker(new URL("./binaryPreview.worker.ts", import.meta.url), {
type: "module",
});
const request = (input: object) =>
new Promise<BinaryWorkerResult>((resolve, reject) => {
worker.addEventListener("message", (event) => resolve(event.data), { once: true });
worker.addEventListener("error", reject, { once: true });
worker.postMessage(input, []);
});
try {
const result = await request({
type: "open",
kind: "archive",
name: "pax.tar",
bytes: bytes.buffer,
});
expect(result.type).toBe("archive");
if (result.type !== "archive") throw new Error("Expected archive");
expect(result.entries.map((entry) => [entry.path, entry.size, entry.modified])).toEqual([
["café\n9 size=1\nname.txt", 5, "1969-12-31T00:00:00.000Z"],
["world.txt", 5, "1969-12-31T00:00:00.000Z"],
["short.txt", 3, "1969-12-30T00:00:00.000Z"],
["again.txt", 5, "1969-12-31T00:00:00.000Z"],
]);
const entry = await request({ type: "entry", path: "café\n9 size=1\nname.txt" });
if (entry.type !== "entry") throw new Error("Expected entry");
expect(new TextDecoder().decode(entry.bytes)).toBe("hello");
expect(entry.bytes.buffer.byteLength).toBe(5);
entry.bytes[0] = 0;
const reopened = await request({ type: "entry", path: entry.path });
if (reopened.type !== "entry") throw new Error("Expected entry");
expect(new TextDecoder().decode(reopened.bytes)).toBe("hello");
expect(reopened.bytes.buffer.byteLength).toBe(5);
} finally {
worker.terminate();
}
});
it("can leave an archive folder with a repeated separator", async () => {
const bytes = new Uint8Array(2048);
const write = (offset: number, value: string) =>
bytes.set(new TextEncoder().encode(value), offset);
write(0, "a//hello.txt");
write(124, "00000000014\0");
bytes.fill(32, 148, 156);
write(156, "0");
write(
148,
bytes
.subarray(0, 512)
.reduce((sum, byte) => sum + byte, 0)
.toString(8)
.padStart(6, "0") + "\0 ",
);
write(512, "nested hello");
const src = URL.createObjectURL(new Blob([bytes]));
try {
await using screen = await render(<BinaryViewer src={src} name="paths.tar" kind="archive" />);
const child = () => screen.container.querySelector<HTMLButtonElement>("tbody button");
await vi.waitFor(() => expect(child()?.textContent).toBe("a"), 10_000);
await act(() => child()!.click());
await act(() => child()!.click());
await vi.waitFor(() => expect(child()?.textContent).toBe("hello.txt"));
const parent = () =>
screen.container.querySelector<HTMLButtonElement>('[aria-label="Parent folder"]')!;
await act(() => parent().click());
await act(() => parent().click());
expect(parent().disabled).toBe(true);
expect(child()?.textContent).toBe("a");
} finally {
URL.revokeObjectURL(src);
}
});
it("uses a PAX size override for the following TAR payload and bounds it", async () => {
const archive = (size: string) => {
const header = (name: string, size: number, type: string) => {
const bytes = new Uint8Array(512);
const write = (offset: number, value: string) =>
bytes.set(new TextEncoder().encode(value), offset);
write(0, name);
write(124, size.toString(8).padStart(11, "0") + "\0");
bytes.fill(32, 148, 156);
write(156, type);
write(
148,
bytes
.reduce((sum, byte) => sum + byte, 0)
.toString(8)
.padStart(6, "0") + "\0 ",
);
return bytes;
};
const payload = ` size=${size}\n`;
let record = `${payload.length + 1}${payload}`;
while (record.length !== Number.parseInt(record, 10)) record = `${record.length}${payload}`;
const bytes = new Uint8Array(3072);
bytes.set(header("PaxHeader", record.length, "x"));
bytes.set(new TextEncoder().encode(record), 512);
bytes.set(header("hello.txt", 0, "0"), 1024);
bytes.set(new TextEncoder().encode("hello"), 1536);
return bytes;
};
for (const size of ["5", "999999999999999999999"]) {
const src = URL.createObjectURL(new Blob([archive(size)]));
try {
await using screen = await render(<BinaryViewer src={src} name="pax.tar" kind="archive" />);
if (size === "5") {
await vi.waitFor(
() =>
expect(screen.container.querySelector("tbody button")?.textContent).toBe("hello.txt"),
10_000,
);
await act(() =>
screen.container.querySelector<HTMLButtonElement>("tbody button")!.click(),
);
await vi.waitFor(
() => expect(screen.container.querySelector("pre")?.textContent).toBe("hello"),
10_000,
);
} else {
await vi.waitFor(
() =>
expect(screen.container.querySelector('[role="alert"]')?.textContent).toContain(
"too large or damaged",
),
10_000,
);
}
} finally {
URL.revokeObjectURL(src);
}
}
});
it.each([320, 1280])(
"shows generated SQLite columns and retains picker focus at %i px",
async (width) => {
await page.viewport(width, 800);
const [{ default: initSqlJs }, { default: wasmUrl }] = await Promise.all([
import("sql.js"),
import("sql.js/dist/sql-wasm.wasm?url"),
]);
const SQL = await initSqlJs({ locateFile: () => wasmUrl });
const database = new SQL.Database();
database.run(
"CREATE TABLE sqliteData (price INTEGER, quantity INTEGER, total INTEGER GENERATED ALWAYS AS (price * quantity) STORED, doubled INTEGER GENERATED ALWAYS AS (price * 2) VIRTUAL); INSERT INTO sqliteData(price, quantity) VALUES (7, 3); CREATE TABLE zzInventory (stock INTEGER); INSERT INTO zzInventory VALUES(42)",
);
const src = URL.createObjectURL(new Blob([new Uint8Array(database.export())]));
database.close();
try {
await using screen = await render(
<BinaryViewer src={src} name="orders.sqlite" kind="sqlite" />,
);
await vi.waitFor(
() =>
expect([...screen.container.querySelectorAll("th")].map((x) => x.textContent)).toEqual([
"price",
"quantity",
"total",
"doubled",
]),
10_000,
);
expect([...screen.container.querySelectorAll("td")].map((x) => x.textContent)).toEqual([
"7",
"3",
"21",
"14",
]);
const trigger = screen.container.querySelector<HTMLButtonElement>('[aria-label="Table"]')!;
await act(() => trigger.focus());
await userEvent.keyboard("{Enter}");
await expect
.element(page.getByRole("option", { name: "zzInventory (1 rows)" }))
.toBeVisible();
await userEvent.keyboard("{ArrowDown}{Enter}");
await vi.waitFor(() =>
expect([...screen.container.querySelectorAll("td")].map((x) => x.textContent)).toEqual([
"42",
]),
);
await vi.waitFor(() => expect(document.activeElement).toBe(trigger));
await userEvent.keyboard("{Enter}");
await expect
.element(page.getByRole("option", { name: "zzInventory (1 rows)" }))
.toBeVisible();
await userEvent.keyboard("{Escape}");
} finally {
URL.revokeObjectURL(src);
await page.viewport(1280, 800);
}
},
);
it("reauthorizes a failed image when retry is clicked", async () => {
const image =
'data:image/svg+xml,<svg xmlns="http://www.w3.org/2000/svg" width="2" height="2"/>';
refresh
.mockReset()
.mockResolvedValueOnce("data:image/png;base64,broken")
.mockResolvedValue(image);
await using screen = await render(
<AttachmentFilePreview
name="photo.png"
mimeType="image/png"
sizeBytes={100}
asset={{ environmentId: EnvironmentId.make("test-environment"), attachmentId: "image" }}
/>,
);
await vi.waitFor(() =>
expect(screen.container.querySelector('[role="alert"]')?.textContent).toContain(
"Unable to load image.",
),
);
await act(() =>
screen.container.querySelector<HTMLButtonElement>('[role="alert"] button')!.click(),
);
await vi.waitFor(() =>
expect(screen.container.querySelector("img")?.getAttribute("src")).toBe(image),
);
expect(refresh).toHaveBeenCalledTimes(2);
});
it("reads a small ZIP64 archive and rejects understated directory counts", async () => {
const zip = new JSZip().file("readme.txt", "hello");
const bytes = await zip.generateAsync({ type: "uint8array" });
const end = bytes.length - 22;
const legacy = new DataView(bytes.buffer);
const extended = new Uint8Array(bytes.length + 76);
extended.set(bytes.subarray(0, end));
extended.set(bytes.subarray(end), end + 76);
const view = new DataView(extended.buffer);
view.setUint32(end, 0x06064b50, true);
view.setBigUint64(end + 4, 44n, true);
view.setBigUint64(end + 24, 1n, true);
view.setBigUint64(end + 32, 1n, true);
view.setBigUint64(end + 40, BigInt(legacy.getUint32(end + 12, true)), true);
view.setBigUint64(end + 48, BigInt(legacy.getUint32(end + 16, true)), true);
view.setUint32(end + 56, 0x07064b50, true);
view.setBigUint64(end + 64, BigInt(end), true);
view.setUint32(end + 72, 1, true);
view.setUint16(end + 76 + 10, 0xffff, true);
expect(
new TextDecoder().decode((await boundedZip(extended.buffer)).get("readme.txt")?.bytes),
).toBe("hello");
const redirected = new Uint8Array(extended.length + 56);
redirected.set(extended.subarray(0, end + 56));
redirected.set(extended.subarray(end + 56), end + 112);
const redirect = new DataView(redirected.buffer);
redirect.setUint32(end + 56, 0x06064b50, true);
redirect.setBigUint64(end + 60, 44n, true);
redirect.setBigUint64(end + 104, BigInt(end), true);
await expect(boundedZip(redirected.buffer)).rejects.toThrow("Unsupported ZIP64 directory");
const commented = new Uint8Array(extended.length + 20);
commented.set(extended);
const comment = new DataView(commented.buffer);
comment.setUint16(extended.length - 2, 20, true);
comment.setUint32(extended.length, 0x07064b50, true);
comment.setBigUint64(extended.length + 8, BigInt(end), true);
comment.setUint32(extended.length + 16, 1, true);
const load = vi.spyOn(JSZip, "loadAsync");
try {
await expect(boundedZip(commented.buffer)).rejects.toThrow("Unsupported ZIP64 directory");
expect(load).not.toHaveBeenCalled();
} finally {
load.mockRestore();
}
const many = new JSZip();
for (let i = 0; i < 2049; i++) many.file(`file-${i}`, "");
const crowded = await many.generateAsync({ type: "arraybuffer" });
new DataView(crowded).setUint16(crowded.byteLength - 12, 1, true);
await expect(boundedZip(crowded)).rejects.toThrow("more than 2,048 entries");
});
it("keeps a file and directory with the same basename accessible", async () => {
const bytes = await new JSZip()
.file("foo.txt", "root file")
.file("foo.txt/bar.txt", "child")
.generateAsync({ type: "arraybuffer" });
const src = URL.createObjectURL(new Blob([bytes]));
try {
await using screen = await render(<BinaryViewer src={src} name="names.zip" kind="archive" />);
await vi.waitFor(
() => expect(screen.container.querySelectorAll("tbody button")).toHaveLength(2),
10_000,
);
const buttons = [...screen.container.querySelectorAll<HTMLButtonElement>("tbody button")];
expect(buttons.map((button) => button.textContent)).toEqual(["foo.txt", "foo.txt"]);
await act(() => buttons[1]!.click());
await vi.waitFor(() => expect(screen.container.textContent).toContain("root file"), 10_000);
} finally {
URL.revokeObjectURL(src);
}
});
it("keeps WhiteIsZero TIFF brightness and rejects oversized metadata before decoding", async () => {
const tags = [
[256, 2],
[257, 1],
[258, 8],
[259, 1],
[262, 0],
[273, 134],
[277, 1],
[278, 1],
[279, 2],
[284, 1],
];
const bytes = new ArrayBuffer(136);
const view = new DataView(bytes);
view.setUint16(0, 0x4949);
view.setUint16(2, 42, true);
view.setUint32(4, 8, true);
view.setUint16(8, tags.length, true);
tags.forEach(([tag, value], index) => {
const offset = 10 + index * 12;
view.setUint16(offset, tag!, true);
view.setUint16(offset + 2, 4, true);
view.setUint32(offset + 4, 1, true);
view.setUint32(offset + 8, value!, true);
});
view.setUint8(135, 255);
const src = URL.createObjectURL(new Blob([bytes]));
try {
const blob = await decodeImagePreview(src, false, new AbortController().signal);
const bitmap = await createImageBitmap(blob);
const canvas = new OffscreenCanvas(2, 1);
const context = canvas.getContext("2d")!;
context.drawImage(bitmap, 0, 0);
expect([...context.getImageData(0, 0, 2, 1).data]).toEqual([
255, 255, 255, 255, 0, 0, 0, 255,
]);
bitmap.close();
} finally {
URL.revokeObjectURL(src);
}
view.setUint32(14, 1_000_000, true);
const invalid = URL.createObjectURL(new Blob([bytes]));
try {
await expect(
decodeImagePreview(invalid, false, new AbortController().signal),
).rejects.toThrow("metadata");
} finally {
URL.revokeObjectURL(invalid);
}
});
});
import { OFFICE_PREVIEW_MAX_COLUMNS, type OfficeWorkerResult } from "./officePreviewProtocol";
describe("large text preview recovery", () => {
it("retains the workspace viewer across URL renewals and reloads revisions and manual refreshes", async () => {
const { WorkspaceLargeTextPreview } = await import("./FilePreviewPanel");
const original = URL.createObjectURL(new Blob(["original\n".repeat(1000)]));
const changed = URL.createObjectURL(new Blob(["changed\n".repeat(1000)]));
const workers: Worker[] = [];
const indexed: Promise<void>[] = [];
using _worker = stubGlobal(
"Worker",
class extends Worker {
constructor(...args: ConstructorParameters<typeof Worker>) {
super(...args);
workers.push(this);
indexed.push(
new Promise((resolve) =>
this.addEventListener("message", (event: MessageEvent<TextPreviewResult>) => {
if (event.data.type === "meta" && event.data.complete) resolve();
}),
),
);
}
},
);
const preview = (mutation: string, key = 0) => (
<div style={{ display: "flex", flexDirection: "column", height: 400, width: 600 }}>
<WorkspaceLargeTextPreview
key={key}
environmentId={EnvironmentId.make("test")}
threadRef={{ environmentId: EnvironmentId.make("test"), threadId: ThreadId.make("test") }}
absolutePath="/repo/large.txt"
name="large.txt"
delimiter={null}
workspaceMutationId={mutation}
revealLine={null}
revealRequestId={0}
wordWrap
/>
</div>
);
const state = (url: string, fileRevision?: string) =>
assetUrlState.mockReturnValue({
_tag: "Success",
url,
expiresAt: Date.now() + 3_600_000,
...(fileRevision === undefined ? {} : { fileRevision }),
});
refresh.mockResolvedValue(`${original}#renewed`);
try {
state(`${original}#initial`, "one");
await using screen = await render(preview("first"));
await vi.waitFor(() => expect(workers).toHaveLength(1));
await vi.waitFor(() => expect(screen.container.textContent).toContain("original"));
// A cold worker can take longer than waitFor allows to load and index on CI.
await indexed[0];
await vi.waitFor(() => expect(screen.container.textContent).toContain("1,000 lines"));
const viewport = screen.container.querySelector<HTMLElement>('[tabindex="0"]')!;
await act(() =>
viewport.dispatchEvent(
new WheelEvent("wheel", { deltaY: 250, bubbles: true, cancelable: true }),
),
);
await vi.waitFor(() => expect(viewport.scrollTop).toBeGreaterThan(0));
const scrollTop = viewport.scrollTop;
state(`${original}#renewed`, "one");
await screen.rerender(preview("unrelated-command"));
expect(screen.container.querySelector('[tabindex="0"]')).toBe(viewport);
expect(viewport.scrollTop).toBe(scrollTop);
expect(workers).toHaveLength(1);
state(`${changed}#updated`, "two");
await screen.rerender(preview("file-edit"));
// The prefetched first screen paints before the worker starts, so wait for the worker itself.
await vi.waitFor(() => expect(workers).toHaveLength(2));
await vi.waitFor(() => expect(screen.container.textContent).toContain("changed"));
await screen.rerender(preview("file-edit", 1));
await vi.waitFor(() => expect(workers).toHaveLength(3));
await vi.waitFor(() => expect(screen.container.textContent).toContain("changed"));
state(`${original}#legacy`);
await screen.rerender(preview("legacy-edit", 1));
await vi.waitFor(() => expect(workers).toHaveLength(4));
await vi.waitFor(() => expect(screen.container.textContent).toContain("original"));
assetUrlState.mockReturnValue({ _tag: "Failure" });
await screen.rerender(preview("legacy-edit", 1));
expect(screen.container.textContent).toContain("Unable to load file preview.");
refresh.mockClear();
refresh.mockImplementation(async () => {
state(`${changed}#retried`);
return changed;
});
await screen.getByRole("button", { name: "Try again" }).click();
expect(refresh).toHaveBeenCalledOnce();
await screen.rerender(preview("legacy-edit", 1));
await vi.waitFor(() => expect(screen.container.textContent).toContain("changed"));
expect(screen.container.querySelector('[role="alert"]')).toBeNull();
} finally {
URL.revokeObjectURL(original);
URL.revokeObjectURL(changed);
}
});
it("scrolls within a wrapped row when the row-count track is shorter than the viewport", async () => {
await using screen = await render(
<div style={{ display: "flex", height: 400, width: 600 }}>
<VirtualTablePreview
name="one.txt"
count={1}
columns={1}
source
wrap
getRows={() => [["wrapped source text ".repeat(500)]]}
/>
</div>,
);
const row = () => screen.container.querySelector<HTMLElement>('[data-preview-row="0"]')!;
const viewport = () => screen.container.querySelector<HTMLElement>('[tabindex="0"]')!;
await vi.waitFor(() => expect(row()?.offsetHeight).toBeGreaterThan(1000));
await act(() =>
viewport().dispatchEvent(
new WheelEvent("wheel", { deltaY: 150, bubbles: true, cancelable: true }),
),
);
await vi.waitFor(() => {
const offset = viewport().getBoundingClientRect().top - row().getBoundingClientRect().top;
expect(offset).toBeGreaterThan(50);
expect(offset).toBeLessThan(300);
});
await act(() =>
viewport().dispatchEvent(new KeyboardEvent("keydown", { key: "End", bubbles: true })),
);
await vi.waitFor(() =>
expect(
Math.abs(row().getBoundingClientRect().bottom - viewport().getBoundingClientRect().bottom),
).toBeLessThan(2),
);
await act(() =>
viewport().dispatchEvent(new KeyboardEvent("keydown", { key: "Home", bubbles: true })),
);
await vi.waitFor(() =>
expect(row().getBoundingClientRect().top).toBe(viewport().getBoundingClientRect().top),
);
});
it("scrolls every tall row in the final virtual viewport", async () => {
const view = (loaded: boolean) => (
<div style={{ display: "flex", height: 400, width: 600 }}>
<VirtualTablePreview
name="tail.txt"
count={100}
columns={1}
source
wrap
getRows={(page) =>
!loaded && page > 0
? undefined
: Array.from({ length: 32 }, (_, i) => [
"line-" + (page * 32 + i + 1) + " wrapped source text".repeat(500),
])
}
/>
</div>
);
await using screen = await render(view(false));
const viewport = () => screen.container.querySelector<HTMLElement>('[tabindex="0"]')!;
const row = (index: number) =>
screen.container.querySelector<HTMLElement>('[data-preview-row="' + index + '"]')!;
await vi.waitFor(() => expect(row(0)?.offsetHeight).toBeGreaterThan(1000));
await act(() =>
viewport().dispatchEvent(new KeyboardEvent("keydown", { key: "End", bubbles: true })),
);
await vi.waitFor(() => expect(row(99)).not.toBeNull());
await screen.rerender(view(true));
await vi.waitFor(() =>
expect(
Math.abs(
row(99).getBoundingClientRect().bottom - viewport().getBoundingClientRect().bottom,
),
).toBeLessThan(2),
);
await act(() =>
viewport().dispatchEvent(new KeyboardEvent("keydown", { key: "Home", bubbles: true })),
);
await vi.waitFor(() => expect(row(0)).not.toBeNull());
await act(() => {
viewport().scrollTop = 100 * 29 - viewport().clientHeight;
viewport().dispatchEvent(new Event("scroll", { bubbles: true }));
});
const checkTop = (index: number) =>
expect(
Math.abs(row(index).getBoundingClientRect().top - viewport().getBoundingClientRect().top),
).toBeLessThan(2);
await vi.waitFor(() => checkTop(87));
for (let index = 88; index < 100; index++) {
await act(() =>
viewport().dispatchEvent(
new WheelEvent("wheel", {
deltaY: row(index - 1).offsetHeight,
bubbles: true,
cancelable: true,
}),
),
);
if (index < 99) await vi.waitFor(() => checkTop(index));
}
await act(() =>
viewport().dispatchEvent(new KeyboardEvent("keydown", { key: "End", bubbles: true })),
);
await vi.waitFor(() =>
expect(
Math.abs(
row(99).getBoundingClientRect().bottom - viewport().getBoundingClientRect().bottom,
),
).toBeLessThan(2),
);
});
it("rejects malformed UTF-8 bytes through the real text worker", async () => {
const src = URL.createObjectURL(new Blob([new Uint8Array([0xe9, 10])]));
try {
await using screen = await render(
<LargeTextViewer src={src} name="latin.txt" delimiter={null} />,
);
await vi.waitFor(
() => expect(screen.container.querySelector('[role="alert"]')).not.toBeNull(),
10_000,
);
} finally {
URL.revokeObjectURL(src);
}
});
it("replaces both prefetched pages with the worker's current file version", async () => {
const old = Array.from({ length: 64 }, (_, i) => "old-" + i).join("\n") + "\n";
const current = Array.from({ length: 100 }, (_, i) => "current-" + i).join("\n");
const src = URL.createObjectURL(new Blob([current]));
using _fetch = stubGlobal(
"fetch",
vi.fn().mockResolvedValue(
new Response(old, {
status: 206,
headers: {
"content-length": String(old.length),
"content-range": "bytes 0-" + (old.length - 1) + "/100000",
},
}),
),
);
try {
await using screen = await render(
<div style={{ display: "flex", height: 2000, width: 600 }}>
<LargeTextViewer src={src} name="log.txt" delimiter={null} />
</div>,
);
await vi.waitFor(() => expect(screen.container.textContent).toContain("current-40"), 10_000);
expect(screen.container.textContent).not.toContain("old-");
} finally {
URL.revokeObjectURL(src);
}
});
it("fills the horizontal viewport using measured column widths", async () => {
const header = Array.from({ length: 20 }, (_, i) => "C" + i);
await using screen = await render(
<div style={{ display: "flex", height: 400, width: 400 }}>
<VirtualTablePreview
name="wide.csv"
count={2}
columns={20}
header={header}
getRows={() => [header, header]}
/>
</div>,
);
const outer = () => screen.container.querySelector('[role="table"]')!.parentElement!;
const check = () => {
const cells = screen.container.querySelectorAll('[role="columnheader"]');
expect(cells.length).toBeGreaterThan(0);
expect(cells[cells.length - 1]!.getBoundingClientRect().right).toBeGreaterThanOrEqual(
outer().getBoundingClientRect().right - 1,
);
};
await vi.waitFor(check);
await act(() => {
outer().scrollLeft = outer().scrollWidth;
outer().dispatchEvent(new Event("scroll", { bubbles: true }));
});
await vi.waitFor(check);
expect(screen.container.textContent).toContain("C19");
});
it("reveals and highlights requested source lines again for a new request", async () => {
const view = (line: number, request: number, loaded = true) => (
<div style={{ display: "flex", height: 400, width: 600 }}>
<VirtualTablePreview
name="log.txt"
count={1000}
columns={1}
source
wrap
revealLine={line}
revealRequestId={request}
getRows={(page) =>
loaded || page === 0
? Array.from({ length: 32 }, (_, i) => [
"line-" + (page * 32 + i + 1) + " wrapped source text".repeat(20),
])
: undefined
}
/>
</div>
);
await using screen = await render(view(500, 1, false));
await vi.waitFor(() =>
expect(screen.container.querySelector('[data-preview-reveal="true"]')?.textContent).toBe(
"500",
),
);
await screen.rerender(view(500, 1));
await vi.waitFor(() =>
expect(screen.container.querySelector('[data-preview-reveal="true"]')?.textContent).toContain(
"line-500",
),
);
const checkVisible = () => {
const row = screen.container.querySelector<HTMLElement>('[data-preview-reveal="true"]')!;
const viewport = screen.container.querySelector<HTMLElement>('[tabindex="0"]')!;
expect(row.getBoundingClientRect().top).toBeGreaterThanOrEqual(
viewport.getBoundingClientRect().top - 1,
);
expect(row.getBoundingClientRect().bottom).toBeLessThanOrEqual(
viewport.getBoundingClientRect().bottom + 1,
);
};
await vi.waitFor(checkVisible);
await screen.rerender(view(900, 2));
await vi.waitFor(() =>
expect(screen.container.querySelector('[data-preview-reveal="true"]')?.textContent).toContain(
"line-900",
),
);
await vi.waitFor(checkVisible);
await screen.rerender(view(999, 3));
await vi.waitFor(() =>
expect(screen.container.querySelector('[data-preview-reveal="true"]')?.textContent).toContain(
"line-999",
),
);
await vi.waitFor(checkVisible);
});
it.each(
[5, 100, 10_000].flatMap((count) => [false, true].map((mixed) => [count, mixed] as const)),
)(
"preserves the source row when indexing grows beyond %i lines (mixed heights: %s)",
async (count, mixed) => {
const view = (count: number) => (
<div style={{ display: "flex", height: 400, width: 600 }}>
<VirtualTablePreview
name="growing.txt"
count={count}
columns={1}
source
wrap
getRows={(page) =>
Array.from({ length: 32 }, (_, i) => [
`line-${page * 32 + i + 1} ` +
"wrapped source text ".repeat(mixed ? 5 + (i % 4) * 20 : 20),
])
}
/>
</div>
);
await using screen = await render(view(count));
const viewport = () => screen.container.querySelector<HTMLElement>('[tabindex="0"]')!;
await vi.waitFor(() => expect(viewport()?.scrollHeight).toBeGreaterThan(400));
await act(() => {
viewport().scrollTop = count === 100 ? 100 * 29 - 400 + 1200 : 1200;
viewport().dispatchEvent(new Event("scroll", { bubbles: true }));
});
const visibleRow = () =>
[...screen.container.querySelectorAll<HTMLElement>("[data-preview-row]")].find(
(row) => row.getBoundingClientRect().bottom > viewport().getBoundingClientRect().top + 1,
)!;
await vi.waitFor(() => expect(visibleRow()).toBeDefined());
const before = visibleRow().dataset.previewRow;
const offset =
visibleRow().getBoundingClientRect().top - viewport().getBoundingClientRect().top;
await screen.rerender(view(1_000_000));
await vi.waitFor(() => {
expect(visibleRow().dataset.previewRow).toBe(before);
expect(
Math.abs(
visibleRow().getBoundingClientRect().top -
viewport().getBoundingClientRect().top -
offset,
),
).toBeLessThan(Math.max(5, visibleRow().offsetHeight / 29 + 1));
});
},
);
it("recovers from a failed worker load when its source changes", async () => {
await using screen = await render(
<LargeTextViewer name="log.txt" text={"bad\0text"} delimiter={null} />,
);
await vi.waitFor(
() => expect(screen.container.textContent).toContain("This file contains binary data."),
10_000,
);
await screen.rerender(<LargeTextViewer name="log.txt" text="" delimiter={null} />);
await vi.waitFor(
() => expect(screen.container.textContent).toContain("This file is empty."),
10_000,
);
expect(screen.container.querySelector('[role="alert"]')).toBeNull();
});
it("reloads a partial page when the indexed row count grows", async () => {
const load = vi.fn();
const rows = [["first"]];
const view = (count: number) => (
<div style={{ display: "flex", height: 400, width: 600 }}>
<VirtualTablePreview
name="log.txt"
count={count}
columns={1}
source
getRows={() => rows}
loadPage={load}
/>
</div>
);
await using screen = await render(view(1));
await vi.waitFor(() => expect(screen.container.textContent).toContain("first"));
expect(load).not.toHaveBeenCalled();
await screen.rerender(view(2));
await vi.waitFor(() => expect(load).toHaveBeenCalledWith(0));
});
});
it.each(["<w:body/>", "<w:body></w:body>"])(
"opens an empty Word document with %s",
async (body) => {
const { default: JSZip } = await import("jszip");
const { prepareOffice } = await import("./officeArchive");
const archive = new JSZip().file(
"word/document.xml",
`<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main">${body}</w:document>`,
);
const prepared = await prepareOffice(
await archive.generateAsync({ type: "arraybuffer" }),
"docx",
);
const result = await JSZip.loadAsync(prepared.bytes);
const xml = new DOMParser().parseFromString(
await result.file("word/document.xml")!.async("string"),
"application/xml",
);
expect(xml.querySelector("parsererror")).toBeNull();
expect(
xml.getElementsByTagNameNS(
"http://schemas.openxmlformats.org/wordprocessingml/2006/main",
"body",
),
).toHaveLength(1);
},
);
it.each([false, true])(
"rejects excessive archive entries before JSZip (directories: %s)",
async (directories) => {
const { default: JSZip } = await import("jszip");
const { prepareOffice } = await import("./officeArchive");
const archive = new JSZip();
for (let i = 0; i < 4096; i++)
archive.file(`entry-${i}${directories ? "/" : ".txt"}`, "", { dir: directories });
const bytes = await archive.generateAsync({ type: "arraybuffer" });
const load = vi.spyOn(JSZip, "loadAsync");
try {
await expect(prepareOffice(bytes, "docx")).rejects.toThrow("2,048 entries");
expect(load).not.toHaveBeenCalled();
// The actual central-directory records must also be bounded if EOCD lies.
const view = new DataView(bytes);
view.setUint16(bytes.byteLength - 22 + 8, 1, true);
view.setUint16(bytes.byteLength - 22 + 10, 1, true);
await expect(prepareOffice(bytes, "docx")).rejects.toThrow("2,048 entries");
expect(load).not.toHaveBeenCalled();
} finally {
load.mockRestore();
}
},
);
it("rejects oversized embedded images before decoding pixels and retains ordinary images", async () => {
const { officeImageBitmap } = await import("./office/image-bitmap");
const canvas = new OffscreenCanvas(2, 3);
canvas.getContext("2d");
const blob = await canvas.convertToBlob({ type: "image/png" });
const bytes = await blob.arrayBuffer();
new DataView(bytes).setUint32(16, 12000);
new DataView(bytes).setUint32(20, 12000);
const decode = vi.spyOn(globalThis, "createImageBitmap");
try {
await expect(officeImageBitmap(new Blob([bytes]))).rejects.toThrow("pixel limit");
expect(decode).not.toHaveBeenCalled();
const bitmap = await officeImageBitmap(blob);
expect([bitmap.width, bitmap.height]).toEqual([2, 3]);
bitmap.close();
} finally {
decode.mockRestore();
}
});
it.each(["utf-16le", "utf-16be", "windows-1252"])(
"preserves %s Office XML and safe hyperlink targets",
async (encoding) => {
const { default: JSZip } = await import("jszip");
const { prepareOffice } = await import("./officeArchive");
const archive = new JSZip();
const encode = (text: string) => {
const xml = `<?xml version="1.0" encoding="${encoding}"?>${text}`;
if (encoding === "windows-1252") return Uint8Array.from(xml, (char) => char.charCodeAt(0));
const bytes = new Uint8Array(2 + xml.length * 2);
const view = new DataView(bytes.buffer);
const little = encoding === "utf-16le";
view.setUint16(0, 0xfeff, little);
for (let i = 0; i < xml.length; i++) view.setUint16(2 + i * 2, xml.charCodeAt(i), little);
return bytes;
};
archive.file(
"word/document.xml",
encode(
'<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:body><w:p><w:r><w:t>café</w:t></w:r></w:p></w:body></w:document>',
),
);
archive.file(
"word/_rels/document.xml.rels",
encode(
`<Relationships>${["https://example.com/page", "http://example.com", "mailto:maria@example.com", "javascript:alert(1)", "file:///tmp/private"].map((target, i) => `<Relationship Id="r${i}" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink" TargetMode="External" Target="${target}"/>`).join("")}</Relationships>`,
),
);
const prepared = await prepareOffice(
await archive.generateAsync({ type: "arraybuffer" }),
"docx",
);
const result = await JSZip.loadAsync(prepared.bytes);
expect(await result.file("word/document.xml")!.async("string")).toContain("café");
const links = await result.file("word/_rels/document.xml.rels")!.async("string");
expect(links).toContain('encoding="UTF-8"');
expect(links).toContain("https://example.com/page");
expect(links).toContain("http://example.com");
expect(links).toContain("mailto:maria@example.com");
expect(links).not.toContain("javascript:");
expect(links).not.toContain("file:");
},
);
it.each([
["", "worksheets/./sheet1.xml", false],
["x:", "../xl/worksheets/sheet1.xml", false],
["", "/xl/worksheets/sheet1.xml", true],
])("preserves %sworksheet metadata with relationship target %s", async (prefix, target, empty) => {
const { default: JSZip } = await import("jszip");
const archive = new JSZip();
const ns = "http://schemas.openxmlformats.org/spreadsheetml/2006/main";
archive.file(
"xl/workbook.xml",
'<workbook xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><sheets><sheet name="Sheet" sheetId="1" r:id="s"/></sheets></workbook>',
);
archive.file(
"xl/_rels/workbook.xml.rels",
`<Relationships><Relationship Id="s" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="${target}"/></Relationships>`,
);
archive.file(
"xl/worksheets/sheet1.xml",
`<${prefix}worksheet xmlns${prefix ? ":x" : ""}="${ns}"><${prefix}dimension ref="XFD1048576"/><${prefix}cols><${prefix}col min="${OFFICE_PREVIEW_MAX_COLUMNS - 1}" max="${OFFICE_PREVIEW_MAX_COLUMNS + 10}" width="20"/><${prefix}col min="${OFFICE_PREVIEW_MAX_COLUMNS + 1}" max="${OFFICE_PREVIEW_MAX_COLUMNS + 30}" hidden="1"/></${prefix}cols><${prefix}sheetData><${prefix}row ht="42" customHeight="1" hidden="1"><${prefix}c r="A50" t="inlineStr"><${prefix}is><${prefix}t>${"value".repeat(1000)}</${prefix}t></${prefix}is></${prefix}c></${prefix}row></${prefix}sheetData><${prefix}mergeCells><${prefix}mergeCell ref="XFD1048576"/></${prefix}mergeCells></${prefix}worksheet>`
.replace(/<((?:x:)?(?:col|dimension|mergeCell))\b([^>]*)\/>/g, prefix ? "<$1$2></$1>" : "Loading Sailfork
amp;")
.replace(/<sheetData>[\s\S]*?<\/sheetData>/, (data) => (empty ? "<sheetData/>" : data))
.replace(/="([^"]*)"/g, (attribute, value: string) =>
prefix || empty
? ` = '${value.replace(/\d/g, (digit) => `&#${digit.charCodeAt(0)};`)}'`
: attribute,
),
);
const bytes = await archive.generateAsync({ type: "arraybuffer" });
const worker = new Worker(new URL("./officePreview.worker.ts", import.meta.url), {
type: "module",
});
try {
const result = await new Promise<OfficeWorkerResult>((resolve) => {
worker.addEventListener(
"message",
(event: MessageEvent<OfficeWorkerResult>) => resolve(event.data),
{ once: true },
);
worker.postMessage({ type: "open", kind: "xlsx", bytes }, [bytes]);
});
expect(result.type).toBe("xlsx");
if (result.type !== "xlsx") throw new Error("Expected bounded workbook");
const bounded = await JSZip.loadAsync(result.bytes);
const sheet = new DOMParser().parseFromString(
await bounded.file("xl/worksheets/sheet1.xml")!.async("string"),
"application/xml",
);
expect(sheet.querySelector("parsererror")).toBeNull();
const row = sheet.getElementsByTagNameNS(ns, "row")[0];
if (empty) expect(row).toBeUndefined();
else {
expect(row!.getAttribute("ht")).toBe("42");
expect(row!.getAttribute("hidden")).toBe("1");
expect(row!.getElementsByTagNameNS(ns, "c")[0]!.getAttribute("r")).toBe("A50");
expect(row!.getElementsByTagNameNS(ns, "t")[0]!.textContent).toHaveLength(4096);
}
expect(sheet.getElementsByTagNameNS(ns, "dimension")).toHaveLength(0);
expect(sheet.getElementsByTagNameNS(ns, "mergeCell")).toHaveLength(0);
const columns = sheet.getElementsByTagNameNS(ns, "col");
expect(columns).toHaveLength(1);
expect(columns[0]!.getAttribute("min")).toBe(String(OFFICE_PREVIEW_MAX_COLUMNS - 1));
expect(columns[0]!.getAttribute("max")).toBe(String(OFFICE_PREVIEW_MAX_COLUMNS));
} finally {
worker.terminate();
}
});
it("reports the final slide at maximum scroll after page visibility changes", async () => {
const { OfficePages } = await import("./office/OfficePages");
const changed = vi.fn();
const container = document.createElement("div");
container.style.cssText = "display:flex;flex-direction:column;width:400px;height:400px";
await using screen = await render(
<OfficePages
pages={Array.from({ length: 6 }, () => ({ width: 400, height: 240 }))}
label="Slide"
paint={async () => undefined}
onPageChange={changed}
onError={(error) => {
throw error;
}}
/>,
{ container },
);
const scroller = screen.container.querySelector<HTMLElement>("[data-office-pages]")!;
await vi.waitFor(() => expect(scroller.scrollHeight).toBeGreaterThan(scroller.clientHeight));
await act(() => {
scroller.scrollTop = scroller.scrollHeight;
});
await vi.waitFor(() => expect(changed).toHaveBeenLastCalledWith(5));
await act(() => {
scroller.scrollTop = 10;
});
await vi.waitFor(() => expect(changed).toHaveBeenLastCalledWith(0));
});
it("preserves merged text across tile clears", async () => {
const { paintFrame } = await import("./office/sheet-frame");
const canvas = new OffscreenCanvas(400, 80);
const context = canvas.getContext("2d")!;
paintFrame(
context,
{
viewport: { x: 0, y: 0, width: 400, height: 80 },
list: { width: 400, height: 80, commands: [] },
tiles: [
{
x: 0,
y: 0,
clipX: 0,
clipY: 0,
list: {
width: 208,
height: 80,
commands: [
{
op: "text",
x: 2,
y: 40,
text: "MMMMMMMMMMMMMMMMMMMMMMMM",
fontSize: 20,
color: "#000",
clip: { x: 0, y: 0, w: 400, h: 80 },
},
],
},
},
{ x: 192, y: 0, clipX: 200, clipY: 0, list: { width: 208, height: 80, commands: [] } },
],
},
{ ratio: 1, origin: { x: 0, y: 0 } },
);
const pixels = context.getImageData(240, 15, 100, 35).data;
expect(pixels.some((value, index) => index % 4 === 3 && value > 0)).toBe(true);
});
it.each([
"paragraphs",
"runs",
"tables",
"auxiliary XML",
"XML bytes",
"renamed XML",
"section after prefix",
"oversized section",
])("bounds excessive Word %s before rendering DOM", async (scenario) => {
const { default: JSZip } = await import("jszip");
const archive = new JSZip();
const body = ["paragraphs", "section after prefix", "oversized section"].includes(scenario)
? "<w:p><w:r><w:t>x</w:t></w:r></w:p>".repeat(200_000)
: scenario === "runs"
? `<w:p>${"<w:r><w:t>x</w:t></w:r>".repeat(50_001)}</w:p>`
: scenario === "tables"
? "<w:tbl/>".repeat(50_001)
: scenario === "XML bytes"
? `<w:p><w:r><w:t>${"x".repeat(2 * 1024 * 1024)}</w:t></w:r></w:p>`
: "<w:p/>";
const section =
'<w:sectPr><w:pgSz w:w="16838" w:h="11906" w:orient="landscape"/><w:pgMar w:top="1440" w:left="1440" w:bottom="1440" w:right="1440"/></w:sectPr>';
archive.file(
"word/document.xml",
`<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:body>${body}${scenario === "section after prefix" ? '<w:p xmlns:s="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:pPr><s:sectPr><s:pgSz s:w="11906" s:h="16838"/></s:sectPr></w:pPr></w:p>' : ""}${scenario === "oversized section" ? `<w:sectPr>${"<w:cols/>".repeat(2_001)}</w:sectPr>` : section}</w:body></w:document>`,
);
if (scenario === "auxiliary XML" || scenario === "renamed XML")
archive.file(
scenario === "renamed XML" ? "word/footnotes.dat" : "word/footnotes.xml",
`<w:footnotes>${"<w:p/>".repeat(50_001)}</w:footnotes>`,
);
const file = await archive.generateAsync({ type: "blob", compression: "DEFLATE" });
const src = URL.createObjectURL(file);
try {
const worker = new Worker(new URL("./officePreview.worker.ts", import.meta.url), {
type: "module",
});
try {
const result = await new Promise<OfficeWorkerResult>((resolve) => {
worker.addEventListener(
"message",
(event: MessageEvent<OfficeWorkerResult>) => resolve(event.data),
{ once: true },
);
void file
.arrayBuffer()
.then((bytes) => worker.postMessage({ type: "open", kind: "docx", bytes }, [bytes]));
});
if (
scenario === "auxiliary XML" ||
scenario === "renamed XML" ||
scenario === "oversized section"
) {
expect(result).toMatchObject({
type: "error",
message: expect.stringContaining("Preview limited"),
});
} else {
expect(result.type).toBe("docx");
if (result.type !== "docx") throw new Error("Expected a Word prefix");
expect(result.truncated).toBe(true);
const bounded = await JSZip.loadAsync(result.bytes);
const markup = await bounded.file("word/document.xml")!.async("string");
{
const xml = markup;
const document = new DOMParser().parseFromString(xml, "application/xml");
expect(document.querySelector("parsererror")).toBeNull();
const bodies = document.getElementsByTagNameNS("*", "body");
expect(bodies).toHaveLength(1);
const section = bodies[0]!.lastElementChild!;
expect(section.localName).toBe("sectPr");
const size = section.getElementsByTagNameNS("*", "pgSz")[0]!;
expect(size.getAttributeNS(section.namespaceURI, "w")).toBe(
scenario === "section after prefix" ? "11906" : "16838",
);
expect(size.getAttributeNS(section.namespaceURI, "orient")).toBe(
scenario === "section after prefix" ? null : "landscape",
);
}
expect(markup.length).toBeLessThan(body.length);
expect(markup.length).toBeLessThanOrEqual(3 * 1024 * 1024);
expect(markup.match(/<(?![!?/])/g)!.length).toBeLessThanOrEqual(100_000);
}
} finally {
worker.terminate();
}
} finally {
URL.revokeObjectURL(src);
}
});
it.each([
"relationship markup",
"relationship bytes",
"content type",
"metadata type",
"deep XML",
"query path",
])("bounds XML hidden in media by %s", async (scenario) => {
const { default: JSZip } = await import("jszip");
const archive = new JSZip();
const path = `word/media/payload.png${scenario === "query path" ? "?xml" : ""}`;
archive.file(
"word/document.xml",
'<w:document xmlns:w="http://schemas.openxmlformats.org/wordprocessingml/2006/main"><w:body><w:p/></w:body></w:document>',
);
archive.file(
"[Content_Types].xml",
`<Types><Override PartName="/${path}" ContentType="${scenario === "content type" ? "application/vnd.openxmlformats-officedocument.wordprocessingml.styles+xml" : "image/png"}"/>${scenario === "metadata type" ? '<Default Extension="rels" ContentType="image/png"/>' : ""}</Types>`,
);
archive.file(
"word/_rels/document.xml.rels",
`<Relationships>${scenario === "content type" ? "" : `<Relationship Id="style" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles" Target="${path.slice(5)}"/>`}${scenario === "metadata type" ? "<unused/>".repeat(50_001) : ""}</Relationships>`,
);
archive.file(
path,
scenario === "relationship bytes"
? `<styles>${"x".repeat(1024 * 1024)}</styles>`
: scenario === "deep XML"
? `${"<styles>".repeat(65)}${"</styles>".repeat(65)}`
: `<styles>${"<style/>".repeat(50_001)}</styles>`,
);
const bytes = await archive.generateAsync({ type: "arraybuffer", compression: "DEFLATE" });
const worker = new Worker(new URL("./officePreview.worker.ts", import.meta.url), {
type: "module",
});
try {
const result = await new Promise<OfficeWorkerResult>((resolve) => {
worker.addEventListener(
"message",
(event: MessageEvent<OfficeWorkerResult>) => resolve(event.data),
{ once: true },
);
worker.postMessage({ type: "open", kind: "docx", bytes }, [bytes]);
});
expect(result).toMatchObject({
type: "error",
message: expect.stringContaining("Preview limited"),
});
} finally {
worker.terminate();
}
});
const EXPANDED_WORD_ROLES = [
"footnotes",
"note roots",
"endnotes",
"header",
"footer",
"comments",
"styles",
"style chain",
"style count",
"style visits",
"numbering",
"picture numbering",
] as const;
async function expandedWordFixture(role: (typeof EXPANDED_WORD_ROLES)[number]) {
const archive = new JSZip();
const ns = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
const type = role.startsWith("style")
? "styles"
: role === "picture numbering"
? "numbering"
: role === "note roots"
? "footnotes"
: role;
archive.file(
"_rels/.rels",
'<Relationships><Relationship Id="doc" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="word/document.xml"/></Relationships>',
);
const text = (value: string) => `<w:p><w:r><w:t>${value}</w:t></w:r></w:p>`;
// Each copy of the 2,000-paragraph payload costs 8,000 markup units, so 20
// references (or pages) exceed the 100,000-unit expansion budget.
archive.file(
"word/document.xml",
`<w:document xmlns:w="${ns}" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><w:body>${text("body retained")}${Array.from({ length: 20 }, () => `<w:p><w:r><w:footnoteReference w:id="1"/><w:endnoteReference w:id="1"/><w:commentReference w:id="1"/><w:br w:type="page"/></w:r></w:p>`).join("")}<w:sectPr><w:headerReference w:type="default" r:id="aux"/><w:footerReference w:type="default" r:id="aux"/></w:sectPr></w:body></w:document>`,
);
archive.file(
"word/_rels/document.xml.rels",
`<Relationships><Relationship Id="aux" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/${type}" Target="media/aux.xml"/></Relationships>`,
);
const xml =
role === "style chain" || role === "style count" || role === "style visits"
? `<w:styles xmlns:w="${ns}">${Array.from({ length: role === "style count" ? 3_000 : 1_000 }, (_, i) => `<w:style w:styleId="s${i}" w:type="paragraph">${i ? `<w:basedOn w:val="s${role === "style visits" && i >= 30 ? 29 : i - 1}"/>` : ""}<w:pPr><w:spacing w:after="120"/></w:pPr></w:style>`).join("")}</w:styles>`
: role === "styles"
? `<w:styles xmlns:w="${ns}">${Array.from({ length: 100 }, (_, i) => `<w:style w:styleId="${"s".repeat(2_000)}${i}" w:type="paragraph"><w:basedOn w:val="s0"/><w:pPr><w:spacing w:after="120"/></w:pPr></w:style>`).join("")}</w:styles>`
: role.includes("numbering")
? `<w:numbering xmlns:w="${ns}">${role === "picture numbering" ? '<w:numPicBullet w:numPicBulletId="1"/>' : ""}<w:abstractNum w:abstractNumId="1">${Array.from({ length: 9 }, (_, i) => `<w:lvl w:ilvl="${i}"><w:lvlText w:val="%1."/></w:lvl>`).join("")}</w:abstractNum>${Array.from({ length: 100 }, (_, i) => `<w:num w:numId="${i}"><w:abstractNumId w:val="1"/></w:num>`).join("")}</w:numbering>`
: role === "header" || role === "footer"
? `<w:${role === "header" ? "hdr" : "ftr"} xmlns:w="${ns}">${text("omitted payload").repeat(2_000)}</w:${role === "header" ? "hdr" : "ftr"}>`
: `<w:${role} xmlns:w="${ns}"><w:${role.slice(0, -1)} w:id="1">${text("omitted payload").repeat(2_000)}</w:${role.slice(0, -1)}></w:${role}>`;
archive.file("word/media/aux.xml", xml);
if (role === "note roots") {
archive.file(
"word/document.xml",
`<w:document xmlns:w="${ns}"><w:body>${text("body retained")}${Array.from({ length: 200 }, (_, id) => `<w:p><w:r><w:footnoteReference w:id="${id}"/></w:r></w:p>`).join("")}</w:body></w:document>`,
);
archive.file(
"word/media/aux.xml",
`<w:footnotes xmlns:w="${ns}" padding="${"x".repeat(32_000)}">${Array.from({ length: 200 }, (_, id) => `<w:footnote w:id="${id}">${text("omitted payload")}</w:footnote>`).join("")}</w:footnotes>`,
);
}
return archive.generateAsync({ type: "blob", compression: "DEFLATE" });
}
// Rendering starts a Word engine worker per case, which compiles about 30 MB of WebAssembly and
// took 10-17 s per test on loaded CI runners. Omission and retention are prepareOffice decisions,
// so they are checked there.
it.each(EXPANDED_WORD_ROLES)(
"keeps the body and omits expanded %s from the prepared document",
async (role) => {
const file = await expandedWordFixture(role);
const { SaxesParser } = await import("saxes");
const { prepareOffice } = await import("./officeArchive");
const parse = vi.spyOn(SaxesParser.prototype, "write");
try {
const prepared = await prepareOffice(await file.arrayBuffer(), "docx");
expect(prepared.truncated).toBe(true);
if (role === "note roots")
expect(
parse.mock.calls.reduce(
(sum, [chunk]) => sum + (typeof chunk === "string" ? chunk.length : 0),
0,
),
).toBeLessThan(4 * 1024 * 1024);
const bounded = await JSZip.loadAsync(prepared.bytes);
const markup = await bounded.file("word/document.xml")!.async("string");
expect(markup).toContain("body retained");
expect(bounded.file("word/media/aux.xml")).toBeNull();
// A dangling header or footer reference makes the engine reject the whole body.
expect(markup).not.toMatch(/<w:(header|footer)Reference/);
for (const entry of Object.values(bounded.files))
if (!entry.dir) expect(await entry.async("string")).not.toContain("omitted payload");
} finally {
parse.mockRestore();
}
},
);
it.each([
"ordinary parts",
"unused parts",
"independent styles",
"inherited styles",
"python-docx package",
"default template styles",
"binary package properties",
])("retains Word %s without a limit warning", async (scenario) => {
const { default: JSZip } = await import("jszip");
const archive = new JSZip();
const ns = "http://schemas.openxmlformats.org/wordprocessingml/2006/main";
const r = "http://schemas.openxmlformats.org/officeDocument/2006/relationships";
const text = (value: string) => `<w:p><w:r><w:t>${value}</w:t></w:r></w:p>`;
archive.file(
"_rels/.rels",
`<Relationships><Relationship Id="doc" Type="${r}/officeDocument" Target="word/document.xml"/></Relationships>`,
);
if (scenario === "python-docx package" || scenario === "binary package properties") {
const packageRelationships = "http://schemas.openxmlformats.org/package/2006/relationships";
archive.file(
"_rels/.rels",
`<Relationships xmlns="${packageRelationships}"><Relationship Id="doc" Type="${r}/officeDocument" Target="word/document.xml"/><Relationship Id="thumbnail" Type="${packageRelationships}/metadata/thumbnail" Target="docProps/thumbnail.jpeg"/><Relationship Id="core" Type="${packageRelationships}/metadata/core-properties" Target="docProps/core.xml"/><Relationship Id="app" Type="${r}/extended-properties" Target="docProps/app.xml"/><Relationship Id="custom" Type="${r}/custom-properties" Target="docProps/custom.xml"/><Relationship Id="signature" Type="${packageRelationships}/digital-signature/origin" Target="_xmlsignatures/origin.sigs"/></Relationships>`,
);
archive.file(
"[Content_Types].xml",
'<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="jpeg" ContentType="image/jpeg"/><Default Extension="xml" ContentType="application/xml"/><Default Extension="sigs" ContentType="application/vnd.openxmlformats-package.digital-signature-origin"/></Types>',
);
archive.file(
"docProps/thumbnail.jpeg",
new Uint8Array([255, 216, 255, 224, 0, 16, 74, 70, 73, 70]),
);
archive.file("_xmlsignatures/origin.sigs", new Uint8Array());
for (const part of ["core", "app", "custom"])
archive.file(`docProps/${part}.xml`, '<properties xmlns="urn:properties"/>');
if (scenario === "binary package properties") {
const roles = [
`${packageRelationships}/metadata/core-properties`,
`${r}/extended-properties`,
`${packageRelationships}/metadata/custom-properties`,
`${packageRelationships}/digital-signature/signature`,
];
archive.file(
"_rels/.rels",
`<Relationships><Relationship Id="doc" Type="${r}/officeDocument" Target="word/document.xml"/>${roles.map((role, i) => `<Relationship Id="metadata${i}" Type="${role}" Target="docProps/metadata${i}.dat"/>`).join("")}</Relationships>`,
);
for (const i of roles.keys())
archive.file(`docProps/metadata${i}.dat`, new Uint8Array([255, 216, 255, 0]));
}
}
const ordinary = scenario === "ordinary parts";
archive.file(
"word/document.xml",
`<w:document xmlns:w="${ns}" xmlns:r="${r}"><w:body>${text("ordinary body")}<w:p><w:pPr><w:pStyle w:val="s19"/></w:pPr><w:r><w:t>styled body</w:t>${ordinary ? '<w:footnoteReference w:id="1"/><w:footnoteReference w:id="1"/><w:endnoteReference w:id="1"/><w:commentReference w:id="1"/>' : ""}</w:r></w:p><w:sectPr>${ordinary ? '<w:headerReference w:type="default" r:id="header"/><w:footerReference w:type="default" r:id="footer"/>' : ""}</w:sectPr></w:body></w:document>`,
);
archive.file(
"word/_rels/document.xml.rels",
`<Relationships>${["header", "footer", "footnotes", "endnotes", "comments", "fontTable", "styles"].map((role) => `<Relationship Id="${role}" Type="${r}/${role}" Target="${role}.xml"/>`).join("")}</Relationships>`,
);
for (const [role, root] of [
["header", "hdr"],
["footer", "ftr"],
])
archive.file(
`word/${role}.xml`,
`<w:${root} xmlns:w="${ns}">${text(`${role} retained`)}</w:${root}>`,
);
for (const role of ["footnotes", "endnotes", "comments"])
archive.file(
`word/${role}.xml`,
`<w:${role} xmlns:w="${ns}"><w:${role.slice(0, -1)} w:id="1" w:author="reviewer" w:date="2026-10-01T00:00:00Z">${text(`${role} retained`)}</w:${role.slice(0, -1)}></w:${role}>`,
);
archive.file(
"word/fontTable.xml",
`<w:fonts xmlns:w="${ns}"><w:font w:name="unused"/></w:fonts>`,
);
archive.file(
"word/styles.xml",
`<w:styles xmlns:w="${ns}"><w:docDefaults/><w:style w:type="paragraph" w:styleId="base"><w:rPr><w:b/></w:rPr></w:style>${Array.from({ length: 20 }, (_, i) => `<w:style w:styleId="s${i}" w:type="paragraph">${scenario === "inherited styles" ? '<w:basedOn w:val="base"/>' : ""}<w:rPr><w:color w:val="123456"/></w:rPr></w:style>`).join("")}</w:styles>`,
);
if (scenario === "default template styles") {
const heading =
'<w:style w:type="paragraph" w:styleId="s19"><w:basedOn w:val="Normal"/><w:link w:val="HeadingChar"/><w:pPr><w:spacing w:after="120"/></w:pPr><w:rPr><w:b/><w:sz w:val="32"/><w:color w:val="123456"/></w:rPr></w:style>';
const conditions = [
"wholeTable",
"firstRow",
"lastRow",
"firstCol",
"lastCol",
"band1Horz",
"band2Horz",
"band1Vert",
"band2Vert",
];
archive.file(
"word/styles.xml",