@beyondwork/docx-react-component 1.0.1 → 1.0.3

package/src/core/selection/mapping.ts

@@ -0,0 +1,238 @@
+export type Position = number;
+export type Assoc = -1 | 1;
+
+export interface DocRange {
+  from: Position;
+  to: Position;
+}
+
+export interface BoundaryAssoc {
+  start: Assoc;
+  end: Assoc;
+}
+
+export interface RangeAnchor {
+  kind: "range";
+  range: DocRange;
+  assoc: BoundaryAssoc;
+}
+
+export interface NodeAnchor {
+  kind: "node";
+  at: Position;
+  assoc: Assoc;
+}
+
+export interface DetachedAnchor {
+  kind: "detached";
+  lastKnownRange: DocRange;
+  reason: "deleted" | "invalidatedByStructureChange" | "importAmbiguity";
+}
+
+export type EditorAnchorProjection = RangeAnchor | NodeAnchor | DetachedAnchor;
+
+export interface MappingStep {
+  from: Position;
+  to: Position;
+  insertSize: number;
+}
+
+export interface MappingResult {
+  position: Position;
+  deleted: boolean;
+}
+
+export interface TransactionMapping {
+  steps: MappingStep[];
+  metadata?: {
+    invalidatesStructures?: boolean;
+    affectsComments?: boolean;
+    affectsRevisions?: boolean;
+    affectsOpaqueFragments?: boolean;
+    [key: string]: unknown;
+  };
+}
+
+export const DEFAULT_BOUNDARY_ASSOC: BoundaryAssoc = {
+  start: 1,
+  end: -1,
+};
+
+export function createRangeAnchor(
+  from: Position,
+  to = from,
+  assoc: BoundaryAssoc = DEFAULT_BOUNDARY_ASSOC,
+): RangeAnchor {
+  return {
+    kind: "range",
+    range: normalizeRange({ from, to }),
+    assoc,
+  };
+}
+
+export function createNodeAnchor(at: Position, assoc: Assoc = 1): NodeAnchor {
+  return {
+    kind: "node",
+    at,
+    assoc,
+  };
+}
+
+export function createDetachedAnchor(
+  lastKnownRange: DocRange,
+  reason: DetachedAnchor["reason"],
+): DetachedAnchor {
+  return {
+    kind: "detached",
+    lastKnownRange: normalizeRange(lastKnownRange),
+    reason,
+  };
+}
+
+export function createEmptyMapping(): TransactionMapping {
+  return {
+    steps: [],
+  };
+}
+
+export function normalizeRange(range: DocRange): DocRange {
+  return range.from <= range.to
+    ? { from: range.from, to: range.to }
+    : { from: range.to, to: range.from };
+}
+
+export function mapPosition(
+  position: Position,
+  assoc: Assoc,
+  mapping: TransactionMapping,
+): MappingResult {
+  let mappedPosition = position;
+  let deleted = false;
+
+  for (const step of mapping.steps) {
+    const next = mapPositionThroughStep(mappedPosition, assoc, step);
+    mappedPosition = next.position;
+    deleted = deleted || next.deleted;
+  }
+
+  return {
+    position: mappedPosition,
+    deleted,
+  };
+}
+
+export function mapAnchor(
+  anchor: EditorAnchorProjection,
+  mapping: TransactionMapping,
+): EditorAnchorProjection {
+  if (anchor.kind === "detached") {
+    return anchor;
+  }
+
+  if (anchor.kind === "node") {
+    const mapped = mapPosition(anchor.at, anchor.assoc, mapping);
+
+    if (mapped.deleted) {
+      return createDetachedAnchor(
+        { from: anchor.at, to: anchor.at + 1 },
+        mapping.metadata?.invalidatesStructures
+          ? "invalidatedByStructureChange"
+          : "deleted",
+      );
+    }
+
+    return createNodeAnchor(mapped.position, anchor.assoc);
+  }
+
+  const from = mapPosition(anchor.range.from, anchor.assoc.start, mapping);
+  const to = mapPosition(anchor.range.to, anchor.assoc.end, mapping);
+  const mappedRange = normalizeRange({ from: from.position, to: to.position });
+
+  if (from.deleted && to.deleted && mappedRange.from === mappedRange.to) {
+    return createDetachedAnchor(
+      anchor.range,
+      mapping.metadata?.invalidatesStructures
+        ? "invalidatedByStructureChange"
+        : "deleted",
+    );
+  }
+
+  return createRangeAnchor(mappedRange.from, mappedRange.to, anchor.assoc);
+}
+
+export function mapRange(
+  range: DocRange,
+  assoc: BoundaryAssoc,
+  mapping: TransactionMapping,
+): RangeAnchor | DetachedAnchor {
+  const mapped = mapAnchor(createRangeAnchor(range.from, range.to, assoc), mapping);
+  return mapped.kind === "node" ? createRangeAnchor(mapped.at, mapped.at, assoc) : mapped;
+}
+
+export function areAnchorsEqual(
+  left: EditorAnchorProjection,
+  right: EditorAnchorProjection,
+): boolean {
+  if (left.kind !== right.kind) {
+    return false;
+  }
+
+  if (left.kind === "detached" && right.kind === "detached") {
+    return (
+      left.reason === right.reason &&
+      left.lastKnownRange.from === right.lastKnownRange.from &&
+      left.lastKnownRange.to === right.lastKnownRange.to
+    );
+  }
+
+  if (left.kind === "node" && right.kind === "node") {
+    return left.at === right.at && left.assoc === right.assoc;
+  }
+
+  if (left.kind === "range" && right.kind === "range") {
+    return (
+      left.range.from === right.range.from &&
+      left.range.to === right.range.to &&
+      left.assoc.start === right.assoc.start &&
+      left.assoc.end === right.assoc.end
+    );
+  }
+
+  return false;
+}
+
+function mapPositionThroughStep(
+  position: Position,
+  assoc: Assoc,
+  step: MappingStep,
+): MappingResult {
+  if (position < step.from) {
+    return { position, deleted: false };
+  }
+
+  if (position > step.to) {
+    return {
+      position: position + step.insertSize - (step.to - step.from),
+      deleted: false,
+    };
+  }
+
+  if (position === step.from) {
+    return {
+      position: assoc < 0 ? step.from : step.from + step.insertSize,
+      deleted: false,
+    };
+  }
+
+  if (position === step.to) {
+    return {
+      position: assoc < 0 ? step.from : step.from + step.insertSize,
+      deleted: false,
+    };
+  }
+
+  return {
+    position: assoc < 0 ? step.from : step.from + step.insertSize,
+    deleted: true,
+  };
+}

package/src/core/selection/review-anchors.ts

@@ -0,0 +1,94 @@
+import { parseTextStory } from "../schema/text-schema.ts";
+import {
+  DEFAULT_BOUNDARY_ASSOC,
+  createDetachedAnchor,
+  createRangeAnchor,
+  mapAnchor,
+  normalizeRange,
+  type BoundaryAssoc,
+  type DetachedAnchor,
+  type DocRange,
+  type EditorAnchorProjection,
+  type TransactionMapping,
+} from "./mapping.ts";
+
+export type ReviewAnchor = EditorAnchorProjection;
+
+export const COMMENT_RANGE_ASSOC: BoundaryAssoc = DEFAULT_BOUNDARY_ASSOC;
+
+export function createCommentReviewAnchor(
+  from: number,
+  to = from,
+  assoc: BoundaryAssoc = COMMENT_RANGE_ASSOC,
+): ReviewAnchor {
+  return createRangeAnchor(from, to, assoc);
+}
+
+export function detachReviewAnchor(
+  lastKnownRange: DocRange,
+  reason: DetachedAnchor["reason"],
+): DetachedAnchor {
+  return createDetachedAnchor(lastKnownRange, reason);
+}
+
+export function mapReviewAnchor(
+  anchor: ReviewAnchor,
+  mapping: TransactionMapping,
+): ReviewAnchor {
+  return mapAnchor(anchor, mapping);
+}
+
+export function getAnchorRange(anchor: ReviewAnchor): DocRange {
+  if (anchor.kind === "range") {
+    return normalizeRange(anchor.range);
+  }
+
+  if (anchor.kind === "node") {
+    return { from: anchor.at, to: anchor.at };
+  }
+
+  return normalizeRange(anchor.lastKnownRange);
+}
+
+export function mappingTouchesAnchorContent(
+  anchor: ReviewAnchor,
+  mapping: TransactionMapping,
+): boolean {
+  const range = getAnchorRange(anchor);
+
+  if (range.from === range.to) {
+    return mapping.steps.some(
+      (step) => step.from <= range.from && step.to >= range.to,
+    );
+  }
+
+  return mapping.steps.some(
+    (step) => step.from < range.to && step.to > range.from,
+  );
+}
+
+export function rangeStaysWithinSingleParagraph(
+  content: unknown,
+  range: DocRange,
+): boolean {
+  const normalized = normalizeRange(range);
+  if (normalized.from === normalized.to) {
+    return true;
+  }
+
+  const story = parseTextStory(content);
+  const upperBound = Math.min(normalized.to, story.units.length);
+
+  for (let index = Math.max(0, normalized.from); index < upperBound; index += 1) {
+    const unit = story.units[index];
+    if (!unit) {
+      continue;
+    }
+
+    if (unit.kind === "paragraph_break" || unit.kind === "opaque_block") {
+      return false;
+    }
+  }
+
+  return true;
+}

package/src/core/state/README.md

@@ -0,0 +1,3 @@
+# Core State
+
+Canonical state containers, selectors, and structural invariants belong here.