@beyondwork/docx-react-component 1.0.0 → 1.0.2

package/src/legal/defined-terms.ts

@@ -0,0 +1,203 @@
+import { parseMainDocumentXml } from "../io/ooxml/parse-main-document.ts";
+import type {
+  CanonicalDocument,
+  DocumentNode,
+  ParagraphNode,
+} from "../model/canonical-document.ts";
+
+export interface DefinedTermOccurrence {
+  paragraphIndex: number;
+  label: string;
+  kind: "definition" | "reference";
+}
+
+export interface DefinedTerm {
+  term: string;
+  normalizedTerm: string;
+  definitionStyle: "quoted" | "bare";
+  definitions: DefinedTermOccurrence[];
+  references: DefinedTermOccurrence[];
+}
+
+const QUOTED_DEFINITION_PATTERN =
+  /["“]([A-Z][A-Za-z0-9]*(?:[ -][A-Z][A-Za-z0-9]*){0,5})["”]\s+(?:means|has the meaning(?: set forth)?|shall mean|refers to)\b/g;
+const BARE_DEFINITION_PATTERN =
+  /\b([A-Z][A-Za-z0-9]*(?:\s+[A-Z][A-Za-z0-9]*){0,5})\s+(?:means|has the meaning(?: set forth)?|shall mean|refers to)\b/g;
+const BLOCKED_BARE_TERMS = new Set([
+  "This Agreement",
+  "Such Term",
+  "The Company",
+  "This Section",
+  "This Clause",
+]);
+
+export function collectDefinedTermsFromDocumentXml(xml: string): DefinedTerm[] {
+  const parsed = parseMainDocumentXml(xml);
+  const paragraphs = parsed.blocks
+    .filter((block): block is typeof parsed.blocks[number] & { type: "paragraph" } => block.type === "paragraph")
+    .map(flattenParagraphText);
+
+  return buildDefinedTermCatalog(paragraphs);
+}
+
+export function collectDefinedTermsFromCanonicalDocument(
+  document: Pick<CanonicalDocument, "content"> | DocumentNode,
+): DefinedTerm[] {
+  const root = "content" in document ? document.content : document;
+  const paragraphs: string[] = [];
+
+  walkDocument(root, (node) => {
+    if (node.type === "paragraph") {
+      paragraphs.push(flattenParagraphText(node));
+    }
+  });
+
+  return buildDefinedTermCatalog(paragraphs);
+}
+
+export function buildDefinedTermCatalog(paragraphs: readonly string[]): DefinedTerm[] {
+  const terms = new Map<string, DefinedTerm>();
+
+  paragraphs.forEach((paragraph, paragraphIndex) => {
+    for (const candidate of extractDefinitionCandidates(paragraph)) {
+      const normalized = normalizeTerm(candidate.term);
+      const existing = terms.get(normalized) ?? {
+        term: candidate.term,
+        normalizedTerm: normalized,
+        definitionStyle: candidate.definitionStyle,
+        definitions: [],
+        references: [],
+      };
+
+      if (!terms.has(normalized)) {
+        terms.set(normalized, existing);
+      }
+
+      existing.definitions.push({
+        paragraphIndex,
+        label: candidate.term,
+        kind: "definition",
+      });
+    }
+  });
+
+  paragraphs.forEach((paragraph, paragraphIndex) => {
+    for (const term of terms.values()) {
+      const references = findTermReferences(paragraph, term.term);
+      if (references === 0) {
+        continue;
+      }
+
+      const hasDefinitionInParagraph = term.definitions.some(
+        (definition) => definition.paragraphIndex === paragraphIndex,
+      );
+      const referenceCount = hasDefinitionInParagraph ? 0 : references;
+
+      for (let count = 0; count < referenceCount; count += 1) {
+        term.references.push({
+          paragraphIndex,
+          label: term.term,
+          kind: "reference",
+        });
+      }
+    }
+  });
+
+  return Array.from(terms.values()).sort((left, right) => left.term.localeCompare(right.term));
+}
+
+interface DefinitionCandidate {
+  term: string;
+  definitionStyle: DefinedTerm["definitionStyle"];
+}
+
+function extractDefinitionCandidates(paragraph: string): DefinitionCandidate[] {
+  const candidates: DefinitionCandidate[] = [];
+
+  for (const match of paragraph.matchAll(QUOTED_DEFINITION_PATTERN)) {
+    const term = match[1]?.trim();
+    if (!term) {
+      continue;
+    }
+
+    candidates.push({
+      term,
+      definitionStyle: "quoted",
+    });
+  }
+
+  for (const match of paragraph.matchAll(BARE_DEFINITION_PATTERN)) {
+    const term = match[1]?.trim();
+    if (!term || BLOCKED_BARE_TERMS.has(term) || isQuotedTerm(term, paragraph)) {
+      continue;
+    }
+
+    candidates.push({
+      term,
+      definitionStyle: "bare",
+    });
+  }
+
+  return candidates;
+}
+
+function normalizeTerm(term: string): string {
+  return term.trim().replace(/\s+/g, " ").toLowerCase();
+}
+
+function isQuotedTerm(term: string, paragraph: string): boolean {
+  return paragraph.includes(`"${term}"`) || paragraph.includes(`“${term}”`);
+}
+
+function findTermReferences(paragraph: string, term: string): number {
+  const escapedTerm = escapeRegExp(term);
+  const pattern = new RegExp(`(?:^|[^A-Za-z0-9])(?:\"|“)?(${escapedTerm})(?:\"|”)?(?=[^A-Za-z0-9]|$)`, "g");
+  return Array.from(paragraph.matchAll(pattern)).length;
+}
+
+function escapeRegExp(value: string): string {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function flattenParagraphText(paragraph: ParagraphNode): string {
+  return paragraph.children
+    .map((child) => {
+      switch (child.type) {
+        case "text":
+          return child.text;
+        case "hyperlink":
+        case "field":
+          return child.children
+            .map((nested) => (nested.type === "text" ? nested.text : nested.type === "tab" ? "\t" : ""))
+            .join("");
+        case "tab":
+          return "\t";
+        case "hard_break":
+        case "column_break":
+          return "\n";
+        default:
+          return "";
+      }
+    })
+    .join("");
+}
+
+function walkDocument(node: DocumentNode, visit: (node: DocumentNode) => void): void {
+  visit(node);
+
+  if ("children" in node && Array.isArray(node.children)) {
+    for (const child of node.children) {
+      walkDocument(child, visit);
+    }
+  }
+
+  if (node.type === "table") {
+    for (const row of node.rows) {
+      walkDocument(row, visit);
+    }
+  } else if (node.type === "table_row") {
+    for (const cell of node.cells) {
+      walkDocument(cell, visit);
+    }
+  }
+}

package/src/runtime/document-runtime.ts

@@ -624,7 +624,7 @@ function toPublicDocumentStats(state: Pick<EditorState, "document">) {
     storyLength: stats.characterCount,
     commentCount: stats.commentCount,
     revisionCount: stats.revisionCount,
-    opaqueFragmentCount: countOpaqueFragments(state.document.preservation),
+    opaqueFragmentCount: countOpaqueFragments(state.document.preservation.opaqueFragments),
   };
 }
 
@@ -717,10 +717,8 @@ function toPublicError(error: InternalEditorError): EditorError {
   return { ...error };
 }
 
-function countOpaqueFragments(preservation: Record<string, unknown>): number {
-  const opaqueFragments =
-    isRecord(preservation.opaqueFragments) ? preservation.opaqueFragments : null;
-  return opaqueFragments ? Object.keys(opaqueFragments).length : 0;
+function countOpaqueFragments(opaqueFragments: Record<string, unknown>): number {
+  return Object.keys(opaqueFragments).length;
 }
 
 function createDerivedCompatibility(state: EditorState): InternalCompatibilityReport {

package/src/runtime/table-commands.ts

@@ -19,7 +19,6 @@ import {
   deleteRow as pmDeleteRow,
   deleteTable,
   goToNextCell,
-  goToPreviousCell,
   mergeCells,
   splitCell,
   toggleHeaderCell,
@@ -27,6 +26,10 @@ import {
   toggleHeaderRow,
 } from "prosemirror-tables";
 
+// prosemirror-tables does not export goToPreviousCell; replicate via direction -1.
+const goToPreviousCell: PMCommand = (state, dispatch, view) =>
+  goToNextCell(-1)(state, dispatch, view);
+
 export type { Command as TableCommand } from "prosemirror-state";
 
 function tableAtSelection(state: EditorState) {

package/src/runtime/table-schema.ts

@@ -11,6 +11,19 @@
 
 import type { NodeSpec } from "prosemirror-model";
 
+function resolveRenderedColspan(attrs: {
+  colspan?: number | null;
+  gridSpan?: number | null;
+}): number {
+  if (typeof attrs.colspan === "number" && attrs.colspan > 1) {
+    return attrs.colspan;
+  }
+  if (typeof attrs.gridSpan === "number" && attrs.gridSpan > 1) {
+    return attrs.gridSpan;
+  }
+  return 1;
+}
+
 export const tableNodeSpec: NodeSpec = {
   content: "table_row+",
   tableRole: "table",
@@ -68,7 +81,8 @@ export const tableCellNodeSpec: NodeSpec = {
     const attrs: Record<string, string> = {
       class: "border border-primary/20 p-2 align-top",
     };
-    if (node.attrs.colspan > 1) attrs.colspan = String(node.attrs.colspan);
+    const colspan = resolveRenderedColspan(node.attrs as { colspan?: number; gridSpan?: number });
+    if (colspan > 1) attrs.colspan = String(colspan);
     if (node.attrs.rowspan > 1) attrs.rowspan = String(node.attrs.rowspan);
     return ["td", attrs, 0];
   },
@@ -103,7 +117,8 @@ export const tableHeaderCellNodeSpec: NodeSpec = {
     const attrs: Record<string, string> = {
       class: "border border-primary/20 p-2 align-top font-semibold bg-surface-raised",
     };
-    if (node.attrs.colspan > 1) attrs.colspan = String(node.attrs.colspan);
+    const colspan = resolveRenderedColspan(node.attrs as { colspan?: number; gridSpan?: number });
+    if (colspan > 1) attrs.colspan = String(colspan);
     if (node.attrs.rowspan > 1) attrs.rowspan = String(node.attrs.rowspan);
     return ["th", attrs, 0];
   },

package/src/runtime/virtualized-rendering.ts

@@ -0,0 +1,258 @@
+import type {
+  EditorSurfaceSnapshot,
+  SurfaceBlockSnapshot,
+} from "../api/public-types";
+
+export interface VirtualizedRenderingMetrics {
+  blockId: string;
+  index: number;
+  top: number;
+  height: number;
+  bottom: number;
+}
+
+export interface VirtualizedRenderingSession {
+  blocks: SurfaceBlockSnapshot[];
+  metrics: VirtualizedRenderingMetrics[];
+  totalHeight: number;
+  averageBlockHeight: number;
+  estimatedPageCount: number;
+}
+
+export interface CreateVirtualizedRenderingSessionOptions {
+  averagePageHeight?: number;
+  paragraphBaseHeight?: number;
+  paragraphLineHeight?: number;
+  segmentWrapWidth?: number;
+  tableRowHeight?: number;
+  opaqueBlockHeight?: number;
+  sdtPaddingHeight?: number;
+}
+
+export interface VirtualizedViewport {
+  scrollTop: number;
+  viewportHeight: number;
+  overscanHeight?: number;
+}
+
+export interface VirtualizedWindow {
+  startIndex: number;
+  endIndex: number;
+  totalHeight: number;
+  offsetTop: number;
+  offsetBottom: number;
+  visibleBlocks: SurfaceBlockSnapshot[];
+  visibleMetrics: VirtualizedRenderingMetrics[];
+}
+
+const DEFAULT_PAGE_HEIGHT = 1120;
+const DEFAULT_PARAGRAPH_BASE_HEIGHT = 28;
+const DEFAULT_PARAGRAPH_LINE_HEIGHT = 18;
+const DEFAULT_SEGMENT_WRAP_WIDTH = 96;
+const DEFAULT_TABLE_ROW_HEIGHT = 44;
+const DEFAULT_OPAQUE_BLOCK_HEIGHT = 72;
+const DEFAULT_SDT_PADDING_HEIGHT = 24;
+
+export function createVirtualizedRenderingSession(
+  surface: EditorSurfaceSnapshot,
+  previous: VirtualizedRenderingSession | undefined = undefined,
+  options: CreateVirtualizedRenderingSessionOptions = {},
+): VirtualizedRenderingSession {
+  const blocks = surface.blocks;
+  const metrics = previous?.metrics ?? [];
+
+  if (metrics.length > blocks.length) {
+    metrics.length = blocks.length;
+  }
+
+  let cursor = 0;
+  for (let index = 0; index < blocks.length; index += 1) {
+    const block = blocks[index]!;
+    const height = estimateBlockHeight(block, options);
+    const top = cursor;
+    const bottom = top + height;
+    const metric = metrics[index];
+    if (metric) {
+      metric.blockId = block.blockId;
+      metric.index = index;
+      metric.top = top;
+      metric.height = height;
+      metric.bottom = bottom;
+    } else {
+      metrics.push({
+        blockId: block.blockId,
+        index,
+        top,
+        height,
+        bottom,
+      });
+    }
+    cursor = bottom;
+  }
+
+  const totalHeight = cursor;
+  const averageBlockHeight = blocks.length > 0 ? totalHeight / blocks.length : 0;
+  const estimatedPageCount =
+    totalHeight > 0
+      ? Math.max(
+          1,
+          Math.ceil(totalHeight / (options.averagePageHeight ?? DEFAULT_PAGE_HEIGHT)),
+        )
+      : 0;
+
+  if (previous) {
+    previous.blocks = blocks;
+    previous.metrics = metrics;
+    previous.totalHeight = totalHeight;
+    previous.averageBlockHeight = averageBlockHeight;
+    previous.estimatedPageCount = estimatedPageCount;
+    return previous;
+  }
+
+  return {
+    blocks,
+    metrics,
+    totalHeight,
+    averageBlockHeight,
+    estimatedPageCount,
+  };
+}
+
+export function computeVirtualizedWindow(
+  session: VirtualizedRenderingSession,
+  viewport: VirtualizedViewport,
+): VirtualizedWindow {
+  if (session.metrics.length === 0) {
+    return {
+      startIndex: 0,
+      endIndex: 0,
+      totalHeight: 0,
+      offsetTop: 0,
+      offsetBottom: 0,
+      visibleBlocks: [],
+      visibleMetrics: [],
+    };
+  }
+
+  const overscanHeight = Math.max(0, viewport.overscanHeight ?? viewport.viewportHeight * 0.5);
+  const windowTop = Math.max(0, viewport.scrollTop - overscanHeight);
+  const windowBottom = Math.min(
+    session.totalHeight,
+    viewport.scrollTop + viewport.viewportHeight + overscanHeight,
+  );
+  const startIndex = findFirstVisibleIndex(session.metrics, windowTop);
+  const endIndexExclusive = findLastVisibleIndex(session.metrics, windowBottom) + 1;
+  const safeEndIndex = Math.max(startIndex + 1, endIndexExclusive);
+  const visibleMetrics = session.metrics.slice(startIndex, safeEndIndex);
+  const visibleBlocks = session.blocks.slice(startIndex, safeEndIndex);
+  const lastMetric = visibleMetrics[visibleMetrics.length - 1]!;
+
+  return {
+    startIndex,
+    endIndex: safeEndIndex,
+    totalHeight: session.totalHeight,
+    offsetTop: visibleMetrics[0]?.top ?? 0,
+    offsetBottom: Math.max(0, session.totalHeight - lastMetric.bottom),
+    visibleBlocks,
+    visibleMetrics,
+  };
+}
+
+function findFirstVisibleIndex(
+  metrics: VirtualizedRenderingMetrics[],
+  top: number,
+): number {
+  let low = 0;
+  let high = metrics.length - 1;
+  let result = 0;
+
+  while (low <= high) {
+    const middle = (low + high) >> 1;
+    const metric = metrics[middle]!;
+    if (metric.bottom >= top) {
+      result = middle;
+      high = middle - 1;
+    } else {
+      low = middle + 1;
+    }
+  }
+
+  return result;
+}
+
+function findLastVisibleIndex(
+  metrics: VirtualizedRenderingMetrics[],
+  bottom: number,
+): number {
+  let low = 0;
+  let high = metrics.length - 1;
+  let result = metrics.length - 1;
+
+  while (low <= high) {
+    const middle = (low + high) >> 1;
+    const metric = metrics[middle]!;
+    if (metric.top <= bottom) {
+      result = middle;
+      low = middle + 1;
+    } else {
+      high = middle - 1;
+    }
+  }
+
+  return result;
+}
+
+function estimateBlockHeight(
+  block: SurfaceBlockSnapshot,
+  options: CreateVirtualizedRenderingSessionOptions,
+): number {
+  switch (block.kind) {
+    case "paragraph":
+      return estimateParagraphHeight(block, options);
+    case "table":
+      return Math.max(
+        options.tableRowHeight ?? DEFAULT_TABLE_ROW_HEIGHT,
+        block.rows.length * (options.tableRowHeight ?? DEFAULT_TABLE_ROW_HEIGHT),
+      );
+    case "opaque_block":
+      return options.opaqueBlockHeight ?? DEFAULT_OPAQUE_BLOCK_HEIGHT;
+    case "sdt_block":
+      return (
+        (options.sdtPaddingHeight ?? DEFAULT_SDT_PADDING_HEIGHT) +
+        block.children.reduce(
+          (total, child) => total + estimateBlockHeight(child, options),
+          0,
+        )
+      );
+    default:
+      return options.paragraphBaseHeight ?? DEFAULT_PARAGRAPH_BASE_HEIGHT;
+  }
+}
+
+function estimateParagraphHeight(
+  block: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>,
+  options: CreateVirtualizedRenderingSessionOptions,
+): number {
+  const wrapWidth = options.segmentWrapWidth ?? DEFAULT_SEGMENT_WRAP_WIDTH;
+  let consumedCharacters = 0;
+
+  for (const segment of block.segments) {
+    switch (segment.kind) {
+      case "text":
+        consumedCharacters += segment.text.length;
+        break;
+      case "image":
+        consumedCharacters += wrapWidth;
+        break;
+      default:
+        consumedCharacters += 4;
+        break;
+    }
+  }
+
+  const estimatedLines = Math.max(1, Math.ceil(consumedCharacters / wrapWidth));
+  return (
+    (options.paragraphBaseHeight ?? DEFAULT_PARAGRAPH_BASE_HEIGHT) +
+    estimatedLines * (options.paragraphLineHeight ?? DEFAULT_PARAGRAPH_LINE_HEIGHT)
+  );
+}