@dra2020/baseclient 1.0.0

package/lib/ot-editutil/oteditutil.ts

@@ -0,0 +1,180 @@
+import * as LogAbstract from '../logabstract/all';
+import * as OT from '../ot-js/all';
+
+import * as DMP from "diff-match-patch";
+let DiffMatchPatch = new DMP.diff_match_patch();
+let DIFF_DELETE = DMP.DIFF_DELETE;
+let DIFF_INSERT = DMP.DIFF_INSERT;
+let DIFF_EQUAL = DMP.DIFF_EQUAL;
+
+export class OTEditUtil
+{
+	// Data members
+	ilog: LogAbstract.ILog;
+	resourceID: string;
+	resourceName: string;
+	clientID: string;
+
+	// Constructor
+	constructor(ilog: LogAbstract.ILog, rid: string, cid: string, name: string)
+		{
+			this.ilog = ilog;
+			this.resourceID = rid;
+			this.clientID = cid;
+			this.resourceName = name;
+		}
+
+	//
+	// Function: insertAtStart
+	//
+	// Description:
+	//	Generate an OTCompositeResource to insert a string at the start of a buffer of the given size.
+	//
+
+	insertAtStart(s: any, nCurrentLen: number): OT.OTCompositeResource
+		{
+			let edit = new OT.OTCompositeResource(this.resourceID, this.clientID);
+			let sEdit = new OT.OTStringResource(this.resourceName);
+			sEdit.edits.push([ OT.OpInsert, s.length, s ]);
+			sEdit.edits.push([ OT.OpCursor, 0, '' ]);
+			sEdit.edits.push([ OT.OpRetain, nCurrentLen, '' ]);
+			edit.edits.push(sEdit);
+			return edit;
+		}
+
+	//
+	// Function: insertAtEnd
+	//
+	// Description:
+	//	Generate an OTCompositeResource to insert a string at the end of a buffer of the given size.
+	//
+
+	insertAtEnd(s: any, nCurrentLen: number): OT.OTCompositeResource
+		{
+			let edit = new OT.OTCompositeResource(this.resourceID, this.clientID);
+			let sEdit = new OT.OTStringResource(this.resourceName);
+			sEdit.edits.push([ OT.OpRetain, nCurrentLen, '' ]);
+			sEdit.edits.push([ OT.OpInsert, s.length, s ]);
+			sEdit.edits.push([ OT.OpCursor, 0, '' ]);
+			edit.edits.push(sEdit);
+			return edit;
+		}
+
+	//
+	// Function: injectCursor
+	//
+	// Inject start/end cursor positions into an existing string resource.
+	//
+
+	injectCursor(edit: OT.OTCompositeResource, start: number, end?: number): void
+		{
+			if (start === undefined) return;
+			if (end === undefined) end = start;
+
+			let sEdit: OT.OTStringResource = edit.findResource(this.resourceName) as OT.OTStringResource;
+			if (sEdit == null)
+				return;
+			let cEdit: OT.OTStringResource = new OT.OTStringResource(this.resourceName);
+			if (start != 0)
+				cEdit.edits.push( [ OT.OpRetain, start, '' ] );
+			cEdit.edits.push( [ OT.OpCursor, 0, this.clientID ] );
+			if (end != start)
+			{
+				cEdit.edits.push( [ OT.OpRetain, end-start, '' ] );
+				cEdit.edits.push( [ OT.OpCursor, 1, this.clientID ] );
+			}
+			let nFinal: number = sEdit.finalLength();
+			if (end != nFinal)
+				cEdit.edits.push( [ OT.OpRetain, nFinal-end, '' ] );
+			sEdit.compose(cEdit);
+		}
+
+	//
+	// Function: extractCursor
+	//
+	// Extract cursor information by client. Returns an object indexed by clientID with an object with
+	// properties startSelection, endSelection.
+	//
+
+	extractCursor(edit: OT.OTCompositeResource): any
+		{
+			let cursors: any = { };
+			let sEdit: OT.OTStringResource = edit.findResource(this.resourceName) as OT.OTStringResource;
+			if (sEdit == null)
+				return cursors;
+			let pos: number = 0;
+			for (let i: number = 0; i < sEdit.length; i++)
+			{
+				let a: OT.OTSingleArrayEdit = sEdit.edits[i];
+				switch (a[0])
+				{
+					case OT.OpInsert:
+						pos += a[1];
+						break;
+					case OT.OpDelete:
+						break;
+					case OT.OpRetain:
+						pos += a[1];
+						break;
+					case OT.OpCursor:
+						if (a[2] != '')	// should have clientID...
+						{
+							let sel: any = cursors[a[2]];	// a[2] is clientID
+							if (sel === undefined) { sel = { }; cursors[a[2]] = sel; }
+							if (a[1] == 0)
+								sel['selectionStart'] = pos;	// 0 is selectionStart
+							else
+								sel['selectionEnd'] = pos;		// 1 is selectionEnd
+						}
+						break;
+					case OT.OpSet:
+						pos += a[1];
+						break;
+				}
+			}
+			return cursors;
+		}
+
+	//
+	// Function: computeEdit
+	//
+	// Description:
+	//	Given an old and new string, generate the (minimal) edits list necessary to convert the old
+	//	string into the new string.
+	//
+	// 	This is useful if you're not actually tracking the specfic edit operations happening to the
+	//	underlying string but rather just examining old and new values and trying to transmit
+	//	minimal diffs.
+	//
+	//	There are various good algorithms for computing the "edit distance" between two strings.
+	//	Here I've used the google DiffMatchPatch algorithm.
+	//
+
+	computeEdit(sOld: string, sNew: string): OT.OTCompositeResource
+		{
+			let edit = new OT.OTCompositeResource(this.resourceID, this.clientID);
+			let sEdit = new OT.OTStringResource(this.resourceName);
+			let diffs: DMP.Diff[] = DiffMatchPatch.diff_main(sOld, sNew);
+			if (diffs)
+				for (let i: number = 0; i < diffs.length; i++)
+				{
+					let diff: DMP.Diff = diffs[i];
+					let s = diff[1];
+					switch (diff[0])
+					{
+						case DIFF_DELETE:
+							sEdit.edits.push([ OT.OpDelete, s.length, '' ]);
+							break;
+						case DIFF_INSERT:
+							sEdit.edits.push([ OT.OpInsert, s.length, s ]);
+							break;
+						case DIFF_EQUAL:
+							sEdit.edits.push([ OT.OpRetain, s.length, '' ]);
+							break;
+					}
+				}
+
+			edit.edits.push(sEdit);
+			return edit;
+		}
+}

package/lib/ot-editutil/otmaputil.ts

@@ -0,0 +1,209 @@
+import * as OT from '../ot-js/all';
+import * as Util from '../util/all';
+
+export const MERGE: number = 0;
+export const REPLACE: number = 1;
+
+export class Editor
+{
+  private engine: OT.OTEngine;
+  private root: OT.OTCompositeResource;
+  private stamps: OT.OTCounterResource;
+
+  constructor(engine: OT.OTEngine)
+    {
+      this.engine = engine;
+      this.root = null;
+      this.stamps = null;
+    }
+
+  startLocalEdit(): void
+    {
+      if (this.root == null)
+        this.root = this.engine.startLocalEdit();
+    }
+
+  stamp(rid: string, prop: string): void
+    {
+      if (this.stamps == null)
+      {
+        this.startLocalEdit();
+        this.stamps = new OT.OTCounterResource(rid);
+        this.root.edits.push(this.stamps);
+      }
+      this.stamps.edits.push([ OT.OpCounterAdd, prop, 1 ]);
+    }
+
+  set(rid: string, p: string, v: any): Editor
+    {
+      this.rawObject(rid).set(p, v);
+      return this;
+    }
+
+  del(rid: string, p: string): Editor
+    {
+      this.rawObject(rid).del(p);
+      return this;
+    }
+
+  rawObject(rid: string): OT.OTMapResource
+    {
+      this.startLocalEdit();
+      return this.root.map(rid);
+    }
+
+  rawArray(rid: string): OT.OTArrayResource
+    {
+      this.startLocalEdit();
+      return this.root.array(rid);
+    }
+
+  editCounter(rid: string, oNew: any, mode: number = MERGE): void
+    {
+      let oOld = this.engine.toPartialValue(rid);
+      let aDiff: string[] = keyDiff(oOld, oNew);
+      
+      let mEdit = new OT.OTCounterResource(rid);
+
+      // Propagate sets
+      for (let i: number = 0; i < aDiff.length; i++)
+        mEdit.edits.push([ OT.OpCounterAdd, aDiff[i], oNew[aDiff[i]] ]);
+
+      // Also propagate deletes if REPLACE mode
+      if (mode == REPLACE)
+      {
+        for (var p in oOld) if (oOld.hasOwnProperty(p))
+          if (oNew[p] === undefined)
+            mEdit.edits.push([ OT.OpCounterDel, p, 0 ]);
+      }
+
+      if (mEdit.edits.length)
+      {
+        this.startLocalEdit();
+        this.root.edits.push(mEdit);
+      }
+    }
+
+  editObject(rid: string, oNew: any, mode: number = MERGE): void
+    {
+      if (rid === 'stamps')
+      {
+        this.editCounter(rid, oNew, mode);
+        return;
+      }
+
+      let oOld = this.engine.toPartialValue(rid);
+      let aDiff: string[] = keyDiff(oOld, oNew);
+      
+      let mEdit = new OT.OTMapResource(rid);
+
+      // Propagate sets
+      for (let i: number = 0; i < aDiff.length; i++)
+        mEdit.edits.push([ OT.OpMapSet, aDiff[i], oNew[aDiff[i]] ]);
+
+      // Also propagate deletes if REPLACE mode
+      if (mode == REPLACE)
+      {
+        for (var p in oOld) if (oOld.hasOwnProperty(p))
+          if (oNew[p] === undefined)
+            mEdit.edits.push([ OT.OpMapDel, p, 0 ]);
+      }
+
+      if (mEdit.edits.length)
+      {
+        this.startLocalEdit();
+        this.root.edits.push(mEdit);
+      }
+    }
+
+    editArray(rid: string, aNew: any[]): void
+    {
+      let aOld = this.engine.toPartialValue(rid);
+      if (aOld == null) aOld = [];
+      if (Util.deepEqual(aNew, aOld))
+        return;
+
+      let aEdit = new OT.OTArrayResource(rid);
+
+      let i: number = 0;
+      let iRetain: number = 0;
+      for (; i < aNew.length && i < aOld.length; i++)
+        if (Util.deepEqual(aNew[i], aOld[i]))
+          iRetain++;
+        else
+        {
+          if (iRetain > 0)
+          {
+            aEdit.edits.push([ OT.OpRetain, iRetain, [] ] );
+            iRetain = 0;
+          }
+          aEdit.edits.push([ OT.OpSet, 1, [ aNew[i] ] ]);
+        }
+      // Preserve equal ones at end
+      if (iRetain > 0)
+        aEdit.edits.push([ OT.OpRetain, iRetain, [] ] );
+      // Add new ones
+      if (aNew.length > i)
+        aEdit.edits.push([ OT.OpInsert, aNew.length - i, aNew.slice(i) ]);
+      // Or delete old ones
+      else if (aOld.length > i)
+        aEdit.edits.push([ OT.OpDelete, aOld.length - i, [] ]);
+
+      if (aEdit.edits.length)
+      {
+        this.startLocalEdit();
+        this.root.edits.push(aEdit);
+      }
+    }
+
+    edit(oNew: any): boolean
+    {
+      for (var p in oNew) if (oNew.hasOwnProperty(p))
+        if (Array.isArray(oNew[p]))
+          this.editArray(p, oNew[p]);
+        else
+          this.editObject(p, oNew[p]);
+      return this.commit();
+    }
+
+    get length(): number
+    {
+      return this.root && this.root.edits ? this.root.edits.length : 0;
+    }
+
+    commit(): boolean
+    {
+      if (this.root)
+      {
+        try
+        {
+          if (this.root.edits.length)
+            this.engine.addLocalEdit(this.root);
+          this.root = null;
+          this.stamps = null;
+          return true;
+        }
+        catch (err)
+        {
+          // Really would like to log this, but effectively this is a programming error of mismatched bases.
+          return false;
+        }
+      }
+    }
+}
+
+function keyDiff(oOld: any, oNew: any): string[]
+	{
+		if (oNew == null)
+			return [];
+
+		let aDiff: string[] = [];
+		for (var p in oNew) if (oNew.hasOwnProperty(p))
+			{
+				if (oOld == null || oOld[p] === undefined)
+					aDiff.push(p)
+				else if (! Util.deepEqual(oNew[p], oOld[p]))
+					aDiff.push(p);
+			}
+		return aDiff;
+	}

package/lib/ot-js/all.ts

@@ -0,0 +1,9 @@
+export * from "./otarray";
+export * from "./otengine";
+export * from "./otclientengine";
+export * from "./otcomposite";
+export * from "./otmap";
+export * from "./otcounter";
+export * from "./otserverengine";
+export * from "./ottypes";
+export * from "./otsession";