papilot 0.0.0-stage → 0.1.0

package/vendor/latex-review/src/types.ts

@@ -0,0 +1,283 @@
+export type Span = [number, number];
+export type Rect = [number, number, number, number];
+export type SourceBox = [
+  page: number,
+  top: number,
+  bottom: number,
+  left?: number,
+  right?: number,
+];
+export type Ranges = Record<string, Span[]>;
+export type Op = [
+  "equal" | "replace" | "insert" | "delete",
+  number,
+  number,
+  number,
+  number,
+];
+export interface Heading {
+  id: string;
+  title: string;
+  number: string;
+  kind: string;
+  level: number;
+  file: string;
+  line: number;
+  parent: string | null;
+  labels: string[];
+  ranges: Ranges;
+  files: string[];
+}
+export interface SectionRef {
+  id: string;
+  number: string;
+  title: string;
+}
+export interface Scope {
+  paths: string[];
+  ranges: Ranges | null;
+  sections: SectionRef[];
+}
+export interface Task {
+  name: string;
+  title: string;
+  worktree: string;
+  base: string;
+  accepted: string;
+  scope: Scope;
+  created: number;
+  closed: number | null;
+}
+export interface Unit {
+  id: string;
+  file: string;
+  status: "added" | "deleted" | "modified";
+  kind: "text" | "figure" | "binary";
+  whole_file: boolean;
+  ops: Op[];
+  old_start: number;
+  old_end: number;
+  new_start: number;
+  new_end: number;
+  old_text: string;
+  new_text: string;
+  truncated: boolean;
+}
+export interface Round {
+  task: string;
+  number: number;
+  before: string;
+  after: string;
+  units: Unit[];
+  summary: { warnings: string[]; targets: string[]; builds: string[] };
+  created: number;
+}
+export type ActionKind = "accept" | "reject" | "comment";
+export type Decision = "accepted" | "rejected" | "commented" | "pending";
+export interface ActionDetail {
+  accepted_before?: string;
+  accepted_after?: string;
+  not_reverted?: string[];
+}
+export interface Action {
+  seq: number;
+  id: string;
+  task: string;
+  round: number;
+  kind: ActionKind;
+  changes: string[];
+  body: string;
+  status: "applying" | "applied" | "undoing" | "undone" | "failed";
+  detail: ActionDetail;
+  created: number;
+}
+export interface Write {
+  action: string;
+  phase: "apply" | "undo";
+  path: string;
+  expected: Buffer | null;
+  target: Buffer | null;
+}
+export interface MessageData {
+  changes?: string[];
+  not_reverted?: string[];
+  undid?: string;
+  message?: number;
+}
+export interface Message {
+  id: number;
+  task: string;
+  round: number | null;
+  kind: ActionKind | "undo" | "note";
+  action: string | null;
+  body: string;
+  data: MessageData;
+  created: number;
+}
+export interface JobResult {
+  outcome?: "published" | "unchanged" | "empty";
+  round?: number | null;
+  changes?: number;
+  kinds?: Record<string, number>;
+  warnings?: string[];
+  error?: string;
+  details?: string[];
+  next?: string;
+  log?: string;
+}
+export interface Job {
+  id: string;
+  task: string;
+  status: "queued" | "running" | "done" | "failed";
+  phase: string;
+  result: JobResult;
+  created: number;
+  finished?: number;
+}
+export interface BuildInfo {
+  key: string;
+  tree: string;
+  targets: string[];
+  root: string;
+  cwd: string;
+  pdf: string;
+  seconds: number;
+  warnings: string[];
+}
+export interface Position {
+  page: number;
+  clip: Rect;
+  label: string;
+}
+export interface Mark {
+  kind: "removed" | "added" | "moved";
+  rect: Rect;
+}
+export interface Pair {
+  old: Position | null;
+  new: Position | null;
+  before_marks: Mark[];
+  after_marks: Mark[];
+}
+export type Visual = "unmapped" | "text" | "layout" | "position" | "identical";
+export interface Card {
+  id: string;
+  file: string;
+  pairs: Pair[];
+  comparison: Visual;
+  own?: { old: SourceBox[]; new: SourceBox[] };
+  context_node?: string | null;
+}
+export interface TextGlyph {
+  text: string;
+  rect: Rect;
+}
+export interface TextLine {
+  text: string;
+  chars: TextGlyph[];
+}
+export interface Strip {
+  src: string;
+  clean: string;
+  width: number;
+  height: number;
+  page: number;
+  label: string;
+  text?: TextLine[];
+}
+export interface ChangeBlock {
+  kind: "change";
+  units: string[];
+  identical: boolean;
+  reflow?: boolean;
+  before: Strip[];
+  after: Strip[];
+}
+export type Block =
+  ChangeBlock | { kind: "context"; image: Strip } | { kind: "gap" };
+export interface VisualUnit {
+  visual: Visual;
+  pages: string[];
+  section: string | null;
+}
+export interface RenderedRound {
+  units: Record<string, VisualUnit>;
+  sections: { node: string; number: string; title: string; blocks: Block[] }[];
+  loose: ChangeBlock[];
+}
+export interface RenderRequest {
+  main: string;
+  source_dir: string;
+  figures: string[];
+  old: BuildInfo;
+  new: BuildInfo;
+  units: Unit[];
+}
+export interface History {
+  round: number;
+  change: string;
+  comment: string;
+  new_text: string;
+}
+export interface RoundDetail extends Omit<RenderedRound, "units"> {
+  task: string;
+  round: number;
+  before: string;
+  after: string;
+  units: (Unit & Partial<VisualUnit> & { history?: History[] })[];
+  warnings: string[];
+  files: string;
+}
+export type TaskState =
+  "editing" | "building" | "build_failed" | "reviewing" | "revise" | "done";
+export interface Summary {
+  task: string;
+  title: string;
+  state: TaskState;
+  round: number | null;
+  counts: Record<Decision, number>;
+  next: string;
+}
+export interface PageState {
+  csrf: string;
+  task: string;
+  title: string;
+  closed: boolean;
+  /** Optional host-provided reason that file decisions or comments are unavailable. */
+  decisionLock?: string | null;
+  commentLock?: string | null;
+  state: TaskState | null;
+  latest: number | null;
+  round: number | null;
+  revision: string | null;
+  decisions: Record<string, Decision>;
+  comments: Record<string, string>;
+  undo: { id: string; kind: ActionKind; changes: string[] } | null;
+  job:
+    | (Pick<Job, "id" | "status" | "phase" | "created"> &
+        JobResult & { ahead: number })
+    | null;
+}
+export interface FeedbackItem {
+  id: number;
+  kind: Message["kind"];
+  round: number | null;
+  text?: string;
+  changes?:
+    | string[]
+    | { id: string; file: string; lines: Span; old: string; new: string }[];
+  not_reverted?: string[];
+  undid?: string;
+}
+export interface Feedback extends Summary {
+  feedback: FeedbackItem[];
+  cursor: number;
+  build_error?: JobResult;
+  warnings?: string[];
+}
+export interface TaskInfo extends Summary {
+  worktree: string;
+  url: string;
+  viewing: boolean;
+  scope: { sections: string[]; files: string[] };
+}

package/vendor/latex-review/src/web/ChangeMap.tsx

@@ -0,0 +1,212 @@
+import { useEffect, useRef, useState, type RefObject } from "react";
+import type { Decision } from "../types.ts";
+import { stopState, type Stop } from "./model.ts";
+
+type Region = { top: number; height: number };
+
+export function ChangeMap({
+  scrollRoot,
+  stops,
+  locations,
+  decisions,
+  current,
+  disabled,
+  onSelect,
+}: {
+  scrollRoot: RefObject<HTMLElement | null>;
+  stops: Stop[];
+  locations: string[];
+  decisions: Record<string, Decision>;
+  current: number;
+  disabled: boolean;
+  onSelect: (index: number) => void;
+}) {
+  const rail = useRef<HTMLElement>(null),
+    drag = useRef<{ pointer: number; offset: number } | null>(null),
+    [regions, setRegions] = useState<Region[]>([]),
+    [viewport, setViewport] = useState<Region>({ top: 0, height: 0 });
+
+  useEffect(() => {
+    const root = scrollRoot.current,
+      track = rail.current;
+    if (!root || !track) return;
+    let frame = 0,
+      needsMeasure = true;
+    const update = () => {
+      frame = 0;
+      const extent = Math.max(root.scrollHeight, 1),
+        trackHeight = track.clientHeight,
+        maxScroll = Math.max(0, extent - root.clientHeight),
+        thumbHeight = Math.min(
+          trackHeight,
+          Math.max(8, (root.clientHeight / extent) * trackHeight),
+        );
+      setViewport({
+        top: maxScroll
+          ? (Math.max(0, Math.min(root.scrollTop, maxScroll)) / maxScroll) *
+            (trackHeight - thumbHeight)
+          : 0,
+        height: thumbHeight,
+      });
+      if (!needsMeasure) return;
+      needsMeasure = false;
+      const origin = root.getBoundingClientRect().top + root.clientTop;
+      setRegions(
+        [...root.querySelectorAll<HTMLElement>("[data-stop]")].map(
+          (article) => {
+            const box = article.getBoundingClientRect(),
+              top = Math.max(
+                0,
+                ((box.top - origin + root.scrollTop) / extent) * trackHeight,
+              );
+            return {
+              top,
+              height: Math.max(
+                0,
+                Math.min(
+                  trackHeight - top,
+                  Math.max(4, (box.height / extent) * trackHeight),
+                ),
+              ),
+            };
+          },
+        ),
+      );
+    };
+    const schedule = () => {
+      if (!frame) frame = requestAnimationFrame(update);
+    };
+    const observer = new ResizeObserver(() => {
+      needsMeasure = true;
+      schedule();
+    });
+    observer.observe(root);
+    observer.observe(track);
+    for (const child of root.children) observer.observe(child);
+    for (const article of root.querySelectorAll("[data-stop]"))
+      observer.observe(article);
+    // Banners can move the document without changing its own dimensions.
+    const mutations = new MutationObserver((records) => {
+      for (const record of records) {
+        for (const child of record.removedNodes)
+          if (child instanceof Element) observer.unobserve(child);
+        for (const child of record.addedNodes)
+          if (child instanceof Element) observer.observe(child);
+      }
+      needsMeasure = true;
+      schedule();
+    });
+    mutations.observe(root, { childList: true });
+    root.addEventListener("scroll", schedule, { passive: true });
+    schedule();
+    return () => {
+      observer.disconnect();
+      mutations.disconnect();
+      root.removeEventListener("scroll", schedule);
+      cancelAnimationFrame(frame);
+    };
+  }, [scrollRoot, stops]);
+
+  if (!stops.length) return null;
+
+  function scrollAt(clientY: number, offset: number) {
+    const root = scrollRoot.current,
+      track = rail.current;
+    if (!root || !track) return;
+    const y = clientY - track.getBoundingClientRect().top - track.clientTop,
+      travel = Math.max(1, track.clientHeight - viewport.height);
+    root.scrollTo({
+      top: ((y - offset) / travel) * (root.scrollHeight - root.clientHeight),
+      behavior: "instant",
+    });
+  }
+
+  return (
+    <nav
+      ref={rail}
+      className="change-map"
+      aria-label="Change map"
+      onPointerDown={(event) => {
+        if (
+          event.button !== 0 ||
+          (event.target as HTMLElement).closest("button")
+        )
+          return;
+        event.preventDefault();
+        const offset = (event.target as HTMLElement).classList.contains(
+          "change-map-viewport",
+        )
+          ? event.clientY -
+            event.currentTarget.getBoundingClientRect().top -
+            event.currentTarget.clientTop -
+            viewport.top
+          : viewport.height / 2;
+        drag.current = { pointer: event.pointerId, offset };
+        event.currentTarget.setPointerCapture(event.pointerId);
+        scrollAt(event.clientY, offset);
+      }}
+      onPointerMove={(event) => {
+        if (drag.current?.pointer === event.pointerId)
+          scrollAt(event.clientY, drag.current.offset);
+      }}
+      onPointerUp={(event) => {
+        if (drag.current?.pointer === event.pointerId) {
+          drag.current = null;
+          event.currentTarget.releasePointerCapture(event.pointerId);
+        }
+      }}
+      onLostPointerCapture={() => {
+        drag.current = null;
+      }}
+    >
+      <div
+        className="change-map-viewport"
+        style={{ top: viewport.top, height: viewport.height }}
+        aria-hidden="true"
+      />
+      {stops.map((stop, index) => {
+        const region = regions[index];
+        if (!region) return null;
+        const state = stopState(stop.units, decisions),
+          label = `Change ${index + 1} · ${state} · ${locations[index]}`;
+        return (
+          <button
+            key={stop.key}
+            type="button"
+            className="change-map-mark"
+            data-stop-index={index}
+            data-state={state}
+            aria-label={label}
+            aria-current={index === current ? "location" : undefined}
+            tabIndex={index === Math.max(0, current) ? 0 : -1}
+            disabled={disabled}
+            style={{ top: region.top, height: region.height }}
+            onClick={() => onSelect(index)}
+            onKeyDown={(event) => {
+              const target =
+                event.key === "ArrowDown"
+                  ? index + 1
+                  : event.key === "ArrowUp"
+                    ? index - 1
+                    : event.key === "Home"
+                      ? 0
+                      : event.key === "End"
+                        ? stops.length - 1
+                        : null;
+              if (target === null) return;
+              event.preventDefault();
+              event.stopPropagation();
+              rail.current
+                ?.querySelector<HTMLButtonElement>(
+                  `[data-stop-index="${Math.max(0, Math.min(stops.length - 1, target))}"]`,
+                )
+                ?.focus();
+            }}
+          >
+            <span className="change-map-tooltip">{label}</span>
+          </button>
+        );
+      })}
+    </nav>
+  );
+}

package/vendor/latex-review/src/web/PdfStrip.tsx

@@ -0,0 +1,77 @@
+import { memo, useMemo, type CSSProperties } from "react";
+import type { Strip, TextGlyph } from "../types.ts";
+let context: CanvasRenderingContext2D | null | undefined;
+const widths = new Map<string, number>();
+function width(text: string) {
+  if (widths.has(text)) return widths.get(text)!;
+  context ??= document.createElement("canvas").getContext("2d");
+  if (!context) return 1;
+  context.font = '100px "Times New Roman", serif';
+  const measured = context.measureText(text).width / 100;
+  widths.set(text, measured);
+  return measured || 1;
+}
+function style(glyph: TextGlyph, image: Strip): CSSProperties {
+  const [x0, y0, x1, y1] = glyph.rect,
+    height = Math.max(y1 - y0, 0.1),
+    scaleX = (x1 - x0) / (height * width(glyph.text));
+  return {
+    left: `${(100 * x0) / image.width}%`,
+    top: `${(100 * y0) / image.height}%`,
+    fontSize: `${(100 * height) / image.width}cqw`,
+    transform: `scaleX(${scaleX})`,
+  };
+}
+export const PdfStrip = memo(function PdfStrip({
+  image,
+  base,
+  label,
+  clean = false,
+}: {
+  image: Strip;
+  base: string;
+  label: string;
+  clean?: boolean;
+}) {
+  const text = useMemo(
+    () =>
+      image.text?.map((line, i) => (
+        <span className="pdf-text-line" key={i}>
+          {line.chars.map((glyph, j) => (
+            <span key={j} className="pdf-glyph" style={style(glyph, image)}>
+              {glyph.text}
+            </span>
+          ))}
+          {"\n"}
+        </span>
+      )),
+    [image],
+  );
+  return (
+    <div
+      className="pdf-strip"
+      data-page={image.label}
+      style={{ aspectRatio: `${image.width}/${image.height}` }}
+    >
+      <img
+        src={base + (clean ? image.clean : image.src)}
+        alt={image.text?.length ? "" : label}
+        width={image.width}
+        height={image.height}
+        loading="lazy"
+        decoding="async"
+        draggable={false}
+        aria-hidden={Boolean(image.text?.length)}
+      />
+      {image.text?.length ? (
+        <div
+          className="pdf-text"
+          role="region"
+          aria-label={`${label}, PDF page ${image.label}`}
+        >
+          {text}
+        </div>
+      ) : null}
+    </div>
+  );
+});

package/vendor/latex-review/src/web/fonts/GUST-FONT-LICENSE.txt

@@ -0,0 +1,29 @@
+% This is a preliminary version (2006-09-30), barring acceptance from
+% the LaTeX Project Team and other feedback, of the GUST Font License.
+% (GUST is the Polish TeX Users Group, http://www.gust.org.pl)
+%
+% For the most recent version of this license see
+% http://www.gust.org.pl/fonts/licenses/GUST-FONT-LICENSE.txt
+% or
+% http://tug.org/fonts/licenses/GUST-FONT-LICENSE.txt
+%
+% This work may be distributed and/or modified under the conditions
+% of the LaTeX Project Public License, either version 1.3c of this
+% license or (at your option) any later version.
+%
+% Please also observe the following clause:
+% 1) it is requested, but not legally required, that derived works be
+%    distributed only after changing the names of the fonts comprising this
+%    work and given in an accompanying "manifest", and that the
+%    files comprising the Work, as listed in the manifest, also be given
+%    new names. Any exceptions to this request are also given in the
+%    manifest.
+%
+%    We recommend the manifest be given in a separate file named
+%    MANIFEST-<fontid>.txt, where <fontid> is some unique identification
+%    of the font family. If a separate "readme" file accompanies the Work,
+%    we recommend a name of the form README-<fontid>.txt.
+%
+% The latest version of the LaTeX Project Public License is in
+% http://www.latex-project.org/lppl.txt and version 1.3c or later
+% is part of all distributions of LaTeX version 2006/05/20 or later.