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
| 1 | import * as Effect from "effect/Effect"; |
| 2 | import * as Equal from "effect/Equal"; |
| 3 | import * as Hash from "effect/Hash"; |
| 4 | import * as Schema from "effect/Schema"; |
| 5 | import { Atom } from "effect/reactivity"; |
| 6 | |
| 7 | import type { DraftComposerImageAttachment } from "./composerImages"; |
| 8 | |
| 9 | const PREVIEW_CACHE_DIRECTORY = "t3-composer-previews"; |
| 10 | |
| 11 | async function materializeDataUrlPreview(id: string, dataUrl: string): Promise<string | null> { |
| 12 | const comma = dataUrl.indexOf(","); |
| 13 | if (comma < 0) return null; |
| 14 | const { Directory, File, Paths } = await import("expo-file-system"); |
| 15 | const mimeType = /^data:([^;,]+)/.exec(dataUrl)?.[1] ?? "image/jpeg"; |
| 16 | const extension = (mimeType.split("/")[1] ?? "jpg").replace("jpeg", "jpg"); |
| 17 | const directory = new Directory(Paths.cache, PREVIEW_CACHE_DIRECTORY); |
| 18 | directory.create({ idempotent: true, intermediates: true }); |
| 19 | const file = new File(directory, `${id}.${extension}`); |
| 20 | if (file.exists) return file.uri; |
| 21 | // Write beside the cache entry and move it in, so a failed or interrupted write is never reused. |
| 22 | const partial = new File(directory, `${id}.${extension}.partial`); |
| 23 | if (partial.exists) partial.delete(); |
| 24 | partial.create(); |
| 25 | try { |
| 26 | await partial.write(dataUrl.slice(comma + 1), { encoding: "base64" }); |
| 27 | } catch (error) { |
| 28 | partial.delete(); |
| 29 | throw error; |
| 30 | } |
| 31 | await partial.move(file); |
| 32 | return file.uri; |
| 33 | } |
| 34 | |
| 35 | const inFlightPreviews = new Map<string, Promise<string | null>>(); |
| 36 | |
| 37 | // A render reads the atom before its effect subscribes, so the registry can drop and rebuild it |
| 38 | // mid-write; a second writer would delete the first one's partial file and fail its own move. |
| 39 | function materializePreviewOnce(id: string, dataUrl: string): Promise<string | null> { |
| 40 | const pending = inFlightPreviews.get(id); |
| 41 | if (pending) return pending; |
| 42 | const next = materializeDataUrlPreview(id, dataUrl).finally(() => inFlightPreviews.delete(id)); |
| 43 | inFlightPreviews.set(id, next); |
| 44 | return next; |
| 45 | } |
| 46 | |
| 47 | class ImagePreviewCacheError extends Schema.TaggedError<ImagePreviewCacheError>()( |
| 48 | "ImagePreviewCacheError", |
| 49 | { cause: Schema.Defect() }, |
| 50 | ) { |
| 51 | override get message(): string { |
| 52 | return "Could not cache an image preview."; |
| 53 | } |
| 54 | } |
| 55 | |
| 56 | /** |
| 57 | * Keyed by attachment id only: the cached file is named by id, and an upload |
| 58 | * reference landing on the same draft must not restart materialization and |
| 59 | * blank the preview. Hashing the id also avoids rehashing a multi-megabyte data URL. |
| 60 | */ |
| 61 | export class MaterializedPreviewKey implements Equal.Equal { |
| 62 | constructor(readonly attachment: DraftComposerImageAttachment) {} |
| 63 | [Equal.symbol](that: unknown): boolean { |
| 64 | return that instanceof MaterializedPreviewKey && that.attachment.id === this.attachment.id; |
| 65 | } |
| 66 | [Hash.symbol](): number { |
| 67 | return Hash.string(this.attachment.id); |
| 68 | } |
| 69 | } |
| 70 | |
| 71 | export const materializedPreviewAtom = Atom.family(({ attachment }: MaterializedPreviewKey) => |
| 72 | Atom.make( |
| 73 | Effect.tryPromise({ |
| 74 | try: () => materializePreviewOnce(attachment.id, attachment.previewUri), |
| 75 | catch: (cause) => new ImagePreviewCacheError({ cause }), |
| 76 | }).pipe( |
| 77 | Effect.catch((error) => |
| 78 | Effect.logWarning("[composer-attachments] could not cache an image preview", error).pipe( |
| 79 | Effect.as(null), |
| 80 | ), |
| 81 | ), |
| 82 | ), |
| 83 | ).pipe(Atom.withLabel(`composer-image-preview:${attachment.id}`)), |
| 84 | ); |