Open History to see the last commit
1import type { MessageId, ThreadId } from "@t3tools/contracts";
2import * as Effect from "effect/Effect";
3import * as Schema from "effect/Schema";
4import { AsyncResult, Atom } from "effect/reactivity";
5import type { SetStateAction } from "react";
6import type { ChatMessage } from "../../types";
7import { collectUserMessageBlobPreviewUrls } from "../ChatView.logic";
8
9/**
10 * Messages shown before the server echoes them. An acknowledged message leaves `messages` in the
11 * render its ack arrives, so it never reappears even if the server later drops its row. Its blob
12 * previews stay in `handoff` until the server's copies load (see useAttachmentPreviewHandoff).
13 */
14export interface OptimisticUserMessages {
15 readonly threadId: ThreadId;
16 readonly messages: ChatMessage[];
17 readonly handoff: Readonly<Record<string, ReadonlyArray<string>>>;
18}
19
20export function emptyOptimisticUserMessages(threadId: ThreadId): OptimisticUserMessages {
21 return { threadId, messages: [], handoff: {} };
22}
23
24/**
25 * The view's state for `threadId`: the previous thread's messages are released when the thread
26 * changes, and acknowledged messages are moved out of `messages`. Returns `state` when nothing changes.
27 */
28export function reconcileOptimisticUserMessages(
29 state: OptimisticUserMessages,
30 threadId: ThreadId,
31 acknowledgedIds: ReadonlySet<MessageId>,
32): OptimisticUserMessages {
33 if (state.threadId !== threadId) return emptyOptimisticUserMessages(threadId);
34 if (!state.messages.some((message) => acknowledgedIds.has(message.id))) return state;
35 const messages: ChatMessage[] = [];
36 const handoff: Record<string, ReadonlyArray<string>> = { ...state.handoff };
37 for (const message of state.messages) {
38 if (!acknowledgedIds.has(message.id)) {
39 messages.push(message);
40 continue;
41 }
42 const previewUrls = collectUserMessageBlobPreviewUrls(message);
43 if (previewUrls.length > 0) handoff[message.id] = previewUrls;
44 }
45 return { ...state, messages, handoff };
46}
47
48/** Applies a send-path update. An update for a thread the view has since left is dropped. */
49export function applyOptimisticUserMessagesAction(
50 state: OptimisticUserMessages,
51 threadId: ThreadId,
52 action: SetStateAction<ChatMessage[]>,
53): OptimisticUserMessages {
54 if (state.threadId !== threadId) return state;
55 const next = typeof action === "function" ? action(state.messages) : action;
56 const unchanged =
57 next.length === state.messages.length &&
58 next.every((message, index) => message === state.messages[index]);
59 return unchanged ? state : { ...state, messages: next };
60}
61
62export function dropOptimisticHandoff(
63 state: OptimisticUserMessages,
64 threadId: ThreadId,
65 messageId: MessageId,
66): OptimisticUserMessages {
67 if (state.threadId !== threadId || !(messageId in state.handoff)) return state;
68 const { [messageId]: _released, ...handoff } = state.handoff;
69 return { ...state, handoff };
70}
71
72/**
73 * Blob previews a chat view owns per thread. Revocation cannot run in a state updater, so handlers
74 * revoke here and leaving the thread revokes the rest. A handed-off preview still stands in for the
75 * server's row, so releasing its message (a send failing after the ack) leaves it to the handoff.
76 */
77export interface OptimisticBlobPreviews {
78 readonly track: (threadId: ThreadId, message: ChatMessage) => void;
79 readonly handOff: (state: OptimisticUserMessages) => void;
80 readonly revoke: (threadId: ThreadId, previewUrls: ReadonlyArray<string>) => void;
81 readonly release: (threadId: ThreadId, message: ChatMessage) => void;
82 readonly revokeThread: (threadId: ThreadId) => void;
83}
84
85export function createOptimisticBlobPreviews(): OptimisticBlobPreviews {
86 const ownedByThread = new Map<ThreadId, Set<string>>();
87 const handedOff = new Set<string>();
88 const revoke = (threadId: ThreadId, previewUrls: ReadonlyArray<string>) => {
89 const owned = ownedByThread.get(threadId);
90 for (const previewUrl of previewUrls) {
91 owned?.delete(previewUrl);
92 handedOff.delete(previewUrl);
93 if (typeof URL !== "undefined") URL.revokeObjectURL(previewUrl);
94 }
95 };
96 return {
97 track: (threadId, message) => {
98 const previewUrls = collectUserMessageBlobPreviewUrls(message);
99 if (previewUrls.length === 0) return;
100 const owned = ownedByThread.get(threadId) ?? new Set<string>();
101 for (const previewUrl of previewUrls) owned.add(previewUrl);
102 ownedByThread.set(threadId, owned);
103 },
104 handOff: (state) => {
105 for (const previewUrls of Object.values(state.handoff)) {
106 for (const previewUrl of previewUrls) handedOff.add(previewUrl);
107 }
108 },
109 revoke,
110 release: (threadId, message) =>
111 revoke(
112 threadId,
113 collectUserMessageBlobPreviewUrls(message).filter((url) => !handedOff.has(url)),
114 ),
115 revokeThread: (threadId) => {
116 revoke(threadId, [...(ownedByThread.get(threadId) ?? [])]);
117 ownedByThread.delete(threadId);
118 },
119 };
120}
121
122// Server asset URLs carry a signed token, so the error keeps only where the image was loaded from.
123class ImagePreloadError extends Schema.TaggedError<ImagePreloadError>()("ImagePreloadError", {
124 protocol: Schema.String,
125 host: Schema.String,
126}) {
127 static fromUrl(url: string) {
128 const parsed = URL.parse(url, globalThis.location?.href);
129 return new ImagePreloadError({ protocol: parsed?.protocol ?? "", host: parsed?.host ?? "" });
130 }
131}
132
133const preloadImage = Effect.fn("optimisticUserMessages.preloadImage")(function* (url: string) {
134 yield* Effect.callback<void, ImagePreloadError>((resume) => {
135 const image = new Image();
136 image.addEventListener("load", () => resume(Effect.void), { once: true });
137 image.addEventListener("error", () => resume(Effect.fail(ImagePreloadError.fromUrl(url))), {
138 once: true,
139 });
140 image.src = url;
141 return Effect.sync(() => {
142 image.src = "";
143 });
144 });
145});
146
147/**
148 * Loads one handoff's server previews, keyed by `[serverUrls, blobUrls]`. Once they have all
149 * loaded the blobs are no longer shown, so they are revoked here, once per load. A failed load
150 * keeps the handoff, and its blobs, until the thread is left.
151 */
152const handoffPreloadAtom = Atom.family((key: string) => {
153 const [serverUrls, blobUrls] = JSON.parse(key) as [string[], string[]];
154 return Atom.make(
155 typeof Image === "undefined"
156 ? Effect.never
157 : Effect.forEach(serverUrls, preloadImage, { concurrency: "unbounded", discard: true }).pipe(
158 Effect.tap(() =>
159 Effect.sync(() => {
160 for (const blobUrl of blobUrls) URL.revokeObjectURL(blobUrl);
161 }),
162 ),
163 ),
164 );
165});
166
167/**
168 * The message ids, among `[messageId, serverUrls, blobUrls]` entries, whose server previews have
169 * loaded. Each handoff preloads in its own atom, so a change to the set does not restart the rest.
170 */
171export const loadedHandoffMessageIdsAtom = Atom.family((key: string) => {
172 const preloads = JSON.parse(key) as Array<[MessageId, string[], string[]]>;
173 return Atom.make((get) =>
174 preloads.flatMap(([messageId, serverUrls, blobUrls]) =>
175 AsyncResult.isSuccess(get(handoffPreloadAtom(JSON.stringify([serverUrls, blobUrls]))))
176 ? [messageId]
177 : [],
178 ),
179 );
180});