feat: expand types to allow differently typed arrays

With a comparator function, there's not a hard requirement for the two arrays to be compatible types. The comparator tells us whether they are "equal", and that's enough. This will maintain
the integrity between which type corresponds to what in the comparators, as well as the functions where appropriate.

This doesn't touch `getPatch` or `applyPatch`, because patching doesn’t make sense if the types don’t match.

Author: ericbf

src/diff/diff.ts

@@ -1,16 +1,16 @@
 import bestSubSequence from './lcs';
 
-export interface DiffData<T> {
+export interface DiffData<T, U = T> {
   removed: T[];
-  added: T[];
+  added: U[];
 }
 
-export function diff<T>(
+export function diff<T, U = T>(
   a: T[],
-  b: T[],
-  compareFunc: (ia: T, ib: T) => boolean = (ia: T, ib: T) => ia === ib,
-): DiffData<T> {
-  const ret: DiffData<T> = {
+  b: U[],
+  compareFunc: (ia: T, ib: U) => boolean = (ia: T, ib: U) => ia === (ib as unknown as T),
+): DiffData<T, U> {
+  const ret: DiffData<T, U> = {
     removed: [],
     added: [],
   };

src/diff/lcs.ts

@@ -1,4 +1,4 @@
-function lcs<T>(a: T[], b: T[], compareFunc: (a: T, b: T) => boolean): number {
+function lcs<T, U = T>(a: T[], b: U[], compareFunc: (a: T, b: U) => boolean): number {
   const M = a.length,
     N = b.length;
   const MAX = M + N;
@@ -39,23 +39,23 @@ enum Direct {
   all = horizontal | vertical | diagonal,
 }
 
-function getSolution<T>(
+function getSolution<T, U = T>(
   a: T[],
   aStart: number,
   aEnd: number,
-  b: T[],
+  b: U[],
   bStart: number,
   bEnd: number,
   d: number,
   startDirect: Direct,
   endDirect: Direct,
-  compareFunc: (a: T, b: T) => boolean,
+  compareFunc: (a: T, b: U) => boolean,
   elementsChanged: (
     type: 'add' | 'remove' | 'same',
     a: T[],
     aStart: number,
     aEnd: number,
-    b: T[],
+    b: U[],
     bStart: number,
     bEnd: number,
   ) => void,
@@ -285,16 +285,16 @@ function getSolution<T>(
   );
 }
 
-export default function bestSubSequence<T>(
+export default function bestSubSequence<T, U = T>(
   a: T[],
-  b: T[],
-  compareFunc: (a: T, b: T) => boolean,
+  b: U[],
+  compareFunc: (a: T, b: U) => boolean,
   elementsChanged: (
     type: 'add' | 'remove' | 'same',
     a: T[],
     aStart: number,
     aEnd: number,
-    b: T[],
+    b: U[],
     bStart: number,
     bEnd: number,
   ) => void,

src/diff/same.ts

@@ -1,9 +1,9 @@
 import bestSubSequence from './lcs';
 
-export default function <T>(
+export default function <T, U = T>(
   a: T[],
-  b: T[],
-  compareFunc: (ia: T, ib: T) => boolean = (ia: T, ib: T) => ia === ib,
+  b: U[],
+  compareFunc: (ia: T, ib: U) => boolean = (ia: T, ib: U) => ia === (ib as unknown as T),
 ): T[] {
   const ret: T[] = [];
   bestSubSequence(a, b, compareFunc, (type, oldArr, oldStart, oldEnd) => {