line.js -> line.ts

Author: ExplodingCabbage

src/diff/base.ts

@@ -26,6 +26,12 @@ export interface DiffOptions<ValueT> {
 
   // diffWords only:
   intlSegmenter?: Intl.Segmenter,
+
+  // diffLines only:
+  stripTrailingCr?: boolean,
+  newlineIsToken?: boolean,
+  ignoreNewlineAtEof?: boolean,
+  ignoreWhitespace?: boolean, // TODO: This is SORT OF supported by diffWords. What to do?
 }
 
 /**

src/diff/json.ts

@@ -17,7 +17,7 @@ class JsonDiff extends Diff<string, string> {
   };
 
   protected equals(left: string, right: string, options: DiffOptions<string>) {
-    return super.equals.call(jsonDiff, left.replace(/,([\r\n])/g, '$1'), right.replace(/,([\r\n])/g, '$1'), options);
+    return super.equals(left.replace(/,([\r\n])/g, '$1'), right.replace(/,([\r\n])/g, '$1'), options);
   };
 }
 

src/diff/line.js

@@ -0,0 +1,86 @@
+import Diff, { DiffOptions } from './base';
+import {generateOptions} from '../util/params';
+
+
+class LineDiff extends Diff<string, string> {
+  protected tokenize(value: string, options: DiffOptions<string>) {
+    if(options.stripTrailingCr) {
+      // remove one \r before \n to match GNU diff's --strip-trailing-cr behavior
+      value = value.replace(/\r\n/g, '\n');
+    }
+
+    let retLines = [],
+        linesAndNewlines = value.split(/(\n|\r\n)/);
+
+    // Ignore the final empty token that occurs if the string ends with a new line
+    if (!linesAndNewlines[linesAndNewlines.length - 1]) {
+      linesAndNewlines.pop();
+    }
+
+    // Merge the content and line separators into single tokens
+    for (let i = 0; i < linesAndNewlines.length; i++) {
+      let line = linesAndNewlines[i];
+
+      if (i % 2 && !options.newlineIsToken) {
+        retLines[retLines.length - 1] += line;
+      } else {
+        retLines.push(line);
+      }
+    }
+
+    return retLines;
+  };
+
+  protected equals(left: string, right: string, options: DiffOptions<string>) {
+    // If we're ignoring whitespace, we need to normalise lines by stripping
+    // whitespace before checking equality. (This has an annoying interaction
+    // with newlineIsToken that requires special handling: if newlines get their
+    // own token, then we DON'T want to trim the *newline* tokens down to empty
+    // strings, since this would cause us to treat whitespace-only line content
+    // as equal to a separator between lines, which would be weird and
+    // inconsistent with the documented behavior of the options.)
+    if (options.ignoreWhitespace) {
+      if (!options.newlineIsToken || !left.includes('\n')) {
+        left = left.trim();
+      }
+      if (!options.newlineIsToken || !right.includes('\n')) {
+        right = right.trim();
+      }
+    } else if (options.ignoreNewlineAtEof && !options.newlineIsToken) {
+      if (left.endsWith('\n')) {
+        left = left.slice(0, -1);
+      }
+      if (right.endsWith('\n')) {
+        right = right.slice(0, -1);
+      }
+    }
+    return super.equals(left, right, options);
+  };
+
+}
+
+export const lineDiff = new LineDiff();
+
+export function diffLines(oldStr: string, newStr: string, options: DiffOptions<string>) {
+  return lineDiff.diff(oldStr, newStr, options);
+}
+
+
+
+export const lineDiff = new Diff();
+lineDiff.
+
+lineDiff.
+
+export function diffLines(oldStr, newStr, callback) { return lineDiff.diff(oldStr, newStr, callback); }
+
+// Kept for backwards compatibility. This is a rather arbitrary wrapper method
+// that just calls `diffLines` with `ignoreWhitespace: true`. It's confusing to
+// have two ways to do exactly the same thing in the API, so we no longer
+// document this one (library users should explicitly use `diffLines` with
+// `ignoreWhitespace: true` instead) but we keep it around to maintain
+// compatibility with code that used old versions.
+export function diffTrimmedLines(oldStr, newStr, callback) {
+  let options = generateOptions(callback, {ignoreWhitespace: true});
+  return lineDiff.diff(oldStr, newStr, options);
+}

src/diff/line.ts

@@ -141,7 +141,7 @@ class WordDiff extends Diff<string, string> {
 
 export const wordDiff = new WordDiff();
 
-export function diffWords(oldStr, newStr, options) {
+export function diffWords(oldStr: string, newStr: string, options) {
   // This option has never been documented and never will be (it's clearer to
   // just call `diffWordsWithSpace` directly if you need that behavior), but
   // has existed in jsdiff for a long time, so we retain support for it here