@beyondwork/docx-react-component 1.0.18 → 1.0.19

package/src/core/commands/paragraph-layout-commands.ts

@@ -0,0 +1,339 @@
+import type {
+  RuntimeRenderSnapshot,
+  SurfaceBlockSnapshot,
+} from "../../api/public-types";
+import type {
+  BlockNode,
+  CanonicalDocument as CanonicalDocumentEnvelope,
+  ParagraphIndentation,
+  ParagraphNode,
+  TabStop,
+  TableCellNode,
+  TableNode,
+  TableRowNode,
+} from "../../model/canonical-document.ts";
+
+export interface ParagraphLayoutCommandContext {
+  timestamp: string;
+}
+
+export interface ParagraphLayoutMutationResult {
+  document: CanonicalDocumentEnvelope;
+  selection: RuntimeRenderSnapshot["selection"];
+  changed: boolean;
+}
+
+export function setActiveParagraphIndentation(
+  document: CanonicalDocumentEnvelope,
+  snapshot: RuntimeRenderSnapshot,
+  indentation: ParagraphIndentation,
+  _context: ParagraphLayoutCommandContext,
+): ParagraphLayoutMutationResult {
+  return mutateActiveParagraph(document, snapshot, (paragraph) => {
+    const nextIndentation = mergeIndentationPatch(paragraph.indentation, indentation);
+    if (indentationEquals(paragraph.indentation, nextIndentation)) {
+      return false;
+    }
+    if (nextIndentation) {
+      paragraph.indentation = nextIndentation;
+    } else {
+      delete paragraph.indentation;
+    }
+    return true;
+  });
+}
+
+export function setActiveParagraphTabStops(
+  document: CanonicalDocumentEnvelope,
+  snapshot: RuntimeRenderSnapshot,
+  tabStops: ReadonlyArray<{ pos: number; val?: string; leader?: string }>,
+  _context: ParagraphLayoutCommandContext,
+): ParagraphLayoutMutationResult {
+  return mutateActiveParagraph(document, snapshot, (paragraph) => {
+    const nextTabStops = normalizeTabStops(tabStops);
+    if (tabStopsEqual(paragraph.tabStops, nextTabStops)) {
+      return false;
+    }
+    if (nextTabStops.length > 0) {
+      paragraph.tabStops = nextTabStops;
+    } else {
+      delete paragraph.tabStops;
+    }
+    return true;
+  });
+}
+
+function mutateActiveParagraph(
+  document: CanonicalDocumentEnvelope,
+  snapshot: RuntimeRenderSnapshot,
+  mutate: (paragraph: ParagraphNode) => boolean,
+): ParagraphLayoutMutationResult {
+  const surface = snapshot.surface;
+  if (!surface) {
+    return {
+      document,
+      selection: snapshot.selection,
+      changed: false,
+    };
+  }
+
+  const paragraphIndex = resolveActiveParagraphIndex(surface.blocks, snapshot.selection);
+  if (paragraphIndex === null) {
+    return {
+      document,
+      selection: snapshot.selection,
+      changed: false,
+    };
+  }
+
+  const working = structuredClone(document) as CanonicalDocumentEnvelope;
+  const paragraphs = collectCanonicalParagraphs(working.content.children);
+  const target = paragraphs[paragraphIndex];
+  if (!target) {
+    return {
+      document,
+      selection: snapshot.selection,
+      changed: false,
+    };
+  }
+
+  const changed = mutate(target);
+  return {
+    document: changed ? working : document,
+    selection: snapshot.selection,
+    changed,
+  };
+}
+
+export function resolveActiveParagraphIndex(
+  blocks: readonly SurfaceBlockSnapshot[],
+  selection: RuntimeRenderSnapshot["selection"],
+): number | null {
+  const paragraphs = collectSurfaceParagraphs(blocks);
+  if (paragraphs.length === 0) {
+    return null;
+  }
+
+  if (selection.activeRange.kind === "node") {
+    const nodePosition = selection.activeRange.at;
+    const nodeIndex = paragraphs.findIndex(
+      (paragraph) => nodePosition >= paragraph.from && nodePosition <= paragraph.to,
+    );
+    if (nodeIndex >= 0) {
+      return nodeIndex;
+    }
+  }
+
+  const selectionFrom = Math.min(selection.anchor, selection.head);
+  const selectionTo = Math.max(selection.anchor, selection.head);
+
+  const exactIndex = paragraphs.findIndex((paragraph) =>
+    selection.isCollapsed
+      ? selection.head >= paragraph.from && selection.head <= paragraph.to
+      : selectionFrom < paragraph.to && paragraph.from < selectionTo,
+  );
+  if (exactIndex >= 0) {
+    return exactIndex;
+  }
+
+  return null;
+}
+
+function collectSurfaceParagraphs(
+  blocks: readonly SurfaceBlockSnapshot[],
+  output: Array<Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>> = [],
+): Array<Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>> {
+  for (const block of blocks) {
+    if (block.kind === "paragraph") {
+      output.push(block);
+      continue;
+    }
+    if (block.kind === "table") {
+      for (const row of block.rows) {
+        for (const cell of row.cells) {
+          collectSurfaceParagraphs(cell.content, output);
+        }
+      }
+      continue;
+    }
+    if (block.kind === "sdt_block") {
+      collectSurfaceParagraphs(block.children, output);
+    }
+  }
+  return output;
+}
+
+function collectCanonicalParagraphs(
+  blocks: readonly BlockNode[],
+  output: ParagraphNode[] = [],
+): ParagraphNode[] {
+  for (const block of blocks) {
+    switch (block.type) {
+      case "paragraph":
+        output.push(block);
+        break;
+      case "table":
+        collectParagraphsFromTable(block, output);
+        break;
+      case "sdt":
+        collectCanonicalParagraphs(block.children, output);
+        break;
+      case "custom_xml":
+        // `custom_xml` wrappers are projected as preserve-only opaque blocks on
+        // the live surface, so their hidden descendants must stay out of the
+        // paragraph mutation index or surface/canonical ordinals drift.
+        break;
+      default:
+        break;
+    }
+  }
+  return output;
+}
+
+function collectParagraphsFromTable(table: TableNode, output: ParagraphNode[]): void {
+  for (const row of table.rows) {
+    collectParagraphsFromRow(row, output);
+  }
+}
+
+function collectParagraphsFromRow(row: TableRowNode, output: ParagraphNode[]): void {
+  for (const cell of row.cells) {
+    collectParagraphsFromCell(cell, output);
+  }
+}
+
+function collectParagraphsFromCell(cell: TableCellNode, output: ParagraphNode[]): void {
+  collectCanonicalParagraphs(cell.children, output);
+}
+
+function mergeIndentationPatch(
+  current: ParagraphIndentation | undefined,
+  patch: ParagraphIndentation,
+): ParagraphIndentation | undefined {
+  const merged: ParagraphIndentation = {
+    ...(current ?? {}),
+  };
+
+  if ("left" in patch) {
+    merged.left = patch.left;
+  }
+  if ("right" in patch) {
+    merged.right = patch.right;
+  }
+  if ("firstLine" in patch) {
+    merged.firstLine = patch.firstLine;
+    if (!("hanging" in patch)) {
+      delete merged.hanging;
+    }
+  }
+  if ("hanging" in patch) {
+    merged.hanging = patch.hanging;
+    if (!("firstLine" in patch)) {
+      delete merged.firstLine;
+    }
+  }
+
+  return normalizeIndentation(merged);
+}
+
+function normalizeIndentation(
+  indentation: ParagraphIndentation,
+): ParagraphIndentation | undefined {
+  const normalized: ParagraphIndentation = {};
+  if (indentation.left !== undefined && indentation.left > 0) {
+    normalized.left = Math.round(indentation.left);
+  }
+  if (indentation.right !== undefined && indentation.right > 0) {
+    normalized.right = Math.round(indentation.right);
+  }
+  if (indentation.firstLine !== undefined && indentation.firstLine > 0) {
+    normalized.firstLine = Math.round(indentation.firstLine);
+  }
+  if (indentation.hanging !== undefined && indentation.hanging > 0) {
+    normalized.hanging = Math.round(indentation.hanging);
+    delete normalized.firstLine;
+  }
+  return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+
+function indentationEquals(
+  left: ParagraphIndentation | undefined,
+  right: ParagraphIndentation | undefined,
+): boolean {
+  return (
+    (left?.left ?? 0) === (right?.left ?? 0) &&
+    (left?.right ?? 0) === (right?.right ?? 0) &&
+    (left?.firstLine ?? 0) === (right?.firstLine ?? 0) &&
+    (left?.hanging ?? 0) === (right?.hanging ?? 0)
+  );
+}
+
+function normalizeTabStops(
+  tabStops: ReadonlyArray<{ pos: number; val?: string; leader?: string }>,
+): TabStop[] {
+  const seen = new Set<number>();
+  const normalized = [...tabStops]
+    .map((tabStop) => ({
+      position: Math.max(0, Math.round(tabStop.pos)),
+      align: normalizeTabAlign(tabStop.val),
+      ...(normalizeTabLeader(tabStop.leader)
+        ? { leader: normalizeTabLeader(tabStop.leader) }
+        : {}),
+    }))
+    .filter((tabStop) => {
+      if (seen.has(tabStop.position)) {
+        return false;
+      }
+      seen.add(tabStop.position);
+      return true;
+    })
+    .sort((left, right) => left.position - right.position);
+
+  return normalized;
+}
+
+function normalizeTabAlign(value: string | undefined): TabStop["align"] {
+  switch (value) {
+    case "center":
+    case "right":
+    case "decimal":
+    case "bar":
+    case "clear":
+      return value;
+    default:
+      return "left";
+  }
+}
+
+function normalizeTabLeader(value: string | undefined): TabStop["leader"] | undefined {
+  switch (value) {
+    case "none":
+    case "dot":
+    case "hyphen":
+    case "underscore":
+    case "heavy":
+    case "middleDot":
+      return value;
+    default:
+      return undefined;
+  }
+}
+
+function tabStopsEqual(
+  left: readonly TabStop[] | undefined,
+  right: readonly TabStop[] | undefined,
+): boolean {
+  const normalizedLeft = left ?? [];
+  const normalizedRight = right ?? [];
+  if (normalizedLeft.length !== normalizedRight.length) {
+    return false;
+  }
+  return normalizedLeft.every((tabStop, index) => {
+    const other = normalizedRight[index];
+    return (
+      tabStop.position === other?.position &&
+      (tabStop.align ?? "left") === (other?.align ?? "left") &&
+      (tabStop.leader ?? "") === (other?.leader ?? "")
+    );
+  });
+}