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

/* oxlint-disable react/no-array-index-key -- Text spans retain their order within an immutable page. */
/* oxlint-disable react/no-unstable-nested-components -- These callbacks return overlays, and are invoked as render functions. */
import { Tooltip, TooltipTrigger, TooltipPopup } from "~/components/ui/tooltip";
import { Fragment, useEffect, useRef, useState } from "react";
import { FileSurfaceLoading } from "../fileSurfaceChrome";
import { OfficePages, type PaintPage } from "./OfficePages";
import { createWorkerClient } from "./worker-rpc";
import {
  layerFont,
  lineHeight,
  type WordMethods,
  type WordPageSize,
  type WordSpan,
  type WordLink,
} from "./word-protocol";

type Opened = {
  pages: readonly WordPageSize[];
  paint: PaintPage;
  engine: ReturnType<typeof createWorkerClient<WordMethods>>;
};

export default function WordDocument(props: {
  bytes: ArrayBuffer;
  onDetails: (text: string) => void;
  onError: (cause: unknown) => void;
}) {
  const { onError, bytes, onDetails } = props;
  const [opened, setOpened] = useState<Opened>();
  const scroll = useRef<((index: number, y?: number) => void) | null>(null);
  // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- Own the document worker and cancel its layout and painting requests when the document changes or unmounts.
  useEffect(() => {
    const controller = new AbortController();
    const worker = new Worker(new URL("./document.worker.ts", import.meta.url), { type: "module" });
    const engine = createWorkerClient<WordMethods>(worker);
    const fail = (error: unknown) => {
      if (!controller.signal.aborted) onError(error);
    };
    worker.addEventListener("error", fail);
    worker.addEventListener("messageerror", fail);
    const buffer = bytes.slice(0);
    const paint: PaintPage = async (index, canvas, scale, signal) => {
      const bitmap = await engine.call(
        "paint",
        { index, scale, ratio: window.devicePixelRatio || 1 },
        { key: `paint:${index}`, signal },
      );
      void engine
        .call("build", { index: index + 1 }, { key: "build", signal })
        .catch(() => undefined);
      if (!bitmap) return;
      const context = canvas.getContext("bitmaprenderer");
      if (!context || signal.aborted) {
        bitmap.close();
        return;
      }
      canvas.width = bitmap.width;
      canvas.height = bitmap.height;
      context.transferFromImageBitmap(bitmap);
    };
    void engine
      .call("open", { bytes: buffer }, { transfer: [buffer], signal: controller.signal })
      .then(async (first) => {
        if (controller.signal.aborted) return;
        setOpened({ pages: first.pages, paint, engine });
        onDetails(`${first.pages.length}${first.loading ? "+" : ""} pages`);
        if (!first.loading) return;
        await new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve)));
        while (!controller.signal.aborted) {
          const step = await engine.call("layout", undefined, { signal: controller.signal });
          if (!step.done) continue;
          if (step.pages.length > 1000) throw new Error("Preview limited to 1,000 pages.");
          setOpened({ pages: step.pages, paint, engine });
          onDetails(`${step.pages.length} pages`);
          break;
        }
      })
      .catch(fail);
    return () => {
      controller.abort();
      engine.close();
    };
  }, [bytes, onDetails, onError]);
  if (!opened) return <FileSurfaceLoading />;
  const follow = (link: WordLink) => {
    if (link.kind === "external") {
      window.open(link.url, "_blank", "noopener,noreferrer");
      return;
    }
    void opened.engine
      .call("bookmark", { name: link.bookmark })
      .then((target) => {
        if (target) scroll.current?.(target.index, target.y);
      })
      .catch(onError);
  };
  return (
    <OfficePages
      pages={opened.pages}
      paint={opened.paint}
      label="Page"
      scrollRef={scroll}
      onError={onError}
      overlay={(index) => (
        <WordTextLayer
          engine={opened.engine}
          index={index}
          page={opened.pages[index]}
          follow={follow}
        />
      )}
    />
  );
}

function WordTextLayer(props: {
  engine: Opened["engine"];
  index: number;
  page: WordPageSize | undefined;
  follow: (link: WordLink) => void;
}) {
  const { engine, index, page, follow } = props;
  const [spans, setSpans] = useState<readonly WordSpan[]>([]);
  // oxlint-disable-next-line t3code/no-unreasoned-state-sync -- Request selectable text from the document worker and cancel the request when its page leaves the viewport.
  useEffect(() => {
    if (!page) return;
    const controller = new AbortController();
    void engine
      .call("text", { index: index }, { signal: controller.signal })
      .then(setSpans)
      .catch(() => undefined);
    return () => controller.abort();
  }, [engine, index, page]);
  return (
    <div
      className="absolute inset-0 select-text overflow-hidden whitespace-pre text-transparent selection:bg-primary/30 selection:text-transparent"
      style={{ containerType: "inline-size", fontFamily: layerFont, fontSize: 0, lineHeight }}
    >
      {spans.map((span, index) => {
        const text = (
          <span
            dir={span.dir}
            role={span.link ? "link" : undefined}
            tabIndex={span.link ? 0 : undefined}
            aria-label={span.title}
            className="absolute origin-top-left"
            style={{
              left: `${span.left * 100}%`,
              top: `${span.top * 100}%`,
              fontSize: `${span.size * 100}cqw`,
              transform: span.transform,
              cursor: span.link ? "pointer" : "text",
            }}
            onClick={(event) => {
              if (span.link && event.button === 0 && (getSelection()?.isCollapsed ?? true))
                follow(span.link);
            }}
            onKeyDown={(event) => {
              if (span.link && event.key === "Enter") {
                event.preventDefault();
                follow(span.link);
              }
            }}
          >
            {span.text}
          </span>
        );
        return (
          <Fragment key={index}>
            {span.title ? (
              <Tooltip>
                <TooltipTrigger render={text} />
                <TooltipPopup>{span.title}</TooltipPopup>
              </Tooltip>
            ) : (
              text
            )}
            {span.after === "br" ? <br /> : span.after === "tab" ? "\t" : null}
          </Fragment>
        );
      })}
    </div>
  );
}