@devries-cameron20 / t3code Mirror · read-only / commits / 73afb57097
Fork 0

The best way to control Claude Code, Codex and more from any computer or phone

Mirrored from https://github.com/Camo67/t3code.git

Synced Nov 22, 17:00 UTC

feat(web): virtualize large file previews (#21466)

maria committed Oct 26, 2026 at 02:17 UTC 73afb57097d7bb0d1f943a563b65c16261b98707
20 files changed +1862 -111
apps/server/src/assets/AssetAccess.test.ts
+2 -1
@@ -995,7 +995,7 @@ describe("AssetAccess", () => {
995 }).pipe(Effect.provide(layerTest)),
996 );
997
998 - it.effect("issues exact workspace URLs for image, office, and font previews", () =>
998 + it.effect("issues exact workspace URLs for every non-HTML preview", () =>
999 Effect.gen(function* () {
1000 const fileSystem = yield* FileSystem.FileSystem;
1001 const path = yield* Path.Path;
@@ -1009,6 +1009,7 @@ describe("AssetAccess", () => {
1009 "private document",
1010 );
1011 for (const extension of [
1012 + "pdf",
1013 "png",
1014 "bmp",
1015 "heic",
apps/server/src/assets/AssetAccess.ts
+15 -21
@@ -20,10 +20,7 @@ import {
20 } from "@t3tools/contracts";
21 import {
22 hostPreviewMimeTypeFromExtension,
23 - officePreviewKind,
23 isWorkspaceAudioPreviewPath,
25 - isWorkspaceImagePreviewPath,
26 - isWorkspaceFontPreviewPath,
24 isWorkspacePreviewEntryPath,
25 isWorkspaceVideoPreviewPath,
26 WORKSPACE_BROWSER_PREVIEW_EXTENSIONS,
@@ -517,24 +514,21 @@ const finalizeWorkspaceFileAsset = Effect.fn("AssetAccess.finalizeWorkspaceFileA
514 ? yield* readImageDimensionsFromHeader(canonicalFile)
515 : null;
516 return {
520 - claims:
521 - isWorkspaceImagePreviewPath(resolved.relativePath) ||
522 - isWorkspaceFontPreviewPath(resolved.relativePath) ||
523 - officePreviewKind({ name: resolved.relativePath }) !== null
524 - ? {
525 - version: 1 as const,
526 - kind: "workspace-file-exact" as const,
527 - workspaceRoot: canonicalWorkspaceRoot,
528 - relativePath: resolved.relativePath,
529 - expiresAt: input.expiresAt,
530 - }
531 - : {
532 - version: 1 as const,
533 - kind: "workspace-file" as const,
534 - workspaceRoot: canonicalWorkspaceRoot,
535 - baseRelativePath: path.dirname(resolved.relativePath),
536 - expiresAt: input.expiresAt,
537 - },
517 + claims: !/\.html?$/i.test(resolved.relativePath)
518 + ? {
519 + version: 1 as const,
520 + kind: "workspace-file-exact" as const,
521 + workspaceRoot: canonicalWorkspaceRoot,
522 + relativePath: resolved.relativePath,
523 + expiresAt: input.expiresAt,
524 + }
525 + : {
526 + version: 1 as const,
527 + kind: "workspace-file" as const,
528 + workspaceRoot: canonicalWorkspaceRoot,
529 + baseRelativePath: path.dirname(resolved.relativePath),
530 + expiresAt: input.expiresAt,
531 + },
532 fileName: path.basename(resolved.relativePath),
533 imageDimensions,
534 fileRevision: undefined,
apps/server/src/http.test.ts
+16 -3
@@ -630,9 +630,22 @@ describe("video asset byte ranges", () => {
630 const image = HttpServerResponse.toWeb(
631 yield* assetFileResponse({ path: file, mimeType: "image/png" }, "bytes=0-1"),
632 );
633 - expect(image.status).toBe(200);
634 - expect(image.headers.has("accept-ranges")).toBe(false);
635 - expect(yield* Effect.promise(() => image.text())).toBe("0123456789");
633 + expect(image.status).toBe(206);
634 + expect(image.headers.get("accept-ranges")).toBe("bytes");
635 + expect(yield* Effect.promise(() => image.text())).toBe("01");
636 + for (const mimeType of ["text/plain", "text/csv", "application/octet-stream"]) {
637 + for (const [range, expected, status] of [
638 + ["bytes=2-5", "2345", 206],
639 + ["bytes=-3", "789", 206],
640 + ["bytes=10-", "", 416],
641 + ] as const) {
642 + const result = HttpServerResponse.toWeb(
643 + yield* assetFileResponse({ path: file, mimeType }, range),
644 + );
645 + expect(result.status).toBe(status);
646 + expect(yield* Effect.promise(() => result.text())).toBe(expected);
647 + }
648 + }
649 }).pipe(Effect.provide(layerFileResponse)),
650 );
651
apps/server/src/http.ts
+1 -1
@@ -199,7 +199,7 @@ export const assetFileResponse = Effect.fn("assetFileResponse")(function* (
199 let status = 200;
200 let offset = 0n;
201 let bytesToRead: bigint | undefined;
202 - if (isMedia) {
202 + {
203 headers["Accept-Ranges"] = "bytes";
204 // If-Range requires a matching validator. A full response is safe when we cannot validate it.
205 if (method === "GET" && rangeHeader && ifRangeHeader === undefined) {
apps/web/package.json
+1
@@ -61,6 +61,7 @@
61 "culori": "^4.0.2",
62 "dompurify": "^3.4.16",
63 "effect": "catalog:",
64 + "fast-xml-parser": "5.7.3",
65 "hast-util-to-html": "^9.0.5",
66 "hast-util-to-jsx-runtime": "^2.3.6",
67 "heic-to": "^1.5.2",
apps/web/src/components/files/AttachmentFilePreview.browser.test.tsx
+562 -4
@@ -1,14 +1,18 @@
1 import { act, render, stubGlobal, type Screen } from "../../../test/render";
2 -import { EnvironmentId } from "@t3tools/contracts";
2 +import { EnvironmentId, ThreadId } from "@t3tools/contracts";
3 import { describe, expect, it, vi } from "vite-plus/test";
4 import { page } from "vite-plus/test/browser";
5 import "~/index.css";
6
7 -const { refresh } = vi.hoisted(() => ({ refresh: vi.fn<() => Promise<string | null>>() }));
7 +const { refresh, assetUrlState } = vi.hoisted(() => ({
8 + refresh: vi.fn<() => Promise<string | null>>(),
9 + assetUrlState: vi.fn<() => import("~/assets/assetUrls").AssetUrlState>(),
10 +}));
11
12 vi.mock(import("~/assets/assetUrls"), async (original) => ({
13 ...(await original()),
14 useAssetUrlRefresh: () => refresh,
15 + useAssetUrlState: assetUrlState,
16 }));
17 // The real source view highlights through a worker pool; the text it receives is what matters here.
18 // Never load the original: its highlighter graph can outlast waitFor on a cold CI browser.
@@ -17,10 +21,432 @@ vi.mock(import("./ReadOnlySourcePreview"), () => ({
21 }));
22
23 import { AttachmentFilePreview } from "./AttachmentFilePreview";
24 +import LargeTextViewer from "./LargeTextViewer";
25 +import VirtualTablePreview from "./VirtualTablePreview";
26 import { OfficeFilePreview } from "./OfficeFilePreview";
27 import { MermaidFilePreview } from "./MermaidFilePreview";
28 import { OFFICE_PREVIEW_MAX_COLUMNS, type OfficeWorkerResult } from "./officePreviewProtocol";
29
30 +describe("large text preview recovery", () => {
31 + it("retains the workspace viewer across URL renewals and reloads revisions and manual refreshes", async () => {
32 + const { WorkspaceLargeTextPreview } = await import("./FilePreviewPanel");
33 + const original = URL.createObjectURL(new Blob(["original\n".repeat(1000)]));
34 + const changed = URL.createObjectURL(new Blob(["changed\n".repeat(1000)]));
35 + const workers: Worker[] = [];
36 + using _worker = stubGlobal(
37 + "Worker",
38 + class extends Worker {
39 + constructor(...args: ConstructorParameters<typeof Worker>) {
40 + super(...args);
41 + workers.push(this);
42 + }
43 + },
44 + );
45 + const preview = (mutation: string, key = 0) => (
46 + <div style={{ display: "flex", flexDirection: "column", height: 400, width: 600 }}>
47 + <WorkspaceLargeTextPreview
48 + key={key}
49 + environmentId={EnvironmentId.make("test")}
50 + threadRef={{ environmentId: EnvironmentId.make("test"), threadId: ThreadId.make("test") }}
51 + absolutePath="/repo/large.txt"
52 + name="large.txt"
53 + delimiter={null}
54 + workspaceMutationId={mutation}
55 + revealLine={null}
56 + revealRequestId={0}
57 + />
58 + </div>
59 + );
60 + const state = (url: string, fileRevision?: string) =>
61 + assetUrlState.mockReturnValue({
62 + _tag: "Success",
63 + url,
64 + expiresAt: Date.now() + 3_600_000,
65 + ...(fileRevision === undefined ? {} : { fileRevision }),
66 + });
67 + refresh.mockResolvedValue(`${original}#renewed`);
68 + try {
69 + state(`${original}#initial`, "one");
70 + await using screen = await render(preview("first"));
71 + await vi.waitFor(() => expect(workers).toHaveLength(1));
72 + await vi.waitFor(() => expect(screen.container.textContent).toContain("original"));
73 + await vi.waitFor(() => expect(screen.container.textContent).toContain("1,000 lines"));
74 + const viewport = screen.container.querySelector<HTMLElement>('[tabindex="0"]')!;
75 + await act(() =>
76 + viewport.dispatchEvent(
77 + new WheelEvent("wheel", { deltaY: 250, bubbles: true, cancelable: true }),
78 + ),
79 + );
80 + await vi.waitFor(() => expect(viewport.scrollTop).toBeGreaterThan(0));
81 + const scrollTop = viewport.scrollTop;
82 + state(`${original}#renewed`, "one");
83 + await screen.rerender(preview("unrelated-command"));
84 + expect(screen.container.querySelector('[tabindex="0"]')).toBe(viewport);
85 + expect(viewport.scrollTop).toBe(scrollTop);
86 + expect(workers).toHaveLength(1);
87 + state(`${changed}#updated`, "two");
88 + await screen.rerender(preview("file-edit"));
89 + await vi.waitFor(() => expect(screen.container.textContent).toContain("changed"));
90 + expect(workers).toHaveLength(2);
91 + await screen.rerender(preview("file-edit", 1));
92 + await vi.waitFor(() => expect(workers).toHaveLength(3));
93 + await vi.waitFor(() => expect(screen.container.textContent).toContain("changed"));
94 + state(`${original}#legacy`);
95 + await screen.rerender(preview("legacy-edit", 1));
96 + await vi.waitFor(() => expect(screen.container.textContent).toContain("original"));
97 + expect(workers).toHaveLength(4);
98 + assetUrlState.mockReturnValue({ _tag: "Failure" });
99 + await screen.rerender(preview("legacy-edit", 1));
100 + expect(screen.container.textContent).toContain("Unable to load file preview.");
101 + refresh.mockClear();
102 + refresh.mockImplementation(async () => {
103 + state(`${changed}#retried`);
104 + return changed;
105 + });
106 + await screen.getByRole("button", { name: "Try again" }).click();
107 + expect(refresh).toHaveBeenCalledOnce();
108 + await screen.rerender(preview("legacy-edit", 1));
109 + await vi.waitFor(() => expect(screen.container.textContent).toContain("changed"));
110 + expect(screen.container.querySelector('[role="alert"]')).toBeNull();
111 + } finally {
112 + URL.revokeObjectURL(original);
113 + URL.revokeObjectURL(changed);
114 + }
115 + });
116 +
117 + it("scrolls within a wrapped row when the row-count track is shorter than the viewport", async () => {
118 + await using screen = await render(
119 + <div style={{ display: "flex", height: 400, width: 600 }}>
120 + <VirtualTablePreview
121 + name="one.txt"
122 + count={1}
123 + columns={1}
124 + source
125 + wrap
126 + getRows={() => [["wrapped source text ".repeat(500)]]}
127 + />
128 + </div>,
129 + );
130 + const row = () => screen.container.querySelector<HTMLElement>('[data-preview-row="0"]')!;
131 + const viewport = () => screen.container.querySelector<HTMLElement>('[tabindex="0"]')!;
132 + await vi.waitFor(() => expect(row()?.offsetHeight).toBeGreaterThan(1000));
133 + await act(() =>
134 + viewport().dispatchEvent(
135 + new WheelEvent("wheel", { deltaY: 150, bubbles: true, cancelable: true }),
136 + ),
137 + );
138 + await vi.waitFor(() => {
139 + const offset = viewport().getBoundingClientRect().top - row().getBoundingClientRect().top;
140 + expect(offset).toBeGreaterThan(50);
141 + expect(offset).toBeLessThan(300);
142 + });
143 + await act(() =>
144 + viewport().dispatchEvent(new KeyboardEvent("keydown", { key: "End", bubbles: true })),
145 + );
146 + await vi.waitFor(() =>
147 + expect(
148 + Math.abs(row().getBoundingClientRect().bottom - viewport().getBoundingClientRect().bottom),
149 + ).toBeLessThan(2),
150 + );
151 + await act(() =>
152 + viewport().dispatchEvent(new KeyboardEvent("keydown", { key: "Home", bubbles: true })),
153 + );
154 + await vi.waitFor(() =>
155 + expect(row().getBoundingClientRect().top).toBe(viewport().getBoundingClientRect().top),
156 + );
157 + });
158 +
159 + it("scrolls every tall row in the final virtual viewport", async () => {
160 + const view = (loaded: boolean) => (
161 + <div style={{ display: "flex", height: 400, width: 600 }}>
162 + <VirtualTablePreview
163 + name="tail.txt"
164 + count={100}
165 + columns={1}
166 + source
167 + wrap
168 + getRows={(page) =>
169 + !loaded && page > 0
170 + ? undefined
171 + : Array.from({ length: 32 }, (_, i) => [
172 + "line-" + (page * 32 + i + 1) + " wrapped source text".repeat(500),
173 + ])
174 + }
175 + />
176 + </div>
177 + );
178 + await using screen = await render(view(false));
179 + const viewport = () => screen.container.querySelector<HTMLElement>('[tabindex="0"]')!;
180 + const row = (index: number) =>
181 + screen.container.querySelector<HTMLElement>('[data-preview-row="' + index + '"]')!;
182 + await vi.waitFor(() => expect(row(0)?.offsetHeight).toBeGreaterThan(1000));
183 + await act(() =>
184 + viewport().dispatchEvent(new KeyboardEvent("keydown", { key: "End", bubbles: true })),
185 + );
186 + await vi.waitFor(() => expect(row(99)).not.toBeNull());
187 + await screen.rerender(view(true));
188 + await vi.waitFor(() =>
189 + expect(
190 + Math.abs(
191 + row(99).getBoundingClientRect().bottom - viewport().getBoundingClientRect().bottom,
192 + ),
193 + ).toBeLessThan(2),
194 + );
195 + await act(() =>
196 + viewport().dispatchEvent(new KeyboardEvent("keydown", { key: "Home", bubbles: true })),
197 + );
198 + await vi.waitFor(() => expect(row(0)).not.toBeNull());
199 + await act(() => {
200 + viewport().scrollTop = 100 * 29 - viewport().clientHeight;
201 + viewport().dispatchEvent(new Event("scroll", { bubbles: true }));
202 + });
203 + const checkTop = (index: number) =>
204 + expect(
205 + Math.abs(row(index).getBoundingClientRect().top - viewport().getBoundingClientRect().top),
206 + ).toBeLessThan(2);
207 + await vi.waitFor(() => checkTop(87));
208 + for (let index = 88; index < 100; index++) {
209 + await act(() =>
210 + viewport().dispatchEvent(
211 + new WheelEvent("wheel", {
212 + deltaY: row(index - 1).offsetHeight,
213 + bubbles: true,
214 + cancelable: true,
215 + }),
216 + ),
217 + );
218 + if (index < 99) await vi.waitFor(() => checkTop(index));
219 + }
220 + await act(() =>
221 + viewport().dispatchEvent(new KeyboardEvent("keydown", { key: "End", bubbles: true })),
222 + );
223 + await vi.waitFor(() =>
224 + expect(
225 + Math.abs(
226 + row(99).getBoundingClientRect().bottom - viewport().getBoundingClientRect().bottom,
227 + ),
228 + ).toBeLessThan(2),
229 + );
230 + });
231 +
232 + it("rejects malformed UTF-8 bytes through the real text worker", async () => {
233 + const src = URL.createObjectURL(new Blob([new Uint8Array([0xe9, 10])]));
234 + try {
235 + await using screen = await render(
236 + <LargeTextViewer src={src} name="latin.txt" delimiter={null} />,
237 + );
238 + await vi.waitFor(() =>
239 + expect(screen.container.querySelector('[role="alert"]')).not.toBeNull(),
240 + );
241 + } finally {
242 + URL.revokeObjectURL(src);
243 + }
244 + });
245 +
246 + it("replaces both prefetched pages with the worker's current file version", async () => {
247 + const old = Array.from({ length: 64 }, (_, i) => "old-" + i).join("\n") + "\n";
248 + const current = Array.from({ length: 100 }, (_, i) => "current-" + i).join("\n");
249 + const src = URL.createObjectURL(new Blob([current]));
250 + using _fetch = stubGlobal(
251 + "fetch",
252 + vi.fn().mockResolvedValue(
253 + new Response(old, {
254 + status: 206,
255 + headers: {
256 + "content-length": String(old.length),
257 + "content-range": "bytes 0-" + (old.length - 1) + "/100000",
258 + },
259 + }),
260 + ),
261 + );
262 + try {
263 + await using screen = await render(
264 + <div style={{ display: "flex", height: 2000, width: 600 }}>
265 + <LargeTextViewer src={src} name="log.txt" delimiter={null} />
266 + </div>,
267 + );
268 + await vi.waitFor(() => expect(screen.container.textContent).toContain("current-40"));
269 + expect(screen.container.textContent).not.toContain("old-");
270 + } finally {
271 + URL.revokeObjectURL(src);
272 + }
273 + });
274 +
275 + it("fills the horizontal viewport using measured column widths", async () => {
276 + const header = Array.from({ length: 20 }, (_, i) => "C" + i);
277 + await using screen = await render(
278 + <div style={{ display: "flex", height: 400, width: 400 }}>
279 + <VirtualTablePreview
280 + name="wide.csv"
281 + count={2}
282 + columns={20}
283 + header={header}
284 + getRows={() => [header, header]}
285 + />
286 + </div>,
287 + );
288 + const outer = () => screen.container.querySelector('[role="table"]')!.parentElement!;
289 + const check = () => {
290 + const cells = screen.container.querySelectorAll('[role="columnheader"]');
291 + expect(cells.length).toBeGreaterThan(0);
292 + expect(cells[cells.length - 1]!.getBoundingClientRect().right).toBeGreaterThanOrEqual(
293 + outer().getBoundingClientRect().right - 1,
294 + );
295 + };
296 + await vi.waitFor(check);
297 + await act(() => {
298 + outer().scrollLeft = outer().scrollWidth;
299 + outer().dispatchEvent(new Event("scroll", { bubbles: true }));
300 + });
301 + await vi.waitFor(check);
302 + expect(screen.container.textContent).toContain("C19");
303 + });
304 +
305 + it("reveals and highlights requested source lines again for a new request", async () => {
306 + const view = (line: number, request: number, loaded = true) => (
307 + <div style={{ display: "flex", height: 400, width: 600 }}>
308 + <VirtualTablePreview
309 + name="log.txt"
310 + count={1000}
311 + columns={1}
312 + source
313 + wrap
314 + revealLine={line}
315 + revealRequestId={request}
316 + getRows={(page) =>
317 + loaded || page === 0
318 + ? Array.from({ length: 32 }, (_, i) => [
319 + "line-" + (page * 32 + i + 1) + " wrapped source text".repeat(20),
320 + ])
321 + : undefined
322 + }
323 + />
324 + </div>
325 + );
326 + await using screen = await render(view(500, 1, false));
327 + await vi.waitFor(() =>
328 + expect(screen.container.querySelector('[data-preview-reveal="true"]')?.textContent).toBe(
329 + "500",
330 + ),
331 + );
332 + await screen.rerender(view(500, 1));
333 + await vi.waitFor(() =>
334 + expect(screen.container.querySelector('[data-preview-reveal="true"]')?.textContent).toContain(
335 + "line-500",
336 + ),
337 + );
338 + const checkVisible = () => {
339 + const row = screen.container.querySelector<HTMLElement>('[data-preview-reveal="true"]')!;
340 + const viewport = screen.container.querySelector<HTMLElement>('[tabindex="0"]')!;
341 + expect(row.getBoundingClientRect().top).toBeGreaterThanOrEqual(
342 + viewport.getBoundingClientRect().top - 1,
343 + );
344 + expect(row.getBoundingClientRect().bottom).toBeLessThanOrEqual(
345 + viewport.getBoundingClientRect().bottom + 1,
346 + );
347 + };
348 + await vi.waitFor(checkVisible);
349 + await screen.rerender(view(900, 2));
350 + await vi.waitFor(() =>
351 + expect(screen.container.querySelector('[data-preview-reveal="true"]')?.textContent).toContain(
352 + "line-900",
353 + ),
354 + );
355 + await vi.waitFor(checkVisible);
356 + await screen.rerender(view(999, 3));
357 + await vi.waitFor(() =>
358 + expect(screen.container.querySelector('[data-preview-reveal="true"]')?.textContent).toContain(
359 + "line-999",
360 + ),
361 + );
362 + await vi.waitFor(checkVisible);
363 + });
364 +
365 + it.each(
366 + [5, 100, 10_000].flatMap((count) => [false, true].map((mixed) => [count, mixed] as const)),
367 + )(
368 + "preserves the source row when indexing grows beyond %i lines (mixed heights: %s)",
369 + async (count, mixed) => {
370 + const view = (count: number) => (
371 + <div style={{ display: "flex", height: 400, width: 600 }}>
372 + <VirtualTablePreview
373 + name="growing.txt"
374 + count={count}
375 + columns={1}
376 + source
377 + wrap
378 + getRows={(page) =>
379 + Array.from({ length: 32 }, (_, i) => [
380 + `line-${page * 32 + i + 1} ` +
381 + "wrapped source text ".repeat(mixed ? 5 + (i % 4) * 20 : 20),
382 + ])
383 + }
384 + />
385 + </div>
386 + );
387 + await using screen = await render(view(count));
388 + const viewport = () => screen.container.querySelector<HTMLElement>('[tabindex="0"]')!;
389 + await vi.waitFor(() => expect(viewport()?.scrollHeight).toBeGreaterThan(400));
390 + await act(() => {
391 + viewport().scrollTop = count === 100 ? 100 * 29 - 400 + 1200 : 1200;
392 + viewport().dispatchEvent(new Event("scroll", { bubbles: true }));
393 + });
394 + const visibleRow = () =>
395 + [...screen.container.querySelectorAll<HTMLElement>("[data-preview-row]")].find(
396 + (row) => row.getBoundingClientRect().bottom > viewport().getBoundingClientRect().top + 1,
397 + )!;
398 + await vi.waitFor(() => expect(visibleRow()).toBeDefined());
399 + const before = visibleRow().dataset.previewRow;
400 + const offset =
401 + visibleRow().getBoundingClientRect().top - viewport().getBoundingClientRect().top;
402 + await screen.rerender(view(1_000_000));
403 + await vi.waitFor(() => {
404 + expect(visibleRow().dataset.previewRow).toBe(before);
405 + expect(
406 + Math.abs(
407 + visibleRow().getBoundingClientRect().top -
408 + viewport().getBoundingClientRect().top -
409 + offset,
410 + ),
411 + ).toBeLessThan(Math.max(5, visibleRow().offsetHeight / 29 + 1));
412 + });
413 + },
414 + );
415 +
416 + it("recovers from a failed worker load when its source changes", async () => {
417 + await using screen = await render(
418 + <LargeTextViewer name="log.txt" text={"bad\0text"} delimiter={null} />,
419 + );
420 + await vi.waitFor(() =>
421 + expect(screen.container.textContent).toContain("This file contains binary data."),
422 + );
423 + await screen.rerender(<LargeTextViewer name="log.txt" text="" delimiter={null} />);
424 + await vi.waitFor(() => expect(screen.container.textContent).toContain("This file is empty."));
425 + expect(screen.container.querySelector('[role="alert"]')).toBeNull();
426 + });
427 +
428 + it("reloads a partial page when the indexed row count grows", async () => {
429 + const load = vi.fn();
430 + const rows = [["first"]];
431 + const view = (count: number) => (
432 + <div style={{ display: "flex", height: 400, width: 600 }}>
433 + <VirtualTablePreview
434 + name="log.txt"
435 + count={count}
436 + columns={1}
437 + source
438 + getRows={() => rows}
439 + loadPage={load}
440 + />
441 + </div>
442 + );
443 + await using screen = await render(view(1));
444 + await vi.waitFor(() => expect(screen.container.textContent).toContain("first"));
445 + expect(load).not.toHaveBeenCalled();
446 + await screen.rerender(view(2));
447 + await vi.waitFor(() => expect(load).toHaveBeenCalledWith(0));
448 + });
449 +});
450 it.each(["<w:body/>", "<w:body></w:body>"])(
451 "opens an empty Word document with %s",
452 async (body) => {
@@ -877,10 +1303,10 @@ it.each(["XFD200", "XFD1048576", "AX500", "AZ9999999"])(
1303 );
1304 worker.postMessage({ type: "open", kind: "xlsx", bytes }, [bytes]);
1305 });
880 - if (ref === "AZ9999999") {
1306 + if (ref === "AZ9999999" || ref === "XFD1048576") {
1307 expect(result).toMatchObject({
1308 type: "error",
883 - message: expect.stringContaining("invalid"),
1309 + message: expect.stringContaining(ref === "AZ9999999" ? "invalid" : "preview limit"),
1310 });
1311 } else {
1312 expect(result.type).toBe("xlsx");
@@ -1218,6 +1644,138 @@ describe("attachment HTML preview recovery", () => {
1644 });
1645 });
1646
1647 +it("opens a known empty attachment even when its range response is inaccessible", async () => {
1648 + refresh.mockResolvedValue("https://unreachable.invalid/empty.txt");
1649 + await using screen = await render(
1650 + <AttachmentFilePreview
1651 + name="empty.txt"
1652 + mimeType="text/plain"
1653 + sizeBytes={0}
1654 + asset={{ environmentId: EnvironmentId.make("test"), attachmentId: "empty" }}
1655 + />,
1656 + );
1657 + await vi.waitFor(
1658 + () => expect(screen.container.textContent).toContain("This file is empty."),
1659 + 10_000,
1660 + );
1661 +});
1662 +
1663 +it.each(["draft", "thread"] as const)(
1664 + "reads an unknown-size %s workspace file instead of treating it as empty",
1665 + async (source) => {
1666 + refresh.mockResolvedValue("https://example.test/binary.txt");
1667 + using _fetch = stubGlobal(
1668 + "fetch",
1669 + vi.fn(async () => new Response("invalid\0text")),
1670 + );
1671 + await using screen = await render(
1672 + <AttachmentFilePreview
1673 + name="binary.txt"
1674 + mimeType="application/octet-stream"
1675 + sizeBytes={0}
1676 + asset={{
1677 + environmentId: EnvironmentId.make("test"),
1678 + resource:
1679 + source === "draft"
1680 + ? { _tag: "draft-workspace-file", cwd: "/repo", path: "/repo/binary.txt" }
1681 + : { _tag: "media-file", threadId: ThreadId.make("test"), path: "/repo/binary.txt" },
1682 + }}
1683 + />,
1684 + );
1685 + await vi.waitFor(() =>
1686 + expect(screen.container.textContent).toContain(
1687 + "This file contains binary data and cannot be shown as text.",
1688 + ),
1689 + );
1690 + expect(fetch).toHaveBeenCalled();
1691 + expect(screen.container.textContent).not.toContain("This file is empty.");
1692 + },
1693 +);
1694 +
1695 +it("refreshes authorization and retries a failed streamed attachment", async () => {
1696 + const bad = URL.createObjectURL(new Blob(["invalid\0text"]));
1697 + const good = URL.createObjectURL(new Blob(["recovered text\n"]));
1698 + refresh.mockReset().mockResolvedValueOnce(bad).mockResolvedValue(good);
1699 + try {
1700 + await using screen = await render(
1701 + <AttachmentFilePreview
1702 + name="retry.txt"
1703 + mimeType="text/plain"
1704 + sizeBytes={2_000_000}
1705 + asset={{ environmentId: EnvironmentId.make("test"), attachmentId: "retry" }}
1706 + />,
1707 + );
1708 + await vi.waitFor(() =>
1709 + expect(screen.container.textContent).toContain("This file contains binary data."),
1710 + );
1711 + await act(() =>
1712 + screen.container.querySelector<HTMLButtonElement>('[role="alert"] button')!.click(),
1713 + );
1714 + await vi.waitFor(() => expect(screen.container.textContent).toContain("recovered text"));
1715 + expect(refresh).toHaveBeenCalledTimes(2);
1716 + } finally {
1717 + URL.revokeObjectURL(bad);
1718 + URL.revokeObjectURL(good);
1719 + }
1720 +});
1721 +
1722 +it.each([
1723 + ["custom/sheet1.xml", 250001],
1724 + ["/xl/custom/sheet1.bin", 250001],
1725 + ["custom/valid.xml", 1],
1726 +] as const)(
1727 + "bounds the worksheet relationship target %s at row %i before the reader allocates its grid",
1728 + async (target, row) => {
1729 + const { default: JSZip } = await import("jszip");
1730 + const zip = new JSZip();
1731 + zip.file(
1732 + "xl/workbook.xml",
1733 + '<workbook xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships"><sheets><sheet name="Sheet" sheetId="1" r:id="rId1"/></sheets></workbook>',
1734 + );
1735 + zip.file(
1736 + "xl/_rels/workbook.xml.rels",
1737 + `<Relationships><Relationship Id="rId1" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet" Target="${target}"/></Relationships>`,
1738 + );
1739 + zip.file(
1740 + target.startsWith("/") ? target.slice(1) : `xl/${target}`,
1741 + `<worksheet><sheetData><row r="${row}"><c r="A${row}" t="inlineStr"><is><t>worksheet value</t></is></c></row></sheetData></worksheet>`,
1742 + );
1743 + const file = await zip.generateAsync({ type: "blob", compression: "DEFLATE" });
1744 + const src = URL.createObjectURL(file);
1745 + try {
1746 + await using screen = await render(
1747 + <div style={{ display: "flex", height: 400, width: 600 }}>
1748 + <OfficeFilePreview name="custom.xlsx" src={src} kind="xlsx" sizeBytes={file.size} />
1749 + </div>,
1750 + );
1751 + await vi.waitFor(
1752 + () =>
1753 + expect(screen.container.textContent).toContain(
1754 + row > 250000 ? "This workbook exceeds the preview limit" : "worksheet value",
1755 + ),
1756 + { timeout: 10_000 },
1757 + );
1758 + } finally {
1759 + URL.revokeObjectURL(src);
1760 + }
1761 + },
1762 +);
1763 +
1764 +it("copies every indexed line rather than the mounted preview rows", async () => {
1765 + const text = Array.from({ length: 10_000 }, (_, i) => `line-${i}`).join("\n");
1766 + const copyContents = { current: null as (() => Promise<string>) | null };
1767 + await using screen = await render(
1768 + <LargeTextViewer name="whole.txt" text={text} delimiter={null} copyContents={copyContents} />,
1769 + );
1770 + await vi.waitFor(() => expect(screen.container.textContent).toContain("line-0"));
1771 + await vi.waitFor(async () => expect(await copyContents.current!()).toBe(text));
1772 + const first = copyContents.current!();
1773 + await expect(copyContents.current!()).rejects.toThrow("Another copy is in progress.");
1774 + expect(await first).toBe(text);
1775 + expect(await copyContents.current!()).toBe(text);
1776 + expect(screen.container.querySelector('[role="alert"]')).toBeNull();
1777 +});
1778 +
1779 it("loads a font attachment through the lazy preview", async () => {
1780 const { default: fontUrl } =
1781 await import("../../../node_modules/@betteroffice/fonts/assets/Carlito-Regular.ttf?url");
apps/web/src/components/files/AttachmentFilePreview.tsx
+48 -6
@@ -34,6 +34,8 @@ import {
34 FileSurfaceNotice,
35 } from "./fileSurfaceChrome";
36
37 +const LargeTextViewer = lazy(() => import("./LargeTextViewer"));
38 +
39 const OfficeFilePreview = lazy(() =>
40 import("./OfficeFilePreview").then((module) => ({ default: module.OfficeFilePreview })),
41 );
@@ -132,6 +134,7 @@ export function AttachmentFilePreview(props: {
134 const [content, setContent] = useState<{ text: string; truncated: boolean } | null>(null);
135 const [error, setError] = useState<string | null>(null);
136 const [contentError, setContentError] = useState<string | null>(null);
137 + const copyContents = useRef<(() => Promise<string>) | null>(null);
138 const authorizedAt = useRef(0);
139 useEffect(() => {
140 if (!props.file) return;
@@ -163,10 +166,14 @@ export function AttachmentFilePreview(props: {
166 // oxlint-disable-next-line react/exhaustive-effect-dependencies -- Retry must reauthorize the remote file.
167 }, [props.file, refresh, revision]);
168 const url = props.file ? localUrl : remoteUrl;
169 + const streamsText =
170 + kind === "text" &&
171 + (props.sizeBytes > FILE_TEXT_PREVIEW_MAX_BYTES ||
172 + (props.sizeBytes === 0 && (!resource || resource._tag === "attachment")));
173 const needsText =
174 kind === "text" || kind === "markdown" || kind === "mermaid" || (kind === "html" && !rendered);
175 useEffect(() => {
169 - if (!needsText || !url) return;
176 + if (!needsText || streamsText || !url) return;
177 const controller = new AbortController();
178 // oxlint-disable-next-line react/set-state-in-effect -- A new external resource must clear the previous response before loading.
179 setContent(null);
@@ -199,13 +206,13 @@ export function AttachmentFilePreview(props: {
206 setContentError(cause instanceof Error ? cause.message : "Could not load this file.");
207 });
208 return () => controller.abort();
202 - }, [url, needsText, revision, props.sizeBytes, props.file, refresh]);
209 + }, [url, needsText, streamsText, revision, props.sizeBytes, props.file, refresh]);
210 const failure = error ?? (needsText ? contentError : null);
211 const wordWrap = useClientSettings((settings) => settings.wordWrap);
212 const showsRawText =
213 failure === null &&
214 needsText &&
208 - content !== null &&
215 + (content !== null || streamsText) &&
216 !(delimiter && rendered) &&
217 !((kind === "markdown" || kind === "mermaid") && rendered);
218
@@ -249,6 +256,18 @@ export function AttachmentFilePreview(props: {
256 setRevision((value) => value + 1);
257 }}
258 />
259 + ) : streamsText && url ? (
260 + <Suspense fallback={<FileSurfaceLoading />}>
261 + <LargeTextViewer
262 + key={`${url}:${rendered}:${revision}`}
263 + name={props.name}
264 + src={url}
265 + sizeBytes={props.sizeBytes}
266 + onRetry={() => setRevision((value) => value + 1)}
267 + delimiter={rendered ? delimiter : null}
268 + copyContents={copyContents}
269 + />
270 + </Suspense>
271 ) : !url || (needsText && !content) ? (
272 <FileSurfaceLoading />
273 ) : needsText && content ? (
@@ -357,10 +376,33 @@ export function AttachmentFilePreview(props: {
376 <WrapTextIcon className="size-3.5" />
377 </FileSurfaceAction>
378 ) : null}
360 - {content ? (
379 + {content || streamsText ? (
380 <FileSurfaceAction
362 - label={isCopied ? "Copied" : content.truncated ? "Copy preview" : "Copy contents"}
363 - onPress={() => copyToClipboard(content.text, undefined)}
381 + label={isCopied ? "Copied" : content?.truncated ? "Copy preview" : "Copy contents"}
382 + onPress={() => {
383 + if (content) {
384 + void copyToClipboard(content.text, undefined);
385 + return;
386 + }
387 + const copy = copyContents.current;
388 + if (!copy) {
389 + toastManager.add({
390 + type: "error",
391 + title: "Could not copy file",
392 + description: "Wait for the file to finish loading before copying.",
393 + });
394 + return;
395 + }
396 + void copy()
397 + .then((text) => copyToClipboard(text, undefined))
398 + .catch((cause: unknown) =>
399 + toastManager.add({
400 + type: "error",
401 + title: "Could not copy file",
402 + description: cause instanceof Error ? cause.message : "Try again.",
403 + }),
404 + );
405 + }}
406 >
407 <MorphIcon className="size-3.5" icon={isCopied ? Check : Copy} />
408 </FileSurfaceAction>
apps/web/src/components/files/DelimitedTablePreview.tsx
+6 -49
@@ -1,58 +1,15 @@
1 -/* oxlint-disable react/no-array-index-key -- Table rows and columns have stable positions and may contain identical values. */
2 -import { parseDelimitedPreview } from "@t3tools/shared/delimitedPreview";
3 -
4 -import { FileSurfaceNotice } from "./fileSurfaceChrome";
1 +import { lazy, Suspense } from "react";
2 +import { FileSurfaceLoading } from "./fileSurfaceChrome";
3
4 +const LargeTextViewer = lazy(() => import("./LargeTextViewer"));
5 export function DelimitedTablePreview(props: {
6 readonly name: string;
7 readonly text: string;
8 readonly delimiter: "," | "\t";
9 }) {
11 - const table = parseDelimitedPreview(props.text, props.delimiter);
12 - const [header, ...body] = table.rows;
10 return (
14 - <div className="flex min-h-0 flex-1 flex-col">
15 - {table.truncated ? (
16 - <FileSurfaceNotice>
17 - Table limited to the first 100 rows and 30 columns. Switch to source for the rest.
18 - </FileSurfaceNotice>
19 - ) : null}
20 - <div className="min-h-0 flex-1 overflow-auto">
21 - <table
22 - className="min-w-full border-separate border-spacing-0 text-xs"
23 - aria-label={props.name}
24 - >
25 - {header ? (
26 - <thead className="sticky top-0 z-10">
27 - <tr>
28 - {header.map((cell, columnIndex) => (
29 - <th
30 - key={columnIndex}
31 - scope="col"
32 - className="max-w-80 border-b border-border bg-muted/60 px-3 py-1.5 text-left align-bottom font-medium whitespace-pre-wrap break-words backdrop-blur"
33 - >
34 - {cell}
35 - </th>
36 - ))}
37 - </tr>
38 - </thead>
39 - ) : null}
40 - <tbody>
41 - {body.map((row, rowIndex) => (
42 - <tr key={rowIndex} className="even:bg-muted/30">
43 - {row.map((cell, columnIndex) => (
44 - <td
45 - key={columnIndex}
46 - className="max-w-80 border-b border-border/60 px-3 py-1.5 align-top whitespace-pre-wrap break-words tabular-nums"
47 - >
48 - {cell}
49 - </td>
50 - ))}
51 - </tr>
52 - ))}
53 - </tbody>
54 - </table>
55 - </div>
56 - </div>
11 + <Suspense fallback={<FileSurfaceLoading />}>
12 + <LargeTextViewer key={props.name} {...props} />
13 + </Suspense>
14 );
15 }
apps/web/src/components/files/FilePreviewPanel.tsx
+149 -6
@@ -1,3 +1,5 @@
1 +import { DownloadIcon, CopyIcon, CheckIcon } from "lucide-react";
2 +import { useCopyToClipboard } from "~/hooks/useCopyToClipboard";
3 import { Spinner } from "~/components/ui/spinner";
4 import {
5 AuthPreviewOperateScope,
@@ -1002,7 +1004,6 @@ export default function FilePreviewPanel({
1004 const relativePath =
1005 attachment === undefined ? resolveFilePreviewPath(requestedPath, cwd) : requestedPath;
1006 const draft = typeof composerDraftTarget === "string";
1005 - const [documentRefreshId, setDocumentRefreshId] = useState(0);
1007 const { resolvedTheme } = useTheme();
1008 const wordWrap = useClientSettings((settings) => settings.wordWrap);
1009 const canOperatePreview = useEnvironmentScope(environmentId, AuthPreviewOperateScope);
@@ -1038,6 +1039,7 @@ export default function FilePreviewPanel({
1039 relativePath,
1040 attachment === undefined && relativePath !== null,
1041 );
1042 + const [fileRefreshRevision, setFileRefreshRevision] = useState(0);
1043 const attemptedPath = file.readError?.resolvedPath ?? file.readError?.operationPath;
1044 // Folder links fail file reads; retain mutation refresh to detect conversion to files. Host folders own
1045 // roots; folderTrail keeps descendants.
@@ -1323,7 +1325,8 @@ export default function FilePreviewPanel({
1325 attachment === undefined &&
1326 !isMedia &&
1327 !renderBrowserFile &&
1326 - file.data?.truncated ? (
1328 + file.data?.truncated &&
1329 + (draft || isMarkdown || isMermaid || isHtml) ? (
1330 <div className="shrink-0 border-b border-warning/20 bg-warning-surface px-3 py-1.5 text-2xs text-warning-foreground">
1331 Preview limited to the first 1 MB of a {file.data.byteLength.toLocaleString()} byte file.
1332 </div>
@@ -1386,11 +1389,30 @@ export default function FilePreviewPanel({
1389 title={relativePath}
1390 workspaceMutationId={workspaceMutationId}
1391 />
1392 + ) : relativePath &&
1393 + absolutePath &&
1394 + file.data?.truncated &&
1395 + !isDocument &&
1396 + !draft &&
1397 + !isMarkdown &&
1398 + !isMermaid &&
1399 + !isHtml ? (
1400 + <WorkspaceLargeTextPreview
1401 + key={`${absolutePath}:${renderTable}:${fileRefreshRevision}`}
1402 + environmentId={environmentId}
1403 + threadRef={threadRef}
1404 + absolutePath={absolutePath}
1405 + name={relativePath}
1406 + delimiter={renderTable ? tableDelimiter : null}
1407 + workspaceMutationId={workspaceMutationId}
1408 + revealLine={revealLine}
1409 + revealRequestId={revealRequestId}
1410 + />
1411 ) : relativePath &&
1412 absolutePath &&
1413 (isDocument || file.readError?.failure === "binary_file") ? (
1414 <AttachmentFilePreview
1393 - key={`${environmentId}:${absolutePath}:${workspaceMutationId}:${documentRefreshId}`}
1415 + key={`${environmentId}:${absolutePath}:${workspaceMutationId}:${fileRefreshRevision}`}
1416 name={relativePath.split(/[\\/]/).at(-1) || relativePath}
1417 mimeType="application/octet-stream"
1418 sizeBytes={0}
@@ -1515,9 +1537,10 @@ export default function FilePreviewPanel({
1537 workspaceMutationId={workspaceMutationId}
1538 {...(previewPath && !isMedia && !isPdf
1539 ? {
1518 - onRefreshSelectedFile: isDocument
1519 - ? () => setDocumentRefreshId((revision) => revision + 1)
1520 - : file.refresh,
1540 + onRefreshSelectedFile: () => {
1541 + if (!isDocument) file.refresh();
1542 + setFileRefreshRevision((value) => value + 1);
1543 + },
1544 }
1545 : {})}
1546 />
@@ -1527,3 +1550,123 @@ export default function FilePreviewPanel({
1550 </div>
1551 );
1552 }
1553 +
1554 +const LargeTextViewer = lazy(() => import("./LargeTextViewer"));
1555 +export function WorkspaceLargeTextPreview(props: {
1556 + environmentId: EnvironmentId;
1557 + threadRef: ScopedThreadRef;
1558 + absolutePath: string;
1559 + name: string;
1560 + delimiter: "," | "\t" | null;
1561 + workspaceMutationId: string | null;
1562 + revealLine: number | null;
1563 + revealRequestId: number;
1564 +}) {
1565 + const resource = {
1566 + _tag: "media-file",
1567 + threadId: props.threadRef.threadId,
1568 + path: props.absolutePath,
1569 + disposition: "attachment",
1570 + } as const;
1571 + const copyContents = useRef<(() => Promise<string>) | null>(null);
1572 + const { copyToClipboard, isCopied } = useCopyToClipboard({ target: props.name });
1573 + const [saving, setSaving] = useState(false);
1574 + const [revision, setRevision] = useState(0);
1575 + const showError = (cause: unknown) => {
1576 + toastManager.add({
1577 + type: "error",
1578 + title: "Could not read file",
1579 + description: cause instanceof Error ? cause.message : "Try again.",
1580 + });
1581 + };
1582 + const assetUrl = useAssetUrlState(props.environmentId, resource);
1583 + const refreshAssetUrl = useAssetUrlRefresh(props.environmentId, resource);
1584 + useWorkspaceMutationRefresh({
1585 + mutationId: props.workspaceMutationId,
1586 + resourceKey: JSON.stringify([props.environmentId, resource]),
1587 + refresh: () => {
1588 + void refreshAssetUrl().catch(() => undefined);
1589 + },
1590 + });
1591 + const contentRevision = JSON.stringify([
1592 + props.environmentId,
1593 + resource,
1594 + assetUrl._tag === "Success" ? (assetUrl.fileRevision ?? props.workspaceMutationId) : null,
1595 + revision,
1596 + ]);
1597 + const [loaded, setLoaded] = useState<{ revision: string; url: string } | null>(null);
1598 + if (assetUrl._tag === "Success" && loaded?.revision !== contentRevision) {
1599 + setLoaded({ revision: contentRevision, url: assetUrl.url });
1600 + }
1601 + if (assetUrl._tag === "Failure")
1602 + return (
1603 + <FileSurfaceFailure
1604 + message="Unable to load file preview."
1605 + onRetry={() => {
1606 + setRevision((value) => value + 1);
1607 + void refreshAssetUrl().catch(showError);
1608 + }}
1609 + />
1610 + );
1611 + if (assetUrl._tag !== "Success" || loaded === null)
1612 + return <div className="p-6 text-xs text-muted-foreground">Loading…</div>;
1613 + const src = `${loaded.url}${loaded.url.includes("?") ? "&" : "?"}revision=${encodeURIComponent(loaded.revision)}`;
1614 + return (
1615 + <>
1616 + <div className={FILE_SURFACE_SUBHEADER_CLASS}>
1617 + <span className="min-w-0 flex-1 text-xs text-muted-foreground">Full file</span>
1618 + <FileSurfaceAction
1619 + label={isCopied ? "Copied" : "Copy contents"}
1620 + onPress={() => {
1621 + const copy = copyContents.current;
1622 + if (!copy) return;
1623 + void copy()
1624 + .then((text) => copyToClipboard(text, undefined))
1625 + .catch(showError);
1626 + }}
1627 + >
1628 + {isCopied ? <CheckIcon className="size-3.5" /> : <CopyIcon className="size-3.5" />}
1629 + </FileSurfaceAction>
1630 + <FileSurfaceAction
1631 + label={saving ? "Preparing file…" : "Save file"}
1632 + disabled={saving}
1633 + onPress={() => {
1634 + setSaving(true);
1635 + void (async () => {
1636 + const url = await refreshAssetUrl();
1637 + if (!url) throw new Error("Reconnect to the environment and try again.");
1638 + const response = await fetch(url);
1639 + if (!response.ok) throw new Error("The file could not be loaded. Try again.");
1640 + const downloadUrl = URL.createObjectURL(await response.blob());
1641 + setTimeout(() => URL.revokeObjectURL(downloadUrl), 30_000);
1642 + const anchor = document.createElement("a");
1643 + anchor.href = downloadUrl;
1644 + anchor.download = props.name.split(/[\\/]/).at(-1) || props.name;
1645 + anchor.click();
1646 + })()
1647 + .catch(showError)
1648 + .finally(() => setSaving(false));
1649 + }}
1650 + >
1651 + <DownloadIcon className="size-3.5" />
1652 + </FileSurfaceAction>
1653 + </div>
1654 + <Suspense fallback={<div className="p-6 text-xs text-muted-foreground">Loading…</div>}>
1655 + <LargeTextViewer
1656 + key={`${src}:${revision}`}
1657 + name={props.name}
1658 + copyContents={copyContents}
1659 + onRetry={() => {
1660 + void refreshAssetUrl()
1661 + .then(() => setRevision((value) => value + 1))
1662 + .catch(showError);
1663 + }}
1664 + src={src}
1665 + delimiter={props.delimiter}
1666 + revealLine={props.revealLine}
1667 + revealRequestId={props.revealRequestId}
1668 + />
1669 + </Suspense>
1670 + </>
1671 + );
1672 +}
apps/web/src/components/files/LargeTextViewer.tsx new
+257
@@ -0,0 +1,257 @@
1 +import { useEffect, useImperativeHandle, useRef, useState, type RefObject } from "react";
2 +import { parseDelimitedPreview } from "@t3tools/shared/delimitedPreview";
3 +import { formatAttachmentSize } from "@t3tools/client-runtime/state/attachments";
4 +import { useClientSettings } from "~/hooks/useSettings";
5 +import { FileSurfaceFailure, FileSurfaceLoading, FileSurfaceNotice } from "./fileSurfaceChrome";
6 +import { PREVIEW_PAGE_ROWS, type TextPreviewResult } from "./largeTextProtocol";
7 +import VirtualTablePreview from "./VirtualTablePreview";
8 +
9 +const FIRST_SCREEN_BYTES = 16 * 1024;
10 +
11 +function firstScreen(text: string, delimiter: "," | "\t" | null, complete: boolean) {
12 + if (!text || text.includes("\0")) return [];
13 + const rows = delimiter
14 + ? parseDelimitedPreview(text, delimiter, {
15 + maxRows: PREVIEW_PAGE_ROWS * 2 + 1,
16 + maxColumns: 1024,
17 + maxCellLength: FIRST_SCREEN_BYTES,
18 + }).rows
19 + : text
20 + .replace(/\r?\n$|\r$/, "")
21 + .split(/\r\n|\n|\r/)
22 + .slice(0, PREVIEW_PAGE_ROWS * 2 + 1)
23 + .map((line) => [line]);
24 + // A byte range can end inside a quoted record or a UTF-8 character.
25 + if (!complete) rows.pop();
26 + return rows.slice(0, PREVIEW_PAGE_ROWS * 2);
27 +}
28 +
29 +export default function LargeTextViewer(props: {
30 + readonly name: string;
31 + readonly src?: string;
32 + readonly text?: string;
33 + readonly sizeBytes?: number;
34 + readonly onRetry?: () => void;
35 + readonly copyContents?: RefObject<(() => Promise<string>) | null>;
36 + readonly delimiter: "," | "\t" | null;
37 + readonly revealLine?: number | null;
38 + readonly revealRequestId?: number;
39 +}) {
40 + const [meta, setMeta] = useState<Extract<TextPreviewResult, { type: "meta" }> | null>(null);
41 + const [pages, setPages] = useState(new Map<number, string[][]>());
42 + const [error, setError] = useState<string | null>(null);
43 + const worker = useRef<Worker | null>(null);
44 + const copyPending = useRef<{
45 + resolve: (text: string) => void;
46 + reject: (cause: Error) => void;
47 + } | null>(null);
48 + const pending = useRef(new Set<number>());
49 + const wordWrap = useClientSettings((settings) => settings.wordWrap);
50 + // oxlint-disable-next-line t3code/react-effect-budget -- Own the prefix fetch and indexing worker, cancelling requests and pending copies when the source changes or unmounts.
51 + useEffect(() => {
52 + // oxlint-disable-next-line react/set-state-in-effect -- A replacement source must discard the previous worker's error and pages.
53 + setError(null);
54 + setMeta(null);
55 + setPages(new Map());
56 + const controller = new AbortController();
57 + let indexed = false;
58 + let prefetched = false;
59 + const paintFirstScreen = (text: string, complete: boolean) => {
60 + if (indexed || controller.signal.aborted) return;
61 + const rows = firstScreen(text, props.delimiter, complete);
62 + if (!rows.length) return;
63 + prefetched = true;
64 + setPages(
65 + new Map(
66 + [0, PREVIEW_PAGE_ROWS]
67 + .filter((start) => start < rows.length)
68 + .map((start) => [
69 + start / PREVIEW_PAGE_ROWS,
70 + rows.slice(start, start + PREVIEW_PAGE_ROWS),
71 + ]),
72 + ),
73 + );
74 + setMeta({
75 + type: "meta",
76 + count: rows.length,
77 + columns: rows.reduce((max, row) => Math.max(max, row.length), 1),
78 + complete: false,
79 + });
80 + };
81 + const startWorker = () => {
82 + if (controller.signal.aborted) return;
83 + const engine = new Worker(new URL("./largeText.worker.ts", import.meta.url), {
84 + type: "module",
85 + });
86 + worker.current = engine;
87 + engine.addEventListener("message", (event: MessageEvent<TextPreviewResult>) => {
88 + const result = event.data;
89 + if (result.type === "copy") {
90 + copyPending.current?.resolve(result.text);
91 + copyPending.current = null;
92 + } else if (result.type === "error") {
93 + copyPending.current?.reject(new Error(result.message));
94 + copyPending.current = null;
95 + if (result.operation !== "copy") setError(result.message);
96 + } else if (result.type === "meta") {
97 + indexed = true;
98 + if (prefetched) {
99 + setPages(new Map());
100 + pending.current.clear();
101 + prefetched = false;
102 + }
103 + setMeta(result);
104 + } else if (result.type === "page") {
105 + pending.current.delete(result.index);
106 + setPages((old) => {
107 + const previous = old.get(result.index);
108 + if (
109 + previous?.length === result.rows.length &&
110 + previous.every(
111 + (row, index) =>
112 + row.length === result.rows[index]!.length &&
113 + row.every((cell, column) => cell === result.rows[index]![column]),
114 + )
115 + )
116 + return old;
117 + const next = new Map(old);
118 + next.delete(result.index);
119 + next.set(result.index, result.rows);
120 + if (next.size > 12) next.delete([...next.keys()].find((key) => key !== 0)!);
121 + return next;
122 + });
123 + }
124 + });
125 + engine.addEventListener("error", () => {
126 + copyPending.current?.reject(new Error("The text viewer stopped."));
127 + copyPending.current = null;
128 + setError("Could not load the text viewer. Close the file and try again.");
129 + });
130 + engine.postMessage(
131 + {
132 + type: "open",
133 + src: props.src,
134 + text: props.text,
135 + sizeBytes: props.sizeBytes,
136 + delimiter: props.delimiter,
137 + },
138 + [],
139 + );
140 + };
141 + const scheduleWorker = () => {
142 + if (prefetched) requestAnimationFrame(() => requestAnimationFrame(startWorker));
143 + else startWorker();
144 + };
145 + // Only this bounded prefix is parsed on the main thread. Indexing the full
146 + // file and fetching later pages remain in the worker.
147 + if (props.sizeBytes === 0) {
148 + startWorker();
149 + } else if (props.text !== undefined) {
150 + paintFirstScreen(
151 + props.text.slice(0, FIRST_SCREEN_BYTES),
152 + props.text.length <= FIRST_SCREEN_BYTES,
153 + );
154 + scheduleWorker();
155 + } else if (props.src) {
156 + void fetch(props.src, {
157 + headers: { Range: `bytes=0-${FIRST_SCREEN_BYTES - 1}` },
158 + cache: "no-store",
159 + signal: controller.signal,
160 + })
161 + .then(async (response) => {
162 + if (
163 + !response.ok ||
164 + Number(response.headers.get("content-length")) > FIRST_SCREEN_BYTES ||
165 + response.status !== 206
166 + ) {
167 + await response.body?.cancel();
168 + return;
169 + }
170 + const total = Number(response.headers.get("content-range")?.split("/")[1]);
171 + paintFirstScreen(await response.text(), total <= FIRST_SCREEN_BYTES);
172 + })
173 + .catch(() => {
174 + // The worker reports authorization, network and format failures.
175 + })
176 + .finally(scheduleWorker);
177 + } else startWorker();
178 + return () => {
179 + controller.abort();
180 + copyPending.current?.reject(new Error("Preview closed."));
181 + copyPending.current = null;
182 + worker.current?.terminate();
183 + worker.current = null;
184 + pending.current.clear();
185 + };
186 + }, [props.src, props.text, props.delimiter, props.sizeBytes]);
187 + useImperativeHandle(
188 + props.copyContents,
189 + () => () =>
190 + new Promise<string>((resolve, reject) => {
191 + if (!worker.current) {
192 + reject(new Error("The file is unavailable."));
193 + return;
194 + }
195 + if (copyPending.current) {
196 + reject(new Error("Another copy is in progress."));
197 + return;
198 + }
199 + copyPending.current = { resolve, reject };
200 + worker.current.postMessage({ type: "copy" }, []);
201 + }),
202 + [],
203 + );
204 + if (error)
205 + return (
206 + <FileSurfaceFailure message={error} {...(props.onRetry ? { onRetry: props.onRetry } : {})} />
207 + );
208 + if (!meta || (meta.count > 0 && !pages.has(0))) return <FileSurfaceLoading />;
209 + const header = props.delimiter ? pages.get(0)?.[0] : undefined;
210 + return (
211 + <div className="relative flex min-h-0 flex-1 flex-col">
212 + <div
213 + className="flex min-h-10 shrink-0 flex-wrap items-center gap-x-1 border-b border-border/60 px-3 py-2 text-xs text-muted-foreground tabular-nums"
214 + role="status"
215 + >
216 + {Math.max(0, meta.count - (props.delimiter && meta.count ? 1 : 0)).toLocaleString()}{" "}
217 + {props.delimiter ? "rows" : "lines"}
218 + {props.delimiter ? ` · ${meta.count ? meta.columns.toLocaleString() : 0} columns` : ""}
219 + {meta.complete && meta.sizeBytes !== undefined
220 + ? ` · ${meta.sizeBytes === 0 ? "0 bytes" : formatAttachmentSize(meta.sizeBytes)}`
221 + : " · Indexing…"}
222 + </div>
223 + {!meta.complete ? (
224 + <div className="pointer-events-none absolute inset-x-0 bottom-0 z-20">
225 + <FileSurfaceNotice>Loading the rest of the file…</FileSurfaceNotice>
226 + </div>
227 + ) : null}
228 + {meta.columns === 1024 ? (
229 + <FileSurfaceNotice>
230 + Showing the first 1,024 columns. Source and Save retain every column.
231 + </FileSurfaceNotice>
232 + ) : null}
233 + {meta.count > 0 ? (
234 + <VirtualTablePreview
235 + name={props.name}
236 + count={meta.count}
237 + columns={meta.columns}
238 + header={header}
239 + source={!props.delimiter}
240 + wrap={wordWrap}
241 + revealLine={meta.complete ? (props.revealLine ?? null) : null}
242 + revealRequestId={props.revealRequestId ?? 0}
243 + getRows={(page) => pages.get(page)}
244 + loadPage={(page) => {
245 + if (pending.current.has(page)) return;
246 + pending.current.add(page);
247 + worker.current?.postMessage({ type: "page", index: page });
248 + }}
249 + />
250 + ) : (
251 + <div className="flex flex-1 items-center justify-center p-6 text-xs text-muted-foreground">
252 + This file is empty.
253 + </div>
254 + )}
255 + </div>
256 + );
257 +}
apps/web/src/components/files/VirtualTablePreview.tsx new
+507
@@ -0,0 +1,507 @@
1 +/* oxlint-disable react/no-array-index-key -- Positions identify source rows and columns. */
2 +import { useEffect, useEffectEvent, useLayoutEffect, useRef, useState } from "react";
3 +import { observeResize } from "~/lib/observeResize";
4 +import { Tooltip, TooltipPopup, TooltipTrigger } from "~/components/ui/tooltip";
5 +import { PREVIEW_PAGE_ROWS } from "./largeTextProtocol";
6 +
7 +export default function VirtualTablePreview(props: {
8 + readonly name: string;
9 + readonly count: number;
10 + readonly columns: number;
11 + readonly getRows: (page: number) => readonly (readonly string[])[] | undefined;
12 + readonly loadPage?: (page: number) => void;
13 + readonly header?: readonly string[] | undefined;
14 + readonly source?: boolean;
15 + readonly wrap?: boolean;
16 + readonly revealLine?: number | null;
17 + readonly revealRequestId?: number;
18 +}) {
19 + const ref = useRef<HTMLDivElement>(null);
20 + const [left, setLeft] = useState(0);
21 + const [size, setSize] = useState({ width: 0, height: 600 });
22 + const { width } = size;
23 + const widthRef = useRef(0);
24 + const measureRef = useRef<HTMLTableElement>(null);
25 + const [measured, setMeasured] = useState<number[] | null>(null);
26 + // oxlint-disable-next-line t3code/react-effect-budget -- Measure the viewport before paint and observe container resizes to invalidate column measurements.
27 + useLayoutEffect(() => {
28 + const node = ref.current;
29 + if (!node) return;
30 + const update = () => {
31 + const width = node.clientWidth;
32 + const height = node.clientHeight;
33 + setSize((old) => (old.width === width && old.height === height ? old : { width, height }));
34 + if (widthRef.current !== width) {
35 + widthRef.current = width;
36 + setMeasured(null);
37 + }
38 + };
39 + update();
40 + return observeResize(node, update);
41 + }, []);
42 + // oxlint-disable-next-line t3code/react-effect-budget -- Read the browser's laid-out table column widths before displaying the virtual table.
43 + useLayoutEffect(() => {
44 + if (!width || !props.header || !measureRef.current || measured) return;
45 + const widths = [...measureRef.current.querySelectorAll("thead th")].map(
46 + (cell) => cell.getBoundingClientRect().width,
47 + );
48 + if (widths.length) setMeasured(widths);
49 + }, [measured, width, props.header]);
50 + const columnWidth = props.source
51 + ? 0
52 + : Math.max(128, Math.min(320, (width - 56) / Math.min(props.columns, 6)));
53 + const rowHeader = 56;
54 + const sizes = Array.from(
55 + { length: props.columns },
56 + (_, column) => measured?.[column] ?? columnWidth,
57 + );
58 + const offsets = [0];
59 + for (const size of sizes) offsets.push(offsets[offsets.length - 1]! + size);
60 + const firstColumn = props.source
61 + ? 0
62 + : Math.max(0, sizes.findIndex((_, column) => offsets[column + 1]! > left - rowHeader) - 1);
63 + const lastColumn = props.source
64 + ? 1
65 + : Math.min(
66 + props.columns,
67 + offsets.findIndex((offset) => offset >= left + width - rowHeader) + 1 || props.columns,
68 + );
69 + const columns = Array.from(
70 + { length: Math.max(0, lastColumn - firstColumn) },
71 + (_, i) => firstColumn + i,
72 + );
73 + const offset = (column: number) => offsets[column]!;
74 + const tableWidth = props.source ? "100%" : Math.max(width, offset(props.columns) + rowHeader);
75 + return (
76 + <div
77 + ref={ref}
78 + className="relative min-h-0 flex-1 overflow-x-auto contain-strict"
79 + onScroll={(event) => {
80 + event.currentTarget.style.setProperty(
81 + "--preview-scroll-left",
82 + `${event.currentTarget.scrollLeft}px`,
83 + );
84 + setLeft(event.currentTarget.scrollLeft);
85 + }}
86 + >
87 + {props.header && props.columns <= 30 && !measured && width > 0 ? (
88 + <table
89 + ref={measureRef}
90 + aria-hidden="true"
91 + className="invisible absolute top-0 border-separate border-spacing-0 text-xs"
92 + style={{ width: Math.max(width - rowHeader, props.columns * 128) }}
93 + >
94 + <thead>
95 + <tr>
96 + {props.header.map((cell, i) => (
97 + <th
98 + key={i}
99 + className="min-w-32 max-w-80 border-b px-3 py-1.5 text-left font-medium whitespace-nowrap"
100 + >
101 + {cell}
102 + </th>
103 + ))}
104 + </tr>
105 + </thead>
106 + <tbody>
107 + {props
108 + .getRows(0)
109 + ?.slice(1, 20)
110 + .map((row, i) => (
111 + <tr key={i}>
112 + {row.map((cell, j) => (
113 + <td
114 + key={j}
115 + className="max-w-80 border-b px-3 py-1.5 whitespace-pre-wrap break-words tabular-nums"
116 + >
117 + {cell}
118 + </td>
119 + ))}
120 + </tr>
121 + ))}
122 + </tbody>
123 + </table>
124 + ) : null}
125 + {width > 0 && (!props.header || props.columns > 30 || measured) ? (
126 + <div
127 + role={props.source ? "region" : "table"}
128 + aria-label={props.name}
129 + aria-rowcount={props.count}
130 + aria-colcount={props.source ? undefined : props.columns}
131 + className="flex h-full min-h-0 flex-col text-xs"
132 + style={{ width: tableWidth }}
133 + >
134 + {!props.source ? (
135 + <div
136 + role="row"
137 + className="relative z-10 flex min-h-[29px] shrink-0 border-b border-border bg-muted/60 font-medium backdrop-blur"
138 + >
139 + <div className="sticky left-0 z-10 w-14 shrink-0 border-r border-border bg-background" />
140 + <div style={{ width: offset(firstColumn), flexShrink: 0 }} />
141 + {columns.map((column) => (
142 + <Tooltip key={column}>
143 + <TooltipTrigger
144 + render={
145 + <div
146 + role="columnheader"
147 + aria-colindex={column + 1}
148 + className="shrink-0 overflow-hidden border-r border-border/40 px-3 py-1.5 text-ellipsis whitespace-pre"
149 + style={{ width: sizes[column] }}
150 + >
151 + {props.header?.[column] ?? columnLabel(column)}
152 + </div>
153 + }
154 + />
155 + <TooltipPopup>{props.header?.[column] ?? columnLabel(column)}</TooltipPopup>
156 + </Tooltip>
157 + ))}
158 + </div>
159 + ) : null}
160 + <ScaledRows
161 + {...props}
162 + columnsVisible={columns}
163 + sizes={sizes}
164 + rowHeader={rowHeader}
165 + firstColumn={firstColumn}
166 + viewportHeight={size.height - (props.source ? 0 : 29)}
167 + />
168 + </div>
169 + ) : null}
170 + </div>
171 + );
172 +}
173 +function RowPage(
174 + props: Parameters<typeof VirtualTablePreview>[0] & {
175 + page: number;
176 + columnsVisible: number[];
177 + sizes: number[];
178 + rowHeader: number;
179 + firstColumn: number;
180 + viewportHeight: number;
181 + limit?: number;
182 + },
183 +) {
184 + const rows = props.getRows(props.page);
185 + // A page stays mounted while the worker fills it, preserving the scroll position.
186 + const { loadPage, page } = props;
187 + // oxlint-disable-next-line t3code/react-effect-budget -- Request missing rows from the indexing worker while preserving the mounted page's scroll position.
188 + useEffect(() => {
189 + const expected = Math.min(PREVIEW_PAGE_ROWS, props.count - page * PREVIEW_PAGE_ROWS);
190 + if (!rows || rows.length < expected) loadPage?.(page);
191 + }, [rows, page, loadPage, props.count]);
192 + const start = props.page * PREVIEW_PAGE_ROWS;
193 + const count = Math.min(PREVIEW_PAGE_ROWS, props.count - start, props.limit ?? PREVIEW_PAGE_ROWS);
194 + return (
195 + <div role="rowgroup">
196 + {Array.from({ length: count }, (_, local) => {
197 + const row = rows?.[local];
198 + const index = start + local;
199 + if (props.header && index === 0) return null;
200 + return (
201 + <div
202 + key={local}
203 + data-preview-row={index}
204 + role={props.source ? undefined : "row"}
205 + aria-rowindex={props.source ? undefined : index + 1}
206 + className={
207 + props.source
208 + ? `flex min-h-[29px] font-mono ${props.revealLine != null && Math.min(props.count, Math.max(1, props.revealLine)) === index + 1 ? "bg-primary/10" : ""}`
209 + : `flex min-h-[29px] border-b border-border/60 ${(index - (props.header ? 1 : 0)) % 2 ? "bg-muted/30" : ""}`
210 + }
211 + data-preview-reveal={
212 + props.revealLine != null &&
213 + Math.min(props.count, Math.max(1, props.revealLine)) === index + 1
214 + ? "true"
215 + : undefined
216 + }
217 + >
218 + <div
219 + role={props.source ? undefined : "rowheader"}
220 + className={`${props.source ? "sticky left-0" : "relative"} z-1 shrink-0 border-r border-border bg-background px-2 py-1.5 text-right font-normal text-muted-foreground tabular-nums select-none`}
221 + style={{
222 + width: props.rowHeader,
223 + transform: props.source ? undefined : "translateX(var(--preview-scroll-left, 0px))",
224 + }}
225 + >
226 + <span className="sticky top-0 block">{index + (props.header ? 0 : 1)}</span>
227 + </div>
228 + {!props.source ? (
229 + <div
230 + style={{
231 + width: props.sizes.slice(0, props.firstColumn).reduce((a, b) => a + b, 0),
232 + flexShrink: 0,
233 + }}
234 + />
235 + ) : null}
236 + {props.columnsVisible.map((column) => (
237 + <div
238 + key={column}
239 + role={props.source ? undefined : "cell"}
240 + aria-colindex={props.source ? undefined : column + 1}
241 + className={
242 + props.source
243 + ? `min-w-0 flex-1 px-3 py-1 ${props.wrap ? "whitespace-pre-wrap break-words" : "whitespace-pre"}`
244 + : "shrink-0 border-r border-border/40 px-3 py-1.5 whitespace-pre-wrap break-words tabular-nums"
245 + }
246 + style={props.source ? undefined : { width: props.sizes[column] }}
247 + >
248 + {row?.[column] ?? ""}
249 + </div>
250 + ))}
251 + </div>
252 + );
253 + })}
254 + </div>
255 + );
256 +}
257 +
258 +function ScaledRows(props: Omit<Parameters<typeof RowPage>[0], "page">) {
259 + const ref = useRef<HTMLDivElement>(null);
260 + const contentRef = useRef<HTMLDivElement>(null);
261 + const [layout, setLayout] = useState({ offset: 0, height: 0, rowHeight: 29 });
262 + const [top, setTop] = useState(0);
263 + const handledReveal = useRef<string | null>(null);
264 + const pendingReveal = useRef<{ row: number; attempts: number } | null>(null);
265 + const pendingEnd = useRef(false);
266 + const position = { top, height: props.viewportHeight };
267 + const scrollHeight = Math.min(8_000_000, props.count * 29);
268 + // Chromium caps a scroll surface at 33 million pixels. Scale the track for
269 + // multi-million-line logs while retaining real row heights in the viewport.
270 + const headerRows = props.header ? 1 : 0;
271 + const maxFirst = Math.max(0, props.count - headerRows - Math.floor(position.height / 29));
272 + const scale = Math.max(1, scrollHeight - position.height) / Math.max(1, maxFirst * 29);
273 + const first = Math.min(maxFirst, Math.floor(position.top / scale / 29)) + headerRows;
274 + // The final mounted rows keep their measured height and scroll natively.
275 + const nativeTail = first - headerRows === maxFirst;
276 + const scrollModel = useRef({ scale, maxFirst, heights: [] as number[] });
277 + // oxlint-disable-next-line t3code/react-effect-budget -- Measure native tail rows and preserve the DOM scroll position when the virtual track scale changes.
278 + useLayoutEffect(() => {
279 + const previous = scrollModel.current;
280 + const heights = nativeTail
281 + ? Array.from(contentRef.current?.querySelectorAll<HTMLElement>("[data-preview-row]") ?? [])
282 + .filter((row) => Number(row.dataset.previewRow) >= first)
283 + .map((row) => row.offsetHeight)
284 + : [];
285 + scrollModel.current = { scale, maxFirst, heights };
286 + const node = ref.current;
287 + if (!node || (previous.scale === scale && previous.maxFirst === maxFirst)) return;
288 + const previousEnd = previous.maxFirst * 29 * previous.scale;
289 + let logicalTop = Math.min(previous.maxFirst * 29, node.scrollTop / previous.scale);
290 + let remaining = Math.max(0, node.scrollTop - previousEnd);
291 + // Native-tail pixels cross rows of different heights before returning to the scaled track.
292 + for (const height of previous.heights) {
293 + logicalTop += Math.min(1, remaining / height) * 29;
294 + remaining = Math.max(0, remaining - height);
295 + if (!remaining) break;
296 + }
297 + let nativeOffset = 0;
298 + remaining = Math.max(0, logicalTop / 29 - maxFirst);
299 + for (const height of heights) {
300 + nativeOffset += Math.min(1, remaining) * height;
301 + remaining = Math.max(0, remaining - 1);
302 + if (!remaining) break;
303 + }
304 + node.scrollTop = Math.min(maxFirst * 29, logicalTop) * scale + nativeOffset;
305 + setTop(node.scrollTop);
306 + });
307 + // oxlint-disable-next-line t3code/react-effect-budget -- Scroll the DOM viewport to a requested line after its virtual track has committed.
308 + useLayoutEffect(() => {
309 + const node = ref.current;
310 + if (props.revealLine == null) {
311 + handledReveal.current = null;
312 + pendingReveal.current = null;
313 + return;
314 + }
315 + const key = `${props.revealRequestId}:${props.revealLine}`;
316 + if (!node || !props.count || handledReveal.current === key) return;
317 + const row = Math.min(props.count, Math.max(1, props.revealLine)) - 1;
318 + node.scrollTop = Math.max(0, (row - headerRows) * 29) * scale;
319 + setTop(node.scrollTop);
320 + pendingEnd.current = false;
321 + pendingReveal.current = { row, attempts: 0 };
322 + handledReveal.current = key;
323 + }, [props.revealLine, props.revealRequestId, props.count, headerRows, scale]);
324 + const atStart = position.top === 0;
325 + const rowHeight = () =>
326 + contentRef.current?.querySelector<HTMLElement>(`[data-preview-row="${first}"]`)?.offsetHeight ||
327 + 29;
328 + const onWheel = useEffectEvent((event: WheelEvent) => {
329 + const node = ref.current;
330 + if (!node || event.ctrlKey || Math.abs(event.deltaX) > Math.abs(event.deltaY)) return;
331 + const delta =
332 + event.deltaY * (event.deltaMode === 1 ? 29 : event.deltaMode === 2 ? node.clientHeight : 1);
333 + if (!delta) return;
334 + event.preventDefault();
335 + pendingEnd.current = false;
336 + node.scrollTop += delta * (nativeTail ? 1 : (scale * 29) / rowHeight());
337 + });
338 + // oxlint-disable-next-line t3code/react-effect-budget -- Install a non-passive native wheel listener so virtual scrolling can prevent the browser's default scroll.
339 + useEffect(() => {
340 + const node = ref.current;
341 + if (!node) return;
342 + const wheel = (event: WheelEvent) => onWheel(event);
343 + node.addEventListener("wheel", wheel, { passive: false });
344 + return () => {
345 + node.removeEventListener("wheel", wheel);
346 + };
347 + }, []);
348 + const page = Math.floor(first / PREVIEW_PAGE_ROWS);
349 + const visibleEnd = (first % PREVIEW_PAGE_ROWS) + Math.ceil(position.height / 29) + 1;
350 + // oxlint-disable-next-line t3code/react-effect-budget -- Measure mounted row offsets and observe content resizes to position the virtual rows against the scroll track.
351 + useLayoutEffect(() => {
352 + if (atStart) return;
353 + const node = contentRef.current;
354 + if (!node) return;
355 + const update = () => {
356 + const row = node.querySelector<HTMLElement>(`[data-preview-row="${first}"]`);
357 + const offset = row ? row.getBoundingClientRect().top - node.getBoundingClientRect().top : 0;
358 + const height = node.clientHeight;
359 + const rowHeight = row?.offsetHeight || 29;
360 + setLayout((old) =>
361 + old.offset === offset && old.height === height && old.rowHeight === rowHeight
362 + ? old
363 + : { offset, height, rowHeight },
364 + );
365 + };
366 + update();
367 + return observeResize(node, update);
368 + }, [first, atStart]);
369 + // oxlint-disable-next-line t3code/react-effect-budget -- Correct the DOM scroll position once a requested worker row has loaded and its actual bounds are measurable.
370 + useLayoutEffect(() => {
371 + const pending = pendingReveal.current;
372 + const node = ref.current;
373 + const row =
374 + pending &&
375 + contentRef.current?.querySelector<HTMLElement>(`[data-preview-row="${pending.row}"]`);
376 + if (
377 + !pending ||
378 + !node ||
379 + !row ||
380 + !props.getRows(Math.floor(pending.row / PREVIEW_PAGE_ROWS))?.[pending.row % PREVIEW_PAGE_ROWS]
381 + )
382 + return;
383 + const content = contentRef.current!;
384 + const firstRow = content.querySelector<HTMLElement>(`[data-preview-row="${first}"]`);
385 + if (
386 + !atStart &&
387 + (layout.height !== content.clientHeight ||
388 + layout.offset !==
389 + (firstRow
390 + ? firstRow.getBoundingClientRect().top - content.getBoundingClientRect().top
391 + : 0))
392 + )
393 + return;
394 + const bounds = row.getBoundingClientRect();
395 + const viewport = node.getBoundingClientRect();
396 + const delta =
397 + bounds.top < viewport.top
398 + ? bounds.top - viewport.top
399 + : Math.min(bounds.bottom, bounds.top + viewport.height) > viewport.bottom
400 + ? Math.min(bounds.bottom, bounds.top + viewport.height) - viewport.bottom
401 + : 0;
402 + if (Math.abs(delta) < 1 || pending.attempts++ >= 8) {
403 + pendingReveal.current = null;
404 + return;
405 + }
406 + node.scrollTop += delta * (nativeTail ? 1 : (scale * 29) / Math.max(29, bounds.height));
407 + setTop(node.scrollTop);
408 + });
409 + // oxlint-disable-next-line t3code/react-effect-budget -- Complete End-key scrolling after the final worker row has loaded and its DOM layout has settled.
410 + useLayoutEffect(() => {
411 + const node = ref.current;
412 + const content = contentRef.current;
413 + if (!pendingEnd.current || !nativeTail || !node || !content || !props.count) return;
414 + const last = props.count - 1;
415 + if (!props.getRows(Math.floor(last / PREVIEW_PAGE_ROWS))?.[last % PREVIEW_PAGE_ROWS]) return;
416 + const row = content.querySelector<HTMLElement>(`[data-preview-row="${last}"]`);
417 + const firstRow = content.querySelector<HTMLElement>(`[data-preview-row="${first}"]`);
418 + if (
419 + !row ||
420 + (!atStart &&
421 + (layout.height !== content.clientHeight ||
422 + layout.offset !==
423 + (firstRow
424 + ? firstRow.getBoundingClientRect().top - content.getBoundingClientRect().top
425 + : 0)))
426 + )
427 + return;
428 + node.scrollTop = node.scrollHeight;
429 + setTop(node.scrollTop);
430 + if (Math.abs(row.getBoundingClientRect().bottom - node.getBoundingClientRect().bottom) < 1)
431 + pendingEnd.current = false;
432 + });
433 + return (
434 + <div
435 + ref={ref}
436 + tabIndex={0}
437 + className="min-h-0 flex-1 overflow-auto"
438 + onKeyDown={(event) => {
439 + const node = event.currentTarget;
440 + const delta =
441 + event.key === "ArrowDown"
442 + ? 29
443 + : event.key === "ArrowUp"
444 + ? -29
445 + : event.key === "PageDown"
446 + ? node.clientHeight
447 + : event.key === "PageUp"
448 + ? -node.clientHeight
449 + : null;
450 + if (delta !== null) {
451 + pendingEnd.current = false;
452 + event.preventDefault();
453 + node.scrollTop += delta * (nativeTail ? 1 : (scale * 29) / rowHeight());
454 + } else if (event.key === "Home" || event.key === "End") {
455 + event.preventDefault();
456 + pendingEnd.current = event.key === "End";
457 + pendingReveal.current = null;
458 + node.scrollTop = event.key === "Home" ? 0 : node.scrollHeight;
459 + setTop(node.scrollTop);
460 + }
461 + }}
462 + onScroll={(event) => setTop(event.currentTarget.scrollTop)}
463 + >
464 + <div className="relative" style={{ height: scrollHeight }}>
465 + <div
466 + ref={contentRef}
467 + className="absolute inset-x-0"
468 + style={{
469 + top:
470 + maxFirst === 0
471 + ? 0
472 + : nativeTail
473 + ? maxFirst * scale * 29 - layout.offset
474 + : position.top +
475 + (atStart
476 + ? 0
477 + : -layout.offset - ((position.top / scale / 29) % 1) * layout.rowHeight),
478 + }}
479 + >
480 + {Array.from(
481 + {
482 + length: Math.min(
483 + Math.ceil(visibleEnd / PREVIEW_PAGE_ROWS),
484 + Math.ceil(props.count / PREVIEW_PAGE_ROWS) - page,
485 + ),
486 + },
487 + (_, offset) => (
488 + <RowPage
489 + key={page + offset}
490 + {...props}
491 + page={page + offset}
492 + limit={visibleEnd - offset * PREVIEW_PAGE_ROWS}
493 + />
494 + ),
495 + )}
496 + </div>
497 + </div>
498 + </div>
499 + );
500 +}
501 +
502 +function columnLabel(index: number): string {
503 + let label = "";
504 + for (let value = index + 1; value > 0; value = Math.floor((value - 1) / 26))
505 + label = String.fromCharCode(65 + ((value - 1) % 26)) + label;
506 + return label;
507 +}
apps/web/src/components/files/largeText.worker.ts new
+189
@@ -0,0 +1,189 @@
1 +import { parseDelimitedPreview } from "@t3tools/shared/delimitedPreview";
2 +import {
3 + LARGE_TEXT_MAX_BYTES,
4 + LARGE_TEXT_MAX_ROWS,
5 + LARGE_TEXT_MAX_COLUMNS,
6 + PREVIEW_PAGE_ROWS,
7 + type TextPreviewRequest,
8 + type TextPreviewResult,
9 +} from "./largeTextProtocol";
10 +
11 +const chunks: { start: number; blob: Blob }[] = [];
12 +const offsets: Uint32Array[] = [new Uint32Array(65536)];
13 +let entries = 1;
14 +let size = 0;
15 +let delimiter: "," | "\t" | null = null;
16 +let complete = false;
17 +let columns = 1;
18 +function reply(value: TextPreviewResult) {
19 + self.postMessage(value, { transfer: [] });
20 +}
21 +function at(index: number) {
22 + return offsets[index >>> 16]![index & 65535]!;
23 +}
24 +function set(index: number, value: number) {
25 + offsets[index >>> 16] ??= new Uint32Array(65536);
26 + offsets[index >>> 16]![index & 65535] = value;
27 +}
28 +async function read(start: number, end: number) {
29 + let low = 0;
30 + let high = chunks.length;
31 + while (low + 1 < high) {
32 + const mid = (low + high) >>> 1;
33 + if (chunks[mid]!.start <= start) low = mid;
34 + else high = mid;
35 + }
36 + const parts: Blob[] = [];
37 + for (let i = low; i < chunks.length; i++) {
38 + const part = chunks[i]!;
39 + if (part.start >= end) break;
40 + parts.push(part.blob.slice(Math.max(0, start - part.start), end - part.start));
41 + }
42 + return new TextDecoder("utf-8", { fatal: true }).decode(await new Blob(parts).arrayBuffer());
43 +}
44 +async function page(index: number) {
45 + const start = index * PREVIEW_PAGE_ROWS;
46 + const end = Math.min(entries - 1, start + PREVIEW_PAGE_ROWS);
47 + if (start >= end) return;
48 + const text = await read(at(start), at(end));
49 + const rows = delimiter
50 + ? parseDelimitedPreview(text, delimiter, {
51 + maxRows: PREVIEW_PAGE_ROWS,
52 + maxColumns: LARGE_TEXT_MAX_COLUMNS,
53 + maxCellLength: 1024 * 1024,
54 + }).rows
55 + : text
56 + .replace(/\r?\n$|\r$/, "")
57 + .split(/\r\n|\n|\r/)
58 + .map((line) => [line]);
59 + reply({ type: "page", index, rows });
60 +}
61 +async function open(input: Extract<TextPreviewRequest, { type: "open" }>) {
62 + delimiter = input.delimiter;
63 + let response =
64 + input.sizeBytes === 0
65 + ? new Response(new Blob([]))
66 + : input.text !== undefined
67 + ? new Response(new Blob([input.text]))
68 + : await fetch(input.src!, {
69 + headers: { Range: `bytes=0-${LARGE_TEXT_MAX_BYTES}` },
70 + cache: "no-store",
71 + });
72 + if (response.status === 416 && response.headers.get("content-range") === "bytes */0") {
73 + await response.body?.cancel();
74 + response = new Response(new Blob([]));
75 + }
76 + if (!response.ok || !response.body)
77 + throw new Error("The file could not be loaded. Close it and try again.");
78 + const total = Number(
79 + response.headers.get("content-range")?.split("/")[1] ?? response.headers.get("content-length"),
80 + );
81 + if (total > LARGE_TEXT_MAX_BYTES) {
82 + await response.body.cancel();
83 + throw new Error("Text previews support files up to 256 MB.");
84 + }
85 + const reader = response.body.getReader();
86 + let state = 0;
87 + let fieldStart = true;
88 + let cr = false;
89 + let rowColumns = 1;
90 + let first = false;
91 + try {
92 + while (true) {
93 + const { value, done } = await reader.read();
94 + if (done) break;
95 + if (size + value.length > LARGE_TEXT_MAX_BYTES)
96 + throw new Error("Text previews support files up to 256 MB.");
97 + chunks.push({ start: size, blob: new Blob([value]) });
98 + for (let i = 0; i < value.length; i++) {
99 + const byte = value[i]!;
100 + const pos = size + i;
101 + if (
102 + (pos === 0 && byte === 239) ||
103 + (pos === 1 && byte === 187) ||
104 + (pos === 2 && byte === 191)
105 + )
106 + continue;
107 + if (byte === 0) throw new Error("This file contains binary data.");
108 + if (pos - at(entries - 1) > 1024 * 1024)
109 + throw new Error("A line or record exceeds the 1 MB preview limit.");
110 + if (cr) {
111 + cr = false;
112 + if (byte === 10) {
113 + set(entries - 1, pos + 1);
114 + continue;
115 + }
116 + }
117 + if (delimiter) {
118 + if (state === 1) {
119 + if (byte === 34) state = 2;
120 + continue;
121 + }
122 + if (state === 2) {
123 + if (byte === 34) {
124 + state = 1;
125 + continue;
126 + }
127 + state = 0;
128 + }
129 + if (byte === 34 && fieldStart) {
130 + state = 1;
131 + fieldStart = false;
132 + continue;
133 + }
134 + if (byte === delimiter.charCodeAt(0)) {
135 + rowColumns++;
136 + fieldStart = true;
137 + continue;
138 + }
139 + }
140 + if (byte === 10 || byte === 13) {
141 + if (entries > LARGE_TEXT_MAX_ROWS)
142 + throw new Error("Text previews support up to 5 million rows.");
143 + set(entries++, pos + 1);
144 + columns = Math.min(LARGE_TEXT_MAX_COLUMNS, Math.max(columns, rowColumns));
145 + rowColumns = 1;
146 + fieldStart = true;
147 + cr = byte === 13;
148 + } else fieldStart = false;
149 + }
150 + size += value.length;
151 + if (!first && entries > 1) {
152 + reply({ type: "meta", count: entries - 1, columns, complete: false, sizeBytes: size });
153 + await page(0);
154 + first = true;
155 + }
156 + }
157 + if (total > 0 && size !== total)
158 + throw new Error("The file download was incomplete. Close it and try again.");
159 + if (size > at(entries - 1)) {
160 + if (entries > LARGE_TEXT_MAX_ROWS)
161 + throw new Error("Text previews support up to 5 million rows.");
162 + set(entries++, size);
163 + columns = Math.min(LARGE_TEXT_MAX_COLUMNS, Math.max(columns, rowColumns));
164 + }
165 + complete = true;
166 + reply({ type: "meta", count: entries - 1, columns, complete, sizeBytes: size });
167 + await page(0);
168 + } finally {
169 + await reader.cancel();
170 + }
171 +}
172 +self.addEventListener("message", (event: MessageEvent<TextPreviewRequest>) => {
173 + const input = event.data;
174 + void (
175 + input.type === "open"
176 + ? open(input)
177 + : input.type === "page"
178 + ? page(input.index)
179 + : complete
180 + ? read(0, size).then((text) => reply({ type: "copy", text }))
181 + : Promise.reject(new Error("Wait for the file to finish loading before copying."))
182 + ).catch((cause: unknown) =>
183 + reply({
184 + type: "error",
185 + operation: input.type,
186 + message: cause instanceof Error ? cause.message : "Could not read this file.",
187 + }),
188 + );
189 +});
apps/web/src/components/files/largeTextProtocol.ts new
+13
@@ -0,0 +1,13 @@
1 +export const LARGE_TEXT_MAX_BYTES = 256 * 1024 * 1024;
2 +export const LARGE_TEXT_MAX_ROWS = 5_000_000;
3 +export const LARGE_TEXT_MAX_COLUMNS = 1024;
4 +export const PREVIEW_PAGE_ROWS = 32;
5 +export type TextPreviewRequest =
6 + | { type: "open"; src?: string; text?: string; sizeBytes?: number; delimiter: "," | "\t" | null }
7 + | { type: "page"; index: number }
8 + | { type: "copy" };
9 +export type TextPreviewResult =
10 + | { type: "meta"; count: number; columns: number; complete: boolean; sizeBytes?: number }
11 + | { type: "page"; index: number; rows: string[][] }
12 + | { type: "copy"; text: string }
13 + | { type: "error"; operation: TextPreviewRequest["type"]; message: string };
apps/web/src/components/files/officeArchive.ts
+30 -13
@@ -205,7 +205,11 @@ function wordDocuments(
205 return { documents, truncated };
206 }
207
208 -function boundedWorksheet(xml: string, strings: readonly string[], budget: { remaining: number }) {
208 +function boundedWorksheet(
209 + xml: string,
210 + strings: readonly string[],
211 + budget: { remaining: number; cells: number },
212 +) {
213 const parser = xmlParser();
214 const rows = new Map<number, Map<number, string>>();
215 const rowTags = new Map<number, string>();
@@ -282,7 +286,8 @@ function boundedWorksheet(xml: string, strings: readonly string[], budget: { rem
286 .replace(/\/>$/, ">");
287 column = 0;
288 cells = rows.get(row) ?? new Map<number, string>();
285 - if (row > OFFICE_PREVIEW_MAX_ROWS) truncated = true;
289 + if (row > OFFICE_PREVIEW_MAX_ROWS)
290 + throw new Error("This workbook exceeds the preview limit: 250,000 rows.");
291 } else if (depth === 4 && tag.local === "c") {
292 const ref = attribute("r");
293 const position = ref ? coordinate(ref) : { col: column + 1, line: row };
@@ -294,9 +299,14 @@ function boundedWorksheet(xml: string, strings: readonly string[], budget: { rem
299 truncated = true;
300 return;
301 }
302 + if (++budget.cells > 2_000_000 || row * column > 8_000_000)
303 + throw new Error(
304 + "This workbook exceeds the preview limit: 2 million cells or 8 million grid positions.",
305 + );
306 // Explicit coordinates also bound sheets whose rows/cells omit r.
298 - const letters =
299 - column <= 26 ? String.fromCharCode(64 + column) : `A${String.fromCharCode(38 + column)}`;
307 + let letters = "";
308 + for (let value = column; value > 0; value = Math.floor((value - 1) / 26))
309 + letters = String.fromCharCode(65 + ((value - 1) % 26)) + letters;
310 const style = attribute("s");
311 const type = attribute("t");
312 if ((style && !/^\d{1,6}$/.test(style)) || (type && !/^[a-zA-Z]+$/.test(type)))
@@ -360,10 +370,15 @@ function boundedWorksheet(xml: string, strings: readonly string[], budget: { rem
370 const [a, b = a] = ref.split(":");
371 const first = coordinate(a!);
372 const last = coordinate(b!);
363 - if (first.col > 50 || first.line > 500) return "";
364 - const col = Math.min(50, last.col);
365 - const letters = col <= 26 ? String.fromCharCode(64 + col) : "A" + String.fromCharCode(38 + col);
366 - return a + ":" + letters + Math.min(500, last.line);
373 + if (first.col > OFFICE_PREVIEW_MAX_COLUMNS || first.line > OFFICE_PREVIEW_MAX_ROWS) return "";
374 + let letters = "";
375 + for (
376 + let col = Math.min(OFFICE_PREVIEW_MAX_COLUMNS, last.col);
377 + col > 0;
378 + col = Math.floor((col - 1) / 26)
379 + )
380 + letters = String.fromCharCode(65 + ((col - 1) % 26)) + letters;
381 + return a + ":" + letters + Math.min(OFFICE_PREVIEW_MAX_ROWS, last.line);
382 };
383 const metadata = (part: string) =>
384 part.replace(
@@ -458,7 +473,7 @@ async function boundWorkbook(archive: JSZip) {
473 });
474 parser.write(shared).close();
475 }
461 - const budget = { remaining: 1024 * 1024 };
476 + const budget = { remaining: 1024 * 1024, cells: 0 };
477 const limited = new Map<string, boolean>();
478 for (const path of new Set(sheetPaths)) {
479 const file = archive.file(path);
@@ -921,6 +936,7 @@ async function wordExpansion(
936 // must not turn into an unbounded allocation on the UI thread.
937 async function boundedArchive(input: Extract<OfficeWorkerRequest, { type: "open" }>) {
938 const { bytes } = input;
939 + const spreadsheet = input.kind === "xlsx";
940 if (bytes.byteLength > OFFICE_PREVIEW_MAX_BYTES)
941 throw new Error("Preview limited to files under 50 MB.");
942 checkZipDirectory(bytes);
@@ -969,7 +985,7 @@ async function boundedArchive(input: Extract<OfficeWorkerRequest, { type: "open"
985 .on("data", (chunk: Uint8Array) => {
986 total += chunk.length;
987 length += chunk.length;
972 - if (total > OFFICE_PREVIEW_MAX_BYTES) {
988 + if (total > (spreadsheet ? 128 * 1024 * 1024 : OFFICE_PREVIEW_MAX_BYTES)) {
989 stream.pause();
990 reject(new Error("The expanded document is too large to preview safely."));
991 return;
@@ -1003,10 +1019,11 @@ async function boundedArchive(input: Extract<OfficeWorkerRequest, { type: "open"
1019 }
1020 }
1021 if (
1006 - total > OFFICE_PREVIEW_MAX_BYTES ||
1022 + total > (spreadsheet ? 128 * 1024 * 1024 : OFFICE_PREVIEW_MAX_BYTES) ||
1023 + (spreadsheet && total > Math.max(bytes.byteLength * 200, 8 * 1024 * 1024)) ||
1024 (!document &&
1008 - (input.kind === "xlsx" || media || entry.name.endsWith(".xml")) &&
1009 - length > 8 * 1024 * 1024)
1025 + (spreadsheet || media || entry.name.endsWith(".xml")) &&
1026 + length > (spreadsheet ? 64 * 1024 * 1024 : 8 * 1024 * 1024))
1027 ) {
1028 stream.pause();
1029 reject(new Error("The expanded document is too large to preview safely."));
apps/web/src/components/files/officePreviewProtocol.ts
+2 -2
@@ -1,7 +1,7 @@
1 import type { OfficePreviewKind } from "@t3tools/shared/filePreview";
2 export const OFFICE_PREVIEW_MAX_BYTES = 50 * 1024 * 1024;
3 -export const OFFICE_PREVIEW_MAX_ROWS = 500;
4 -export const OFFICE_PREVIEW_MAX_COLUMNS = 50;
3 +export const OFFICE_PREVIEW_MAX_ROWS = 250_000;
4 +export const OFFICE_PREVIEW_MAX_COLUMNS = 1024;
5 export type OfficeWorkerRequest = {
6 readonly type: "open";
7 readonly kind: OfficePreviewKind;
apps/web/vite.config.ts
+3
@@ -111,6 +111,9 @@ const browserTestProject = {
111 "@betteroffice/pptx",
112 "@betteroffice/xlsx",
113 "@betteroffice/xlsx/headless",
114 + "fast-xml-parser",
115 + "dompurify",
116 + "jszip",
117 ],
118 },
119 test: {
packages/shared/src/delimitedPreview.test.ts
+20
@@ -59,4 +59,24 @@ describe("delimited file previews", () => {
59 expect(table.rows[0]?.[0]).toHaveLength(2000);
60 expect(parseDelimitedPreview('a,"unfinished', ",").truncated).toBe(true);
61 });
62 + it("reads worker pages beyond the old row, column and cell limits", () => {
63 + const text = Array.from({ length: 128 }, (_, row) =>
64 + Array.from({ length: 40 }, (_, column) => `${row}:${column}`).join(","),
65 + ).join("\n");
66 + const result = parseDelimitedPreview(text, ",", {
67 + maxRows: 128,
68 + maxColumns: 40,
69 + maxCellLength: 4096,
70 + });
71 + expect(result.rows).toHaveLength(128);
72 + expect(result.rows.at(-1)?.at(-1)).toBe("127:39");
73 + expect(result.truncated).toBe(false);
74 + expect(
75 + parseDelimitedPreview(`"${"x".repeat(3000)}"`, ",", {
76 + maxRows: 1,
77 + maxColumns: 1,
78 + maxCellLength: 4096,
79 + }).rows[0]?.[0],
80 + ).toHaveLength(3000);
81 + });
82 });
packages/shared/src/delimitedPreview.ts
+14 -5
@@ -8,7 +8,15 @@ export function filePreviewDelimiter(file: { name: string; mimeType?: string }):
8 return null;
9 }
10
11 -export function parseDelimitedPreview(text: string, delimiter: "," | "\t") {
11 +export function parseDelimitedPreview(
12 + text: string,
13 + delimiter: "," | "\t",
14 + limits: { maxRows: number; maxColumns: number; maxCellLength: number } = {
15 + maxRows: 100,
16 + maxColumns: 30,
17 + maxCellLength: 2000,
18 + },
19 +) {
20 const rows: string[][] = [];
21 let row: string[] = [];
22 let cell = "";
@@ -16,7 +24,7 @@ export function parseDelimitedPreview(text: string, delimiter: "," | "\t") {
24 let truncated = false;
25 let rowStart = text.charCodeAt(0) === 0xfeff ? 1 : 0;
26 const endCell = () => {
19 - if (row.length < 30) row.push(cell);
27 + if (row.length < limits.maxColumns) row.push(cell);
28 else truncated = true;
29 cell = "";
30 };
@@ -24,7 +32,7 @@ export function parseDelimitedPreview(text: string, delimiter: "," | "\t") {
32 const char = text[index];
33 if (char === '"') {
34 if (quoted && text[index + 1] === '"') {
27 - if (cell.length < 2000) cell += '"';
35 + if (cell.length < limits.maxCellLength) cell += '"';
36 else truncated = true;
37 index++;
38 continue;
@@ -41,9 +49,10 @@ export function parseDelimitedPreview(text: string, delimiter: "," | "\t") {
49 row = [];
50 if (char === "\r" && text[index + 1] === "\n") index++;
51 rowStart = index + 1;
44 - if (rows.length === 100) return { rows, truncated: truncated || index < text.length - 1 };
52 + if (rows.length === limits.maxRows)
53 + return { rows, truncated: truncated || index < text.length - 1 };
54 }
46 - } else if (cell.length < 2000) cell += char;
55 + } else if (cell.length < limits.maxCellLength) cell += char;
56 else truncated = true;
57 }
58 if (rowStart < text.length) {
pnpm-lock.yaml
+3
@@ -1136,6 +1136,9 @@ importers:
1136 effect:
1137 specifier: 4.0.5
1138 version: 4.0.5
1139 + fast-xml-parser:
1140 + specifier: 5.7.3
1141 + version: 5.7.3
1142 hast-util-to-html:
1143 specifier: ^9.0.5
1144 version: 9.0.5
third-party-licenses.config.json
+24
@@ -229,6 +229,30 @@
229 }
230 ],
231 "packageOverrides": [
232 + {
233 + "name": "@nodable/entities",
234 + "version": "2.1.1",
235 + "sourceUrl": "https://github.com/nodable/val-parsers",
236 + "generatedNotice": {
237 + "licenseId": "MIT",
238 + "copyrights": ["Copyright (c) 2026 Nodable"]
239 + }
240 + },
241 + {
242 + "name": "xml-naming",
243 + "version": "0.1.0",
244 + "sourceUrl": "https://github.com/NaturalIntelligence/xml-naming",
245 + "generatedNotice": {
246 + "licenseId": "MIT",
247 + "copyrights": ["Copyright (c) 2026 Natural Intelligence"]
248 + }
249 + },
250 + {
251 + "name": "fast-xml-parser",
252 + "version": "5.7.3",
253 + "license": "MIT",
254 + "sourceUrl": "https://github.com/NaturalIntelligence/fast-xml-parser"
255 + },
256 {
257 "name": "@betteroffice/xlsx",
258 "version": "0.3.0",