@plannotator/ui 0.30.0 → 0.32.0

package/components/html-viewer/composerYield.ts

@@ -1,51 +1 @@
-/**
- * Composer-yield state machine for shift-click multi-select.
- *
- * While Shift is held during an HTML pinpoint draft, the comment composer must
- * get out of the way of the pointer: fade to ~40% as the pointer approaches,
- * and to near-zero + click-through (pointer-events: none) when the pointer is
- * over it — the DOM equivalent of Codex's setIgnoreMouseEvents click-through
- * popup, so the shift-click lands on the iframe beneath.
- *
- * Restoration uses hysteresis so the composer doesn't flicker at the border:
- * once 'over', the pointer must clear the composer by OVER_EXIT px before the
- * state drops back, and 'near' persists until NEAR_EXIT px (> NEAR_ENTER).
- */
-
-export type ComposerYieldState = "none" | "near" | "over";
-
-/** Distance (px from the composer rect) at which the composer starts fading. */
-export const COMPOSER_YIELD_NEAR_ENTER_PX = 80;
-/** Distance the pointer must exceed before a faded composer fully restores. */
-export const COMPOSER_YIELD_NEAR_EXIT_PX = 96;
-/** Distance the pointer must clear a click-through composer by to restore. */
-export const COMPOSER_YIELD_OVER_EXIT_PX = 48;
-
-/** Shortest distance from a point to a rect's edge; <= 0 means inside. */
-export function distanceToRect(
-  x: number,
-  y: number,
-  rect: { left: number; top: number; right: number; bottom: number },
-): number {
-  const dx = Math.max(rect.left - x, 0, x - rect.right);
-  const dy = Math.max(rect.top - y, 0, y - rect.bottom);
-  if (dx === 0 && dy === 0) return 0;
-  return Math.hypot(dx, dy);
-}
-
-/** Next yield state for a pointer at `distance` px from the composer rect. */
-export function computeComposerYield(
-  prev: ComposerYieldState,
-  distance: number,
-): ComposerYieldState {
-  if (distance <= 0) return "over";
-  if (prev === "over") {
-    // Hysteresis: don't restore until the pointer has moved well away.
-    if (distance <= COMPOSER_YIELD_OVER_EXIT_PX) return "over";
-    return distance <= COMPOSER_YIELD_NEAR_EXIT_PX ? "near" : "none";
-  }
-  if (prev === "near") {
-    return distance <= COMPOSER_YIELD_NEAR_EXIT_PX ? "near" : "none";
-  }
-  return distance <= COMPOSER_YIELD_NEAR_ENTER_PX ? "near" : "none";
-}
+export * from '../../utils/composerYield';

package/components/html-viewer/hostThreads.ts

@@ -0,0 +1,37 @@
+/**
+ * Host-side helpers for the raw-HTML viewer, re-exported from
+ * `@plannotator/core/html-anchor` with the package's `Annotation` type.
+ *
+ * `projectHostThreads` turns a host's stored rows into the `annotations`
+ * prop (output order == marker numbering); `buildPersistedHtmlAnchor` trims a
+ * composed comment's anchor to a bounded record the host can persist. Both
+ * are pure and dependency-free (they live in `@plannotator/core`).
+ */
+import {
+  projectHostThreads as projectHostThreadsCore,
+  type HostThread,
+  type ProjectHostThreadsOptions,
+} from "@plannotator/core/html-anchor";
+import type { Annotation } from "../../types";
+
+export {
+  buildPersistedHtmlAnchor,
+  type BuildPersistedHtmlAnchorOptions,
+  type HostThread,
+  type PersistedHtmlAnchor,
+  type PersistedHtmlAnchorResult,
+  type ProjectHostThreadsOptions,
+} from "@plannotator/core/html-anchor";
+
+/**
+ * Project stored host rows onto the viewer's `annotations` prop, in the
+ * host's order (which becomes the marker numbering). See the core function
+ * for the projection rules; the `type` literals it emits are the string
+ * values of `AnnotationType`, so the cast below is representation-exact.
+ */
+export function projectHostThreads(
+  threads: readonly HostThread[],
+  options?: ProjectHostThreadsOptions,
+): Annotation[] {
+  return projectHostThreadsCore(threads, options) as unknown as Annotation[];
+}

package/components/html-viewer/index.ts

@@ -1 +1,10 @@
 export { HtmlViewer, type HtmlViewerProps } from "./HtmlViewer";
+export {
+  buildPersistedHtmlAnchor,
+  projectHostThreads,
+  type BuildPersistedHtmlAnchorOptions,
+  type HostThread,
+  type PersistedHtmlAnchor,
+  type PersistedHtmlAnchorResult,
+  type ProjectHostThreadsOptions,
+} from "./hostThreads";

package/components/html-viewer/unanchored.ts

@@ -0,0 +1,47 @@
+import { AnnotationType, type Annotation } from "../../types";
+
+/**
+ * A page-anchored row the viewer can never post to the bridge: nothing to
+ * find it by (no quoted text, no element anchor, no additional target
+ * anchor). Document-level comments are excluded on purpose: a
+ * GLOBAL_COMMENT has no page location by design and is not "unanchored".
+ */
+export function isTextlessPageAnnotation(annotation: Annotation): boolean {
+  if (annotation.type === AnnotationType.GLOBAL_COMMENT) return false;
+  if (annotation.originalText) return false;
+  if (annotation.htmlAnchor) return false;
+  return !(annotation.htmlAdditionalTargets ?? []).some((target) => !!target.anchor);
+}
+
+/**
+ * The host-facing unanchored set: the bridge's report (ids with no live
+ * representation on the page) completed with what the bridge cannot see.
+ *
+ * - Textless page rows are added: they were never posted, so the bridge
+ *   cannot report them, yet they have no marker and no highlight.
+ * - An id this viewer minted for a locally created comment (`create-mark`)
+ *   that the host never carried in `annotations`, or has since swapped out
+ *   for its own id, is dropped: the host holds no card for it, so naming it
+ *   would be noise. Every other bridge id passes through untouched, so a
+ *   host that paints through the imperative handle keeps today's delivery.
+ *
+ * Sorted and deduplicated like the bridge's own emission. With no textless
+ * rows and no swapped-out minted ids the result is exactly the bridge list.
+ */
+export function mergeUnanchoredIds(input: {
+  bridgeIds: readonly string[];
+  annotations: readonly Annotation[];
+  createdIds: ReadonlySet<string>;
+}): string[] {
+  const known = new Set<string>();
+  for (const annotation of input.annotations) known.add(annotation.id);
+  const out = new Set<string>();
+  for (const id of input.bridgeIds) {
+    if (input.createdIds.has(id) && !known.has(id)) continue;
+    out.add(id);
+  }
+  for (const annotation of input.annotations) {
+    if (isTextlessPageAnnotation(annotation)) out.add(annotation.id);
+  }
+  return [...out].sort();
+}