Rewrite json.js -> json.ts and get tests passing (I'm honestly shocked they passed)

Author: ExplodingCabbage

src/diff/base.ts

@@ -19,6 +19,10 @@ export interface DiffOptions<ValueT> {
 
   // diffChars or diffWords only:
   ignoreCase?: boolean,
+
+  // diffJson only:
+  undefinedReplacement?: any,
+  stringifyReplacer?: (k: string, v: any) => any,
 }
 
 /**
@@ -66,7 +70,7 @@ export default class Diff<
   }
 
   private diffWithOptionsObj(oldTokens: TokenT[], newTokens: TokenT[], options: DiffOptions<TokenT>, callback: DiffCallback<TokenT>) {
-    let self = this;
+    const self = this;
     function done(value) {
       value = self.postProcess(value, options);
       if (callback) {
@@ -156,7 +160,7 @@ export default class Diff<
 
         if (basePath.oldPos + 1 >= oldLen && newPos + 1 >= newLen) {
           // If we have hit the end of both strings, then we are done
-          return done(this.buildValues(basePath.lastComponent, newTokens, oldTokens));
+          return done(self.buildValues(basePath.lastComponent, newTokens, oldTokens));
         } else {
           bestPath[diagonalPath] = basePath;
           if (basePath.oldPos + 1 >= oldLen) {

src/diff/json.js renamed to src/diff/json.ts

@@ -1,27 +1,34 @@
-import Diff from './base';
+import Diff, {DiffOptions} from './base';
 import {lineDiff} from './line';
 
-export const jsonDiff = new Diff();
-// Discriminate between two lines of pretty-printed, serialized JSON where one of them has a
-// dangling comma and the other doesn't. Turns out including the dangling comma yields the nicest output:
-// TODO: Override getter
-jsonDiff.useLongestToken = true;
+class JsonDiff extends Diff<string, string> {
+  protected get useLongestToken() {
+    // Discriminate between two lines of pretty-printed, serialized JSON where one of them has a
+    // dangling comma and the other doesn't. Turns out including the dangling comma yields the nicest output:
+    return true;
+  }
+
+  protected tokenize = lineDiff.tokenize
+
+  protected castInput(value: string, options: DiffOptions<string>) {
+    const {undefinedReplacement, stringifyReplacer = (k, v) => typeof v === 'undefined' ? undefinedReplacement : v} = options;
+
+    return typeof value === 'string' ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), stringifyReplacer, '  ');
+  };
+
+  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);
+  };
+}
 
-jsonDiff.tokenize = lineDiff.tokenize;
-jsonDiff.castInput = function(value, options) {
-  const {undefinedReplacement, stringifyReplacer = (k, v) => typeof v === 'undefined' ? undefinedReplacement : v} = options;
+const jsonDiff = new JsonDiff();
 
-  return typeof value === 'string' ? value : JSON.stringify(canonicalize(value, null, null, stringifyReplacer), stringifyReplacer, '  ');
-};
-jsonDiff.equals = function(left, right, options) {
-  return Diff.prototype.equals.call(jsonDiff, left.replace(/,([\r\n])/g, '$1'), right.replace(/,([\r\n])/g, '$1'), options);
-};
 
-export function diffJson(oldObj, newObj, options) { return jsonDiff.diff(oldObj, newObj, options); }
+export function diffJson(oldObj: any, newObj: any, options: DiffOptions<string>) { return jsonDiff.diff(oldObj, newObj, options); }
 
 // This function handles the presence of circular references by bailing out when encountering an
 // object that is already on the "stack" of items being processed. Accepts an optional replacer
-export function canonicalize(obj, stack, replacementStack, replacer, key) {
+export function canonicalize(obj: any, stack: Array<any> | null, replacementStack: Array<any> | null, replacer: (string, any) => any, key?: string) {
   stack = stack || [];
   replacementStack = replacementStack || [];