@devries-cameron20 / t3code Mirror · read-only
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 21, 04:45 UTC

main
ts 209 lines 6.95 KB
Raw
1 import { csvPreviewDelimiter, 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 import { PreviewError, previewFailure } from "./previewFailure";
11
12 const chunks: { start: number; blob: Blob }[] = [];
13 const offsets: Uint32Array[] = [new Uint32Array(65536)];
14 let entries = 1;
15 let size = 0;
16 let delimiter: "," | ";" | "\t" | null = null;
17 let complete = false;
18 let columns = 1;
19 function reply(value: TextPreviewResult) {
20 self.postMessage(value, { transfer: [] });
21 }
22 function at(index: number) {
23 return offsets[index >>> 16]![index & 65535]!;
24 }
25 function set(index: number, value: number) {
26 offsets[index >>> 16] ??= new Uint32Array(65536);
27 offsets[index >>> 16]![index & 65535] = value;
28 }
29 async function read(start: number, end: number) {
30 let low = 0;
31 let high = chunks.length;
32 while (low + 1 < high) {
33 const mid = (low + high) >>> 1;
34 if (chunks[mid]!.start <= start) low = mid;
35 else high = mid;
36 }
37 const parts: Blob[] = [];
38 for (let i = low; i < chunks.length; i++) {
39 const part = chunks[i]!;
40 if (part.start >= end) break;
41 parts.push(part.blob.slice(Math.max(0, start - part.start), end - part.start));
42 }
43 return new TextDecoder("utf-8", { fatal: true }).decode(await new Blob(parts).arrayBuffer());
44 }
45 async function page(index: number) {
46 const start = index * PREVIEW_PAGE_ROWS;
47 const end = Math.min(entries - 1, start + PREVIEW_PAGE_ROWS);
48 if (start >= end) return;
49 const text = await read(at(start), at(end));
50 const rows = delimiter
51 ? parseDelimitedPreview(text, delimiter, {
52 maxRows: PREVIEW_PAGE_ROWS,
53 maxColumns: LARGE_TEXT_MAX_COLUMNS,
54 maxCellLength: 1024 * 1024,
55 detectCsv: false,
56 }).rows
57 : text
58 .replace(/\r?\n$|\r$/, "")
59 .split(/\r\n|\n|\r/)
60 .map((line) => [line]);
61 reply({ type: "page", index, rows });
62 }
63 async function open(input: Extract<TextPreviewRequest, { type: "open" }>) {
64 delimiter = input.delimiter;
65 let response =
66 input.sizeBytes === 0
67 ? new Response(new Blob([]))
68 : input.text !== undefined
69 ? new Response(new Blob([input.text]))
70 : await fetch(input.src!, {
71 headers: { Range: `bytes=0-${LARGE_TEXT_MAX_BYTES}` },
72 cache: "no-store",
73 });
74 if (response.status === 416 && response.headers.get("content-range") === "bytes */0") {
75 await response.body?.cancel();
76 response = new Response(new Blob([]));
77 }
78 if (!response.ok || !response.body) throw new PreviewError({ code: "file-load-failed" });
79 const total = Number(
80 response.headers.get("content-range")?.split("/")[1] ?? response.headers.get("content-length"),
81 );
82 if (total > LARGE_TEXT_MAX_BYTES) {
83 await response.body.cancel();
84 throw new PreviewError({ code: "text-too-large" });
85 }
86 const reader = response.body.getReader();
87 let state = 0;
88 let fieldStart = true;
89 let cr = false;
90 let rowColumns = 1;
91 let first = false;
92 try {
93 let prefix: Uint8Array<ArrayBuffer> | undefined;
94 if (delimiter === ",") {
95 const parts: Uint8Array<ArrayBuffer>[] = [];
96 let length = 0;
97 let quoted = false;
98 let breaks = 0;
99 let previous = 0;
100 while (length <= 1024 * 1024 && breaks < 2) {
101 const next = await reader.read();
102 if (next.done) break;
103 parts.push(next.value);
104 length += next.value.length;
105 for (const byte of next.value) {
106 if (byte === 34) quoted = !quoted;
107 else if (!quoted && (byte === 13 || (byte === 10 && previous !== 13))) breaks++;
108 previous = byte;
109 }
110 }
111 prefix = new Uint8Array(await new Blob(parts).arrayBuffer());
112 delimiter = csvPreviewDelimiter(new TextDecoder().decode(prefix));
113 }
114 while (true) {
115 const { value, done } = prefix ? { value: prefix, done: false } : await reader.read();
116 prefix = undefined;
117 if (done) break;
118 if (size + value.length > LARGE_TEXT_MAX_BYTES)
119 throw new PreviewError({ code: "text-too-large" });
120 chunks.push({ start: size, blob: new Blob([value]) });
121 for (let i = 0; i < value.length; i++) {
122 const byte = value[i]!;
123 const pos = size + i;
124 if (
125 (pos === 0 && byte === 239) ||
126 (pos === 1 && byte === 187) ||
127 (pos === 2 && byte === 191)
128 )
129 continue;
130 if (byte === 0) throw new PreviewError({ code: "text-binary" });
131 if (pos - at(entries - 1) > 1024 * 1024)
132 throw new PreviewError({ code: "text-line-too-long" });
133 if (cr) {
134 cr = false;
135 if (byte === 10) {
136 set(entries - 1, pos + 1);
137 continue;
138 }
139 }
140 if (delimiter) {
141 if (state === 1) {
142 if (byte === 34) state = 2;
143 continue;
144 }
145 if (state === 2) {
146 if (byte === 34) {
147 state = 1;
148 continue;
149 }
150 state = 0;
151 }
152 if (byte === 34 && fieldStart) {
153 state = 1;
154 fieldStart = false;
155 continue;
156 }
157 if (byte === delimiter.charCodeAt(0)) {
158 rowColumns++;
159 fieldStart = true;
160 continue;
161 }
162 }
163 if (byte === 10 || byte === 13) {
164 if (entries > LARGE_TEXT_MAX_ROWS) throw new PreviewError({ code: "text-too-many-rows" });
165 set(entries++, pos + 1);
166 columns = Math.min(LARGE_TEXT_MAX_COLUMNS, Math.max(columns, rowColumns));
167 rowColumns = 1;
168 fieldStart = true;
169 cr = byte === 13;
170 } else fieldStart = false;
171 }
172 size += value.length;
173 if (!first && entries > 1) {
174 reply({ type: "meta", count: entries - 1, columns, complete: false, sizeBytes: size });
175 await page(0);
176 first = true;
177 }
178 }
179 if (total > 0 && size !== total) throw new PreviewError({ code: "text-download-incomplete" });
180 if (size > at(entries - 1)) {
181 if (entries > LARGE_TEXT_MAX_ROWS) throw new PreviewError({ code: "text-too-many-rows" });
182 set(entries++, size);
183 columns = Math.min(LARGE_TEXT_MAX_COLUMNS, Math.max(columns, rowColumns));
184 }
185 complete = true;
186 reply({ type: "meta", count: entries - 1, columns, complete, sizeBytes: size });
187 await page(0);
188 } finally {
189 await reader.cancel();
190 }
191 }
192 self.addEventListener("message", (event: MessageEvent<TextPreviewRequest>) => {
193 const input = event.data;
194 void (
195 input.type === "open"
196 ? open(input)
197 : input.type === "page"
198 ? page(input.index)
199 : complete
200 ? read(0, size).then((text) => reply({ type: "copy", text }))
201 : Promise.reject(new PreviewError({ code: "text-copy-before-loaded" }))
202 ).catch((cause: unknown) =>
203 reply({
204 type: "error",
205 operation: input.type,
206 ...previewFailure(cause, "read-failed"),
207 }),
208 );
209 });