@beyondwork/docx-react-component 1.0.12 → 1.0.14

package/src/formats/xlsx/model/sheet.ts

@@ -5,7 +5,7 @@
  * explicit style are stored. Row and column metadata is also sparse.
  */
 
-import type { CellAddress, CellKey, CellValue, ColIndex, RowIndex } from "./cell.ts";
+import type { CellAddress, CellKey, CellValue, ColIndex, RowIndex, StyleRef } from "./cell.ts";
 import { cellKey } from "./cell.ts";
 
 export type { ColIndex, RowIndex } from "./cell.ts";
@@ -23,6 +23,8 @@ export interface RowProperties {
   hidden?: boolean;
   /** Whether the row height was set via customHeight attribute. */
   customHeight?: boolean;
+  /** Style index reference applied at the row level, if present. */
+  styleRef?: StyleRef;
 }
 
 export interface ColProperties {
@@ -34,6 +36,8 @@ export interface ColProperties {
   hidden?: boolean;
   /** Whether the width was explicitly customized. */
   customWidth?: boolean;
+  /** Style index reference applied at the column level, if present. */
+  styleRef?: StyleRef;
 }
 
 // ---------------------------------------------------------------------------
@@ -164,6 +168,60 @@ export function getCell(
   return sheet.cells.get(cellKey(row, col));
 }
 
+/**
+ * Set sparse row metadata.
+ * Passing `undefined`, or only default fields, removes the row entry.
+ */
+export function setRowProperties(
+  sheet: CanonicalSheet,
+  rowIndex: RowIndex,
+  props: Omit<RowProperties, "rowIndex"> | undefined,
+): void {
+  if (!props || isDefaultRowProperties(props)) {
+    sheet.rowProps.delete(rowIndex);
+    return;
+  }
+
+  sheet.rowProps.set(rowIndex, {
+    rowIndex,
+    ...props,
+  });
+}
+
+export function getRowProperties(
+  sheet: CanonicalSheet,
+  rowIndex: RowIndex,
+): RowProperties | undefined {
+  return sheet.rowProps.get(rowIndex);
+}
+
+/**
+ * Set sparse column metadata.
+ * Passing `undefined`, or only default fields, removes the column entry.
+ */
+export function setColProperties(
+  sheet: CanonicalSheet,
+  colIndex: ColIndex,
+  props: Omit<ColProperties, "colIndex"> | undefined,
+): void {
+  if (!props || isDefaultColProperties(props)) {
+    sheet.colProps.delete(colIndex);
+    return;
+  }
+
+  sheet.colProps.set(colIndex, {
+    colIndex,
+    ...props,
+  });
+}
+
+export function getColProperties(
+  sheet: CanonicalSheet,
+  colIndex: ColIndex,
+): ColProperties | undefined {
+  return sheet.colProps.get(colIndex);
+}
+
 /**
  * Return the effective address bounds for all occupied cells.
  * Returns `null` when the sheet has no cells.
@@ -244,3 +302,25 @@ export function findMergesContaining(
       col <= m.endCol,
   );
 }
+
+function isDefaultRowProperties(
+  props: Omit<RowProperties, "rowIndex">,
+): boolean {
+  return (
+    props.heightPt === undefined &&
+    props.hidden === undefined &&
+    props.customHeight === undefined &&
+    props.styleRef === undefined
+  );
+}
+
+function isDefaultColProperties(
+  props: Omit<ColProperties, "colIndex">,
+): boolean {
+  return (
+    props.widthChars === undefined &&
+    props.hidden === undefined &&
+    props.customWidth === undefined &&
+    props.styleRef === undefined
+  );
+}

package/src/formats/xlsx/model/workbook.ts

@@ -158,15 +158,15 @@ export function addSheet(
   }
   const orderIndex =
     atIndex !== undefined
-      ? Math.min(atIndex, workbook.sheetOrder.length)
+      ? clampSheetIndex(atIndex, workbook.sheetOrder.length)
       : workbook.sheetOrder.length;
   const sheet = createSheet(sheetId, name, orderIndex);
   workbook.sheets.set(sheetId, sheet);
 
-  if (atIndex !== undefined && atIndex < workbook.sheetOrder.length) {
-    workbook.sheetOrder.splice(atIndex, 0, sheetId);
+  if (atIndex !== undefined && orderIndex < workbook.sheetOrder.length) {
+    workbook.sheetOrder.splice(orderIndex, 0, sheetId);
     // Reindex sheets after the insertion point
-    for (let i = atIndex + 1; i < workbook.sheetOrder.length; i++) {
+    for (let i = orderIndex + 1; i < workbook.sheetOrder.length; i++) {
       const id = workbook.sheetOrder[i];
       const s = workbook.sheets.get(id);
       if (s) s.orderIndex = i;
@@ -258,10 +258,10 @@ export function moveSheet(
 ): void {
   const currentIndex = workbook.sheetOrder.indexOf(sheetId);
   if (currentIndex === -1) throw new Error(`Sheet not found: ${sheetId}`);
-  if (currentIndex === toIndex) return;
+  const clampedTarget = clampSheetIndex(toIndex, workbook.sheetOrder.length - 1);
+  if (currentIndex === clampedTarget) return;
 
   workbook.sheetOrder.splice(currentIndex, 1);
-  const clampedTarget = Math.min(toIndex, workbook.sheetOrder.length);
   workbook.sheetOrder.splice(clampedTarget, 0, sheetId);
 
   // Reindex all sheets
@@ -272,6 +272,10 @@ export function moveSheet(
   }
 }
 
+function clampSheetIndex(index: number, maxIndex: number): number {
+  return Math.max(0, Math.min(index, maxIndex));
+}
+
 // ---------------------------------------------------------------------------
 // Shared string table helpers
 // ---------------------------------------------------------------------------

package/src/runtime/document-runtime.ts

@@ -41,6 +41,7 @@ import {
   createRangeAnchor,
   type EditorAnchorProjection as InternalEditorAnchorProjection,
 } from "../core/selection/mapping.ts";
+import { canCreateDocxCommentAnchor } from "../core/selection/review-anchors.ts";
 import { createCommentSidebarProjection } from "../review/store/comment-store.ts";
 import { createCommentStoreFromRuntimeComments } from "../review/store/runtime-comment-store.ts";
 import {
@@ -212,6 +213,18 @@ export function createDocumentRuntime(
       const anchor = params.anchor
         ? toInternalAnchorProjection(params.anchor)
         : state.selection.activeRange;
+      if (!canCreateDocxCommentAnchor(state.document.content, anchor)) {
+        const message =
+          "DOCX comments must use a non-empty range that stays within a single paragraph.";
+        emitError({
+          errorId: createSessionId("comment-anchor", clock()),
+          code: "validation_failed",
+          isFatal: false,
+          message,
+          source: "runtime",
+        });
+        throw new Error(message);
+      }
       const authorId = params.authorId ?? options.defaultAuthorId ?? "unknown";
       const createdAt = clock();
       const entries: CommentEntryRecord[] = [

package/src/runtime/session-capabilities.ts

@@ -1,4 +1,10 @@
 import type { RuntimeRenderSnapshot } from "../api/public-types";
+import {
+  createDetachedAnchor,
+  createNodeAnchor,
+  createRangeAnchor,
+} from "../core/selection/mapping.ts";
+import { canCreateDocxCommentAnchor } from "../core/selection/review-anchors";
 
 /**
  * Session capabilities derived from the runtime snapshot.
@@ -80,7 +86,11 @@ export function deriveCapabilities(
   const canEdit = isReady && !isReadOnly && !hasFatalError;
   const canUndo = snapshot.commandState.canUndo && canEdit;
   const canRedo = snapshot.commandState.canRedo && canEdit;
-  const canAddComment = canEdit && !snapshot.selection.isCollapsed;
+  const canAddComment =
+    canEdit &&
+    !snapshot.selection.isCollapsed &&
+    Boolean(snapshot.surface) &&
+    canCreateDocxCommentAnchor(snapshot.surface, toRuntimeAnchor(snapshot.selection.activeRange));
   const canExport = isReady && !exportBlocked && !hasFatalError;
 
   // Revision capabilities
@@ -136,3 +146,14 @@ export function deriveCapabilities(
     hasFatalError,
   };
 }
+
+function toRuntimeAnchor(anchor: RuntimeRenderSnapshot["selection"]["activeRange"]) {
+  switch (anchor.kind) {
+    case "range":
+      return createRangeAnchor(anchor.from, anchor.to, anchor.assoc);
+    case "node":
+      return createNodeAnchor(anchor.at, anchor.assoc);
+    case "detached":
+      return createDetachedAnchor(anchor.lastKnownRange, anchor.reason);
+  }
+}

package/src/runtime/surface-projection.ts

@@ -226,6 +226,7 @@ function createTableBlock(
         verticalMerge: cell.verticalMerge ?? null,
         colspan: cell.gridSpan ?? 1,
         rowspan: rowSpans.get(`${rowIndex}:${cellIndex}`) ?? 1,
+        ...(cell.shading?.fill ? { backgroundColor: `#${cell.shading.fill}` } : {}),
         content: cellContent,
       });
     }

package/src/runtime/table-commands.ts

@@ -11,6 +11,7 @@
 
 import type { Command as PMCommand, EditorState } from "prosemirror-state";
 import {
+  CellSelection,
   TableMap,
   addColumnAfter as pmAddColumnAfter,
   addColumnBefore as pmAddColumnBefore,
@@ -21,10 +22,13 @@ import {
   deleteTable,
   goToNextCell,
   mergeCells,
+  selectedRect,
+  selectionCell,
   splitCell,
   toggleHeaderCell,
   toggleHeaderColumn,
   toggleHeaderRow,
+  findTable,
 } from "prosemirror-tables";
 
 // prosemirror-tables does not export goToPreviousCell; replicate via direction -1.
@@ -33,6 +37,25 @@ const goToPreviousCell: PMCommand = (state, dispatch, view) =>
 
 export type { Command as TableCommand } from "prosemirror-state";
 
+export interface TableSelectionDescriptor {
+  tableBlockIndex: number;
+  selectionKind: "text" | "cell";
+  anchorCell: {
+    rowIndex: number;
+    columnIndex: number;
+  };
+  headCell: {
+    rowIndex: number;
+    columnIndex: number;
+  };
+  rect: {
+    top: number;
+    left: number;
+    bottom: number;
+    right: number;
+  };
+}
+
 function tableAtSelection(state: EditorState) {
   const { $head } = state.selection;
   for (let depth = $head.depth; depth > 0; depth -= 1) {
@@ -92,3 +115,59 @@ export {
   goToNextCell,
   goToPreviousCell,
 };
+
+export function getTableSelectionDescriptor(
+  state: EditorState,
+): TableSelectionDescriptor | null {
+  const tableInfo = findTable(state.selection.$from);
+  if (!tableInfo) {
+    return null;
+  }
+
+  const tableBlockIndex = resolveTopLevelTableIndex(state, tableInfo.pos);
+  if (tableBlockIndex < 0) {
+    return null;
+  }
+
+  const rect = selectedRect(state);
+  const isCellSelection = state.selection instanceof CellSelection;
+  const anchorCellPos = (
+    isCellSelection ? (state.selection as CellSelection).$anchorCell : selectionCell(state)
+  ).pos - rect.tableStart;
+  const headCellPos = (
+    isCellSelection ? (state.selection as CellSelection).$headCell : selectionCell(state)
+  ).pos - rect.tableStart;
+  const anchorRect = rect.map.findCell(anchorCellPos);
+  const headRect = rect.map.findCell(headCellPos);
+
+  return {
+    tableBlockIndex,
+    selectionKind: isCellSelection ? "cell" : "text",
+    anchorCell: {
+      rowIndex: anchorRect.top,
+      columnIndex: anchorRect.left,
+    },
+    headCell: {
+      rowIndex: headRect.top,
+      columnIndex: headRect.left,
+    },
+    rect: {
+      top: rect.top,
+      left: rect.left,
+      bottom: rect.bottom,
+      right: rect.right,
+    },
+  };
+}
+
+function resolveTopLevelTableIndex(state: EditorState, tablePos: number): number {
+  let index = -1;
+
+  state.doc.forEach((node, offset, currentIndex) => {
+    if (offset === tablePos && node.type.spec.tableRole === "table") {
+      index = currentIndex;
+    }
+  });
+
+  return index;
+}

package/src/runtime/table-schema.ts

@@ -17,6 +17,7 @@ type TableCellAttrs = {
   colwidth?: number[] | null;
   gridSpan?: number | null;
   verticalMerge?: "restart" | "continue" | null;
+  backgroundColor?: string | null;
 };
 
 function resolveRenderedColspan(attrs: {
@@ -52,6 +53,8 @@ function getCellAttrs(dom: HTMLElement): TableCellAttrs {
   const gridSpanAttr = dom.getAttribute("data-grid-span");
   const verticalMergeAttr = dom.getAttribute("data-vertical-merge");
   const gridSpan = gridSpanAttr ? Number.parseInt(gridSpanAttr, 10) : colspan;
+  const backgroundColor =
+    dom.getAttribute("data-cell-background") ?? dom.style.backgroundColor ?? null;
 
   return {
     colspan,
@@ -62,6 +65,7 @@ function getCellAttrs(dom: HTMLElement): TableCellAttrs {
       verticalMergeAttr === "restart" || verticalMergeAttr === "continue"
         ? verticalMergeAttr
         : null,
+    backgroundColor,
   };
 }
 
@@ -85,6 +89,10 @@ function setCellDomAttrs(nodeAttrs: TableCellAttrs, className: string): Record<s
   if (nodeAttrs.verticalMerge) {
     attrs["data-vertical-merge"] = nodeAttrs.verticalMerge;
   }
+  if (nodeAttrs.backgroundColor) {
+    attrs["data-cell-background"] = nodeAttrs.backgroundColor;
+    attrs.style = `background-color: ${nodeAttrs.backgroundColor}`;
+  }
 
   return attrs;
 }
@@ -117,6 +125,7 @@ const tableCellSpecAttrs = {
   colspan: { default: 1, validate: "number" },
   rowspan: { default: 1, validate: "number" },
   colwidth: { default: null, validate: validateColwidth },
+  backgroundColor: { default: null },
 } as const;
 
 export const tableNodeSpec: NodeSpec = {