docxmlater 10.1.3 → 10.1.5

package/src/utils/formatting.ts

@@ -1,213 +1,220 @@
-/**
- * Formatting utilities for deep merging and cloning formatting objects
- * Used for style inheritance and applying formatting
- */
-
-/**
- * Deep merges two formatting objects, with override taking precedence
- * Used for style inheritance and applying formatting
- *
- * @param base - Base formatting object
- * @param override - Override formatting object (takes precedence)
- * @returns Merged formatting object
- *
- * @example
- * ```typescript
- * const baseFormat = { bold: true, fontSize: 24 };
- * const overrideFormat = { fontSize: 28, italic: true };
- * const result = mergeFormatting(baseFormat, overrideFormat);
- * // Result: { bold: true, fontSize: 28, italic: true }
- * ```
- */
-export function mergeFormatting<T extends Record<string, any>>(
-  base: T,
-  override: Partial<T>
-): T {
-  const result = { ...base };
-
-  for (const [key, value] of Object.entries(override)) {
-    if (value === undefined) continue;
-
-    if (typeof value === 'object' && !Array.isArray(value) && value !== null) {
-      // Deep merge nested objects
-      result[key as keyof T] = mergeFormatting(
-        result[key as keyof T] || ({} as any),
-        value
-      );
-    } else {
-      // Direct assignment for primitives
-      result[key as keyof T] = value;
-    }
-  }
-
-  return result;
-}
-
-/**
- * Deep clones a formatting object
- * Creates a completely independent copy with no shared references
- *
- * @param formatting - Formatting object to clone
- * @returns Cloned formatting object
- *
- * @example
- * ```typescript
- * const original = { bold: true, indentation: { left: 100 } };
- * const cloned = cloneFormatting(original);
- * cloned.indentation.left = 200; // Doesn't affect original
- * ```
- */
-export function cloneFormatting<T>(formatting: T): T {
-  return JSON.parse(JSON.stringify(formatting));
-}
-
-/**
- * Checks if a formatting object has any defined properties
- *
- * @param formatting - Formatting object to check
- * @returns True if the object has at least one defined property
- *
- * @example
- * ```typescript
- * hasFormatting({}) // false
- * hasFormatting({ bold: true }) // true
- * hasFormatting({ bold: undefined }) // false
- * ```
- */
-export function hasFormatting(formatting: Record<string, unknown>): boolean {
-  for (const value of Object.values(formatting)) {
-    if (value !== undefined && value !== null) {
-      return true;
-    }
-  }
-  return false;
-}
-
-/**
- * Removes undefined and null properties from a formatting object
- * Useful for cleaning up formatting before comparison or serialization
- *
- * @param formatting - Formatting object to clean
- * @returns Cleaned formatting object with no undefined/null values
- *
- * @example
- * ```typescript
- * const dirty = { bold: true, italic: undefined, fontSize: null, underline: false };
- * const clean = cleanFormatting(dirty);
- * // Result: { bold: true, underline: false }
- * ```
- */
-export function cleanFormatting<T extends Record<string, any>>(formatting: T): Partial<T> {
-  const cleaned: Partial<T> = {};
-
-  for (const [key, value] of Object.entries(formatting)) {
-    if (value !== undefined && value !== null) {
-      if (typeof value === 'object' && !Array.isArray(value)) {
-        // Recursively clean nested objects
-        const cleanedNested = cleanFormatting(value);
-        if (Object.keys(cleanedNested).length > 0) {
-          cleaned[key as keyof T] = cleanedNested as any;
-        }
-      } else {
-        cleaned[key as keyof T] = value;
-      }
-    }
-  }
-
-  return cleaned;
-}
-
-/**
- * Compares two formatting objects for equality
- * Performs deep comparison of all properties
- *
- * @param format1 - First formatting object
- * @param format2 - Second formatting object
- * @returns True if the formatting objects are equal
- *
- * @example
- * ```typescript
- * const a = { bold: true, fontSize: 24 };
- * const b = { bold: true, fontSize: 24 };
- * const c = { bold: true, fontSize: 28 };
- * isEqualFormatting(a, b) // true
- * isEqualFormatting(a, c) // false
- * ```
- */
-export function isEqualFormatting(
-  format1: Record<string, unknown>,
-  format2: Record<string, unknown>
-): boolean {
-  // Quick reference check
-  if (format1 === format2) return true;
-
-  // Null/undefined checks
-  if (!format1 || !format2) return false;
-
-  // Get all keys from both objects
-  const keys1 = Object.keys(format1);
-  const keys2 = Object.keys(format2);
-
-  // Check if they have the same number of properties
-  if (keys1.length !== keys2.length) return false;
-
-  // Check all properties
-  for (const key of keys1) {
-    const val1 = format1[key];
-    const val2 = format2[key];
-
-    // Both undefined/null - considered equal
-    if ((val1 === undefined || val1 === null) && (val2 === undefined || val2 === null)) {
-      continue;
-    }
-
-    // One is undefined/null and the other isn't
-    if ((val1 === undefined || val1 === null) !== (val2 === undefined || val2 === null)) {
-      return false;
-    }
-
-    // Check nested objects
-    if (typeof val1 === 'object' && val1 !== null && typeof val2 === 'object' && val2 !== null && !Array.isArray(val1) && !Array.isArray(val2)) {
-      if (!isEqualFormatting(val1 as Record<string, unknown>, val2 as Record<string, unknown>)) return false;
-    } else if (val1 !== val2) {
-      return false;
-    }
-  }
-
-  return true;
-}
-
-/**
- * Applies default values to a formatting object for any undefined properties
- *
- * @param formatting - Formatting object to apply defaults to
- * @param defaults - Default values
- * @returns Formatting object with defaults applied
- *
- * @example
- * ```typescript
- * const format = { bold: true };
- * const defaults = { bold: false, italic: false, fontSize: 24 };
- * const result = applyDefaults(format, defaults);
- * // Result: { bold: true, italic: false, fontSize: 24 }
- * ```
- */
-export function applyDefaults<T extends Record<string, any>>(
-  formatting: Partial<T>,
-  defaults: T
-): T {
-  const result = { ...defaults };
-
-  for (const [key, value] of Object.entries(formatting)) {
-    if (value !== undefined) {
-      if (typeof value === 'object' && !Array.isArray(value) && value !== null && typeof defaults[key] === 'object') {
-        // Deep merge nested objects
-        result[key as keyof T] = applyDefaults(value, defaults[key]);
-      } else {
-        result[key as keyof T] = value;
-      }
-    }
-  }
-
-  return result;
-}
+/**
+ * Formatting utilities for deep merging and cloning formatting objects
+ * Used for style inheritance and applying formatting
+ */
+
+/**
+ * Deep merges two formatting objects, with override taking precedence
+ * Used for style inheritance and applying formatting
+ *
+ * @param base - Base formatting object
+ * @param override - Override formatting object (takes precedence)
+ * @returns Merged formatting object
+ *
+ * @example
+ * ```typescript
+ * const baseFormat = { bold: true, fontSize: 24 };
+ * const overrideFormat = { fontSize: 28, italic: true };
+ * const result = mergeFormatting(baseFormat, overrideFormat);
+ * // Result: { bold: true, fontSize: 28, italic: true }
+ * ```
+ */
+export function mergeFormatting<T extends Record<string, any>>(base: T, override: Partial<T>): T {
+  const result = { ...base };
+
+  for (const [key, value] of Object.entries(override)) {
+    if (value === undefined) continue;
+
+    if (typeof value === 'object' && !Array.isArray(value) && value !== null) {
+      // Deep merge nested objects
+      result[key as keyof T] = mergeFormatting(result[key as keyof T] || ({} as any), value);
+    } else {
+      // Direct assignment for primitives
+      result[key as keyof T] = value;
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Deep clones a formatting object
+ * Creates a completely independent copy with no shared references
+ *
+ * @param formatting - Formatting object to clone
+ * @returns Cloned formatting object
+ *
+ * @example
+ * ```typescript
+ * const original = { bold: true, indentation: { left: 100 } };
+ * const cloned = cloneFormatting(original);
+ * cloned.indentation.left = 200; // Doesn't affect original
+ * ```
+ */
+export function cloneFormatting<T>(formatting: T): T {
+  return JSON.parse(JSON.stringify(formatting));
+}
+
+/**
+ * Checks if a formatting object has any defined properties
+ *
+ * @param formatting - Formatting object to check
+ * @returns True if the object has at least one defined property
+ *
+ * @example
+ * ```typescript
+ * hasFormatting({}) // false
+ * hasFormatting({ bold: true }) // true
+ * hasFormatting({ bold: undefined }) // false
+ * ```
+ */
+export function hasFormatting(formatting: Record<string, unknown>): boolean {
+  for (const value of Object.values(formatting)) {
+    if (value !== undefined && value !== null) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Removes undefined and null properties from a formatting object
+ * Useful for cleaning up formatting before comparison or serialization
+ *
+ * @param formatting - Formatting object to clean
+ * @returns Cleaned formatting object with no undefined/null values
+ *
+ * @example
+ * ```typescript
+ * const dirty = { bold: true, italic: undefined, fontSize: null, underline: false };
+ * const clean = cleanFormatting(dirty);
+ * // Result: { bold: true, underline: false }
+ * ```
+ */
+export function cleanFormatting<T extends Record<string, any>>(formatting: T): Partial<T> {
+  const cleaned: Partial<T> = {};
+
+  for (const [key, value] of Object.entries(formatting)) {
+    if (value !== undefined && value !== null) {
+      if (typeof value === 'object' && !Array.isArray(value)) {
+        // Recursively clean nested objects
+        const cleanedNested = cleanFormatting(value);
+        if (Object.keys(cleanedNested).length > 0) {
+          cleaned[key as keyof T] = cleanedNested as any;
+        }
+      } else {
+        cleaned[key as keyof T] = value;
+      }
+    }
+  }
+
+  return cleaned;
+}
+
+/**
+ * Compares two formatting objects for equality
+ * Performs deep comparison of all properties
+ *
+ * @param format1 - First formatting object
+ * @param format2 - Second formatting object
+ * @returns True if the formatting objects are equal
+ *
+ * @example
+ * ```typescript
+ * const a = { bold: true, fontSize: 24 };
+ * const b = { bold: true, fontSize: 24 };
+ * const c = { bold: true, fontSize: 28 };
+ * isEqualFormatting(a, b) // true
+ * isEqualFormatting(a, c) // false
+ * ```
+ */
+export function isEqualFormatting(
+  format1: Record<string, unknown>,
+  format2: Record<string, unknown>
+): boolean {
+  // Quick reference check
+  if (format1 === format2) return true;
+
+  // Null/undefined checks
+  if (!format1 || !format2) return false;
+
+  // Get all keys from both objects
+  const keys1 = Object.keys(format1);
+  const keys2 = Object.keys(format2);
+
+  // Check if they have the same number of properties
+  if (keys1.length !== keys2.length) return false;
+
+  // Check all properties
+  for (const key of keys1) {
+    const val1 = format1[key];
+    const val2 = format2[key];
+
+    // Both undefined/null - considered equal
+    if ((val1 === undefined || val1 === null) && (val2 === undefined || val2 === null)) {
+      continue;
+    }
+
+    // One is undefined/null and the other isn't
+    if ((val1 === undefined || val1 === null) !== (val2 === undefined || val2 === null)) {
+      return false;
+    }
+
+    // Check nested objects
+    if (
+      typeof val1 === 'object' &&
+      val1 !== null &&
+      typeof val2 === 'object' &&
+      val2 !== null &&
+      !Array.isArray(val1) &&
+      !Array.isArray(val2)
+    ) {
+      if (!isEqualFormatting(val1 as Record<string, unknown>, val2 as Record<string, unknown>))
+        return false;
+    } else if (val1 !== val2) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+/**
+ * Applies default values to a formatting object for any undefined properties
+ *
+ * @param formatting - Formatting object to apply defaults to
+ * @param defaults - Default values
+ * @returns Formatting object with defaults applied
+ *
+ * @example
+ * ```typescript
+ * const format = { bold: true };
+ * const defaults = { bold: false, italic: false, fontSize: 24 };
+ * const result = applyDefaults(format, defaults);
+ * // Result: { bold: true, italic: false, fontSize: 24 }
+ * ```
+ */
+export function applyDefaults<T extends Record<string, any>>(
+  formatting: Partial<T>,
+  defaults: T
+): T {
+  const result = { ...defaults };
+
+  for (const [key, value] of Object.entries(formatting)) {
+    if (value !== undefined) {
+      if (
+        typeof value === 'object' &&
+        !Array.isArray(value) &&
+        value !== null &&
+        typeof defaults[key] === 'object'
+      ) {
+        // Deep merge nested objects
+        result[key as keyof T] = applyDefaults(value, defaults[key]);
+      } else {
+        result[key as keyof T] = value;
+      }
+    }
+  }
+
+  return result;
+}

package/src/utils/list-detection.ts

@@ -5,13 +5,13 @@
  * paragraph list properties.
  */
 
-import type { Paragraph } from "../elements/Paragraph";
+import type { Paragraph } from '../elements/Paragraph';
 import type {
   ListCategory,
   ListDetectionResult,
   NumberFormat,
   BulletFormat,
-} from "../types/list-types";
+} from '../types/list-types';
 
 // =============================================================================
 // CONSTANTS
@@ -36,13 +36,13 @@ export const TYPED_LIST_PATTERNS: Record<string, RegExp> = {
 
 /** Map pattern names to categories */
 export const PATTERN_TO_CATEGORY: Record<string, ListCategory> = {
-  decimal: "numbered",
-  lowerLetter: "numbered",
-  upperLetter: "numbered",
-  lowerRoman: "numbered",
-  bullet: "bullet",
-  dash: "bullet",
-  arrow: "bullet",
+  decimal: 'numbered',
+  lowerLetter: 'numbered',
+  upperLetter: 'numbered',
+  lowerRoman: 'numbered',
+  bullet: 'bullet',
+  dash: 'bullet',
+  arrow: 'bullet',
 };
 
 /**
@@ -53,14 +53,14 @@ export const PATTERN_TO_CATEGORY: Record<string, ListCategory> = {
  *   Level 2: i., ii., iii. (lowerRoman)
  */
 export const FORMAT_TO_LEVEL: Record<string, number> = {
-  decimal: 0,      // 1., 2., 3.
-  lowerLetter: 1,  // a., b., c.
-  upperLetter: 1,  // A., B., C.
-  lowerRoman: 2,   // i., ii., iii.
-  upperRoman: 2,   // I., II., III.
-  bullet: 0,       // Top-level bullet (filled circle)
-  dash: 0,         // Top-level dash marker
-  arrow: 0,        // Top-level arrow marker
+  decimal: 0, // 1., 2., 3.
+  lowerLetter: 1, // a., b., c.
+  upperLetter: 1, // A., B., C.
+  lowerRoman: 2, // i., ii., iii.
+  upperRoman: 2, // I., II., III.
+  bullet: 0, // Top-level bullet (filled circle)
+  dash: 0, // Top-level dash marker
+  arrow: 0, // Top-level arrow marker
 };
 
 /**
@@ -124,7 +124,7 @@ export function detectTypedPrefix(text: string): {
     if (match) {
       // Special check for single-letter patterns (lowerLetter, upperLetter)
       // to avoid false positives on abbreviations like "P.O. Box", "U.S.", "A.M."
-      if (format === "lowerLetter" || format === "upperLetter") {
+      if (format === 'lowerLetter' || format === 'upperLetter') {
         const remaining = text.substring(match[0].length);
         // If remaining text starts with another letter followed by period,
         // this is likely an abbreviation, not a list marker
@@ -136,12 +136,12 @@ export function detectTypedPrefix(text: string): {
       return {
         prefix: match[0],
         format: format as NumberFormat | BulletFormat,
-        category: PATTERN_TO_CATEGORY[format] ?? "none",
+        category: PATTERN_TO_CATEGORY[format] ?? 'none',
       };
     }
   }
 
-  return { prefix: null, format: null, category: "none" };
+  return { prefix: null, format: null, category: 'none' };
 }
 
 /**
@@ -163,7 +163,7 @@ export function detectListType(paragraph: Paragraph): ListDetectionResult {
   // Priority 1: Real Word list with <w:numPr>
   if (numbering?.numId !== undefined && numbering.numId !== 0) {
     return {
-      category: "numbered", // Default, caller can refine with NumberingManager lookup
+      category: 'numbered', // Default, caller can refine with NumberingManager lookup
       isWordList: true,
       typedPrefix: null,
       inferredLevel: numbering.level ?? 0,
@@ -193,7 +193,7 @@ export function detectListType(paragraph: Paragraph): ListDetectionResult {
 
   // Priority 3: Not a list
   return {
-    category: "none",
+    category: 'none',
     isWordList: false,
     typedPrefix: null,
     inferredLevel: 0,
@@ -213,10 +213,10 @@ export function validateListSequence(
 ): { valid: boolean; warnings: string[] } {
   const warnings: string[] = [];
   let lastDecimal = 0;
-  let lastLetter = "";
+  let lastLetter = '';
 
   for (const { detection } of paragraphs) {
-    if (!detection.typedPrefix || detection.category !== "numbered") continue;
+    if (!detection.typedPrefix || detection.category !== 'numbered') continue;
 
     const match = /^(\d+|[a-zA-Z]+)/.exec(detection.typedPrefix);
     if (!match?.[1]) continue;
@@ -235,11 +235,7 @@ export function validateListSequence(
     // Check letter sequence
     if (/^[a-z]$/i.test(marker)) {
       const letter = marker.toLowerCase();
-      if (
-        lastLetter &&
-        letter.charCodeAt(0) !== lastLetter.charCodeAt(0) + 1 &&
-        letter !== "a"
-      ) {
+      if (lastLetter && letter.charCodeAt(0) !== lastLetter.charCodeAt(0) + 1 && letter !== 'a') {
         warnings.push(`Unexpected letter sequence: ${lastLetter} → ${letter}`);
       }
       lastLetter = letter;
@@ -253,22 +249,16 @@ export function validateListSequence(
  * Determine the list category for a given numId by checking the abstractNum.
  * This requires access to the NumberingManager.
  */
-export function getListCategoryFromFormat(
-  format: string | undefined
-): ListCategory {
-  if (!format) return "none";
+export function getListCategoryFromFormat(format: string | undefined): ListCategory {
+  if (!format) return 'none';
 
-  if (["bullet", "dash", "arrow"].includes(format)) {
-    return "bullet";
+  if (['bullet', 'dash', 'arrow'].includes(format)) {
+    return 'bullet';
   }
 
-  if (
-    ["decimal", "lowerLetter", "upperLetter", "lowerRoman", "upperRoman"].includes(
-      format
-    )
-  ) {
-    return "numbered";
+  if (['decimal', 'lowerLetter', 'upperLetter', 'lowerRoman', 'upperRoman'].includes(format)) {
+    return 'numbered';
   }
 
-  return "none";
+  return 'none';
 }