sailfork / t3code-github / apps/ web/ src/ components/ chat/ optimisticUserMessages.ts

import type { MessageId, ThreadId } from "@t3tools/contracts";
import * as Effect from "effect/Effect";
import * as Schema from "effect/Schema";
import { AsyncResult, Atom } from "effect/reactivity";
import type { SetStateAction } from "react";
import type { ChatMessage } from "../../types";
import { collectUserMessageBlobPreviewUrls } from "../ChatView.logic";

/**
 * Messages shown before the server echoes them. An acknowledged message leaves `messages` in the
 * render its ack arrives, so it never reappears even if the server later drops its row. Its blob
 * previews stay in `handoff` until the server's copies load (see useAttachmentPreviewHandoff).
 */
export interface OptimisticUserMessages {
  readonly threadId: ThreadId;
  readonly messages: ChatMessage[];
  readonly handoff: Readonly<Record<string, ReadonlyArray<string>>>;
}

export function emptyOptimisticUserMessages(threadId: ThreadId): OptimisticUserMessages {
  return { threadId, messages: [], handoff: {} };
}

/**
 * The view's state for `threadId`: the previous thread's messages are released when the thread
 * changes, and acknowledged messages are moved out of `messages`. Returns `state` when nothing changes.
 */
export function reconcileOptimisticUserMessages(
  state: OptimisticUserMessages,
  threadId: ThreadId,
  acknowledgedIds: ReadonlySet<MessageId>,
): OptimisticUserMessages {
  if (state.threadId !== threadId) return emptyOptimisticUserMessages(threadId);
  if (!state.messages.some((message) => acknowledgedIds.has(message.id))) return state;
  const messages: ChatMessage[] = [];
  const handoff: Record<string, ReadonlyArray<string>> = { ...state.handoff };
  for (const message of state.messages) {
    if (!acknowledgedIds.has(message.id)) {
      messages.push(message);
      continue;
    }
    const previewUrls = collectUserMessageBlobPreviewUrls(message);
    if (previewUrls.length > 0) handoff[message.id] = previewUrls;
  }
  return { ...state, messages, handoff };
}

/** Applies a send-path update. An update for a thread the view has since left is dropped. */
export function applyOptimisticUserMessagesAction(
  state: OptimisticUserMessages,
  threadId: ThreadId,
  action: SetStateAction<ChatMessage[]>,
): OptimisticUserMessages {
  if (state.threadId !== threadId) return state;
  const next = typeof action === "function" ? action(state.messages) : action;
  const unchanged =
    next.length === state.messages.length &&
    next.every((message, index) => message === state.messages[index]);
  return unchanged ? state : { ...state, messages: next };
}

export function dropOptimisticHandoff(
  state: OptimisticUserMessages,
  threadId: ThreadId,
  messageId: MessageId,
): OptimisticUserMessages {
  if (state.threadId !== threadId || !(messageId in state.handoff)) return state;
  const { [messageId]: _released, ...handoff } = state.handoff;
  return { ...state, handoff };
}

/**
 * Blob previews a chat view owns per thread. Revocation cannot run in a state updater, so handlers
 * revoke here and leaving the thread revokes the rest. A handed-off preview still stands in for the
 * server's row, so releasing its message (a send failing after the ack) leaves it to the handoff.
 */
export interface OptimisticBlobPreviews {
  readonly track: (threadId: ThreadId, message: ChatMessage) => void;
  readonly handOff: (state: OptimisticUserMessages) => void;
  readonly revoke: (threadId: ThreadId, previewUrls: ReadonlyArray<string>) => void;
  readonly release: (threadId: ThreadId, message: ChatMessage) => void;
  readonly revokeThread: (threadId: ThreadId) => void;
}

export function createOptimisticBlobPreviews(): OptimisticBlobPreviews {
  const ownedByThread = new Map<ThreadId, Set<string>>();
  const handedOff = new Set<string>();
  const revoke = (threadId: ThreadId, previewUrls: ReadonlyArray<string>) => {
    const owned = ownedByThread.get(threadId);
    for (const previewUrl of previewUrls) {
      owned?.delete(previewUrl);
      handedOff.delete(previewUrl);
      if (typeof URL !== "undefined") URL.revokeObjectURL(previewUrl);
    }
  };
  return {
    track: (threadId, message) => {
      const previewUrls = collectUserMessageBlobPreviewUrls(message);
      if (previewUrls.length === 0) return;
      const owned = ownedByThread.get(threadId) ?? new Set<string>();
      for (const previewUrl of previewUrls) owned.add(previewUrl);
      ownedByThread.set(threadId, owned);
    },
    handOff: (state) => {
      for (const previewUrls of Object.values(state.handoff)) {
        for (const previewUrl of previewUrls) handedOff.add(previewUrl);
      }
    },
    revoke,
    release: (threadId, message) =>
      revoke(
        threadId,
        collectUserMessageBlobPreviewUrls(message).filter((url) => !handedOff.has(url)),
      ),
    revokeThread: (threadId) => {
      revoke(threadId, [...(ownedByThread.get(threadId) ?? [])]);
      ownedByThread.delete(threadId);
    },
  };
}

// Server asset URLs carry a signed token, so the error keeps only where the image was loaded from.
class ImagePreloadError extends Schema.TaggedError<ImagePreloadError>()("ImagePreloadError", {
  protocol: Schema.String,
  host: Schema.String,
}) {
  static fromUrl(url: string) {
    const parsed = URL.parse(url, globalThis.location?.href);
    return new ImagePreloadError({ protocol: parsed?.protocol ?? "", host: parsed?.host ?? "" });
  }
}

const preloadImage = Effect.fn("optimisticUserMessages.preloadImage")(function* (url: string) {
  yield* Effect.callback<void, ImagePreloadError>((resume) => {
    const image = new Image();
    image.addEventListener("load", () => resume(Effect.void), { once: true });
    image.addEventListener("error", () => resume(Effect.fail(ImagePreloadError.fromUrl(url))), {
      once: true,
    });
    image.src = url;
    return Effect.sync(() => {
      image.src = "";
    });
  });
});

/**
 * Loads one handoff's server previews, keyed by `[serverUrls, blobUrls]`. Once they have all
 * loaded the blobs are no longer shown, so they are revoked here, once per load. A failed load
 * keeps the handoff, and its blobs, until the thread is left.
 */
const handoffPreloadAtom = Atom.family((key: string) => {
  const [serverUrls, blobUrls] = JSON.parse(key) as [string[], string[]];
  return Atom.make(
    typeof Image === "undefined"
      ? Effect.never
      : Effect.forEach(serverUrls, preloadImage, { concurrency: "unbounded", discard: true }).pipe(
          Effect.tap(() =>
            Effect.sync(() => {
              for (const blobUrl of blobUrls) URL.revokeObjectURL(blobUrl);
            }),
          ),
        ),
  );
});

/**
 * The message ids, among `[messageId, serverUrls, blobUrls]` entries, whose server previews have
 * loaded. Each handoff preloads in its own atom, so a change to the set does not restart the rest.
 */
export const loadedHandoffMessageIdsAtom = Atom.family((key: string) => {
  const preloads = JSON.parse(key) as Array<[MessageId, string[], string[]]>;
  return Atom.make((get) =>
    preloads.flatMap(([messageId, serverUrls, blobUrls]) =>
      AsyncResult.isSuccess(get(handoffPreloadAtom(JSON.stringify([serverUrls, blobUrls]))))
        ? [messageId]
        : [],
    ),
  );
});