@beyondwork/docx-react-component 1.0.28 → 1.0.30

package/src/runtime/surface-projection.ts

@@ -30,11 +30,14 @@ import type {
 } from "../model/canonical-document.ts";
 import {
   describeOpaqueFragment,
+  describeStructuredWrapperBlock,
   getOpaqueFragment,
+  isBlockedImportFeatureKey,
 } from "../preservation/store.ts";
 import { getStoryBlocks } from "./story-targeting.ts";
 import {
   createNumberingPrefixResolver,
+  type NumberingPrefixResult,
   type NumberingPrefixResolver,
 } from "./numbering-prefix.ts";
 import {
@@ -42,6 +45,7 @@ import {
   findHeaderFooterDocumentEntry,
   resolveSectionVariants,
 } from "./story-context.ts";
+import { resolveTableStyleResolution } from "./table-style-resolver.ts";
 
 interface ParagraphAccumulator {
   blockId: string;
@@ -52,6 +56,7 @@ interface ParagraphAccumulator {
   numbering?: ParagraphNode["numbering"];
   numberingPrefix?: string;
   numberingSuffix?: "tab" | "space" | "nothing";
+  resolvedNumbering?: Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>["resolvedNumbering"];
   contextualSpacing?: boolean;
   segments: SurfaceInlineSegment[];
 }
@@ -122,6 +127,9 @@ function createSurfaceBlock(
   if (block.type === "opaque_block") {
     const fragment = getOpaqueFragment(document.preservation as never, block.fragmentId);
     const descriptor = fragment ? describeOpaqueFragment(fragment) : null;
+    const blockedReasonCode = descriptor && isBlockedImportFeatureKey(descriptor.featureKey)
+      ? "workflow_blocked_import"
+      : "workflow_preserve_only";
     const blockId = `opaque-${counters.opaque}`;
     counters.opaque += 1;
     return {
@@ -136,6 +144,7 @@ function createSurfaceBlock(
         detail:
           descriptor?.detail ??
           "Locked whole-unit to keep unsupported OOXML intact through export.",
+        ...(descriptor ? { featureKey: descriptor.featureKey, blockedReasonCode } : {}),
         state: "locked-preserve-only",
       },
       lockedFragmentIds: [block.fragmentId],
@@ -157,6 +166,31 @@ function createSurfaceBlock(
   }
 
   if (block.type === "sdt") {
+    const descriptor = describeStructuredWrapperBlock(block);
+    if (descriptor) {
+      const blockId = `sdt-wrapper-${counters.sdt}`;
+      counters.sdt += 1;
+      return {
+        block: {
+          blockId,
+          kind: "opaque_block",
+          from: cursor,
+          to: cursor + 1,
+          fragmentId: blockId,
+          warningId: blockId,
+          label: descriptor.label,
+          detail: descriptor.detail,
+          featureKey: descriptor.featureKey,
+          blockedReasonCode: isBlockedImportFeatureKey(descriptor.featureKey)
+            ? "workflow_blocked_import"
+            : "workflow_preserve_only",
+          state: "locked-preserve-only",
+        },
+        lockedFragmentIds: [],
+        nextCursor: cursor + 1,
+      };
+    }
+
     const sdtIndex = counters.sdt;
     counters.sdt += 1;
     return createSdtBlock(
@@ -170,6 +204,7 @@ function createSurfaceBlock(
   }
 
   if (block.type === "custom_xml") {
+    const descriptor = describeStructuredWrapperBlock(block);
     const blockId = `custom-xml-${counters.customXml}`;
     counters.customXml += 1;
     return {
@@ -180,11 +215,16 @@ function createSurfaceBlock(
         to: cursor + 1,
         fragmentId: blockId,
         warningId: blockId,
-        label: "Custom XML block",
-        detail:
-          block.uri || block.element
-            ? `Custom XML wrapper ${[block.element, block.uri].filter(Boolean).join(" ")} preserved as a read-only block.`
-            : "Custom XML wrapper preserved as a read-only block.",
+        label: descriptor?.label ?? "Custom XML wrapper",
+        detail: descriptor?.detail ?? "Custom XML wrapper remains package-backed and read-only.",
+        ...(descriptor
+          ? {
+              featureKey: descriptor.featureKey,
+              blockedReasonCode: isBlockedImportFeatureKey(descriptor.featureKey)
+                ? "workflow_blocked_import"
+                : "workflow_preserve_only",
+            }
+          : {}),
         state: "locked-preserve-only",
       },
       lockedFragmentIds: [],
@@ -193,6 +233,7 @@ function createSurfaceBlock(
   }
 
   if (block.type === "alt_chunk") {
+    const descriptor = describeStructuredWrapperBlock(block);
     const blockId = `alt-chunk-${counters.altChunk}`;
     counters.altChunk += 1;
     return {
@@ -203,8 +244,18 @@ function createSurfaceBlock(
         to: cursor + 1,
         fragmentId: blockId,
         warningId: blockId,
-        label: "AltChunk import",
-        detail: `Alternate content import remains read-only through relationship ${block.relationshipId}.`,
+        label: descriptor?.label ?? "AltChunk import",
+        detail:
+          descriptor?.detail ??
+          `AltChunk import remains package-backed and blocked through relationship ${block.relationshipId}.`,
+        ...(descriptor
+          ? {
+              featureKey: descriptor.featureKey,
+              blockedReasonCode: isBlockedImportFeatureKey(descriptor.featureKey)
+                ? "workflow_blocked_import"
+                : "workflow_preserve_only",
+            }
+          : {}),
         state: "locked-preserve-only",
       },
       lockedFragmentIds: [],
@@ -262,9 +313,11 @@ function createTableBlock(
   let innerCursor = cursor;
   const rows: SurfaceTableRowSnapshot[] = [];
   const rowSpans = computeTableRowSpans(table);
+  const resolvedTable = resolveTableStyleResolution(table, document.styles.tables);
 
   for (const [rowIndex, row] of table.rows.entries()) {
     const cells: SurfaceTableCellSnapshot[] = [];
+    const resolvedRow = resolvedTable.rows[rowIndex];
     for (const [cellIndex, cell] of row.cells.entries()) {
       const cellContent: SurfaceBlockSnapshot[] = [];
       for (const child of cell.children) {
@@ -279,14 +332,15 @@ function createTableBlock(
         lockedFragmentIds.push(...result.lockedFragmentIds);
         innerCursor = result.nextCursor;
       }
-      const cellBorders = resolveCellBorderStyles(cell.borders);
+      const resolvedCell = resolvedRow?.cells[cellIndex];
+      const cellBorders = resolveCellBorderStyles(resolvedCell?.borders ?? cell.borders);
       cells.push({
         gridSpan: cell.gridSpan ?? 1,
         verticalMerge: cell.verticalMerge ?? null,
         colspan: cell.gridSpan ?? 1,
         rowspan: rowSpans.get(`${rowIndex}:${cellIndex}`) ?? 1,
-        ...(cell.shading?.fill ? { backgroundColor: `#${cell.shading.fill}` } : {}),
-        ...(cell.verticalAlign ? { verticalAlign: cell.verticalAlign } : {}),
+        ...(resolvedCell?.shading?.fill ? { backgroundColor: `#${resolvedCell.shading.fill}` } : {}),
+        ...(resolvedCell?.verticalAlign ? { verticalAlign: resolvedCell.verticalAlign } : {}),
         ...(cellBorders.borderTop ? { borderTop: cellBorders.borderTop } : {}),
         ...(cellBorders.borderRight ? { borderRight: cellBorders.borderRight } : {}),
         ...(cellBorders.borderBottom ? { borderBottom: cellBorders.borderBottom } : {}),
@@ -294,13 +348,16 @@ function createTableBlock(
         content: cellContent,
       });
     }
+    const headerLike =
+      row.isHeader === true ||
+      resolvedRow?.style.isHeader === true;
     rows.push({
       cells,
       ...(row.gridBefore !== undefined ? { gridBefore: row.gridBefore } : {}),
       ...(row.gridAfter !== undefined ? { gridAfter: row.gridAfter } : {}),
-      ...(row.height !== undefined ? { height: row.height } : {}),
-      ...(row.heightRule ? { heightRule: row.heightRule } : {}),
-      ...(row.isHeader ? { isHeader: row.isHeader } : {}),
+      ...(resolvedRow?.style.height !== undefined ? { height: resolvedRow.style.height } : {}),
+      ...(resolvedRow?.style.heightRule ? { heightRule: resolvedRow.style.heightRule } : {}),
+      ...(headerLike ? { isHeader: true } : {}),
     });
   }
 
@@ -312,8 +369,8 @@ function createTableBlock(
       to: innerCursor,
       styleId: table.styleId,
       gridColumns: table.gridColumns,
-      ...(table.alignment ? { alignment: table.alignment } : {}),
-      ...(table.tblLook ? { tblLook: table.tblLook } : {}),
+      ...(resolvedTable.table?.alignment ? { alignment: resolvedTable.table.alignment } : {}),
+      tblLook: resolvedTable.effectiveTblLook,
       rows,
     },
     lockedFragmentIds,
@@ -452,23 +509,25 @@ function createParagraphBlock(
   nextCursor: number;
   lockedFragmentIds: string[];
 } {
+  const effectiveNumbering = resolveEffectiveParagraphNumbering(document, paragraph);
+  const resolvedNumbering = effectiveNumbering
+    ? numberingPrefixResolver.resolveDetailed(effectiveNumbering, paragraph)
+    : null;
   const accumulator: ParagraphAccumulator = {
     blockId: `paragraph-${paragraphIndex}`,
     kind: "paragraph",
     from: start,
     to: start,
     ...(paragraph.styleId ? { styleId: paragraph.styleId } : {}),
-    ...(paragraph.numbering ? { numbering: paragraph.numbering } : {}),
-    ...(paragraph.numbering
-      ? (() => {
-          const detailed = numberingPrefixResolver.resolveDetailed(paragraph.numbering);
-          return detailed
-            ? {
-                numberingPrefix: detailed.text,
-                ...(detailed.suffix ? { numberingSuffix: detailed.suffix } : {}),
-              }
-            : {};
-        })()
+    ...(effectiveNumbering ? { numbering: effectiveNumbering } : {}),
+    ...(resolvedNumbering
+      ? {
+          ...(resolvedNumbering.text !== null ? { numberingPrefix: resolvedNumbering.text } : {}),
+          ...(resolvedNumbering.text !== null && resolvedNumbering.suffix
+            ? { numberingSuffix: resolvedNumbering.suffix }
+            : {}),
+          resolvedNumbering: toSurfaceResolvedNumbering(resolvedNumbering),
+        }
       : {}),
     ...(paragraph.alignment ? { alignment: paragraph.alignment } : {}),
     ...(paragraph.spacing ? { spacing: paragraph.spacing } : {}),
@@ -507,6 +566,106 @@ function createParagraphBlock(
   };
 }
 
+function resolveEffectiveParagraphNumbering(
+  document: CanonicalDocumentEnvelope,
+  paragraph: ParagraphNode,
+): ParagraphNode["numbering"] | undefined {
+  if (paragraph.numbering) {
+    return paragraph.numbering;
+  }
+  if (!paragraph.styleId) {
+    return undefined;
+  }
+
+  const paragraphStyles = document.styles?.paragraphs ?? {};
+  const styleChain = collectParagraphStyleChain(document, paragraph.styleId);
+  let styleNumbering:
+    | CanonicalDocumentEnvelope["styles"]["paragraphs"][string]["numbering"]
+    | undefined;
+  for (const styleId of styleChain) {
+    const style = paragraphStyles[styleId];
+    if (style?.numbering) {
+      styleNumbering = style.numbering;
+      break;
+    }
+  }
+  if (!styleNumbering) {
+    return undefined;
+  }
+  if (styleNumbering.level !== undefined) {
+    return {
+      numberingInstanceId: styleNumbering.numberingInstanceId,
+      level: styleNumbering.level,
+    };
+  }
+
+  const resolvedLevel = resolveStyleLinkedNumberingLevel(
+    document,
+    styleNumbering.numberingInstanceId,
+    styleChain,
+  );
+  return resolvedLevel !== undefined
+    ? {
+        numberingInstanceId: styleNumbering.numberingInstanceId,
+        level: resolvedLevel,
+      }
+    : undefined;
+}
+
+function collectParagraphStyleChain(
+  document: CanonicalDocumentEnvelope,
+  styleId: string,
+): string[] {
+  const paragraphStyles = document.styles?.paragraphs ?? {};
+  const chain: string[] = [];
+  const visited = new Set<string>();
+  let currentStyleId: string | undefined = styleId;
+
+  while (currentStyleId && !visited.has(currentStyleId)) {
+    visited.add(currentStyleId);
+    chain.push(currentStyleId);
+    currentStyleId = paragraphStyles[currentStyleId]?.basedOn;
+  }
+
+  return chain;
+}
+
+function resolveStyleLinkedNumberingLevel(
+  document: CanonicalDocumentEnvelope,
+  numberingInstanceId: string,
+  styleChain: readonly string[],
+): number | undefined {
+  const instance = document.numbering.instances[numberingInstanceId];
+  if (!instance) {
+    return undefined;
+  }
+
+  for (const styleId of styleChain) {
+    const overrideMatch = instance.overrides.find(
+      (override) => override.levelDefinition?.paragraphStyleId === styleId,
+    );
+    if (overrideMatch) {
+      return overrideMatch.level;
+    }
+  }
+
+  const abstractDefinition = document.numbering.abstractDefinitions[instance.abstractNumberingId];
+  if (!abstractDefinition) {
+    return undefined;
+  }
+
+  for (const styleId of styleChain) {
+    const levelMatch = abstractDefinition.levels.find(
+      (levelDefinition) => levelDefinition.paragraphStyleId === styleId,
+    );
+    if (levelMatch) {
+      return levelMatch.level;
+    }
+  }
+
+  return undefined;
+}
+
 function appendInlineSegments(
   paragraph: ParagraphAccumulator,
   node: InlineNode,
@@ -580,6 +739,9 @@ function appendInlineSegments(
       const fragment = getOpaqueFragment(document.preservation as never, node.fragmentId);
       const descriptor = fragment ? describeOpaqueFragment(fragment) : null;
       const preview = fragment ? describePreservedInlinePreview(fragment.payloadReference) : null;
+      const blockedReasonCode = descriptor && isBlockedImportFeatureKey(descriptor.featureKey)
+        ? "workflow_blocked_import"
+        : "workflow_preserve_only";
       paragraph.segments.push({
         segmentId: `${paragraph.blockId}-segment-${paragraph.segments.length}`,
         kind: "opaque_inline",
@@ -592,6 +754,7 @@ function appendInlineSegments(
           preview?.detail ??
           descriptor?.detail ??
           "Locked whole-unit to keep unsupported inline OOXML intact through export.",
+        ...(descriptor ? { featureKey: descriptor.featureKey, blockedReasonCode } : {}),
         ...(preview?.presentation ? { presentation: preview.presentation } : {}),
         state: "locked-preserve-only",
       });
@@ -626,7 +789,8 @@ function appendInlineSegments(
         fragmentId: "",
         warningId: "",
         label: "Column break",
-        detail: "Column break marker preserved for export.",
+        detail: "Word column break marker preserved for export safety.",
+        presentation: "quiet-marker",
         state: "locked-preserve-only",
       });
       return { nextCursor: start + 1, lockedFragmentIds: [] };
@@ -1116,6 +1280,38 @@ function toSurfaceTabStop(
   };
 }
 
+function toSurfaceResolvedNumbering(
+  numbering: NumberingPrefixResult,
+): NonNullable<Extract<SurfaceBlockSnapshot, { kind: "paragraph" }>["resolvedNumbering"]> {
+  return {
+    level: numbering.level,
+    format: numbering.format,
+    ...(numbering.text !== null ? { text: numbering.text } : {}),
+    startAt: numbering.startAt,
+    ...(numbering.paragraphStyleId ? { paragraphStyleId: numbering.paragraphStyleId } : {}),
+    ...(numbering.isLegalNumbering ? { isLegalNumbering: true } : {}),
+    ...(numbering.suffix ? { suffix: numbering.suffix } : {}),
+    geometry: {
+      ...(numbering.geometry.markerJustification
+        ? { markerJustification: numbering.geometry.markerJustification }
+        : {}),
+      ...(numbering.geometry.spacing ? { spacing: { ...numbering.geometry.spacing } } : {}),
+      ...(numbering.geometry.indentation
+        ? { indentation: { ...numbering.geometry.indentation } }
+        : {}),
+      ...(numbering.geometry.tabStops && numbering.geometry.tabStops.length > 0
+        ? { tabStops: numbering.geometry.tabStops.map((tabStop) => toSurfaceTabStop(tabStop)) }
+        : {}),
+      ...(numbering.geometry.markerLane
+        ? { markerLane: { ...numbering.geometry.markerLane } }
+        : {}),
+      ...(numbering.geometry.textColumn
+        ? { textColumn: { ...numbering.geometry.textColumn } }
+        : {}),
+    },
+  };
+}
+
 function describePreservedInlinePreview(
   payloadReference: string,
 ): {