zidane-ui 9.0.4 → 9.1.3

package/src/chat/transcript/useTranscriptFindKey.ts

@@ -1,52 +0,0 @@
-/**
- * ⌘F / Ctrl+F: find. Files and Diffs search themselves first (⌘F in the file
- * or the diffs, ⌘⇧F across files): the one holding focus, else the one
- * under the pointer (`TabScope.find`, `zidane-ui/workspace`). Otherwise ⌘F
- * opens the find in the conversation on show. A plain window listener, not
- * a catalog action: find is outside the shared catalog. It fires from the
- * prompt too (a modifier says the user meant a shortcut), never over a
- * modal, and never when the code editor took the press for its own find.
- */
-import { useEffect, useRef } from 'react';
-
-import { keyScopeOf } from '../../keybindings/headless/key-scope';
-import { focusedTabScope, hoveredTabScope } from '../../workspace/tab-scopes';
-
-/** Options for {@link useTranscriptFindKey}. */
-export interface TranscriptFindKeyOptions<K extends string = string> {
-  /** The session on show, or `null` (only the tab scopes find then). */
-  sessionId: K | null;
-  /** Opens the find on a session's conversation. */
-  onFind(sessionId: K): void;
-  /** Whether something else owns input now (a modal is open). */
-  blocked?(): boolean;
-}
-
-/**
- * Routes ⌘F / ⌘⇧F to the tab scope in reach, else to the conversation. The listener attaches once.
- *
- * @param options - The session on show and what opens its find.
- */
-export function useTranscriptFindKey<K extends string = string>(options: TranscriptFindKeyOptions<K>): void {
-  const latest = useRef(options);
-  // eslint-disable-next-line react-hooks/refs -- read at event time only, never during render
-  latest.current = options;
-  useEffect(() => {
-    const onKey = (e: KeyboardEvent) => {
-      if (e.key.toLowerCase() !== 'f' || (!e.metaKey && !e.ctrlKey) || e.altKey) return;
-      // The code editor's own find took it (focus in the editor).
-      if (e.defaultPrevented || latest.current.blocked?.()) return;
-      const mode = e.shiftKey ? 'files' : 'file';
-      if (focusedTabScope()?.find?.(mode) || hoveredTabScope()?.find?.(mode)) {
-        e.preventDefault();
-        return;
-      }
-      const { sessionId, onFind } = latest.current;
-      if (e.shiftKey || !sessionId || keyScopeOf(e) === 'editor') return;
-      e.preventDefault();
-      onFind(sessionId);
-    };
-    window.addEventListener('keydown', onKey);
-    return () => window.removeEventListener('keydown', onKey);
-  }, []);
-}

package/src/chat/transcript/useTranscriptScroll.ts

@@ -1,162 +0,0 @@
-/**
- * The conversation's transcript scroll: stick-to-bottom (paused while
- * select-turn mode drives the cursor), where a conversation opens (back where
- * it was left, or at the bottom), the scrolled-from-top signal for the
- * footer's fade, and lazy scrollback. The container hands it the session's
- * page state and loader, whether select-turn drives the view, and the
- * Keep scroll position setting.
- */
-import { useEffect, useLayoutEffect, useRef, useState } from 'react';
-
-import type { SessionPageState } from '../headless/streams/types';
-import { useFillViewportScrollback } from './EarlierHistory';
-import { type ScrollPosition, useStickToBottom } from './useStickToBottom';
-import { useWheelHoverPause } from './useWheelHoverPause';
-
-/** What {@link useTranscriptScroll} reads from its container. */
-export interface TranscriptScrollInputs<K extends string = string> {
-  /** The session's page state (`hasMore`, `loadingEarlier`, `firstSeq`). */
-  page: SessionPageState;
-  /** Loads the session's previous page; `false` when nothing went out. */
-  loadEarlier: (sessionId: K, opts?: { onSettled?: (prepended: boolean) => void }) => boolean;
-  /** Select-turn mode drives this session's view: stick-to-bottom is paused, and resumes on exit if it was on. */
-  selecting: boolean;
-  /** Reopen a conversation where it was left (Keep scroll position). */
-  keepPosition: boolean;
-}
-
-/** How close to the top of the hydrated window a scroll fetches the previous page. */
-const LOAD_EARLIER_PX = 600;
-
-/**
- * Where each conversation's view was left, across conversation switches
- * (Settings › Interface › Conversation › Keep scroll position). In memory
- * only: a position names rows by ids that last as long as the loaded events,
- * so after a reload, or once a transcript left the cache, it reopens at the
- * bottom.
- */
-const positions = new Map<string, ScrollPosition>();
-
-/**
- * The transcript's scroll: stick-to-bottom, where a conversation opens, the from-top signal and lazy scrollback (see the module comment).
- *
- * @param sessionId - The conversation shown.
- * @param hydrated - Its events have loaded.
- * @param inputs - The {@link TranscriptScrollInputs}.
- */
-export function useTranscriptScroll<K extends string>(
-  sessionId: K | null,
-  hydrated: boolean,
-  { page, loadEarlier, selecting, keepPosition }: TranscriptScrollInputs<K>,
-) {
-  const scrollRef = useRef<HTMLElement | null>(null);
-
-  /*
-   * Select-turn mode owns the scroll: the cursor follows itself, so the
-   * stick-to-bottom pass is paused for the mode's duration; on exit, back to
-   * the bottom if that is where the user was.
-   */
-  const { pinned, snapToBottom, glideToBottom, readPosition, restorePosition } = useStickToBottom(scrollRef, {
-    paused: selecting,
-  });
-  useWheelHoverPause(scrollRef);
-
-  const pinnedRef = useRef(pinned);
-  // eslint-disable-next-line react-hooks/refs -- the mode's entry reads where the view was, without re-running on scroll
-  pinnedRef.current = pinned;
-  const pinnedBeforeSelect = useRef(false);
-  useEffect(() => {
-    if (selecting) {
-      pinnedBeforeSelect.current = pinnedRef.current;
-      return;
-    }
-    if (!pinnedBeforeSelect.current) return;
-    pinnedBeforeSelect.current = false;
-    snapToBottom();
-  }, [selecting, snapToBottom]);
-
-  /*
-   * The conversation whose place the view holds: set once it opened (below),
-   * cleared as it leaves. In between, the view still shows where the one
-   * before was, which is nobody's position.
-   */
-  const shown = useRef<string | null>(null);
-
-  /*
-   * Leaving a conversation (another one shown here, or the view unmounting):
-   * remember where its view was. Read from the last settled frame, not the
-   * DOM, which shows the next conversation by the time this runs.
-   */
-  useLayoutEffect(() => {
-    if (!sessionId) return undefined;
-    return () => {
-      const position = shown.current === sessionId ? readPosition() : null;
-      if (position) positions.set(sessionId, position);
-      shown.current = null;
-    };
-  }, [sessionId, readPosition]);
-
-  /**
-   * Opening a conversation, once its events are hydrated into the stream
-   * lane: back where it was left (Keep scroll position), otherwise, or when
-   * its rows are gone, at the bottom. Once per opening, so later renders
-   * (streaming deltas, mask toggles) never move the user's view. Keyed on
-   * the id, not the session object (the list rebuilds its objects on every
-   * refresh), and done only once its frame ran: a re-render cancelling the
-   * frame schedules it again instead of leaving the conversation at the top.
-   *
-   * `requestAnimationFrame` so it lands AFTER React commits the freshly
-   * hydrated rows (`scrollHeight` is real by then); instant, since
-   * animating to the latest message on activation reads as laggy.
-   */
-  useEffect(() => {
-    if (!sessionId || !hydrated || shown.current === sessionId || !scrollRef.current) return undefined;
-    const rafId = requestAnimationFrame(() => {
-      const saved = keepPosition ? positions.get(sessionId) : undefined;
-      if (!saved || !restorePosition(saved)) snapToBottom();
-      shown.current = sessionId;
-    });
-    return () => cancelAnimationFrame(rafId);
-  }, [sessionId, hydrated, keepPosition, snapToBottom, restorePosition]);
-
-  /**
-   * Scrolled-from-top signal — combined with `!pinned` to drive the soft
-   * fade above the footer that suggests the chat surface is layered above
-   * the transcript. Threshold > 0 (8px) so the fade doesn't flicker on at
-   * the very top during initial paint / 1-px subpixel scroll noise.
-   */
-  const [scrolledFromTop, setScrolledFromTop] = useState(false);
-  useEffect(() => {
-    const el = scrollRef.current;
-    if (!el) return undefined;
-    const onScroll = () => {
-      const next = el.scrollTop > 8;
-      setScrolledFromTop((current) => (current === next ? current : next));
-    };
-    el.addEventListener('scroll', onScroll, { passive: true });
-    return () => el.removeEventListener('scroll', onScroll);
-  }, []);
-
-  /**
-   * Lazy scrollback — wheel/scroll nearing the top of the hydrated window
-   * fetches the previous page and splices it in front. The row at the top
-   * of the view stays put through the prepend: `useStickToBottom` anchors
-   * it. The in-flight guard lives in the store (`loadingEarlier`).
-   */
-  useEffect(() => {
-    const el = scrollRef.current;
-    if (!el || !sessionId || !page.hasMore) return undefined;
-    const onScroll = () => {
-      if (el.scrollTop > LOAD_EARLIER_PX || page.loadingEarlier) return;
-      loadEarlier(sessionId);
-    };
-    el.addEventListener('scroll', onScroll, { passive: true });
-    return () => el.removeEventListener('scroll', onScroll);
-  }, [sessionId, page.hasMore, page.loadingEarlier, page.firstSeq, loadEarlier]);
-
-  // Scroll-to-load needs an overflowing viewport; a live run folded into one
-  // `Working` row never overflows (see `useFillViewportScrollback`).
-  useFillViewportScrollback({ scrollRef, sessionId, hydrated, page, loadEarlier, slackPx: LOAD_EARLIER_PX });
-
-  return { scrollRef, pinned, scrolledFromTop, glideToBottom };
-}

package/src/chat/transcript/useTranscriptSearch.tsx

@@ -1,382 +0,0 @@
-/**
- * useTranscriptSearch — the transcript search ENGINE, shared by the ⌘F
- * overlay (`TranscriptSearch`) and the composer's `?` search mode
- * (Chatbox via Center). Owns: keystroke → needle debounce, the DOM
- * text-node walk, CSS Custom Highlight registration, active-match
- * cursor, and scroll-to-match.
- *
- * Matching walks the scroll container's TEXT nodes directly rather than
- * re-deriving text from stream events — the DOM is the source of truth
- * for "what the user can see" (markdown rendering, tool-row formatting,
- * masking all live there). `content-visibility: auto` rows keep their
- * text in the DOM even when paint is skipped, and rows that mount on
- * approach (`LazyRow`) are all mounted while a needle is active, so the
- * walk still finds offscreen matches. Highlighting uses the CSS Custom Highlight API
- * (`CSS.highlights`) so we never mutate the transcript's DOM — wrapping
- * matches in `<mark>` would fight React's reconciler on the next
- * streaming tick.
- *
- * Two opt-ins serve a search opened from a palette match inside the
- * conversation (`TranscriptSearchOptions`): `terms` matches each term of
- * the query (split by the app's own tokenizer, the one its content scan
- * used) rather than the query as one phrase;
- * `revealFirstMatch` keeps waiting for a first match while the transcript
- * is still loading, then jumps to it once.
- */
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
-
-import { useHydrated } from '../../hooks/useHydrated';
-import { holdForceMountRows, useForceMountRows } from './LazyRow';
-
-/**
- * What {@link useTranscriptSearch} returns: the match count and cursor, and the hop.
- */
-export interface TranscriptSearchState {
-  /** Total matches found (capped at `MAX_MATCHES`). */
-  count: number;
-  /** True when the cap was hit — render the counter as "500+". */
-  capped: boolean;
-  /** Zero-based cursor into the match list. */
-  activeIndex: number;
-  /** Debounced needle is non-empty — gates the counter's visibility. */
-  hasNeedle: boolean;
-  /** Hop to the next (+1) / previous (-1) match, wrapping. */
-  goTo: (direction: 1 | -1) => void;
-}
-
-/**
- * Range cap — a short query ("e") over a long transcript can produce
- * tens of thousands of matches; building Ranges + a Highlight for all
- * of them stalls the frame for no navigational benefit. The counter
- * shows "500+" when the cap is hit.
- */
-export const MAX_MATCHES = 500;
-/** How long the transcript must be still before a standing search re-walks it. */
-const RESCAN_MS = 150;
-
-const HIGHLIGHT_ALL = 'zg-search';
-const HIGHLIGHT_ACTIVE = 'zg-search-active';
-
-/**
- * Electron's Chromium ships the Custom Highlight API, but guard anyway —
- * without it search degrades to counter + jump-navigation only.
- */
-const highlightsSupported = typeof CSS !== 'undefined' && 'highlights' in CSS;
-
-/**
- * The highlight names are document-global, and two consumers can be
- * mounted at once (⌘F overlay + composer mode both live under Center).
- * Ownership tracking keeps an idle instance's clear (its needle is
- * empty, its recompute effect still runs on stream ticks) from wiping
- * the active instance's highlights.
- */
-let highlightOwner: object | null = null;
-
-/**
- * Opt-ins of a search opened from a palette match (see the module comment).
- */
-export interface TranscriptSearchOptions {
-  /**
-   * Match every term the tokenizer splits the query into (words, quoted
-   * phrases whole) instead of the query as one phrase. The app's content
-   * search tokenizer, so its matches are the ones highlighted.
-   */
-  terms?: (query: string) => readonly string[];
-  /**
-   * Until a first match appears, rescans keep looking and jump to it when
-   * it does: the search opened with the conversation, whose transcript is
-   * still loading. Disarmed by that jump or by the query changing.
-   */
-  revealFirstMatch?: boolean;
-}
-
-/**
- * A settled search. `key` identifies it: a new key is a new search (the
- * cursor resets and the view jumps), the same key is a rescan. `needles`
- * are what the walk looks for, lowercased.
- */
-interface Needle {
-  key: string;
-  needles: readonly string[];
-}
-
-const NO_NEEDLE: Needle = { key: '', needles: [] };
-
-/** The search `query` settles to: the phrase, or (`terms`) each distinct term. */
-function needleOf(query: string, terms: ((query: string) => readonly string[]) | undefined): Needle {
-  const text = query.trim().toLowerCase();
-  if (!text) return NO_NEEDLE;
-  return terms
-    ? { key: `terms:${text}`, needles: [...new Set(terms(text))] }
-    : { key: `phrase:${text}`, needles: [text] };
-}
-
-/** Where each needle occurs in `haystack`, in order, overlaps dropped (the earlier match wins). */
-function occurrences(haystack: string, needles: readonly string[]): [number, number][] {
-  const found: [number, number][] = [];
-  for (const needle of needles) {
-    for (let at = haystack.indexOf(needle); at !== -1; at = haystack.indexOf(needle, at + needle.length)) {
-      found.push([at, at + needle.length]);
-    }
-  }
-  if (needles.length === 1) return found;
-  found.sort((a, b) => a[0] - b[0] || b[1] - a[1]);
-  const kept: [number, number][] = [];
-  for (const span of found) if (kept.length === 0 || span[0] >= kept.at(-1)![1]) kept.push(span);
-  return kept;
-}
-
-/**
- * Case-insensitive, non-overlapping substring scan for any of `needles`
- * (lowercased) over every text node under `root`. Matches inside collapsed tool outputs
- * (`.zg-collapsible[data-open="false"]`) are excluded — their text is
- * still in the DOM (the collapse is a `grid-template-rows` animation,
- * not an unmount) but the user can't see it, and jumping to an
- * invisible match reads as a broken no-op.
- */
-function collectMatches(root: HTMLElement, needles: readonly string[]): Range[] {
-  const ranges: Range[] = [];
-  const walker = document.createTreeWalker(root, NodeFilter.SHOW_TEXT);
-
-  let node: Node | null;
-
-  while ((node = walker.nextNode())) {
-    const spans = occurrences((node as Text).data.toLowerCase(), needles);
-
-    if (spans.length === 0) {
-      continue;
-    }
-
-    if (node.parentElement?.closest('.zg-collapsible[data-open="false"]')) {
-      continue;
-    }
-
-    for (const [start, end] of spans) {
-      const range = document.createRange();
-      range.setStart(node, start);
-      range.setEnd(node, end);
-      ranges.push(range);
-
-      if (ranges.length >= MAX_MATCHES) {
-        return ranges;
-      }
-    }
-  }
-
-  return ranges;
-}
-
-function setHighlights(owner: object, ranges: Range[], activeIndex: number): void {
-  if (!highlightsSupported) {
-    return;
-  }
-
-  highlightOwner = owner;
-  CSS.highlights.set(HIGHLIGHT_ALL, new Highlight(...ranges));
-
-  const active = ranges[activeIndex];
-
-  if (active) {
-    CSS.highlights.set(HIGHLIGHT_ACTIVE, new Highlight(active));
-  } else {
-    CSS.highlights.delete(HIGHLIGHT_ACTIVE);
-  }
-}
-
-/** Drop the document-wide highlights — but only if `owner` set them. */
-function releaseHighlights(owner: object): void {
-  if (!highlightsSupported || highlightOwner !== owner) {
-    return;
-  }
-
-  highlightOwner = null;
-  CSS.highlights.delete(HIGHLIGHT_ALL);
-  CSS.highlights.delete(HIGHLIGHT_ACTIVE);
-}
-
-/**
- * Jump to a match's row. `block: 'center'` keeps context visible above
- * and below; on a `content-visibility: auto` row this forces render,
- * which is exactly what we want before the user reads the match.
- */
-function scrollToRange(range: Range): void {
-  range.startContainer.parentElement?.scrollIntoView({ block: 'center' });
-}
-
-/**
- * `revision` is any value whose identity changes when the transcript
- * re-renders (the host's `events` array) — it triggers a match
- * recompute without moving the viewport, so streaming deltas don't yank
- * the user away from the match they're reading. Only a needle CHANGE
- * scrolls.
- *
- * @param container - The transcript's scroll container.
- * @param query - The query as typed.
- * @param revision - Changes identity when the transcript re-renders.
- * @param options - The {@link TranscriptSearchOptions}.
- */
-export function useTranscriptSearch(
-  container: React.RefObject<HTMLElement | null>,
-  query: string,
-  revision: unknown,
-  { terms, revealFirstMatch = false }: TranscriptSearchOptions = {},
-): TranscriptSearchState {
-  const [needle, setNeedle] = useState<Needle>(NO_NEEDLE);
-  const [matches, setMatches] = useState<{ count: number; capped: boolean }>({ count: 0, capped: false });
-  const [activeIndex, setActiveIndex] = useState(0);
-
-  /**
-   * Ranges live in a ref, not state — they're DOM handles the navigation
-   * handlers read imperatively; re-rendering on their identity would be
-   * churn without payoff. `activeIndexRef` mirrors state so the
-   * recompute effect can preserve the cursor without listing
-   * `activeIndex` in its deps (which would loop: effect → setActiveIndex
-   * → effect).
-   */
-  const rangesRef = useRef<Range[]>([]);
-  const activeIndexRef = useRef(0);
-  // eslint-disable-next-line react-hooks/refs -- the rescan keeps the cursor without listing it (that would loop)
-  activeIndexRef.current = activeIndex;
-
-  /** Stable per-instance identity for highlight ownership. */
-  const ownerRef = useRef<object | null>(null);
-  ownerRef.current ??= {};
-
-  /** Debounce keystrokes → `needle` so we don't walk the DOM per character. */
-  useEffect(() => {
-    const next = needleOf(query, terms);
-    const timer = setTimeout(() => setNeedle((current) => (current.key === next.key ? current : next)), 150);
-
-    return () => clearTimeout(timer);
-  }, [query, terms]);
-
-  /** {@link TranscriptSearchOptions.revealFirstMatch}: armed until the jump, or until the needle is replaced. */
-  const revealArmed = useRef(revealFirstMatch);
-
-  /**
-   * Recompute matches when the needle settles AND whenever the
-   * transcript changes underneath us (`revision` — streaming deltas,
-   * lazy scrollback prepends). Effects run post-commit, so the walk
-   * sees the freshly-rendered rows.
-   */
-  const prevNeedleRef = useRef('');
-  const rowsMounted = useForceMountRows();
-
-  const searching = needle.key !== '';
-  useEffect(() => (searching ? holdForceMountRows() : undefined), [searching]);
-
-  /** A rescan the transcript changing asked for, waiting out a burst of stream updates. */
-  const rescanTimer = useRef<ReturnType<typeof setTimeout> | null>(null);
-  useEffect(
-    () => () => {
-      if (rescanTimer.current) clearTimeout(rescanTimer.current);
-    },
-    [],
-  );
-
-  useEffect(() => {
-    const owner = ownerRef.current!;
-    const root = container.current;
-    // Wait for the render that mounts every row; the walk would miss the lazy ones.
-    if (searching && !rowsMounted) return;
-    const needleChanged = prevNeedleRef.current !== needle.key;
-    // The first needle is the one the search opened with; any later one is the user's.
-    if (needleChanged && prevNeedleRef.current !== '') revealArmed.current = false;
-    prevNeedleRef.current = needle.key;
-    if (rescanTimer.current) {
-      clearTimeout(rescanTimer.current);
-      rescanTimer.current = null;
-    }
-
-    if (!root || !searching) {
-      // Idle (no needle) on every stream update: nothing to clear twice, no extra render.
-      if (rangesRef.current.length === 0 && !needleChanged) return;
-      rangesRef.current = [];
-      setMatches((prev) => (prev.count === 0 && !prev.capped ? prev : { count: 0, capped: false }));
-      setActiveIndex(0);
-      releaseHighlights(owner);
-
-      return;
-    }
-
-    const scan = () => {
-      rescanTimer.current = null;
-      const ranges = collectMatches(root, needle.needles);
-      const jump = needleChanged || revealArmed.current;
-      const nextIndex = needleChanged ? 0 : Math.min(activeIndexRef.current, Math.max(0, ranges.length - 1));
-
-      rangesRef.current = ranges;
-      setMatches((prev) =>
-        prev.count === ranges.length && prev.capped === ranges.length >= MAX_MATCHES
-          ? prev
-          : { count: ranges.length, capped: ranges.length >= MAX_MATCHES },
-      );
-      setActiveIndex(nextIndex);
-      setHighlights(owner, ranges, nextIndex);
-
-      if (jump && ranges.length > 0) {
-        revealArmed.current = false;
-        scrollToRange(ranges[nextIndex]!);
-      }
-    };
-    // A new needle answers at once; the transcript streaming under a standing one re-walks the
-    // whole DOM, so it waits for a pause (a scan per token pinned the frame while searching).
-    if (needleChanged) scan();
-    else rescanTimer.current = setTimeout(scan, RESCAN_MS);
-  }, [needle, searching, revision, container, rowsMounted]);
-
-  /** Highlights are registered document-wide — drop ours on unmount. */
-  useEffect(() => {
-    const owner = ownerRef.current!;
-
-    return () => releaseHighlights(owner);
-  }, []);
-
-  const goTo = useCallback((direction: 1 | -1) => {
-    const ranges = rangesRef.current;
-
-    if (ranges.length === 0) {
-      return;
-    }
-
-    const next = (activeIndexRef.current + direction + ranges.length) % ranges.length;
-    setActiveIndex(next);
-    setHighlights(ownerRef.current!, ranges, next);
-    scrollToRange(ranges[next]!);
-  }, []);
-
-  return { count: matches.count, capped: matches.capped, activeIndex, hasNeedle: searching, goTo };
-}
-
-/**
- * The `::highlight()` color rules, resolved once per mount.
- * `::highlight()` pseudos can't reliably resolve CSS custom properties
- * in all Chromium versions, so the accent is resolved to a concrete
- * color and interpolated into the injected rules. Theme changes
- * mid-search show the old accent until reopen — acceptable for a
- * transient surface. Render exactly one instance while search is
- * active (overlay OR composer mode).
- */
-export function SearchHighlightStyle() {
-  const hydrated = useHydrated();
-  const accent = useMemo(
-    () =>
-      // No document on a server render (where `highlightsSupported` is false and nothing renders anyway).
-      (typeof document === 'undefined'
-        ? ''
-        : getComputedStyle(document.documentElement).getPropertyValue('--zg-accent').trim()) || '#1488fc',
-    [],
-  );
-
-  // Not while hydrating: the server can't tell whether the browser has highlights.
-  if (!highlightsSupported || !hydrated) {
-    return null;
-  }
-
-  return (
-    <style>{`
-      ::highlight(${HIGHLIGHT_ALL}) { background-color: color-mix(in srgb, ${accent} 30%, transparent); }
-      ::highlight(${HIGHLIGHT_ACTIVE}) { background-color: color-mix(in srgb, ${accent} 65%, transparent); }
-    `}</style>
-  );
-}

package/src/chat/transcript/useTranscriptSelectionCopy.ts

@@ -1,63 +0,0 @@
-import { useEffect, useRef } from 'react';
-
-/**
- * Drag-select transcript copy — mirrors the TUI's OSC-52 hook. On
- * mouseup inside the timeline, if the live selection intersects the
- * transcript and is non-empty, write its plain-text contents to the
- * clipboard. Debounced via `lastCopiedRef` so dragging across the same
- * selection doesn't spam the clipboard.
- *
- * Web equivalent of the TUI's OSC-52 path. We don't subscribe to
- * `selectionchange` directly because that event fires per-character
- * during a drag — mouseup is the natural "I'm done picking" boundary.
- *
- * @param containerRef - Ref to the transcript's root element. A selection inside it is copied on mouse up.
- */
-export function useTranscriptSelectionCopy(containerRef: React.RefObject<HTMLDivElement | null>): void {
-  const lastCopiedRef = useRef<string>('');
-
-  useEffect(() => {
-    const root = containerRef.current;
-
-    if (!root) {
-      return undefined;
-    }
-
-    const onMouseUp = () => {
-      // Defer to the next task so the browser has finalized the selection.
-      window.setTimeout(() => {
-        const selection = window.getSelection();
-
-        if (!selection || selection.isCollapsed) {
-          return;
-        }
-
-        const text = selection.toString();
-
-        if (text.length === 0) {
-          return;
-        }
-
-        const anchor = selection.anchorNode;
-
-        if (!anchor || !root.contains(anchor)) {
-          return;
-        }
-
-        if (text === lastCopiedRef.current) {
-          return;
-        }
-
-        lastCopiedRef.current = text;
-
-        navigator.clipboard.writeText(text).catch(() => {
-          // Restricted contexts silently fail; user retains visual selection.
-        });
-      }, 0);
-    };
-
-    root.addEventListener('mouseup', onMouseUp);
-
-    return () => root.removeEventListener('mouseup', onMouseUp);
-  }, [containerRef]);
-}