fix #6327 -- replace vendored ancient diff-match-patch with an upstream modern typescript library that fixes a number of significant issues

- complete diffTimeout implementation
- surrogate pairs unicode support
- unit testing
- typescript

Author: williamstein

src/packages/backend/conat/test/sync/dkv-merge.test.ts

@@ -9,7 +9,7 @@ pnpm test ./dkv-merge.test.ts
 
 import { dkv as createDkv } from "@cocalc/backend/conat/sync";
 import { once } from "@cocalc/util/async-utils";
-import { diff_match_patch } from "@cocalc/util/dmp";
+import { DiffMatchPatch } from "@cocalc/util/dmp";
 import { before, after } from "@cocalc/backend/conat/test/setup";
 
 beforeAll(before);
@@ -118,7 +118,7 @@ describe("test a trivial merge conflict resolution function", () => {
 });
 
 describe("test a 3-way merge of strings conflict resolution function", () => {
-  const dmp = new diff_match_patch();
+  const dmp = new DiffMatchPatch();
   const threeWayMerge = (opts: {
     prev: string;
     local: string;

src/packages/pnpm-lock.yaml

@@ -3,7 +3,7 @@
  *  License: MS-RSL – see LICENSE.md for details
  */
 
-import { CompressedPatch, Document } from "../generic/types";
+import { Document } from "../generic/types";
 import * as immutable from "immutable";
 import { isEqual } from "lodash";
 import { is_array, is_object, copy_without, len } from "@cocalc/util/misc";
@@ -25,6 +25,7 @@ type Index = immutable.Map<string, immutable.Set<number>>;
 type Indexes = immutable.Map<string, Index>;
 
 type jsmap = { [field: string]: any };
+type DBPatch = any // TODO: It's really this, but... [-1 | 1, jsmap];
 
 export type WhereCondition = { [field: string]: any };
 export type SetCondition =
@@ -163,7 +164,7 @@ export class DBDocument implements Document {
       .equals(immutable.Set(other.records).add(undefined));
   }
 
-  public apply_patch(patch: CompressedPatch): DBDocument {
+  public apply_patch(patch: DBPatch): DBDocument {
     let i = 0;
     let db: DBDocument = this;
     while (i < patch.length) {
@@ -177,7 +178,7 @@ export class DBDocument implements Document {
     return db;
   }
 
-  public make_patch(other: DBDocument): CompressedPatch {
+  public make_patch(other: DBDocument): DBPatch {
     if (other.size === 0) {
       // Special case -- delete everything
       return [-1, [{}]];

src/packages/sync/editor/db/doc.ts

@@ -10,6 +10,8 @@
 // A Patch is an entry in the patches table, as represented in memory locally here.
 
 import { SyncTable } from "@cocalc/sync/table/synctable";
+import { type CompressedPatch } from "@cocalc/util/dmp";
+export { type CompressedPatch };
 
 import type { ExecuteCodeOptionsWithCallback } from "@cocalc/util/types/execute-code";
 import type {
@@ -74,8 +76,6 @@ export interface Document {
   count(): number;
 }
 
-export type CompressedPatch = any[];
-
 export interface FileWatcher {
   on: (event: string, handler: Function) => void;
   close: () => void;

src/packages/sync/editor/generic/types.ts

@@ -3,97 +3,11 @@
  *  License: MS-RSL – see LICENSE.md for details
  */
 
-import { CompressedPatch, Patch } from "./types";
-import { diff_match_patch } from "@cocalc/util/dmp";
-
-const dmp = new diff_match_patch();
-dmp.Diff_Timeout = 0.2; // computing a diff won't block longer than about 0.2s
-
-// Here's what a diff-match-patch patch looks like
-//
-// [{"diffs":[[1,"{\"x\":5,\"y\":3}"]],"start1":0,"start2":0,"length1":0,"length2":13},...]
-//
-
-// TODO: we must explicitly type these as "Function" or typescript gives errors.
-// We should of course explicitly type the inputs and outputs of each, which
-// will make other code more robust. See above and look at the source...
-export const diff_main: Function = dmp.diff_main.bind(dmp);
-export const patch_make: Function = dmp.patch_make.bind(dmp);
-
-// The diff-match-patch library changed the format, but we must keep it the same
-// for backward compat and two stay JSON friendly.
-
-const Diff = diff_match_patch.Diff;
-
-function diffs_to_arrays(diffs: any[]): any[] {
-  const v: any[] = [];
-  for (const d of diffs) {
-    v.push([d[0], d[1]]);
-  }
-  return v;
-}
-
-function arrays_to_diffs(arrays: any[]): any[] {
-  const v: any[] = [];
-  for (const x of arrays) {
-    v.push(new Diff(x[0], x[1]));
-  }
-  return v;
-}
-
-export function compress_patch(patch: CompressedPatch): CompressedPatch {
-  return patch.map((p) => [
-    diffs_to_arrays(p.diffs),
-    p.start1,
-    p.start2,
-    p.length1,
-    p.length2,
-  ]);
-}
-
-export function decompress_patch(patch: CompressedPatch): CompressedPatch {
-  return patch.map((p) => ({
-    diffs: arrays_to_diffs(p[0]),
-    start1: p[1],
-    start2: p[2],
-    length1: p[3],
-    length2: p[4],
-  }));
-}
-
-// return *a* compressed patch that transforms string s0 into string s1.
-export function make_patch(s0: string, s1: string): CompressedPatch {
-  // @ts-ignore
-  return compress_patch(dmp.patch_make(s0, s1));
-}
-
-// apply a compressed patch to a string.
-export function apply_patch(
-  patch: CompressedPatch,
-  s: string,
-): [string, boolean] {
-  let x;
-  try {
-    x = dmp.patch_apply(decompress_patch(patch), s);
-    //console.log('patch_apply ', misc.to_json(decompress_patch(patch)), x)
-  } catch (err) {
-    // If a patch is so corrupted it can't be parsed -- e.g., due to a bug in SMC -- we at least
-    // want to make application the identity map (i.e., "best effort"), so
-    // the document isn't completely unreadable!
-    console.warn(`apply_patch -- ${err}, ${JSON.stringify(patch)}`);
-    return [s, false];
-  }
-  let clean = true;
-  for (const a of x[1]) {
-    if (!a) {
-      clean = false;
-      break;
-    }
-  }
-  return [x[0], clean];
-}
-
+import { Patch } from "./types";
 import { cmp_array } from "@cocalc/util/misc";
+export * from "@cocalc/util/dmp";
+import { type CompressedPatch } from "@cocalc/util/dmp";
+export { type CompressedPatch };
 
 export function patch_cmp(a: Patch, b: Patch): number {
   return cmp_array(
@@ -113,21 +27,6 @@ export function time_cmp(a: Date, b: Date): number {
   }
 }
 
-// Do a 3-way **string** merge by computing patch that transforms
-// base to remote, then applying that patch to local.
-export function three_way_merge(opts: {
-  base: string;
-  local: string;
-  remote: string;
-}): string {
-  if (opts.base === opts.remote) {
-    // trivial special case...
-    return opts.local;
-  }
-  // @ts-ignore
-  return dmp.patch_apply(dmp.patch_make(opts.base, opts.remote), opts.local)[0];
-}
-
 export function isTestClient(client: any) {
   return !!client?.isTestClient?.();
 }