sailfork / t3code-github / apps/ web/ src/ components/ files/ LargeTextViewer.tsx

import { useEffect, useImperativeHandle, useRef, useState, type RefObject } from "react";
import { parseDelimitedPreview } from "@t3tools/shared/delimitedPreview";
import { formatAttachmentSize } from "@t3tools/client-runtime/state/attachments";
import { useClientSettings } from "~/hooks/useSettings";
import { FileSurfaceFailure, FileSurfaceLoading, FileSurfaceNotice } from "./fileSurfaceChrome";
import { PREVIEW_PAGE_ROWS, type TextPreviewResult } from "./largeTextProtocol";
import VirtualTablePreview from "./VirtualTablePreview";

const FIRST_SCREEN_BYTES = 16 * 1024;

function firstScreen(text: string, delimiter: "," | "\t" | null, complete: boolean) {
  if (!text || text.includes("\0")) return [];
  const rows = delimiter
    ? parseDelimitedPreview(text, delimiter, {
        maxRows: PREVIEW_PAGE_ROWS * 2 + 1,
        maxColumns: 1024,
        maxCellLength: FIRST_SCREEN_BYTES,
      }).rows
    : text
        .replace(/\r?\n$|\r$/, "")
        .split(/\r\n|\n|\r/)
        .slice(0, PREVIEW_PAGE_ROWS * 2 + 1)
        .map((line) => [line]);
  // A byte range can end inside a quoted record or a UTF-8 character.
  if (!complete) rows.pop();
  return rows.slice(0, PREVIEW_PAGE_ROWS * 2);
}

export default function LargeTextViewer(props: {
  readonly name: string;
  readonly src?: string;
  readonly text?: string;
  readonly sizeBytes?: number;
  readonly onRetry?: () => void;
  readonly copyContents?: RefObject<(() => Promise<string>) | null>;
  readonly delimiter: "," | "\t" | null;
  readonly revealLine?: number | null;
  readonly revealRequestId?: number;
  /** A preview's own wrap toggle; omitted follows the word wrap setting. */
  readonly wordWrap?: boolean;
}) {
  const [meta, setMeta] = useState<Extract<TextPreviewResult, { type: "meta" }> | null>(null);
  const [pages, setPages] = useState(new Map<number, string[][]>());
  const [error, setError] = useState<string | null>(null);
  const worker = useRef<Worker | null>(null);
  const copyPending = useRef<{
    resolve: (text: string) => void;
    reject: (cause: Error) => void;
  } | null>(null);
  const pending = useRef(new Set<number>());
  const defaultWordWrap = useClientSettings((settings) => settings.wordWrap);
  const wordWrap = props.wordWrap ?? defaultWordWrap;
  // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- Own the prefix fetch and indexing worker, cancelling requests and pending copies when the source changes or unmounts.
  useEffect(() => {
    // oxlint-disable-next-line react/set-state-in-effect -- A replacement source must discard the previous worker's error and pages.
    setError(null);
    setMeta(null);
    setPages(new Map());
    const controller = new AbortController();
    let indexed = false;
    let prefetched = false;
    const paintFirstScreen = (text: string, complete: boolean) => {
      if (indexed || controller.signal.aborted) return;
      const rows = firstScreen(text, props.delimiter, complete);
      if (!rows.length) return;
      prefetched = true;
      setPages(
        new Map(
          [0, PREVIEW_PAGE_ROWS]
            .filter((start) => start < rows.length)
            .map((start) => [
              start / PREVIEW_PAGE_ROWS,
              rows.slice(start, start + PREVIEW_PAGE_ROWS),
            ]),
        ),
      );
      setMeta({
        type: "meta",
        count: rows.length,
        columns: rows.reduce((max, row) => Math.max(max, row.length), 1),
        complete: false,
      });
    };
    const startWorker = () => {
      if (controller.signal.aborted) return;
      const engine = new Worker(new URL("./largeText.worker.ts", import.meta.url), {
        type: "module",
      });
      worker.current = engine;
      engine.addEventListener("message", (event: MessageEvent<TextPreviewResult>) => {
        const result = event.data;
        if (result.type === "copy") {
          copyPending.current?.resolve(result.text);
          copyPending.current = null;
        } else if (result.type === "error") {
          copyPending.current?.reject(new Error(result.message));
          copyPending.current = null;
          if (result.operation !== "copy") setError(result.message);
        } else if (result.type === "meta") {
          indexed = true;
          if (prefetched) {
            setPages(new Map());
            pending.current.clear();
            prefetched = false;
          }
          setMeta(result);
        } else if (result.type === "page") {
          pending.current.delete(result.index);
          setPages((old) => {
            const previous = old.get(result.index);
            if (
              previous?.length === result.rows.length &&
              previous.every(
                (row, index) =>
                  row.length === result.rows[index]!.length &&
                  row.every((cell, column) => cell === result.rows[index]![column]),
              )
            )
              return old;
            const next = new Map(old);
            next.delete(result.index);
            next.set(result.index, result.rows);
            if (next.size > 12) next.delete([...next.keys()].find((key) => key !== 0)!);
            return next;
          });
        }
      });
      engine.addEventListener("error", () => {
        copyPending.current?.reject(new Error("The text viewer stopped."));
        copyPending.current = null;
        setError("Could not load the text viewer. Close the file and try again.");
      });
      engine.postMessage(
        {
          type: "open",
          src: props.src,
          text: props.text,
          sizeBytes: props.sizeBytes,
          delimiter: props.delimiter,
        },
        [],
      );
    };
    const scheduleWorker = () => {
      if (prefetched) requestAnimationFrame(() => requestAnimationFrame(startWorker));
      else startWorker();
    };
    // Only this bounded prefix is parsed on the main thread. Indexing the full
    // file and fetching later pages remain in the worker.
    if (props.sizeBytes === 0) {
      startWorker();
    } else if (props.text !== undefined) {
      paintFirstScreen(
        props.text.slice(0, FIRST_SCREEN_BYTES),
        props.text.length <= FIRST_SCREEN_BYTES,
      );
      scheduleWorker();
    } else if (props.src) {
      void fetch(props.src, {
        headers: { Range: `bytes=0-${FIRST_SCREEN_BYTES - 1}` },
        cache: "no-store",
        signal: controller.signal,
      })
        .then(async (response) => {
          if (
            !response.ok ||
            Number(response.headers.get("content-length")) > FIRST_SCREEN_BYTES ||
            response.status !== 206
          ) {
            await response.body?.cancel();
            return;
          }
          const total = Number(response.headers.get("content-range")?.split("/")[1]);
          paintFirstScreen(await response.text(), total <= FIRST_SCREEN_BYTES);
        })
        .catch(() => {
          // The worker reports authorization, network and format failures.
        })
        .finally(scheduleWorker);
    } else startWorker();
    return () => {
      controller.abort();
      copyPending.current?.reject(new Error("Preview closed."));
      copyPending.current = null;
      worker.current?.terminate();
      worker.current = null;
      pending.current.clear();
    };
  }, [props.src, props.text, props.delimiter, props.sizeBytes]);
  useImperativeHandle(
    props.copyContents,
    () => () =>
      new Promise<string>((resolve, reject) => {
        if (!worker.current) {
          reject(new Error("The file is unavailable."));
          return;
        }
        if (copyPending.current) {
          reject(new Error("Another copy is in progress."));
          return;
        }
        copyPending.current = { resolve, reject };
        worker.current.postMessage({ type: "copy" }, []);
      }),
    [],
  );
  if (error)
    return (
      <FileSurfaceFailure message={error} {...(props.onRetry ? { onRetry: props.onRetry } : {})} />
    );
  if (!meta || (meta.count > 0 && !pages.has(0))) return <FileSurfaceLoading />;
  const header = props.delimiter ? pages.get(0)?.[0] : undefined;
  return (
    <div className="relative flex min-h-0 flex-1 flex-col">
      <div
        className="flex min-h-10 shrink-0 flex-wrap items-center gap-x-1 border-b border-border/60 px-3 py-2 text-xs text-muted-foreground tabular-nums"
        role="status"
      >
        {Math.max(0, meta.count - (props.delimiter && meta.count ? 1 : 0)).toLocaleString()}{" "}
        {props.delimiter ? "rows" : "lines"}
        {props.delimiter ? ` · ${meta.count ? meta.columns.toLocaleString() : 0} columns` : ""}
        {meta.complete && meta.sizeBytes !== undefined
          ? ` · ${meta.sizeBytes === 0 ? "0 bytes" : formatAttachmentSize(meta.sizeBytes)}`
          : " · Indexing…"}
      </div>
      {!meta.complete ? (
        <div className="pointer-events-none absolute inset-x-0 bottom-0 z-20">
          <FileSurfaceNotice>Loading the rest of the file…</FileSurfaceNotice>
        </div>
      ) : null}
      {meta.columns === 1024 ? (
        <FileSurfaceNotice>
          Showing the first 1,024 columns. Source and Save retain every column.
        </FileSurfaceNotice>
      ) : null}
      {meta.count > 0 ? (
        <VirtualTablePreview
          name={props.name}
          count={meta.count}
          columns={meta.columns}
          header={header}
          source={!props.delimiter}
          wrap={wordWrap}
          revealLine={meta.complete ? (props.revealLine ?? null) : null}
          revealRequestId={props.revealRequestId ?? 0}
          getRows={(page) => pages.get(page)}
          loadPage={(page) => {
            if (pending.current.has(page)) return;
            pending.current.add(page);
            worker.current?.postMessage({ type: "page", index: page });
          }}
        />
      ) : (
        <div className="flex flex-1 items-center justify-center p-6 text-xs text-muted-foreground">
          This file is empty.
        </div>
      )}
    </div>
  );
}