@beyondwork/docx-react-component 1.0.56 → 1.0.57

package/src/io/ooxml/parse-settings.ts

@@ -1,8 +1,23 @@
 import type {
   CompatSetting,
+  ClrSchemeMapping,
+  ClrSchemeMappingSlot,
   DocumentSettings,
+  ThemeColorSlot,
 } from "../../model/canonical-document.ts";
 
+const CLRSCHEME_MAPPING_SLOTS = new Set<string>([
+  "bg1", "bg2", "t1", "t2",
+  "accent1", "accent2", "accent3", "accent4", "accent5", "accent6",
+  "hlink", "followedHyperlink",
+]);
+
+const THEME_COLOR_SLOTS = new Set<string>([
+  "dk1", "lt1", "dk2", "lt2",
+  "accent1", "accent2", "accent3", "accent4", "accent5", "accent6",
+  "hlink", "folHlink",
+]);
+
 interface XmlElementNode {
   type: "element";
   name: string;
@@ -34,6 +49,7 @@ export function parseSettingsXml(xml: string): DocumentSettings {
   const compatPartition = compat ? partitionCompat(compat) : undefined;
   const rootCompatFlags = readRootCompatFlags(settingsElement);
   const themeFontLangElement = findChildElementOptional(settingsElement, "themeFontLang");
+  const clrSchemeMapping = parseClrSchemeMapping(settingsElement);
   const unmodelled = readUnmodelledSettingsChildren(settingsElement);
 
   return {
@@ -53,6 +69,7 @@ export function parseSettingsXml(xml: string): DocumentSettings {
     ...(themeFontLangElement
       ? { themeFontLang: { ...themeFontLangElement.attributes } }
       : {}),
+    ...(clrSchemeMapping !== undefined ? { clrSchemeMapping } : {}),
     ...(unmodelled.length > 0 ? { unmodelledSettingsChildren: unmodelled } : {}),
   };
 }
@@ -67,6 +84,7 @@ const MODELLED_SETTINGS_CHILD_NAMES = new Set<string>([
   "zoom",
   "compat",
   "themeFontLang",
+  "clrSchemeMapping",
 ]);
 
 function readUnmodelledSettingsChildren(
@@ -134,6 +152,22 @@ function partitionCompat(compatElement: XmlElementNode): CompatPartition {
   return { compatSettings, compatFlags };
 }
 
+function parseClrSchemeMapping(
+  settingsElement: XmlElementNode,
+): ClrSchemeMapping | undefined {
+  const el = findChildElementOptional(settingsElement, "clrSchemeMapping");
+  if (!el) return undefined;
+  const mapping: Partial<Record<ClrSchemeMappingSlot, ThemeColorSlot>> = {};
+  for (const [attr, value] of Object.entries(el.attributes)) {
+    if (!value) continue;
+    const local = localName(attr);
+    if (!CLRSCHEME_MAPPING_SLOTS.has(local)) continue;
+    if (!THEME_COLOR_SLOTS.has(value)) continue;
+    mapping[local as ClrSchemeMappingSlot] = value as ThemeColorSlot;
+  }
+  return Object.keys(mapping).length > 0 ? mapping : undefined;
+}
+
 function findChildElementOptional(
   node: XmlElementNode,
   childLocalName: string,

package/src/io/ooxml/parse-shapes.ts

@@ -10,6 +10,9 @@
  * preserved in the canonical node's rawXml field for lossless round-trip export.
  */
 
+import type { ShapeContent } from "../../model/canonical-document.ts";
+import { parseFill } from "./parse-fill.ts";
+
 const WPS_SHAPE_GRAPHIC_URI =
   "http://schemas.microsoft.com/office/word/2010/wordprocessingShape";
 
@@ -294,3 +297,87 @@ function findTagEnd(xml: string, start: number): number {
   }
   return xml.length - 1;
 }
+
+// ───────────────────────────────────────────────────────────────────────────
+// CO4.3 — parseShapeContent: wps:wsp → ShapeContent (geometry, fill, line,
+// txbxContentXml, optional recursive txbxBlocks).
+// ───────────────────────────────────────────────────────────────────────────
+
+export type TxbxBlockParser = (xml: string) => ReadonlyArray<{ type: string; [key: string]: unknown }>;
+
+export function parseShapeContent(
+  graphicDataEl: XmlElementNode,
+  drawingRawXml: string,
+  blockParser?: TxbxBlockParser,
+): ShapeContent | null {
+  const uri = graphicDataEl.attributes.uri ?? "";
+  if (uri !== WPS_SHAPE_GRAPHIC_URI) return null;
+
+  const wsp = findFirstDescendant(graphicDataEl, "wsp");
+  if (!wsp) return null;
+
+  const spPr = findFirstChild(wsp, "spPr");
+  const prstGeom = spPr ? findFirstChild(spPr, "prstGeom") : undefined;
+  const geometry = prstGeom?.attributes.prst;
+
+  const fill = spPr ? readFill(spPr) : undefined;
+  const line = spPr ? readLine(spPr) : undefined;
+
+  // Text-box content — preserve raw XML for serialization + recurse via the
+  // optional blockParser callback (CO4 F3.3) to populate txbxBlocks.
+  const txbx = findFirstChild(wsp, "txbx");
+  const txbxContent = txbx ? findFirstDescendant(txbx, "txbxContent") : undefined;
+  const txbxContentXml = txbxContent ? extractRawXml(txbxContent, drawingRawXml) : undefined;
+
+  let txbxBlocks: ReadonlyArray<{ type: string; [key: string]: unknown }> | undefined;
+  if (txbxContentXml && blockParser) {
+    try {
+      txbxBlocks = blockParser(txbxContentXml);
+    } catch {
+      // Preserve-only fallback: keep txbxContentXml for serialization; leave
+      // txbxBlocks undefined so consumers know recursion did not succeed.
+      txbxBlocks = undefined;
+    }
+  }
+
+  // WordArt heuristic: geometry starting with "text" is a WordArt preset —
+  // those flow through parseShapeXml/WordArtNode. parseShapeContent covers
+  // rectangular shapes + text boxes.
+  const isTextBox = Boolean(txbxContent && (!geometry || geometry === "rect"));
+
+  const result: ShapeContent = { type: "shape", rawXml: drawingRawXml };
+  if (geometry) result.geometry = geometry;
+  if (fill) result.fill = fill;
+  if (line) result.line = line;
+  if (isTextBox) result.isTextBox = true;
+  if (txbxContentXml) result.txbxContentXml = txbxContentXml;
+  if (txbxBlocks && txbxBlocks.length > 0) result.txbxBlocks = txbxBlocks;
+  return result;
+}
+
+// F3.4 + P5 — readFill delegates to the shared `parseFill` primitive covering
+// solid / none / gradient / pattern. Lane 5 chart-style cascade can consume
+// the same parser via `src/io/ooxml/parse-fill.ts`.
+function readFill(spPr: XmlElementNode): ShapeContent["fill"] {
+  return parseFill(spPr);
+}
+
+function readLine(
+  spPr: XmlElementNode,
+): { color?: string; widthEmu?: number; noLine?: boolean } | undefined {
+  const ln = findFirstChild(spPr, "ln");
+  if (!ln) return undefined;
+  const result: { color?: string; widthEmu?: number; noLine?: boolean } = {};
+  const wRaw = ln.attributes.w;
+  if (wRaw !== undefined) {
+    const w = parseInt(wRaw, 10);
+    if (Number.isFinite(w)) result.widthEmu = w;
+  }
+  if (findFirstChild(ln, "noFill")) result.noLine = true;
+  const solid = findFirstChild(ln, "solidFill");
+  if (solid) {
+    const srgb = findFirstChild(solid, "srgbClr");
+    if (srgb?.attributes.val) result.color = srgb.attributes.val.toUpperCase();
+  }
+  return Object.keys(result).length > 0 ? result : undefined;
+}

package/src/io/ooxml/parse-solid-fill.ts

@@ -0,0 +1,11 @@
+/**
+ * @deprecated Prefer `parseFill` from `./parse-fill.ts` which covers
+ * solid + none + gradient + pattern fills. This file retains the
+ * `parseSolidFill` / `SolidFillResult` exports for back-compat with
+ * external consumers that only need the solid-fill subset.
+ *
+ * CO4 P5: `parseFill` is the canonical entry; `parse-shapes.ts` already
+ * migrated. Remove this shim once no external imports reference it.
+ */
+
+export { parseSolidFill, type SolidFillResult, type XmlElementNode } from "./parse-fill.ts";

package/src/io/ooxml/parse-styles.ts

@@ -12,6 +12,7 @@ import type {
   CharacterStyleDefinition,
   DocumentDefaults,
   LatentStyleDefinition,
+  NumberingStyleDefinition,
   ParagraphStyleDefinition,
   StylesCatalog,
   TableBorders,
@@ -118,6 +119,7 @@ export function parseStylesXml(xml: string): ParseStylesResult {
   const paragraphs: Record<string, ParagraphStyleDefinition> = {};
   const characters: Record<string, CharacterStyleDefinition> = {};
   const tables: Record<string, TableStyleDefinition> = {};
+  const numberingStyles: Record<string, NumberingStyleDefinition> = {};
   const latentStyles: Record<string, LatentStyleDefinition> = {};
   let docDefaults: DocumentDefaults | undefined;
 
@@ -147,6 +149,7 @@ export function parseStylesXml(xml: string): ParseStylesResult {
       if (!styleId) continue;
 
       const displayName = readStyleDisplayName(child) ?? styleId;
+      const aliases = readStyleAliases(child);
       const basedOn = readLinkedStyleId(child, "basedOn");
       const isDefault = (child.attributes["w:default"] ?? child.attributes.default) === "1";
 
@@ -154,6 +157,7 @@ export function parseStylesXml(xml: string): ParseStylesResult {
         case "paragraph": {
           const nextStyle = readLinkedStyleId(child, "next");
           const linkedStyleId = readLinkedStyleId(child, "link");
+          const autoRedefine = readStyleOnOff(child, "autoRedefine");
           const outlineLevel = readParagraphStyleOutlineLevel(child);
           const numbering = readParagraphStyleNumbering(child);
           const pPrNode = findChildElementOptional(child, "pPr");
@@ -165,8 +169,10 @@ export function parseStylesXml(xml: string): ParseStylesResult {
             displayName,
             kind: "paragraph",
             isDefault,
+            ...(aliases ? { aliases } : {}),
             ...(basedOn ? { basedOn } : {}),
             ...(nextStyle ? { nextStyle } : {}),
+            ...(autoRedefine !== undefined ? { autoRedefine } : {}),
             ...(outlineLevel !== undefined ? { outlineLevel } : {}),
             ...(numbering ? { numbering } : {}),
             ...(paragraphProperties ? { paragraphProperties } : {}),
@@ -184,6 +190,7 @@ export function parseStylesXml(xml: string): ParseStylesResult {
             displayName,
             kind: "character",
             isDefault,
+            ...(aliases ? { aliases } : {}),
             ...(basedOn ? { basedOn } : {}),
             ...(runProperties ? { runProperties } : {}),
             ...(linkedStyleId ? { linkedStyleId } : {}),
@@ -198,14 +205,37 @@ export function parseStylesXml(xml: string): ParseStylesResult {
             displayName,
             kind: "table",
             isDefault,
+            ...(aliases ? { aliases } : {}),
             ...(basedOn ? { basedOn } : {}),
             ...(formatting ? { formatting } : {}),
             ...(conditionalFormatting ? { conditionalFormatting } : {}),
           };
           break;
         }
+        case "numbering": {
+          // Preserve-only: stash numId reference if present; no property body.
+          const pPrNode = findChildElementOptional(child, "pPr");
+          const numPrNode = pPrNode ? findChildElementOptional(pPrNode, "numPr") : undefined;
+          const numIdNode = numPrNode ? findChildElementOptional(numPrNode, "numId") : undefined;
+          const rawNumId = numIdNode
+            ? (numIdNode.attributes["w:val"] ?? numIdNode.attributes.val)
+            : undefined;
+          const numberingInstanceId = rawNumId
+            ? toCanonicalNumberingInstanceId(rawNumId)
+            : undefined;
+          numberingStyles[styleId] = {
+            styleId,
+            displayName,
+            kind: "numbering",
+            isDefault,
+            ...(basedOn ? { basedOn } : {}),
+            ...(aliases ? { aliases } : {}),
+            ...(numberingInstanceId ? { numberingInstanceId } : {}),
+          };
+          break;
+        }
         default:
-          // numbering/list styles are not part of the canonical catalog
+          // Unknown w:type — skip. Valid Word outputs paragraph/character/table/numbering only.
           break;
       }
     } else if (local === "latentStyles") {
@@ -216,10 +246,12 @@ export function parseStylesXml(xml: string): ParseStylesResult {
   resolveStyleLinkReciprocals(paragraphs, characters, diagnostics);
 
   const hasLatent = Object.keys(latentStyles).length > 0;
+  const hasNumberingStyles = Object.keys(numberingStyles).length > 0;
   diagnostics.push(
     `parsed ${Object.keys(paragraphs).length} paragraph, ` +
       `${Object.keys(characters).length} character, ` +
       `${Object.keys(tables).length} table styles` +
+      (hasNumberingStyles ? `, ${Object.keys(numberingStyles).length} numbering styles` : "") +
       (hasLatent ? `, ${Object.keys(latentStyles).length} latent styles` : ""),
   );
 
@@ -228,6 +260,7 @@ export function parseStylesXml(xml: string): ParseStylesResult {
       paragraphs,
       characters,
       tables,
+      ...(hasNumberingStyles ? { numberingStyles } : {}),
       ...(hasLatent ? { latentStyles } : {}),
       fromPackage: true,
       ...(docDefaults ? { docDefaults } : {}),
@@ -247,6 +280,39 @@ function readStyleDisplayName(styleNode: XmlElementNode): string | undefined {
   return nameEl.attributes["w:val"] ?? nameEl.attributes.val ?? undefined;
 }
 
+/**
+ * ST_OnOff reader matching `src/io/ooxml/xml-attr-helpers.ts readOnOff`:
+ * missing → undefined; bare `<w:foo/>` or w:val="1|true|on" → true;
+ * w:val="0|false|off" → false. Duplicated locally because parse-styles.ts
+ * uses its own inline XmlElementNode type.
+ */
+function readStyleOnOff(styleNode: XmlElementNode, elementLocalName: string): boolean | undefined {
+  const el = findChildElementOptional(styleNode, elementLocalName);
+  if (!el) return undefined;
+  const raw = el.attributes["w:val"] ?? el.attributes.val;
+  if (raw === undefined) return true;
+  const n = raw.toLowerCase();
+  if (n === "0" || n === "false" || n === "off") return false;
+  return true;
+}
+
+/**
+ * Read `<w:aliases w:val="A,B,C"/>` — ECMA-376 §17.7.4.2.
+ * Returns undefined when the element is missing or carries no values.
+ * Whitespace around individual entries is trimmed; empty entries are dropped.
+ */
+function readStyleAliases(styleNode: XmlElementNode): string[] | undefined {
+  const el = findChildElementOptional(styleNode, "aliases");
+  if (!el) return undefined;
+  const raw = el.attributes["w:val"] ?? el.attributes.val;
+  if (!raw) return undefined;
+  const parts = raw
+    .split(",")
+    .map((s) => s.trim())
+    .filter((s) => s.length > 0);
+  return parts.length > 0 ? parts : undefined;
+}
+
 function readLinkedStyleId(
   styleNode: XmlElementNode,
   elementLocalName: string,
@@ -369,8 +435,15 @@ function readTableStyleFormatting(styleNode: XmlElementNode): TableStyleFormatti
   const tableProperties = findChildElementOptional(styleNode, "tblPr");
   const rowProperties = findChildElementOptional(styleNode, "trPr");
   const cellProperties = findChildElementOptional(styleNode, "tcPr");
+  const pPrNode = findChildElementOptional(styleNode, "pPr");
+  const rPrNode = findChildElementOptional(styleNode, "rPr");
   const formatting: TableStyleFormatting = {};
 
+  const paragraphProperties = readParagraphProperties(pPrNode);
+  if (paragraphProperties) formatting.paragraphProperties = paragraphProperties;
+  const runProperties = readRunProperties(rPrNode);
+  if (runProperties) formatting.runProperties = runProperties;
+
   if (tableProperties) {
     const table: NonNullable<TableStyleFormatting["table"]> = {};
     const width = readTableWidth(tableProperties);

package/src/io/ooxml/parse-theme.ts

@@ -3,6 +3,8 @@ import type {
   ThemeDefinition,
   ThemeFontScheme,
   ResolvedTheme,
+  CanonicalTheme,
+  ClrSchemeMapping,
 } from "../../model/canonical-document.ts";
 import type { XmlElementNode } from "./xml-element.ts";
 import { parseXml } from "./xml-parser.ts";
@@ -103,8 +105,66 @@ export function resolveThemeColor(
   return theme?.colors[colorSlot];
 }
 
+/**
+ * Default clrSchemeMapping per ECMA-376 §17.15.1.17.
+ *
+ * Word applies this identity when `settings.xml` omits `<w:clrSchemeMapping>`.
+ * Without it, style slots like `t1` never reach a physical theme color and
+ * `resolveAuto()` (→ `t1`) returns undefined on every document that doesn't
+ * ship an explicit mapping — which is most of them. See Lane CO1 follow-up.
+ */
+export const DEFAULT_CLR_SCHEME_MAPPING: ClrSchemeMapping = Object.freeze({
+  bg1: "lt1",
+  t1: "dk1",
+  bg2: "lt2",
+  t2: "dk2",
+  accent1: "accent1",
+  accent2: "accent2",
+  accent3: "accent3",
+  accent4: "accent4",
+  accent5: "accent5",
+  accent6: "accent6",
+  hlink: "hlink",
+  followedHyperlink: "folHlink",
+});
+
+/**
+ * Combine a parsed `ThemeDefinition` with a `ClrSchemeMapping` from
+ * settings.xml into a `CanonicalTheme` ready for runtime resolution.
+ *
+ * Any style slot absent from `clrMap` falls back to `DEFAULT_CLR_SCHEME_MAPPING`
+ * (ECMA-376 §17.15.1.17 default) so documents without `<w:clrSchemeMapping>`
+ * still resolve `t1 → dk1` etc.
+ *
+ * The `themeHash` and `clrMapHash` fields are deterministic content hashes
+ * (sorted key:value concatenation) suitable as structural cache keys per
+ * CLAUDE.md §3.
+ */
+export function materializeCanonicalTheme(
+  theme: ThemeDefinition,
+  clrMap: ClrSchemeMapping,
+): CanonicalTheme {
+  const clrScheme: ThemeColorScheme = theme.colorScheme ?? { name: "", colors: {} };
+  const mergedClrMap: ClrSchemeMapping = { ...DEFAULT_CLR_SCHEME_MAPPING, ...clrMap };
+  return {
+    clrScheme,
+    ...(theme.fontScheme !== undefined ? { fontScheme: theme.fontScheme } : {}),
+    clrMap: mergedClrMap,
+    themeHash: hashRecord(clrScheme.colors),
+    clrMapHash: hashRecord(mergedClrMap),
+  };
+}
+
 // ---- Internal helpers ----
 
+function hashRecord(rec: Partial<Record<string, string>>): string {
+  return Object.entries(rec)
+    .filter((entry): entry is [string, string] => entry[1] !== undefined)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([k, v]) => `${k}:${v}`)
+    .join("|");
+}
+
 function parseColorScheme(
   element: XmlElementNode | undefined,
 ): ThemeColorScheme | undefined {