docxmlater 10.0.4 → 10.1.0

package/src/formatting/NumberingInstance.ts

@@ -7,6 +7,7 @@
  */
 
 import { XMLBuilder, XMLElement } from '../xml/XMLBuilder';
+import { NumberingLevel } from './NumberingLevel';
 
 /**
  * Properties for creating a numbering instance
@@ -29,6 +30,7 @@ export class NumberingInstance {
   private numId: number;
   private abstractNumId: number;
   private levelOverrides = new Map<number, number>();
+  private fullLevelOverrides = new Map<number, NumberingLevel>();
 
   /**
    * Creates a new numbering instance
@@ -144,6 +146,44 @@ export class NumberingInstance {
     return this.levelOverrides.get(level);
   }
 
+  /**
+   * Sets a full level definition override for a specific level
+   * This replaces the entire level definition from the abstract numbering
+   * (ECMA-376 §17.9.8 - w:lvlOverride with full w:lvl child)
+   *
+   * @param level The level index (0-based)
+   * @param levelDef The full NumberingLevel definition to use as override
+   */
+  setFullLevelOverride(level: number, levelDef: NumberingLevel): this {
+    if (level < 0) {
+      throw new Error('Level index must be non-negative');
+    }
+    this.fullLevelOverrides.set(level, levelDef);
+    return this;
+  }
+
+  /**
+   * Gets a full level definition override for a specific level
+   */
+  getFullLevelOverride(level: number): NumberingLevel | undefined {
+    return this.fullLevelOverrides.get(level);
+  }
+
+  /**
+   * Gets all full level definition overrides
+   */
+  getFullLevelOverrides(): Map<number, NumberingLevel> {
+    return new Map(this.fullLevelOverrides);
+  }
+
+  /**
+   * Clears a full level override
+   */
+  clearFullLevelOverride(level: number): this {
+    this.fullLevelOverrides.delete(level);
+    return this;
+  }
+
   /**
    * Generates the WordprocessingML XML for this numbering instance
    */
@@ -157,6 +197,8 @@ export class NumberingInstance {
 
     // Add level overrides if any are set
     for (const [level, startValue] of this.levelOverrides) {
+      // Skip levels that have a full level override (they take precedence)
+      if (this.fullLevelOverrides.has(level)) continue;
       children.push({
         name: 'w:lvlOverride',
         attributes: { 'w:ilvl': level.toString() },
@@ -166,6 +208,23 @@ export class NumberingInstance {
       });
     }
 
+    // Add full level overrides
+    for (const [level, levelDef] of this.fullLevelOverrides) {
+      const overrideChildren: XMLElement[] = [];
+      // Include startOverride if also set for this level
+      if (this.levelOverrides.has(level)) {
+        overrideChildren.push(
+          XMLBuilder.wSelf('startOverride', { 'w:val': this.levelOverrides.get(level)!.toString() })
+        );
+      }
+      overrideChildren.push(levelDef.toXML());
+      children.push({
+        name: 'w:lvlOverride',
+        attributes: { 'w:ilvl': level.toString() },
+        children: overrideChildren,
+      });
+    }
+
     return XMLBuilder.w('num', { 'w:numId': this.numId.toString() }, children);
   }
 
@@ -204,9 +263,37 @@ export class NumberingInstance {
     }
     const abstractNumId = parseInt(abstractNumIdMatch[1], 10);
 
-    return new NumberingInstance({
+    const instance = new NumberingInstance({
       numId,
       abstractNumId,
     });
+
+    // Parse level overrides (w:lvlOverride)
+    const lvlOverrideRegex = /<w:lvlOverride[^>]*w:ilvl="(\d+)"[^>]*>([\s\S]*?)<\/w:lvlOverride>/g;
+    let match: RegExpExecArray | null;
+    while ((match = lvlOverrideRegex.exec(xml)) !== null) {
+      const levelStr = match[1]!;
+      const content = match[2]!;
+      const level = parseInt(levelStr, 10);
+
+      // Check for startOverride
+      const startOverrideMatch = /<w:startOverride[^>]*w:val="([^"]+)"/.exec(content);
+      if (startOverrideMatch?.[1]) {
+        instance.setLevelOverride(level, parseInt(startOverrideMatch[1], 10));
+      }
+
+      // Check for full w:lvl element
+      const lvlMatch = /<w:lvl[^>]*>[\s\S]*?<\/w:lvl>/.exec(content);
+      if (lvlMatch) {
+        try {
+          const levelDef = NumberingLevel.fromXML(lvlMatch[0]);
+          instance.setFullLevelOverride(level, levelDef);
+        } catch {
+          // Skip invalid level definitions
+        }
+      }
+    }
+
+    return instance;
   }
 }

package/src/formatting/NumberingLevel.ts

@@ -111,13 +111,16 @@ export interface NumberingLevelProperties {
    * - undefined (default): Restart when level-1 changes (standard behavior)
    */
   lvlRestart?: number;
+
+  /** Paragraph style ID linked to this numbering level (w:pStyle per ECMA-376 §17.9.23) */
+  pStyle?: string;
 }
 
 /**
  * Represents a single level in a numbering definition
  */
 export class NumberingLevel {
-  private properties: Required<Omit<NumberingLevelProperties, 'lvlRestart' | 'underline'>> & Pick<NumberingLevelProperties, 'lvlRestart' | 'underline'>;
+  private properties: Required<Omit<NumberingLevelProperties, 'lvlRestart' | 'underline' | 'pStyle'>> & Pick<NumberingLevelProperties, 'lvlRestart' | 'underline' | 'pStyle'>;
 
   /**
    * Creates a new numbering level
@@ -149,6 +152,7 @@ export class NumberingLevel {
       italic: properties.italic !== undefined ? properties.italic : false,
       underline: properties.underline,
       lvlRestart: properties.lvlRestart, // undefined means default behavior (restart on level-1 change)
+      pStyle: properties.pStyle,
     };
 
     this.validate();
@@ -247,7 +251,7 @@ export class NumberingLevel {
   /**
    * Gets the level properties
    */
-  getProperties(): Required<Omit<NumberingLevelProperties, 'lvlRestart' | 'underline'>> & Pick<NumberingLevelProperties, 'lvlRestart' | 'underline'> {
+  getProperties(): Required<Omit<NumberingLevelProperties, 'lvlRestart' | 'underline' | 'pStyle'>> & Pick<NumberingLevelProperties, 'lvlRestart' | 'underline' | 'pStyle'> {
     return { ...this.properties };
   }
 
@@ -399,6 +403,23 @@ export class NumberingLevel {
     return this.properties.lvlRestart;
   }
 
+  /**
+   * Sets the paragraph style ID linked to this numbering level
+   * Links this level to a paragraph style definition (w:pStyle per ECMA-376 §17.9.23)
+   * @param styleId The paragraph style ID
+   */
+  setParagraphStyle(styleId: string): this {
+    this.properties.pStyle = styleId;
+    return this;
+  }
+
+  /**
+   * Gets the paragraph style ID linked to this numbering level
+   */
+  getParagraphStyle(): string | undefined {
+    return this.properties.pStyle;
+  }
+
   /**
    * Sets the numbering format (decimal, lowerLetter, bullet, etc.)
    * @param format The numbering format
@@ -447,7 +468,12 @@ export class NumberingLevel {
       );
     }
 
-    // 4. pStyle — not modeled, skipped
+    // 4. pStyle (paragraph style link)
+    if (this.properties.pStyle) {
+      children.push(
+        XMLBuilder.wSelf("pStyle", { "w:val": this.properties.pStyle })
+      );
+    }
 
     // 5. Legal numbering style
     if (this.properties.isLegalNumberingStyle) {
@@ -945,6 +971,13 @@ export class NumberingLevel {
       lvlRestart = parseInt(lvlRestartMatch[1], 10);
     }
 
+    // Extract pStyle (paragraph style link)
+    let pStyle: string | undefined;
+    const pStyleMatch = /<w:pStyle[^>]*w:val="([^"]+)"/.exec(xml);
+    if (pStyleMatch?.[1]) {
+      pStyle = pStyleMatch[1];
+    }
+
     // Extract indentation from <w:pPr><w:ind>
     let leftIndent = 720 + level * 360; // default
     let hangingIndent = 360; // default
@@ -1001,6 +1034,7 @@ export class NumberingLevel {
       underline,
       color,
       lvlRestart,
+      pStyle,
     });
   }
 }

package/src/formatting/Style.ts

@@ -222,6 +222,10 @@ export interface StyleProperties {
   locked?: boolean;
   /** Personal - user-specific style */
   personal?: boolean;
+  /** Personal compose - style for composing new messages */
+  personalCompose?: boolean;
+  /** Personal reply - style for replying to messages */
+  personalReply?: boolean;
   /** Link - linked character/paragraph style ID */
   link?: string;
   /** Auto-redefine - update style from manual formatting */
@@ -440,6 +444,38 @@ export class Style {
     return this;
   }
 
+  /**
+   * Sets whether this is a personal compose style (for composing new messages)
+   * @param enabled - True to mark as personal compose
+   */
+  setPersonalCompose(enabled: boolean): this {
+    this.properties.personalCompose = enabled;
+    return this;
+  }
+
+  /**
+   * Gets whether this is a personal compose style
+   */
+  getPersonalCompose(): boolean {
+    return this.properties.personalCompose === true;
+  }
+
+  /**
+   * Sets whether this is a personal reply style (for replying to messages)
+   * @param enabled - True to mark as personal reply
+   */
+  setPersonalReply(enabled: boolean): this {
+    this.properties.personalReply = enabled;
+    return this;
+  }
+
+  /**
+   * Gets whether this is a personal reply style
+   */
+  getPersonalReply(): boolean {
+    return this.properties.personalReply === true;
+  }
+
   /**
    * Sets the linked style ID (for character/paragraph style linking)
    * @param styleId - ID of the linked style
@@ -794,6 +830,16 @@ export class Style {
       styleChildren.push(XMLBuilder.wSelf("personal"));
     }
 
+    // personalCompose - Style for composing new messages
+    if (this.properties.personalCompose) {
+      styleChildren.push(XMLBuilder.wSelf("personalCompose"));
+    }
+
+    // personalReply - Style for replying to messages
+    if (this.properties.personalReply) {
+      styleChildren.push(XMLBuilder.wSelf("personalReply"));
+    }
+
     // Add paragraph properties
     if (this.properties.paragraphFormatting || this.properties.numPr) {
       const pPr = this.generateParagraphProperties(

package/src/formatting/StylesManager.ts

@@ -8,6 +8,43 @@ import { XMLBuilder } from "../xml/XMLBuilder";
 import { XMLParser } from "../xml/XMLParser";
 import { Style, StyleType } from "./Style";
 
+/**
+ * Configuration for latent styles (w:latentStyles per ECMA-376 §17.7.4.6)
+ * Controls which built-in styles are shown in the Word UI gallery
+ */
+export interface LatentStylesConfig {
+  /** Default locked state for built-in styles */
+  defaultLockedState?: boolean;
+  /** Default UI priority for built-in styles */
+  defaultUiPriority?: number;
+  /** Default semi-hidden state */
+  defaultSemiHidden?: boolean;
+  /** Default unhide-when-used state */
+  defaultUnhideWhenUsed?: boolean;
+  /** Default quick format flag */
+  defaultQFormat?: boolean;
+  /** Total count of style definitions */
+  count?: number;
+}
+
+/**
+ * Exception to latent style defaults (w:lsdException per ECMA-376 §17.7.4.7)
+ */
+export interface LatentStyleException {
+  /** Style name */
+  name: string;
+  /** Override: locked state */
+  locked?: boolean;
+  /** Override: UI priority */
+  uiPriority?: number;
+  /** Override: semi-hidden */
+  semiHidden?: boolean;
+  /** Override: unhide when used */
+  unhideWhenUsed?: boolean;
+  /** Override: quick format */
+  qFormat?: boolean;
+}
+
 /**
  * Result of XML validation
  */
@@ -37,6 +74,10 @@ export class StylesManager {
   // Track which specific styles have been modified (for selective merging)
   private _modifiedStyleIds = new Set<string>();
 
+  // Latent styles configuration
+  private latentStyles?: LatentStylesConfig;
+  private latentStyleExceptions: LatentStyleException[] = [];
+
   /**
    * Registry of built-in style factory functions
    * Maps style ID to factory function for lazy loading
@@ -411,6 +452,46 @@ export class StylesManager {
     return style;
   }
 
+  /**
+   * Sets the latent styles configuration
+   * @param config - Latent styles configuration
+   */
+  setLatentStyles(config: LatentStylesConfig): this {
+    this.latentStyles = config;
+    this._modified = true;
+    return this;
+  }
+
+  /**
+   * Gets the latent styles configuration
+   */
+  getLatentStyles(): LatentStylesConfig | undefined {
+    return this.latentStyles;
+  }
+
+  /**
+   * Adds a latent style exception
+   * @param exception - The exception to add
+   */
+  addLatentStyleException(exception: LatentStyleException): this {
+    // Replace existing exception for same name
+    const idx = this.latentStyleExceptions.findIndex(e => e.name === exception.name);
+    if (idx >= 0) {
+      this.latentStyleExceptions[idx] = exception;
+    } else {
+      this.latentStyleExceptions.push(exception);
+    }
+    this._modified = true;
+    return this;
+  }
+
+  /**
+   * Gets all latent style exceptions
+   */
+  getLatentStyleExceptions(): LatentStyleException[] {
+    return [...this.latentStyleExceptions];
+  }
+
   /**
    * Generates the complete styles.xml file
    * @returns XML string for word/styles.xml
@@ -424,6 +505,11 @@ export class StylesManager {
     // Add document defaults
     stylesChildren.push(this.generateDocDefaults());
 
+    // Add latent styles if configured (per ECMA-376 CT_Styles order: docDefaults, latentStyles, style*)
+    if (this.latentStyles) {
+      stylesChildren.push(this.generateLatentStyles());
+    }
+
     // Add all styles
     for (const style of this.getAllStyles()) {
       stylesChildren.push(style.toXML());
@@ -481,6 +567,45 @@ export class StylesManager {
     ]);
   }
 
+  /**
+   * Generates the latent styles XML element
+   */
+  private generateLatentStyles() {
+    if (!this.latentStyles) return XMLBuilder.w("latentStyles", {}, []);
+
+    const attrs: Record<string, string> = {};
+    if (this.latentStyles.defaultLockedState !== undefined) {
+      attrs["w:defLockedState"] = this.latentStyles.defaultLockedState ? "1" : "0";
+    }
+    if (this.latentStyles.defaultUiPriority !== undefined) {
+      attrs["w:defUIPriority"] = this.latentStyles.defaultUiPriority.toString();
+    }
+    if (this.latentStyles.defaultSemiHidden !== undefined) {
+      attrs["w:defSemiHidden"] = this.latentStyles.defaultSemiHidden ? "1" : "0";
+    }
+    if (this.latentStyles.defaultUnhideWhenUsed !== undefined) {
+      attrs["w:defUnhideWhenUsed"] = this.latentStyles.defaultUnhideWhenUsed ? "1" : "0";
+    }
+    if (this.latentStyles.defaultQFormat !== undefined) {
+      attrs["w:defQFormat"] = this.latentStyles.defaultQFormat ? "1" : "0";
+    }
+    if (this.latentStyles.count !== undefined) {
+      attrs["w:count"] = this.latentStyles.count.toString();
+    }
+
+    const children = this.latentStyleExceptions.map(exc => {
+      const excAttrs: Record<string, string> = { "w:name": exc.name };
+      if (exc.locked !== undefined) excAttrs["w:locked"] = exc.locked ? "1" : "0";
+      if (exc.uiPriority !== undefined) excAttrs["w:uiPriority"] = exc.uiPriority.toString();
+      if (exc.semiHidden !== undefined) excAttrs["w:semiHidden"] = exc.semiHidden ? "1" : "0";
+      if (exc.unhideWhenUsed !== undefined) excAttrs["w:unhideWhenUsed"] = exc.unhideWhenUsed ? "1" : "0";
+      if (exc.qFormat !== undefined) excAttrs["w:qFormat"] = exc.qFormat ? "1" : "0";
+      return XMLBuilder.wSelf("lsdException", excAttrs);
+    });
+
+    return XMLBuilder.w("latentStyles", attrs, children);
+  }
+
   /**
    * Creates a new StylesManager with built-in styles
    * @returns New StylesManager instance

package/src/index.ts

@@ -103,7 +103,7 @@ export {
   isHyperlinkInstruction,
   ParsedHyperlinkInstruction,
 } from './elements/FieldHelpers';
-export { StructuredDocumentTag, SDTProperties, SDTLockType, SDTContent } from './elements/StructuredDocumentTag';
+export { StructuredDocumentTag, SDTProperties, SDTLockType, SDTContent, SDTPlaceholder, SDTDataBinding, ContentControlType } from './elements/StructuredDocumentTag';
 export { TableOfContents, TOCProperties } from './elements/TableOfContents';
 export { TableOfContentsElement } from './elements/TableOfContentsElement';
 export { AlternateContent } from './elements/AlternateContent';
@@ -181,7 +181,7 @@ export {
 // =============================================================================
 
 export { Style, StyleType, StyleProperties } from './formatting/Style';
-export { StylesManager, ValidationResult } from './formatting/StylesManager';
+export { StylesManager, ValidationResult, LatentStylesConfig, LatentStyleException } from './formatting/StylesManager';
 export {
   NumberingLevel,
   NumberFormat,

package/src/tracking/DocumentTrackingContext.ts

@@ -343,16 +343,47 @@ export class DocumentTrackingContext implements TrackingContext {
     }
 
     // Apply tblPrChange to each Table
+    // Per ECMA-376 §17.13.5.36, tblPrChange must contain FULL previous tblPr,
+    // not just the delta of changed properties.
     for (const [table, changes] of tableChanges) {
-      this.applyElementPrChange(changes, (prevProps, getNextId, date) => {
-        const existing = table.getTblPrChange();
-        if (existing) {
-          const merged = { ...(existing.previousProperties || {}), ...prevProps };
-          table.setTblPrChange({ ...existing, previousProperties: merged });
+      // Build full snapshot: start from current formatting, roll back changed properties
+      const currentFormatting = table.getFormatting();
+      const fullPrevProps: Record<string, unknown> = {};
+
+      for (const [key, value] of Object.entries(currentFormatting)) {
+        if (value !== undefined) {
+          fullPrevProps[key] = value;
+        }
+      }
+
+      // Roll back changed properties to their previous values
+      let latestTimestamp = 0;
+      for (const change of changes) {
+        if (change.previousValue !== undefined) {
+          fullPrevProps[change.property] = change.previousValue;
         } else {
-          table.setTblPrChange({ author: this.author, date, id: String(getNextId()), previousProperties: prevProps });
+          delete fullPrevProps[change.property];
         }
-      });
+        if (change.timestamp > latestTimestamp) {
+          latestTimestamp = change.timestamp;
+        }
+      }
+
+      const date = formatDateForXml(new Date(latestTimestamp));
+
+      const existing = table.getTblPrChange();
+      if (existing) {
+        // Merge: existing previous state takes precedence (it's the ORIGINAL baseline)
+        const merged = { ...fullPrevProps, ...(existing.previousProperties || {}) };
+        table.setTblPrChange({ ...existing, previousProperties: merged });
+      } else {
+        table.setTblPrChange({
+          author: this.author,
+          date,
+          id: String(this.revisionManager.consumeNextId()),
+          previousProperties: fullPrevProps,
+        });
+      }
     }
 
     // Apply trPrChange to each TableRow