@beyondwork/docx-react-component 1.0.29 → 1.0.31

package/src/core/commands/structural-helpers.ts

@@ -0,0 +1,309 @@
+import {
+  createSelectionSnapshot,
+  type CanonicalDocumentEnvelope,
+  type SelectionSnapshot,
+} from "../state/editor-state.ts";
+import type { TransactionMapping } from "../selection/mapping.ts";
+import type {
+  DocumentRootNode,
+  ParagraphNode,
+  TableCellNode,
+  TableNode,
+  TableRowNode,
+} from "../../model/canonical-document.ts";
+import { createEditorSurfaceSnapshot } from "../../runtime/surface-projection.ts";
+
+export interface TopLevelParagraphScope {
+  kind: "top-level";
+  blockIndex: number;
+  paragraph: ParagraphNode;
+  paragraphStart: number;
+}
+
+export interface TableParagraphScope {
+  kind: "table-cell";
+  tableBlockIndex: number;
+  rowIndex: number;
+  cellIndex: number;
+  childIndex: number;
+  paragraph: ParagraphNode;
+  paragraphStart: number;
+}
+
+export type ParagraphScope = TopLevelParagraphScope | TableParagraphScope;
+
+export interface StructuralMutationResult {
+  changed: boolean;
+  document: CanonicalDocumentEnvelope;
+  selection: SelectionSnapshot;
+  mapping?: TransactionMapping;
+}
+
+const DEFAULT_TABLE_COLUMN_WIDTH = 2400;
+
+export function createNoopStructuralMutation(
+  document: CanonicalDocumentEnvelope,
+  selection: SelectionSnapshot,
+): StructuralMutationResult {
+  return {
+    changed: false,
+    document,
+    selection,
+  };
+}
+
+export function resolveParagraphScope(
+  document: CanonicalDocumentEnvelope,
+  selection: SelectionSnapshot,
+): ParagraphScope | null {
+  const root = asDocumentRoot(document);
+  if (!root) {
+    return null;
+  }
+
+  const surface = createEditorSurfaceSnapshot(document, selection);
+  const selectionFrom = Math.min(selection.anchor, selection.head);
+  const selectionTo = Math.max(selection.anchor, selection.head);
+
+  for (let blockIndex = 0; blockIndex < root.children.length; blockIndex += 1) {
+    const block = root.children[blockIndex];
+    const surfaceBlock = surface.blocks[blockIndex];
+
+    if (!surfaceBlock) {
+      continue;
+    }
+
+    if (
+      block.type === "paragraph" &&
+      surfaceBlock.kind === "paragraph" &&
+      selectionWithinRange(selectionFrom, selectionTo, surfaceBlock.from, surfaceBlock.to)
+    ) {
+      return {
+        kind: "top-level",
+        blockIndex,
+        paragraph: cloneParagraph(block),
+        paragraphStart: surfaceBlock.from,
+      };
+    }
+
+    if (block.type !== "table" || surfaceBlock.kind !== "table") {
+      continue;
+    }
+
+    for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex += 1) {
+      const row = block.rows[rowIndex];
+      const surfaceRow = surfaceBlock.rows[rowIndex];
+      if (!surfaceRow) {
+        continue;
+      }
+
+      for (let cellIndex = 0; cellIndex < row.cells.length; cellIndex += 1) {
+        const cell = row.cells[cellIndex];
+        const surfaceCell = surfaceRow.cells[cellIndex];
+        if (!surfaceCell) {
+          continue;
+        }
+
+        for (let childIndex = 0; childIndex < cell.children.length; childIndex += 1) {
+          const child = cell.children[childIndex];
+          const surfaceChild = surfaceCell.content[childIndex];
+          if (
+            child?.type === "paragraph" &&
+            surfaceChild?.kind === "paragraph" &&
+            selectionWithinRange(selectionFrom, selectionTo, surfaceChild.from, surfaceChild.to)
+          ) {
+            return {
+              kind: "table-cell",
+              tableBlockIndex: blockIndex,
+              rowIndex,
+              cellIndex,
+              childIndex,
+              paragraph: cloneParagraph(child),
+              paragraphStart: surfaceChild.from,
+            };
+          }
+        }
+      }
+    }
+  }
+
+  return null;
+}
+
+export function replaceParagraphScope(
+  document: CanonicalDocumentEnvelope,
+  scope: ParagraphScope,
+  replacementParagraphs: ParagraphNode[],
+): CanonicalDocumentEnvelope {
+  const root = asDocumentRoot(document);
+  if (!root) {
+    return document;
+  }
+
+  const nextRoot: DocumentRootNode =
+    scope.kind === "top-level"
+      ? {
+          ...root,
+          children: [
+            ...root.children.slice(0, scope.blockIndex),
+            ...replacementParagraphs,
+            ...root.children.slice(scope.blockIndex + 1),
+          ],
+        }
+      : {
+          ...root,
+          children: root.children.map((child, blockIndex) => {
+            if (blockIndex !== scope.tableBlockIndex || child.type !== "table") {
+              return child;
+            }
+
+            return {
+              ...child,
+              rows: child.rows.map((row, rowIndex) => {
+                if (rowIndex !== scope.rowIndex) {
+                  return row;
+                }
+
+                return {
+                  ...row,
+                  cells: row.cells.map((cell, cellIndex) => {
+                    if (cellIndex !== scope.cellIndex) {
+                      return cell;
+                    }
+
+                    return {
+                      ...cell,
+                      children: [
+                        ...cell.children.slice(0, scope.childIndex),
+                        ...replacementParagraphs,
+                        ...cell.children.slice(scope.childIndex + 1),
+                      ],
+                    };
+                  }),
+                };
+              }),
+            };
+          }),
+        };
+
+  return {
+    ...document,
+    content: nextRoot,
+  };
+}
+
+export function createEmptyParagraph(): ParagraphNode {
+  return {
+    type: "paragraph",
+    children: [],
+  };
+}
+
+export function createInsertedTableBlock(
+  rows: number,
+  columns: number,
+  styleId?: string,
+): TableNode {
+  const safeRows = Math.max(1, Math.floor(rows));
+  const safeColumns = Math.max(1, Math.floor(columns));
+  const nextRows: TableRowNode[] = [];
+
+  for (let rowIndex = 0; rowIndex < safeRows; rowIndex += 1) {
+    const cells: TableCellNode[] = [];
+    for (let columnIndex = 0; columnIndex < safeColumns; columnIndex += 1) {
+      cells.push({
+        type: "table_cell",
+        children: [createEmptyParagraph()],
+      });
+    }
+    nextRows.push({
+      type: "table_row",
+      cells,
+    });
+  }
+
+  return {
+    type: "table",
+    ...(styleId ? { styleId } : {}),
+    gridColumns: Array.from({ length: safeColumns }, () => DEFAULT_TABLE_COLUMN_WIDTH),
+    rows: nextRows,
+  };
+}
+
+export function resolveInsertedTableStyleId(
+  document: CanonicalDocumentEnvelope,
+): string | undefined {
+  const styles = document.styles?.tables;
+  if (!styles || typeof styles !== "object") {
+    return undefined;
+  }
+  return "TableGrid" in styles ? "TableGrid" : undefined;
+}
+
+export function findTableCellParagraphSelection(
+  document: CanonicalDocumentEnvelope,
+  tableBlockIndex: number,
+  rowIndex: number,
+  cellIndex: number,
+): SelectionSnapshot | null {
+  const surface = createEditorSurfaceSnapshot(document, createSelectionSnapshot(0, 0));
+  const tableBlock = surface.blocks[tableBlockIndex];
+  if (!tableBlock || tableBlock.kind !== "table") {
+    return null;
+  }
+
+  const paragraph = tableBlock.rows[rowIndex]?.cells[cellIndex]?.content.find(
+    (block) => block.kind === "paragraph",
+  );
+  if (!paragraph || paragraph.kind !== "paragraph") {
+    return null;
+  }
+
+  return createSelectionSnapshot(paragraph.from, paragraph.from);
+}
+
+export function findTopLevelParagraphSelectionNearBlock(
+  document: CanonicalDocumentEnvelope,
+  preferredBlockIndex: number,
+): SelectionSnapshot | null {
+  const surface = createEditorSurfaceSnapshot(document, createSelectionSnapshot(0, 0));
+
+  for (let index = preferredBlockIndex; index < surface.blocks.length; index += 1) {
+    const block = surface.blocks[index];
+    if (block?.kind === "paragraph") {
+      return createSelectionSnapshot(block.from, block.from);
+    }
+  }
+
+  for (let index = Math.min(preferredBlockIndex - 1, surface.blocks.length - 1); index >= 0; index -= 1) {
+    const block = surface.blocks[index];
+    if (block?.kind === "paragraph") {
+      return createSelectionSnapshot(block.from, block.from);
+    }
+  }
+
+  return null;
+}
+
+function asDocumentRoot(
+  document: CanonicalDocumentEnvelope,
+): DocumentRootNode | null {
+  const root = document.content;
+  if (!root || root.type !== "doc" || !Array.isArray(root.children)) {
+    return null;
+  }
+  return root;
+}
+
+function selectionWithinRange(
+  selectionFrom: number,
+  selectionTo: number,
+  rangeFrom: number,
+  rangeTo: number,
+): boolean {
+  return selectionFrom >= rangeFrom && selectionTo <= rangeTo;
+}
+
+function cloneParagraph(paragraph: ParagraphNode): ParagraphNode {
+  return structuredClone(paragraph) as ParagraphNode;
+}

package/{dist/core/commands/style-commands.cjs → src/core/commands/style-commands.ts}

@@ -1,61 +1,65 @@
-"use strict";
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, { get: all[name], enumerable: true });
-};
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/core/commands/style-commands.ts
-var style_commands_exports = {};
-__export(style_commands_exports, {
-  applyParagraphStyleToDocument: () => applyParagraphStyleToDocument,
-  applyTableStyleToDocument: () => applyTableStyleToDocument
-});
-module.exports = __toCommonJS(style_commands_exports);
-function applyParagraphStyleToDocument(document, snapshot, styleId) {
+import type {
+  PersistedEditorSnapshot,
+  RuntimeRenderSnapshot,
+  SurfaceBlockSnapshot,
+} from "../../api/public-types";
+import type {
+  BlockNode,
+  DocumentRootNode,
+  ParagraphNode,
+  TableNode,
+} from "../../model/canonical-document.ts";
+
+type CanonicalDocumentEnvelope = PersistedEditorSnapshot["canonicalDocument"];
+
+export interface StyleMutationResult {
+  document: CanonicalDocumentEnvelope;
+  selection: RuntimeRenderSnapshot["selection"];
+  changed: boolean;
+}
+
+export function applyParagraphStyleToDocument(
+  document: CanonicalDocumentEnvelope,
+  snapshot: RuntimeRenderSnapshot,
+  styleId: string | null,
+): StyleMutationResult {
   const surface = snapshot.surface;
   if (!surface) {
     return {
       document,
       selection: snapshot.selection,
-      changed: false
+      changed: false,
     };
   }
+
   const nextDocument = structuredClone(document);
-  const root = nextDocument.content;
+  const root = nextDocument.content as DocumentRootNode;
   const normalizedStyleId = normalizeStyleId(styleId);
   if (!isValidParagraphStyleId(document, normalizedStyleId)) {
     return {
       document,
       selection: snapshot.selection,
-      changed: false
+      changed: false,
     };
   }
   let changed = false;
+
   visitParagraphBindings(root.children, surface.blocks, (paragraph, paragraphSurface) => {
-    if (!selectionTouchesRange(
-      snapshot.selection.anchor,
-      snapshot.selection.head,
-      paragraphSurface.from,
-      paragraphSurface.to
-    )) {
+    if (
+      !selectionTouchesRange(
+        snapshot.selection.anchor,
+        snapshot.selection.head,
+        paragraphSurface.from,
+        paragraphSurface.to,
+      )
+    ) {
       return;
     }
+
     if (paragraph.styleId === normalizedStyleId) {
       return;
     }
+
     if (normalizedStyleId) {
       paragraph.styleId = normalizedStyleId;
     } else {
@@ -63,46 +67,59 @@ function applyParagraphStyleToDocument(document, snapshot, styleId) {
     }
     changed = true;
   });
+
   return {
     document: changed ? nextDocument : document,
     selection: snapshot.selection,
-    changed
+    changed,
   };
 }
-function applyTableStyleToDocument(document, snapshot, styleId) {
+
+export function applyTableStyleToDocument(
+  document: CanonicalDocumentEnvelope,
+  snapshot: RuntimeRenderSnapshot,
+  styleId: string | null,
+): StyleMutationResult {
   const surface = snapshot.surface;
   if (!surface) {
     return {
       document,
       selection: snapshot.selection,
-      changed: false
+      changed: false,
     };
   }
+
   const nextDocument = structuredClone(document);
-  const root = nextDocument.content;
+  const root = nextDocument.content as DocumentRootNode;
   const normalizedStyleId = normalizeStyleId(styleId);
   if (!isValidTableStyleId(document, normalizedStyleId)) {
     return {
       document,
       selection: snapshot.selection,
-      changed: false
+      changed: false,
     };
   }
   let changed = false;
   let applied = false;
+
   visitTableBindings(root.children, surface.blocks, (table, tableSurface) => {
-    if (applied || !selectionTouchesRange(
-      snapshot.selection.anchor,
-      snapshot.selection.head,
-      tableSurface.from,
-      tableSurface.to
-    )) {
+    if (
+      applied ||
+      !selectionTouchesRange(
+        snapshot.selection.anchor,
+        snapshot.selection.head,
+        tableSurface.from,
+        tableSurface.to,
+      )
+    ) {
       return;
     }
+
     if (table.styleId === normalizedStyleId) {
       applied = true;
       return;
     }
+
     if (normalizedStyleId) {
       table.styleId = normalizedStyleId;
     } else {
@@ -111,36 +128,53 @@ function applyTableStyleToDocument(document, snapshot, styleId) {
     changed = true;
     applied = true;
   });
+
   return {
     document: changed ? nextDocument : document,
     selection: snapshot.selection,
-    changed
+    changed,
   };
 }
-function normalizeStyleId(styleId) {
+
+function normalizeStyleId(styleId: string | null): string | undefined {
   if (styleId === null) {
-    return void 0;
+    return undefined;
   }
   const normalized = styleId.trim();
-  return normalized.length > 0 ? normalized : void 0;
+  return normalized.length > 0 ? normalized : undefined;
 }
-function isValidParagraphStyleId(document, styleId) {
-  return styleId === void 0 || Boolean(document.styles.paragraphs[styleId]);
+
+function isValidParagraphStyleId(
+  document: CanonicalDocumentEnvelope,
+  styleId: string | undefined,
+): boolean {
+  return styleId === undefined || Boolean(document.styles.paragraphs[styleId]);
 }
-function isValidTableStyleId(document, styleId) {
-  return styleId === void 0 || Boolean(document.styles.tables[styleId]);
+
+function isValidTableStyleId(
+  document: CanonicalDocumentEnvelope,
+  styleId: string | undefined,
+): boolean {
+  return styleId === undefined || Boolean(document.styles.tables[styleId]);
 }
-function visitParagraphBindings(blocks, surfaceBlocks, visitor) {
+
+function visitParagraphBindings(
+  blocks: BlockNode[],
+  surfaceBlocks: SurfaceBlockSnapshot[],
+  visitor: (paragraph: ParagraphNode, surface: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>) => void,
+): void {
   for (let index = 0; index < Math.min(blocks.length, surfaceBlocks.length); index += 1) {
     const block = blocks[index];
     const surface = surfaceBlocks[index];
     if (!block || !surface) {
       continue;
     }
+
     if (block.type === "paragraph" && surface.kind === "paragraph") {
       visitor(block, surface);
       continue;
     }
+
     if (block.type === "table" && surface.kind === "table") {
       for (let rowIndex = 0; rowIndex < Math.min(block.rows.length, surface.rows.length); rowIndex += 1) {
         const row = block.rows[rowIndex];
@@ -159,18 +193,25 @@ function visitParagraphBindings(blocks, surfaceBlocks, visitor) {
       }
       continue;
     }
+
     if (block.type === "sdt" && surface.kind === "sdt_block") {
       visitParagraphBindings(block.children, surface.children, visitor);
     }
   }
 }
-function visitTableBindings(blocks, surfaceBlocks, visitor) {
+
+function visitTableBindings(
+  blocks: BlockNode[],
+  surfaceBlocks: SurfaceBlockSnapshot[],
+  visitor: (table: TableNode, surface: Extract<SurfaceBlockSnapshot, { kind: "table" }>) => void,
+): void {
   for (let index = 0; index < Math.min(blocks.length, surfaceBlocks.length); index += 1) {
     const block = blocks[index];
     const surface = surfaceBlocks[index];
     if (!block || !surface) {
       continue;
     }
+
     if (block.type === "table" && surface.kind === "table") {
       visitor(block, surface);
       for (let rowIndex = 0; rowIndex < Math.min(block.rows.length, surface.rows.length); rowIndex += 1) {
@@ -190,12 +231,19 @@ function visitTableBindings(blocks, surfaceBlocks, visitor) {
       }
       continue;
     }
+
     if (block.type === "sdt" && surface.kind === "sdt_block") {
       visitTableBindings(block.children, surface.children, visitor);
     }
   }
 }
-function selectionTouchesRange(anchor, head, rangeFrom, rangeTo) {
+
+function selectionTouchesRange(
+  anchor: number,
+  head: number,
+  rangeFrom: number,
+  rangeTo: number,
+): boolean {
   const selectionFrom = Math.min(anchor, head);
   const selectionTo = Math.max(anchor, head);
   if (selectionFrom === selectionTo) {
@@ -203,12 +251,12 @@ function selectionTouchesRange(anchor, head, rangeFrom, rangeTo) {
   }
   return rangesOverlap(selectionFrom, selectionTo, rangeFrom, rangeTo);
 }
-function rangesOverlap(leftFrom, leftTo, rightFrom, rightTo) {
+
+function rangesOverlap(
+  leftFrom: number,
+  leftTo: number,
+  rightFrom: number,
+  rightTo: number,
+): boolean {
   return leftFrom < rightTo && leftTo > rightFrom;
 }
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  applyParagraphStyleToDocument,
-  applyTableStyleToDocument
-});
-//# sourceMappingURL=style-commands.cjs.map