@beyondwork/docx-react-component 1.0.29 → 1.0.31

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

@@ -0,0 +1,183 @@
+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 surfaceBlocks = readSurfaceBlocks(content);
+  if (surfaceBlocks) {
+    return surfaceBlocks.some(
+      (block) =>
+        block.kind === "paragraph" &&
+        normalized.from >= block.from &&
+        normalized.to <= block.to,
+    );
+  }
+
+  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;
+}
+
+export function canCreateDocxCommentAnchor(
+  content: unknown,
+  anchor: ReviewAnchor,
+): boolean {
+  if (anchor.kind !== "range") {
+    return false;
+  }
+
+  const normalized = normalizeRange(anchor.range);
+  if (normalized.from === normalized.to) {
+    return false;
+  }
+
+  return rangeStaysWithinSingleParagraph(content, normalized);
+}
+
+function readSurfaceBlocks(
+  content: unknown,
+): Array<{ kind: string; from: number; to: number }> | undefined {
+  if (!content || typeof content !== "object" || !("blocks" in content)) {
+    return undefined;
+  }
+
+  const blocks = (content as { blocks?: unknown }).blocks;
+  if (!Array.isArray(blocks)) {
+    return undefined;
+  }
+
+  const normalized = flattenSurfaceBlocks(blocks);
+
+  return normalized.length > 0 ? normalized : undefined;
+}
+
+function flattenSurfaceBlocks(
+  blocks: unknown[],
+): Array<{ kind: string; from: number; to: number }> {
+  const flattened: Array<{ kind: string; from: number; to: number }> = [];
+
+  for (const block of blocks) {
+    if (
+      !block ||
+      typeof block !== "object" ||
+      typeof (block as { kind?: unknown }).kind !== "string" ||
+      typeof (block as { from?: unknown }).from !== "number" ||
+      typeof (block as { to?: unknown }).to !== "number"
+    ) {
+      continue;
+    }
+
+    flattened.push({
+      kind: (block as { kind: string }).kind,
+      from: (block as { from: number }).from,
+      to: (block as { to: number }).to,
+    });
+
+    if (
+      (block as { kind: string }).kind === "table" &&
+      Array.isArray((block as { rows?: unknown }).rows)
+    ) {
+      for (const row of (block as { rows: Array<{ cells?: unknown[] }> }).rows) {
+        for (const cell of row.cells ?? []) {
+          if (cell && typeof cell === "object" && Array.isArray((cell as { content?: unknown[] }).content)) {
+            flattened.push(...flattenSurfaceBlocks((cell as { content: unknown[] }).content));
+          }
+        }
+      }
+    }
+
+    if (
+      (block as { kind: string }).kind === "sdt_block" &&
+      Array.isArray((block as { children?: unknown[] }).children)
+    ) {
+      flattened.push(...flattenSurfaceBlocks((block as { children: unknown[] }).children));
+    }
+  }
+
+  return flattened;
+}

package/src/core/state/README.md

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