The best way to control Claude Code, Codex and more from any computer or phone
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",