@createiq/htmldiff 1.0.2 → 1.0.4-beta.0

package/dist/HtmlDiff.d.mts

@@ -0,0 +1,152 @@
+//#region src/HtmlDiff.d.ts
+declare class HtmlDiff {
+  /**
+   * This value defines balance between speed and memory utilization. The higher it is the faster it works and more memory consumes.
+   * @private
+   */
+  private static MatchGranularityMaximum;
+  private static DelTag;
+  private static InsTag;
+  private static SpecialCaseClosingTags;
+  private static SpecialCaseClosingTagsSet;
+  private static SpecialCaseOpeningTagRegex;
+  private static FormattingTags;
+  private content;
+  private newText;
+  private oldText;
+  private specialTagDiffStack;
+  private newWords;
+  private oldWords;
+  /**
+   * Content-only projections of oldWords/newWords (structural tags and adjacent whitespace removed).
+   * When null, no structural normalization is applied (the word arrays are identical for diffing).
+   */
+  private oldContentWords;
+  private newContentWords;
+  /** Maps content-word index → original word index */
+  private oldContentToOriginal;
+  private newContentToOriginal;
+  private matchGranularity;
+  private blockExpressions;
+  /**
+   * Defines how to compare repeating words. Valid values are from 0 to 1.
+   * This value allows to exclude some words from comparison that eventually
+   * reduces the total time of the diff algorithm.
+   * 0 means that all words are excluded so the diff will not find any matching words at all.
+   * 1 (default value) means that all words participate in comparison so this is the most accurate case.
+   * 0.5 means that any word that occurs more than 50% times may be excluded from comparison. This doesn't
+   * mean that such words will definitely be excluded but only gives a permission to exclude them if necessary.
+   */
+  repeatingWordsAccuracy: number;
+  /**
+   * If true all whitespaces are considered as equal
+   */
+  ignoreWhitespaceDifferences: boolean;
+  /**
+   * If some match is too small and located far from its neighbors then it is considered as orphan
+   * and removed. For example:
+   * <code>
+   * aaaaa bb ccccccccc dddddd ee
+   * 11111 bb 222222222 dddddd ee
+   * </code>
+   * will find two matches <code>bb</code> and <code>dddddd ee</code> but the first will be considered
+   * as orphan and ignored, as result it will consider texts <code>aaaaa bb ccccccccc</code> and
+   * <code>11111 bb 222222222</code> as single replacement:
+   * <code>
+   * &lt;del&gt;aaaaa bb ccccccccc&lt;/del&gt;&lt;ins&gt;11111 bb 222222222&lt;/ins&gt; dddddd ee
+   * </code>
+   * This property defines relative size of the match to be considered as orphan, from 0 to 1.
+   * 1 means that all matches will be considered as orphans.
+   * 0 (default) means that no match will be considered as orphan.
+   * 0.2 means that if match length is less than 20% of distance between its neighbors it is considered as orphan.
+   */
+  orphanMatchThreshold: number;
+  /**
+   * Initializes a new instance of the class.
+   * @param oldText The old text.
+   * @param newText The new text.
+   */
+  constructor(oldText: string, newText: string);
+  static execute(oldText: string, newText: string): string;
+  /**
+   * Builds the HTML diff output
+   * @return HTML diff markup
+   */
+  build(): string;
+  /**
+   * Uses {@link expression} to group text together so that any change detected within the group is treated as a single block
+   * @param expression
+   */
+  addBlockExpression(expression: RegExp): void;
+  private splitInputsToWords;
+  /**
+   * Checks whether the two word arrays have structural HTML differences (different non-formatting tags
+   * or different whitespace between structural tags). When they do, builds "content projections" that
+   * strip structural noise so the diff algorithm only sees meaningful content and formatting changes.
+   */
+  private buildContentProjections;
+  /**
+   * Tags that commonly serve as content wrappers and may change structurally
+   * without affecting the actual content. Only these tags are stripped during
+   * structural normalization.
+   */
+  private static WrapperTags;
+  private static isStructuralTag;
+  /**
+   * Returns true if words between structural tags are just whitespace (indentation).
+   */
+  private static isStructuralWhitespace;
+  private static createContentProjection;
+  private static hasStructuralDifferences;
+  private performOperation;
+  private processReplaceOperation;
+  private processInsertOperation;
+  private processDeleteOperation;
+  private processEqualOperation;
+  /**
+   * Gets original old words for a content-index range, including only content and formatting tags
+   * (used for delete/replace operations where we don't want structural tags).
+   */
+  private getOriginalOldWords;
+  /**
+   * Gets original new words for a content-index range, including only content and formatting tags
+   * (used for insert/replace operations where we don't want structural tags).
+   */
+  private getOriginalNewWords;
+  /**
+   * Gets original old words for a content-index range, INCLUDING structural tags and whitespace
+   * between the content words (used for equal operations to preserve old HTML structure).
+   */
+  private getOriginalOldWordsWithStructure;
+  /**
+   * This method encloses words within a specified tag (ins or del), and adds this into "content",
+   * with a twist: if there are words contain tags, it actually creates multiple ins or del,
+   * so that they don't include any ins or del. This handles cases like
+   * old: '<p>a</p>'
+   * new: '<p>ab</p>
+   * <p>
+   *     c</b>'
+   *     diff result: '<p>a<ins>b</ins></p>
+   *     <p>
+   *         <ins>c</ins>
+   *     </p>
+   *     '
+   *     this still doesn't guarantee valid HTML (hint: think about diffing a text containing ins or
+   *     del tags), but handles correctly more cases than the earlier version.
+   *     P.S.: Spare a thought for people who write HTML browsers. They live in this ... every day.
+   * @param tag
+   * @param cssClass
+   * @param words
+   * @private
+   */
+  private insertTag;
+  private extractConsecutiveWords;
+  private operations;
+  private removeOrphans;
+  private matchingBlocks;
+  private findMatchingBlocks;
+  private findMatch;
+}
+//#endregion
+export { HtmlDiff as default };
+//# sourceMappingURL=HtmlDiff.d.mts.map