@beyondwork/docx-react-component 1.0.12 → 1.0.14

package/src/core/commands/text-commands.ts

@@ -1,8 +1,23 @@
-import type { CanonicalDocumentEnvelope, SelectionSnapshot } from "../state/editor-state.ts";
+import type { InsertTableOptions } from "../../api/public-types";
+import type { ParagraphNode } from "../../model/canonical-document.ts";
+import {
+  createSelectionSnapshot,
+  type CanonicalDocumentEnvelope,
+  type SelectionSnapshot,
+} from "../state/editor-state.ts";
 import {
   applyTextTransaction,
   type TextTransactionResult,
 } from "../state/text-transaction.ts";
+import {
+  createInsertedTableBlock,
+  createNoopStructuralMutation,
+  findTableCellParagraphSelection,
+  replaceParagraphScope,
+  resolveInsertedTableStyleId,
+  resolveParagraphScope,
+  type StructuralMutationResult,
+} from "./structural-helpers.ts";
 
 export interface TextCommandContext {
   timestamp: string;
@@ -117,3 +132,153 @@ export function splitParagraph(
     context,
   );
 }
+
+export function insertPageBreak(
+  document: CanonicalDocumentEnvelope,
+  selection: SelectionSnapshot,
+  context: TextCommandContext,
+): StructuralMutationResult {
+  const scope = resolveParagraphScope(document, selection);
+  if (!scope) {
+    return createNoopStructuralMutation(document, selection);
+  }
+
+  const localDocument: CanonicalDocumentEnvelope = {
+    ...document,
+    content: {
+      type: "doc",
+      children: [scope.paragraph],
+    },
+  };
+  const localSelection = createSelectionSnapshot(
+    selection.anchor - scope.paragraphStart,
+    selection.head - scope.paragraphStart,
+  );
+  const splitResult = splitParagraph(localDocument, localSelection, context);
+  const splitRoot = splitResult.document.content;
+  if (!splitRoot || splitRoot.type !== "doc") {
+    return createNoopStructuralMutation(document, selection);
+  }
+
+  const replacementParagraphs = splitRoot.children
+    .filter((block): block is ParagraphNode => block.type === "paragraph")
+    .map((block, index) =>
+      index === 1
+        ? {
+            ...block,
+            pageBreakBefore: true,
+          }
+        : block,
+    );
+  if (replacementParagraphs.length < 2) {
+    return createNoopStructuralMutation(document, selection);
+  }
+
+  const nextDocument = replaceParagraphScope(document, scope, replacementParagraphs);
+  return {
+    changed: true,
+    document: {
+      ...nextDocument,
+      updatedAt: context.timestamp,
+    },
+    selection: createSelectionSnapshot(
+      splitResult.selection.anchor + scope.paragraphStart,
+      splitResult.selection.head + scope.paragraphStart,
+    ),
+    mapping: {
+      ...splitResult.mapping,
+      steps: splitResult.mapping.steps.map((step) => ({
+        ...step,
+        from: step.from + scope.paragraphStart,
+        to: step.to + scope.paragraphStart,
+      })),
+    },
+  };
+}
+
+export function insertTable(
+  document: CanonicalDocumentEnvelope,
+  selection: SelectionSnapshot,
+  options: InsertTableOptions,
+  context: TextCommandContext,
+): StructuralMutationResult {
+  const scope = resolveParagraphScope(document, selection);
+  if (!scope || scope.kind !== "top-level") {
+    return createNoopStructuralMutation(document, selection);
+  }
+
+  const safeRows = Math.max(1, Math.floor(options.rows));
+  const safeColumns = Math.max(1, Math.floor(options.columns));
+  if (!Number.isFinite(safeRows) || !Number.isFinite(safeColumns)) {
+    return createNoopStructuralMutation(document, selection);
+  }
+
+  const localDocument: CanonicalDocumentEnvelope = {
+    ...document,
+    content: {
+      type: "doc",
+      children: [scope.paragraph],
+    },
+  };
+  const localSelection = createSelectionSnapshot(
+    selection.anchor - scope.paragraphStart,
+    selection.head - scope.paragraphStart,
+  );
+  const splitResult = splitParagraph(localDocument, localSelection, context);
+  const splitRoot = splitResult.document.content;
+  if (!splitRoot || splitRoot.type !== "doc") {
+    return createNoopStructuralMutation(document, selection);
+  }
+
+  const replacementParagraphs = splitRoot.children.filter(
+    (block): block is ParagraphNode => block.type === "paragraph",
+  );
+  if (replacementParagraphs.length < 2) {
+    return createNoopStructuralMutation(document, selection);
+  }
+
+  const nextRoot = document.content;
+  if (!nextRoot || nextRoot.type !== "doc") {
+    return createNoopStructuralMutation(document, selection);
+  }
+
+  const insertedTable = createInsertedTableBlock(
+    safeRows,
+    safeColumns,
+    resolveInsertedTableStyleId(document),
+  );
+  const nextDocument: CanonicalDocumentEnvelope = {
+    ...document,
+    updatedAt: context.timestamp,
+    content: {
+      ...nextRoot,
+      children: [
+        ...nextRoot.children.slice(0, scope.blockIndex),
+        replacementParagraphs[0],
+        insertedTable,
+        replacementParagraphs[1],
+        ...nextRoot.children.slice(scope.blockIndex + 1),
+      ],
+    },
+  };
+
+  return {
+    changed: true,
+    document: nextDocument,
+    selection:
+      findTableCellParagraphSelection(
+        nextDocument,
+        scope.blockIndex + 1,
+        0,
+        0,
+      ) ?? selection,
+    mapping: {
+      ...splitResult.mapping,
+      steps: splitResult.mapping.steps.map((step) => ({
+        ...step,
+        from: step.from + scope.paragraphStart,
+        to: step.to + scope.paragraphStart,
+      })),
+    },
+  };
+}

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

@@ -76,6 +76,16 @@ export function rangeStaysWithinSingleParagraph(
     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);
 
@@ -92,3 +102,82 @@ export function rangeStaysWithinSingleParagraph(
 
   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/formats/xlsx/io/parse-sheet.ts

@@ -1,4 +1,4 @@
-import { decodeXmlEntities, parseSharedStringsXml as _unused } from "./parse-shared-strings.ts";
+import { decodeXmlEntities } from "./parse-shared-strings.ts";
 import { parseXmlAttributes } from "./parse-styles.ts";
 
 // Re-export for external use
@@ -12,11 +12,23 @@ export { decodeXmlEntities };
  * b (boolean), e (error), str (formula string result), and blank.
  */
 export type XlsxParsedCellValue =
+  | { type: "blank" }
+  | { type: "text"; value: string; fromSharedString: boolean }
+  | { type: "number"; value: number }
+  | { type: "boolean"; value: boolean }
+  | {
+      type: "formula";
+      formula: string;
+      referenceTokens: string[];
+      cachedValue: XlsxParsedFormulaCachedValue | null;
+    }
+  | { type: "error"; errorCode: string };
+
+export type XlsxParsedFormulaCachedValue =
   | { type: "blank" }
   | { type: "text"; value: string }
   | { type: "number"; value: number }
   | { type: "boolean"; value: boolean }
-  | { type: "formula"; formula: string; cachedValue: string | null }
   | { type: "error"; errorCode: string };
 
 export interface XlsxParsedCell {
@@ -37,9 +49,17 @@ export interface XlsxParsedMerge {
   endCol: number;
 }
 
+export interface XlsxParsedDimension {
+  startRow: number;
+  startCol: number;
+  endRow: number;
+  endCol: number;
+}
+
 export interface SheetParseResult {
   cells: XlsxParsedCell[];
   merges: XlsxParsedMerge[];
+  dimension: XlsxParsedDimension | null;
 }
 
 /**
@@ -54,6 +74,7 @@ export function parseSheetXml(
 ): SheetParseResult {
   const cells: XlsxParsedCell[] = [];
   const merges: XlsxParsedMerge[] = [];
+  const dimension = parseSheetDimension(xml);
 
   const sheetDataMatch = /<sheetData>([\s\S]*?)<\/sheetData>/i.exec(xml);
   if (sheetDataMatch) {
@@ -65,7 +86,7 @@ export function parseSheetXml(
     parseMergeCells(mergeCellsMatch[1] ?? "", merges);
   }
 
-  return { cells, merges };
+  return { cells, merges, dimension };
 }
 
 function parseSheetData(
@@ -145,10 +166,12 @@ function resolveCellValue(
 ): XlsxParsedCellValue {
   // Formula cells may have any result type; store formula + cached value.
   if (formulaText !== null) {
+    const decodedFormula = decodeXmlEntities(formulaText);
     return {
       type: "formula",
-      formula: decodeXmlEntities(formulaText),
-      cachedValue: rawValue !== null ? decodeXmlEntities(rawValue) : null,
+      formula: decodedFormula,
+      referenceTokens: extractFormulaReferenceTokens(decodedFormula),
+      cachedValue: resolveFormulaCachedValue(typeCode, rawValue, inlineText, sharedStrings),
     };
   }
 
@@ -160,11 +183,11 @@ function resolveCellValue(
         !Number.isNaN(index) && index >= 0 && index < sharedStrings.length
           ? (sharedStrings[index] ?? "")
           : "";
-      return { type: "text", value: text };
+      return { type: "text", value: text, fromSharedString: true };
     }
 
     case "inlineStr": {
-      return { type: "text", value: inlineText ?? "" };
+      return { type: "text", value: inlineText ?? "", fromSharedString: false };
     }
 
     case "str": {
@@ -173,6 +196,7 @@ function resolveCellValue(
       return {
         type: "text",
         value: rawValue !== null ? decodeXmlEntities(rawValue) : "",
+        fromSharedString: false,
       };
     }
 
@@ -202,6 +226,61 @@ function resolveCellValue(
   }
 }
 
+function resolveFormulaCachedValue(
+  typeCode: string,
+  rawValue: string | null,
+  inlineText: string | null,
+  sharedStrings: readonly string[],
+): XlsxParsedFormulaCachedValue | null {
+  switch (typeCode) {
+    case "s": {
+      const index = rawValue !== null ? parseInt(rawValue, 10) : NaN;
+      return {
+        type: "text",
+        value:
+          !Number.isNaN(index) && index >= 0 && index < sharedStrings.length
+            ? (sharedStrings[index] ?? "")
+            : "",
+      };
+    }
+
+    case "inlineStr":
+      return { type: "text", value: inlineText ?? "" };
+
+    case "str":
+      return rawValue === null
+        ? { type: "blank" }
+        : { type: "text", value: decodeXmlEntities(rawValue) };
+
+    case "b":
+      return rawValue === null
+        ? { type: "blank" }
+        : { type: "boolean", value: rawValue === "1" };
+
+    case "e":
+      return rawValue === null
+        ? { type: "blank" }
+        : { type: "error", errorCode: decodeXmlEntities(rawValue) };
+
+    default: {
+      if (rawValue === null || rawValue === "") {
+        return { type: "blank" };
+      }
+
+      const numericValue = Number(rawValue);
+      if (!Number.isNaN(numericValue)) {
+        return { type: "number", value: numericValue };
+      }
+
+      if (rawValue === "TRUE" || rawValue === "FALSE") {
+        return { type: "boolean", value: rawValue === "TRUE" };
+      }
+
+      return { type: "text", value: decodeXmlEntities(rawValue) };
+    }
+  }
+}
+
 function extractTextContent(xml: string, tagName: string): string | null {
   const pattern = new RegExp(`<${tagName}(?:\\s[^>]*)?>([^<]*)</${tagName}>`, "i");
   const match = pattern.exec(xml);
@@ -260,6 +339,97 @@ function parseMergeRef(ref: string): XlsxParsedMerge | null {
   };
 }
 
+function parseSheetDimension(xml: string): XlsxParsedDimension | null {
+  const dimensionMatch = /<dimension\b([^>]*?)(?:\/>|>)/i.exec(xml);
+  if (!dimensionMatch) {
+    return null;
+  }
+
+  const attrs = parseXmlAttributes(dimensionMatch[1] ?? "");
+  const ref = attrs["ref"];
+  if (!ref) {
+    return null;
+  }
+
+  return parseDimensionRef(ref);
+}
+
+const SHEET_PREFIX_PATTERN =
+  "(?:'(?:[^']|'')+'|[A-Za-z_][A-Za-z0-9_.]*)!";
+const CELL_REFERENCE_PATTERN = "\\$?[A-Z]{1,3}\\$?[1-9][0-9]*";
+const RANGE_REFERENCE_PATTERN =
+  `${CELL_REFERENCE_PATTERN}(?::${CELL_REFERENCE_PATTERN})?`;
+const FORMULA_REFERENCE_PATTERN = new RegExp(
+  String.raw`(?<![A-Za-z0-9_.$])(?:${SHEET_PREFIX_PATTERN})?${RANGE_REFERENCE_PATTERN}(?![A-Za-z0-9_])`,
+  "g",
+);
+
+function extractFormulaReferenceTokens(formula: string): string[] {
+  const maskedFormula = maskQuotedFormulaStrings(formula);
+  const tokens: string[] = [];
+  const seen = new Set<string>();
+
+  for (const match of maskedFormula.matchAll(FORMULA_REFERENCE_PATTERN)) {
+    const index = match.index ?? -1;
+    if (index < 0) {
+      continue;
+    }
+    const token = formula.slice(index, index + match[0].length);
+    if (seen.has(token)) {
+      continue;
+    }
+    seen.add(token);
+    tokens.push(token);
+  }
+
+  return tokens;
+}
+
+function maskQuotedFormulaStrings(formula: string): string {
+  let output = "";
+  let inString = false;
+
+  for (let index = 0; index < formula.length; index += 1) {
+    const char = formula[index];
+    const next = formula[index + 1];
+
+    if (char === "\"") {
+      output += char;
+      if (inString && next === "\"") {
+        output += " ";
+        index += 1;
+        continue;
+      }
+      inString = !inString;
+      continue;
+    }
+
+    output += inString ? " " : char;
+  }
+
+  return output;
+}
+
+function parseDimensionRef(ref: string): XlsxParsedDimension | null {
+  const [startRef, endRef = startRef] = ref.split(":");
+  if (!startRef || !endRef) {
+    return null;
+  }
+
+  const start = parseCellRef(startRef);
+  const end = parseCellRef(endRef);
+  if (start === null || end === null) {
+    return null;
+  }
+
+  return {
+    startRow: start.row,
+    startCol: start.col,
+    endRow: end.row,
+    endCol: end.col,
+  };
+}
+
 function parseCellRef(ref: string): { row: number; col: number } | null {
   const match = /^([A-Z]+)([0-9]+)$/i.exec(ref.trim());
   if (!match) {

package/src/formats/xlsx/io/parse-styles.ts

@@ -9,6 +9,7 @@ export interface XlsxStyleEntry {
   fontId: number;
   fillId: number;
   borderId: number;
+  rawAttributes: Record<string, string>;
 }
 
 export function parseStylesXml(xml: string): XlsxStyleEntry[] {
@@ -29,6 +30,7 @@ export function parseStylesXml(xml: string): XlsxStyleEntry[] {
       fontId: parseIntAttr(attrs["fontId"], 0),
       fillId: parseIntAttr(attrs["fillId"], 0),
       borderId: parseIntAttr(attrs["borderId"], 0),
+      rawAttributes: attrs,
     });
   }
 

package/src/formats/xlsx/io/xlsx-session.ts

@@ -33,7 +33,7 @@ import { parseWorkbookXml } from "./parse-workbook.ts";
 import { parseSharedStringsXml } from "./parse-shared-strings.ts";
 import { parseStylesXml, parseXmlAttributes } from "./parse-styles.ts";
 import { parseSheetXml } from "./parse-sheet.ts";
-import type { XlsxParsedCellValue } from "./parse-sheet.ts";
+import type { XlsxParsedCellValue, XlsxParsedFormulaCachedValue } from "./parse-sheet.ts";
 
 // ---------------------------------------------------------------------------
 // Relationship type constants (SpreadsheetML / OPC)
@@ -177,7 +177,7 @@ function buildStyleRegistry(stylesXml: string): WorkbookStyleRegistry {
       fillId: entry.fillId,
       borderId: entry.borderId,
       numFmtId: entry.numFmtId,
-      rawAttributes: {},
+      rawAttributes: entry.rawAttributes,
     }),
   );
 
@@ -239,7 +239,7 @@ function convertParsedCellValue(
       return styleRef ? makeBlankCell(styleRef) : null;
 
     case "text":
-      return makeTextCell(parsed.value, false, styleRef);
+      return makeTextCell(parsed.value, parsed.fromSharedString, styleRef);
 
     case "number":
       return makeNumberCell(parsed.value, styleRef);
@@ -255,6 +255,7 @@ function convertParsedCellValue(
         parsed.formula,
         convertCachedFormulaValue(parsed.cachedValue),
         styleRef,
+        parsed.referenceTokens,
       );
   }
 }
@@ -282,19 +283,24 @@ function normalizeErrorCode(raw: string): CellErrorCode {
  * parse layer does not currently surface for formula cells.
  */
 function convertCachedFormulaValue(
-  raw: string | null,
+  cachedValue: XlsxParsedFormulaCachedValue | null,
 ): CachedFormulaValue | undefined {
-  if (raw === null) {
+  if (cachedValue === null) {
     return undefined;
   }
-  const num = Number(raw);
-  if (!Number.isNaN(num)) {
-    return { type: "number", value: num };
-  }
-  if (raw === "TRUE" || raw === "FALSE") {
-    return { type: "boolean", value: raw === "TRUE" };
+
+  switch (cachedValue.type) {
+    case "blank":
+      return { type: "blank" };
+    case "number":
+      return { type: "number", value: cachedValue.value };
+    case "text":
+      return { type: "text", value: cachedValue.value };
+    case "boolean":
+      return { type: "boolean", value: cachedValue.value };
+    case "error":
+      return { type: "error", errorCode: normalizeErrorCode(cachedValue.errorCode) };
   }
-  return { type: "text", value: raw };
 }
 
 // ---------------------------------------------------------------------------