@createiq/htmldiff 1.0.5 → 1.1.0

package/src/HtmlDiff.ts

@@ -2,6 +2,7 @@ import Action from './Action'
 import Match from './Match'
 import MatchFinder from './MatchFinder'
 import Operation from './Operation'
+import { preprocessTables, restoreTablePlaceholders } from './TableDiff'
 import Utils from './Utils'
 import WordSplitter from './WordSplitter'
 
@@ -64,9 +65,21 @@ export default class HtmlDiff {
     'span',
   ])
 
+  /**
+   * Hard cap on nested `HtmlDiff.execute` calls (table preprocessing
+   * recurses through `diffCell` for cell content). Each level allocates
+   * fresh DP matrices and word arrays; without a guard a maliciously
+   * nested table-in-cell-in-table-in-cell input could blow stack and
+   * memory. Set high enough to comfortably handle real legal documents
+   * (tables nested 2-3 deep at most), low enough to short-circuit
+   * pathological input.
+   */
+  private static MaxTablePreprocessDepth = 8
+
   private content: string[] = []
   private newText: string
   private oldText: string
+  private readonly tablePreprocessDepth: number
 
   private specialTagDiffStack: string[] = []
   private newWords: string[] = []
@@ -134,14 +147,18 @@ export default class HtmlDiff {
    * Initializes a new instance of the class.
    * @param oldText The old text.
    * @param newText The new text.
+   * @param tablePreprocessDepth Internal: nested-call depth for table
+   *   preprocessing. Callers should leave at default (0); the recursive
+   *   `diffCell` callback in TableDiff bumps it.
    */
-  constructor(oldText: string, newText: string) {
+  constructor(oldText: string, newText: string, tablePreprocessDepth = 0) {
     this.oldText = oldText
     this.newText = newText
+    this.tablePreprocessDepth = tablePreprocessDepth
   }
 
-  static execute(oldText: string, newText: string) {
-    return new HtmlDiff(oldText, newText).build()
+  static execute(oldText: string, newText: string, tablePreprocessDepth = 0) {
+    return new HtmlDiff(oldText, newText, tablePreprocessDepth).build()
   }
 
   /**
@@ -154,6 +171,34 @@ export default class HtmlDiff {
       return this.newText
     }
 
+    // Table preprocessing: when both sides have matching `<table>` structures,
+    // diff cells positionally so cross-cell content shifts produce one
+    // independent del/ins per cell rather than cell-misaligned output.
+    // Recursion guarded by MaxTablePreprocessDepth to bound work on
+    // deeply-nested table-in-cell-in-table inputs. Caller-configured
+    // settings (block expressions, accuracy thresholds) are propagated to
+    // the recursive cell diff so cell-level output is consistent with the
+    // top-level configuration.
+    const blockExpressions = this.blockExpressions
+    const repeatingWordsAccuracy = this.repeatingWordsAccuracy
+    const orphanMatchThreshold = this.orphanMatchThreshold
+    const ignoreWhitespaceDifferences = this.ignoreWhitespaceDifferences
+    const tablePreprocess =
+      this.tablePreprocessDepth >= HtmlDiff.MaxTablePreprocessDepth
+        ? null
+        : preprocessTables(this.oldText, this.newText, (oldCell, newCell) => {
+            const inner = new HtmlDiff(oldCell, newCell, this.tablePreprocessDepth + 1)
+            for (const expr of blockExpressions) inner.addBlockExpression(expr)
+            inner.repeatingWordsAccuracy = repeatingWordsAccuracy
+            inner.orphanMatchThreshold = orphanMatchThreshold
+            inner.ignoreWhitespaceDifferences = ignoreWhitespaceDifferences
+            return inner.build()
+          })
+    if (tablePreprocess) {
+      this.oldText = tablePreprocess.modifiedOld
+      this.newText = tablePreprocess.modifiedNew
+    }
+
     this.splitInputsToWords()
     this.buildContentProjections()
 
@@ -170,7 +215,8 @@ export default class HtmlDiff {
       this.performOperation(op)
     }
 
-    return this.content.join('')
+    const result = this.content.join('')
+    return tablePreprocess ? restoreTablePlaceholders(result, tablePreprocess.placeholderToDiff) : result
   }
 
   /**
@@ -517,7 +563,7 @@ export default class HtmlDiff {
         const openingAndClosingTagsMatch =
           !!openingTag && Utils.getTagName(openingTag) === Utils.getTagName(words[tagIndexToCompare])
 
-        if (!!openingTag && openingAndClosingTagsMatch) {
+        if (openingTag && openingAndClosingTagsMatch) {
           specialCaseTagInjection = '</ins>'
           specialCaseTagInjectionIsBefore = true
         }