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

import type {
  OrchestrationThreadSearchMatch,
  OrchestrationV2SearchThreadResult,
  ScopedThreadRef,
} from "@t3tools/contracts";
import { scopedThreadKey } from "@t3tools/client-runtime/environment";
import {
  findSearchTokenRanges,
  messagePhrase,
  messageSearchTokens,
} from "@t3tools/shared/paletteSearch";
import { create } from "zustand";
import type { ThreadFindPositionReader, ThreadFindStart } from "./threadFind";

export interface ThreadFindLocalSelection {
  readonly base: OrchestrationV2SearchThreadResult;
  readonly baseNavigationId: number;
  readonly activeIndex: number;
  readonly match: NonNullable<OrchestrationV2SearchThreadResult["match"]>;
  readonly navigationId: number;
}

/** Find is open in at most one thread: the one the chat view shows. */
export interface ThreadFindState {
  readonly threadKey: string | null;
  readonly query: string;
  readonly offset: number;
  readonly start: ThreadFindStart | undefined;
  readonly focusRequestId: number;
  readonly navigationId: number;
  readonly requestId: number;
  readonly localSelection: ThreadFindLocalSelection | null;
}

export const CLOSED_THREAD_FIND: ThreadFindState = {
  threadKey: null,
  query: "",
  offset: 0,
  start: undefined,
  focusRequestId: 0,
  navigationId: 0,
  requestId: 0,
  localSelection: null,
};

export const useThreadFindStore = create<ThreadFindState>(() => CLOSED_THREAD_FIND);

/** What find needs from the timeline that shows a thread. */
interface ThreadFindTimeline {
  readonly threadKey: string;
  readonly readPosition: ThreadFindPositionReader;
  /** Opening find is manual navigation: it releases live follow. */
  readonly navigate: () => void;
}

let attachedTimeline: ThreadFindTimeline | null = null;

function timelineFor(threadKey: string): ThreadFindTimeline | null {
  return attachedTimeline?.threadKey === threadKey ? attachedTimeline : null;
}

/** Attaches the timeline showing a thread; returns the detach. */
export function attachThreadFindTimeline(timeline: ThreadFindTimeline): () => void {
  attachedTimeline = timeline;
  return () => {
    if (attachedTimeline === timeline) attachedTimeline = null;
  };
}

function readThreadFindPosition(threadKey: string, query: string): ThreadFindStart | undefined {
  return timelineFor(threadKey)?.readPosition(query);
}

/**
 * Navigates the timeline showing the thread when find newly opens there. A
 * timeline that starts showing the thread later (a search result opened find
 * before the route switched or the thread painted) releases follow itself as
 * it opens on the thread.
 */
function announceOpening(previous: ThreadFindState, threadKey: string): void {
  if (previous.threadKey !== threadKey) timelineFor(threadKey)?.navigate();
}

/** Opens find, or refocuses it and restarts its search from the viewport when already open. */
export function openThreadFind(threadKey: string): void {
  const previous = useThreadFindStore.getState();
  const current = previous.threadKey === threadKey ? previous : CLOSED_THREAD_FIND;
  const query = current.query.trim();
  const start = query ? readThreadFindPosition(threadKey, query) : undefined;
  announceOpening(previous, threadKey);
  useThreadFindStore.setState({
    ...current,
    threadKey,
    focusRequestId: previous.focusRequestId + 1,
    ...(query
      ? {
          start,
          offset: 0,
          localSelection: null,
          navigationId: current.navigationId + 1,
          requestId: current.navigationId + 1,
        }
      : {}),
  });
}

export interface PendingThreadFind {
  readonly query: string;
  /** Where find starts, such as the message a palette result came from. */
  readonly start?: ThreadFindStart;
}

/**
 * Opens find on `query` in the thread, such as at the message a search result
 * came from. The thread's view shows it once it is on screen.
 */
export function openThreadFindOnQuery(threadKey: string, find: PendingThreadFind): void {
  const previous = useThreadFindStore.getState();
  announceOpening(previous, threadKey);
  useThreadFindStore.setState({
    ...(previous.threadKey === threadKey ? previous : CLOSED_THREAD_FIND),
    threadKey,
    query: find.query,
    offset: 0,
    start: find.start,
    localSelection: null,
    focusRequestId: previous.focusRequestId + 1,
    navigationId: previous.navigationId + 1,
    requestId: previous.navigationId + 1,
  });
}

export function setThreadFindQuery(threadKey: string, query: string): void {
  const start = readThreadFindPosition(threadKey, query.trim());
  useThreadFindStore.setState((previous) => ({
    query,
    offset: 0,
    start,
    localSelection: null,
    navigationId: previous.navigationId + 1,
    requestId: previous.navigationId + 1,
  }));
}

export function closeThreadFind(): void {
  useThreadFindStore.setState(CLOSED_THREAD_FIND);
}

/**
 * Find belongs to the thread it was opened in: a route showing anything else
 * closes it. Settings and Usage draw over the thread, so they keep it.
 */
export function retainThreadFindForRoute(route: {
  readonly modalPage: boolean;
  readonly threadRef: ScopedThreadRef | null;
}): void {
  if (route.modalPage) return;
  const { threadKey } = useThreadFindStore.getState();
  const shownKey = route.threadRef ? scopedThreadKey(route.threadRef) : null;
  if (threadKey !== null && threadKey !== shownKey) closeThreadFind();
}

/** Whether find is open in `thread`, as long as find is available there. */
export function useThreadFindOpen(thread: ScopedThreadRef | null, enabled: boolean): boolean {
  const openThreadKey = useThreadFindStore((state) => state.threadKey);
  return enabled && thread !== null && openThreadKey === scopedThreadKey(thread);
}

/**
 * The find a message search result opens, at the matched message: the whole
 * query when the snippet holds it as typed ("vp run dev"), else its longest
 * word, as the most telling ("sidebar" in "fix sidebar"), written as the
 * snippet writes it ("Café" for "cafe", since find matches accents).
 */
export function findForMessageMatch(
  match: Pick<OrchestrationThreadSearchMatch, "snippet" | "messageId">,
  query: string,
): PendingThreadFind {
  const start = match.messageId ? { start: { entryId: match.messageId, occurrence: 0 } } : {};
  // Apostrophes are straight in the query; straightening keeps offsets.
  const together = messagePhrase(query)?.exec(match.snippet.replace(/[\u2018\u2019]/g, "'"));
  if (together) {
    return {
      query: match.snippet.slice(together.index, together.index + together[0].length),
      ...start,
    };
  }
  const word =
    messageSearchTokens(query).long.reduce(
      (longest, token) => (token.length > longest.length ? token : longest),
      "",
    ) || query;
  const ranges = findSearchTokenRanges(match.snippet, word);
  // A whole word first, as search ranked it: "Café", not "Cafe" in "Cafeteria".
  const shown =
    ranges.find((range) => !/[\p{L}\p{N}]/u.test(match.snippet[range.end] ?? "")) ?? ranges[0];
  return { query: shown ? match.snippet.slice(shown.start, shown.end) : word, ...start };
}