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