@dra2020/baseclient 1.0.122 → 1.0.124

package/dist/fsm/fsm.d.ts

@@ -14,9 +14,7 @@ export declare const FSM_CUSTOM6: number;
 export declare const FSM_CUSTOM7: number;
 export declare const FSM_CUSTOM8: number;
 export declare const FSM_CUSTOM9: number;
-export declare type FsmIndex = {
-    [key: number]: Fsm;
-};
+export declare type FsmIndex = Set<Fsm>;
 export declare class FsmManager {
     theId: number;
     theEpoch: number;
@@ -54,7 +52,8 @@ export declare class Fsm {
     waitOn(fsm: Fsm | Fsm[]): Fsm;
     setState(state: number): void;
     end(state?: number): void;
-    preTick(): void;
+    waitOnCompleted(f: Fsm): void;
+    _completed(f: Fsm): void;
     tick(): void;
 }
 export declare class FsmOnDone extends Fsm {

package/dist/ot-js/otarray.d.ts

@@ -91,8 +91,10 @@ export declare class OTArrayLikeResource extends OT.OTResourceBase {
     alignEdges(rhs: OTArrayLikeResource, st: OTalignEdgesType): void;
     getCursorCache(): any;
     compose(rhs: OTArrayLikeResource): void;
+    tryCompose(rhs: OTArrayLikeResource): boolean;
     performTransformReorder(bForceRetainBeforeInsert: boolean, newA: OTEdits, iBegin: number, iEnd: number): void;
     normalizeNewRetainsAfterTransform(bForceRetainBeforeInsert: boolean): void;
+    tryTransform(prior: OTArrayLikeResource, bPriorIsService: boolean): boolean;
     transform(prior: OTArrayLikeResource, bPriorIsService: boolean): void;
     generateRandom(nInitial: number, clientID: string): void;
 }

package/dist/ot-js/otcomposite.d.ts

@@ -26,7 +26,9 @@ export declare class OTCompositeResource extends OT.OTResourceBase {
     copy(): OTCompositeResource;
     effectivelyEqual(rhs: OTCompositeResource): boolean;
     transform(rhs: OTCompositeResource, bPriorIsService: boolean): void;
+    tryTransform(rhs: OTCompositeResource, bPriorIsService: boolean): boolean;
     compose(rhs: OTCompositeResource): void;
+    tryCompose(rhs: OTCompositeResource): boolean;
     apply(runningValue: any): any;
     toPartialValue(resourceName: string): any;
     toValue(): any;

package/dist/ot-js/ottypes.d.ts

@@ -8,7 +8,9 @@ export interface IOTResource {
     copy(): IOTResource;
     effectivelyEqual(rhs: IOTResource): boolean;
     transform(rhs: IOTResource, bPriorIsService: boolean): void;
+    tryTransform(rhs: IOTResource, bPriorIsService: boolean): boolean;
     compose(rhs: IOTResource): void;
+    tryCompose(rhs: IOTResource): boolean;
     apply(startValue: any): any;
     minimize(): void;
 }
@@ -23,7 +25,9 @@ export declare class OTResourceBase implements IOTResource {
     copy(): OTResourceBase;
     effectivelyEqual(rhs: OTResourceBase): boolean;
     transform(rhs: OTResourceBase, bPriorIsService: boolean): void;
+    tryTransform(rhs: OTResourceBase, bPriorIsServer: boolean): boolean;
     compose(rhs: OTResourceBase): void;
+    tryCompose(rhs: OTResourceBase): boolean;
     apply(startValue: any): any;
     minimize(): void;
 }

package/lib/fsm/fsm.ts

@@ -51,7 +51,7 @@ function FsmStateToString(state: number): string
   }
 }
 
-export type FsmIndex = { [key: number]: Fsm };
+export type FsmIndex = Set<Fsm>;
 
 export class FsmManager
 {
@@ -66,14 +66,14 @@ export class FsmManager
     this.theId = 0;
     this.theEpoch = 0;
     this.bTickSet = false;
-    this.theTickList = {};
+    this.theTickList = new Set<Fsm>();
     this.theBusyLoopCount = 0;
     this.doTick = this.doTick.bind(this);
   }
 
   forceTick(fsm: Fsm): void
   {
-    this.theTickList[fsm.id] = fsm;
+    this.theTickList.add(fsm);
     if (! this.bTickSet)
     {
       this.bTickSet = true;
@@ -82,32 +82,26 @@ export class FsmManager
   }
 
   doTick(): void
-    {
-      this.bTickSet = false;
-      let nLoops: number = 0;
-
-      while (nLoops < 1 && !Util.isEmpty(this.theTickList))
-      {
-        nLoops++;
-        let thisTickList = this.theTickList;
-        this.theTickList = {};
-
-        for (let id in thisTickList) if (thisTickList.hasOwnProperty(id))
-        {
-          let f = thisTickList[id];
-          f.preTick();
-          f.tick();
-        }
-      }
+  {
+    this.bTickSet = false;
+    let nLoops = 0;
 
-      if (Util.isEmpty(this.theTickList))
-        this.theBusyLoopCount = 0;
-      else
-        this.theBusyLoopCount++;
+    while (nLoops < 1 && this.theTickList.size > 0)
+    {
+      nLoops++;
+      let thisTickList = this.theTickList;
+      this.theTickList = new Set<Fsm>();
 
-      this.theEpoch++;
+      thisTickList.forEach((f: Fsm) => f.tick());
     }
 
+    if (this.theTickList.size == 0)
+      this.theBusyLoopCount = 0;
+    else
+      this.theBusyLoopCount++;
+
+    this.theEpoch++;
+  }
 }
 
 export interface FsmEnvironment
@@ -132,143 +126,105 @@ export class Fsm
       this.state = FSM_STARTING;
       this.dependentError = false;
       this.epochDone = -1;
-      this._waitOn = null;
-      this._waitedOn = null;
+      this._waitOn = new Set<Fsm>();
+      this._waitedOn = new Set<Fsm>();
       this.manager.forceTick(this);
     }
 
   get env(): FsmEnvironment { return this._env; }
   get manager(): FsmManager { return this.env.fsmManager; }
 
-  get done(): boolean
-    {
-      return FsmDone(this.state);
-    }
+  get done(): boolean { return FsmDone(this.state) }
 
-  get ready(): boolean
-    {
-      return !this.done && this._waitOn == null;
-    }
+  get ready(): boolean { return !this.done && this.nWaitOn == 0 }
 
-  get iserror(): boolean
-    {
-      return (this.state === FSM_ERROR || this.state === FSM_CANCEL);
-    }
+  get iserror(): boolean { return this.state === FSM_ERROR || this.state === FSM_CANCEL }
 
-  get isDependentError(): boolean
-    {
-      return this.dependentError;
-    }
+  get isDependentError(): boolean { return this.dependentError }
 
-  cancel(): void
-    {
-      // Override if you need to do more than marking complete
-      this.setState(FSM_CANCEL);
-    }
+  // Override if you need to do more than marking complete
+  cancel(): void { this.setState(FSM_CANCEL) }
 
-  setDependentError(): void
-    {
-      this.dependentError = true;
-    }
+  setDependentError(): void { this.dependentError = true }
 
-  clearDependentError(): void
-    {
-      this.dependentError = false;
-    }
+  clearDependentError(): void { this.dependentError = false }
 
-  get ticked(): boolean
-    {
-      return this.done && this.manager.theEpoch > this.epochDone;
-    }
+  get ticked(): boolean { return this.done && this.manager.theEpoch > this.epochDone }
 
-  get nWaitOn(): number
-    {
-      return Util.countKeys(this._waitOn);
-    }
+  get nWaitOn(): number { return this._waitOn.size }
 
-  get nWaitedOn(): number
-    {
-      return Util.countKeys(this._waitedOn);
-    }
+  get nWaitedOn(): number { return this._waitedOn.size }
 
   waitOn(fsm: Fsm | Fsm[]): Fsm
+  {
+    if (fsm == null)
+      return this;
+    else if (Array.isArray(fsm))
     {
-      if (fsm == null)
-        return this;
-      else if (Array.isArray(fsm))
+      fsm.forEach((f: Fsm) => this.waitOn(f));
+    }
+    else
+    {
+      if (fsm.done)
       {
-        for (let i: number = 0; i < fsm.length; i++)
-          this.waitOn(fsm[i]);
+        // If dependency is already done, don't add to waitOn list but ensure that
+        // this Fsm gets ticked during next epoch. This is because the dependent tick
+        // only happens when the dependency state is changed.
+        this.manager.forceTick(this);
+        if (fsm.iserror)
+          this.setDependentError();
       }
       else
       {
-        if (fsm.done)
-        {
-          // If dependency is already done, don't add to waitOn list but ensure that
-          // this Fsm gets ticked during next epoch. This is because the dependent tick
-          // only happens when the dependency state is changed.
-          this.manager.forceTick(this);
-          if (fsm.iserror)
-            this.setDependentError();
-        }
-        else
-        {
-          if (this._waitOn == null) this._waitOn = {};
-          this._waitOn[fsm.id] = fsm;
-          if (fsm._waitedOn == null) fsm._waitedOn = {};
-          fsm._waitedOn[this.id] = this;
-        }
+        this._waitOn.add(fsm);
+        fsm._waitedOn.add(this);
       }
-      return this;
     }
+    return this;
+  }
 
   setState(state: number): void
+  {
+    this.state = state;
+    if (this.done)
     {
-      this.state = state;
-      if (this.done)
+      // Loop because completion might add more to wait list
+      while (this.nWaitedOn)
       {
-        while (this._waitedOn)
-        {
-          let on = this._waitedOn;
-          this._waitedOn = null;
-          for (let id in on) if (on.hasOwnProperty(id))
-          {
-            let f = on[id];
-            if (this.iserror) f.setDependentError();
-            this.manager.forceTick(f);
-          }
-        }
-
-        this.epochDone = this.manager.theEpoch;
+        let waitedOn = this._waitedOn;
+        this._waitedOn = new Set<Fsm>();
+        waitedOn.forEach((f: Fsm) => { f._completed(this); this.manager.forceTick(f) });
       }
-      this.manager.forceTick(this);
+
+      this.epochDone = this.manager.theEpoch;
     }
+    this.manager.forceTick(this);
+  }
 
   // Can override if need to do more here
   end(state: number = FSM_DONE): void
-    {
-      this.setState(state);
-    }
+  {
+    this.setState(state);
+  }
 
-  // Cleans up _waitOn
-  preTick(): void
+  // Override if subclass needs to respond to individual items completing rather than waiting
+  // in tick. Useful to avoid O(n^2) if waiting on lots of items and not wanting to do a linear
+  // scan for completed FSMs. Or to not require separate bookkeeping for list of dependents.
+  waitOnCompleted(f: Fsm): void { }
+
+  _completed(f: Fsm): void
+  {
+    if (f.iserror) this.setDependentError();
+    if (f.done && this._waitOn.has(f))
     {
-      if (this._waitOn == null) return;
-      let bMore: boolean = false;
-      for (let id in this._waitOn) if (this._waitOn.hasOwnProperty(id))
-      {
-        let fsm = this._waitOn[id];
-        if (fsm.done)
-          delete this._waitOn[id];
-        else
-          bMore = true;
-      }
-      if (!bMore) this._waitOn = null;
+      this._waitOn.delete(f);
+      this.waitOnCompleted(f);
     }
+  }
 
   tick(): void
-    {
-    }
+  {
+  }
 }
 
 // Launches callback provided when the associated Fsm (or Fsm array) completes.

package/lib/ot-js/otarray.ts

@@ -770,6 +770,16 @@ export class OTArrayLikeResource extends OT.OTResourceBase
 			this.coalesce();
 		}
 
+	tryCompose(rhs: OTArrayLikeResource): boolean
+		{
+			if (this.length == 0)
+        return true;
+			else if (rhs.edits.length == 0)
+				return true;
+
+			return this.finalLength() == rhs.originalLength();
+    }
+
 	performTransformReorder(bForceRetainBeforeInsert: boolean, newA: OTEdits, iBegin: number, iEnd: number): void
 		{
 			if (iBegin < 0 || iBegin > iEnd) return;
@@ -835,6 +845,14 @@ export class OTArrayLikeResource extends OT.OTResourceBase
 			this.edits = newA;
 		}
 
+  tryTransform(prior: OTArrayLikeResource, bPriorIsService: boolean): boolean
+    {
+			if (this.length == 0 || prior.length == 0)
+				return true;
+
+			return this.originalLength() == prior.originalLength();
+    }
+
 	transform(prior: OTArrayLikeResource, bPriorIsService: boolean): void
 		{
 			if (this.length == 0 || prior.length == 0)

package/lib/ot-js/otcomposite.ts

@@ -133,6 +133,21 @@ export class OTCompositeResource extends OT.OTResourceBase
 			}
 		}
 
+	tryTransform(rhs: OTCompositeResource, bPriorIsService: boolean): boolean
+		{
+      let bSucceed = true;
+
+			for (let i: number = 0; bSucceed && i < rhs.length; i++)
+			{
+				let rhsEdit: OT.IOTResource = rhs.edits[i];
+				let lhsEdit: OT.IOTResource = this.findResource(rhsEdit.resourceName, rhsEdit.underlyingType, false);
+				if (lhsEdit)
+					bSucceed = lhsEdit.tryTransform(rhsEdit, bPriorIsService);
+			}
+
+      return bSucceed;
+		}
+
 	// compose two edit actions
 	compose(rhs: OTCompositeResource): void 			// throws on error
 		{
@@ -149,6 +164,21 @@ export class OTCompositeResource extends OT.OTResourceBase
 			this.clientSequenceNo = rhs.clientSequenceNo;
 		}
 
+	tryCompose(rhs: OTCompositeResource): boolean
+		{
+      let bSucceed = true;
+			for (let i: number = 0; bSucceed && i < rhs.length; i++)
+			{
+				let rhsEdit: OT.IOTResource = rhs.edits[i];
+
+				let lhsEdit: OT.IOTResource = this.findResource(rhsEdit.resourceName, rhsEdit.underlyingType, !rhsEdit.isEmpty());
+				if (lhsEdit)
+					bSucceed = lhsEdit.tryCompose(rhsEdit);
+			}
+
+      return bSucceed;
+		}
+
 	// apply this edit to an existing value, returning new value (if underlying type is mutable, may modify input)
 	// For composite, takes array of values, returns array of results, one for each underlying resource.
 	apply(runningValue: any): any

package/lib/ot-js/otserverengine.ts

@@ -245,11 +245,47 @@ export class OTServerEngine extends OTE.OTEngine
           for (i++; i < this.logServer.length; i++)
             aPrior.compose(this.logServer[i]);
 
+          if (! a.tryTransform(aPrior, true))
+          {
+            console.log('otserverengine: rejecting event on transform failure');
+            this.forgetEvents(orig);
+            return OTS.EClockReset;
+          }
+
           a.transform(aPrior, true);
         }
 
+        let bFail = ! this.stateServer.tryCompose(a);
+        if (bFail)
+        {
+          console.log('otserverengine: rejecting event on compose failure');
+          if (this.logServer.length)
+          {
+            let newState = this.logServer[0].copy();
+            for (let i = 1; i < this.logServer.length; i++)
+              newState.compose(this.logServer[i]);
+            if (newState.tryCompose(a))
+            {
+              console.log('otserverengine: actually... rejected event would succeed on composed log, so patching');
+              this.stateServer = newState;
+              bFail = false;
+            }
+            else
+              console.log('otserverengine: and... rejected event also fails on composed log');
+          }
+          else
+            console.log('otserverengine: and... no log to try to patch state with');
+
+          if (bFail)
+          {
+            this.forgetEvents(orig);
+            return OTS.EClockReset;
+          }
+        }
+
         a.clock = this.stateServer.clock + 1;
         this.stateServer.compose(a);
+
         this.resetCaches();
         this.emit('state');
         this.logServer.push(a.copy());

package/lib/ot-js/ottypes.ts

@@ -20,9 +20,14 @@ export interface IOTResource
 	// Core OT algorithm for this type
 	transform(rhs: IOTResource, bPriorIsService: boolean): void;			// throws on error
 
+  tryTransform(rhs: IOTResource, bPriorIsService: boolean): boolean;
+
 	// compose two edit actions
 	compose(rhs: IOTResource): void; 			// throws on error
 
+  // tests if compose would succeed, false on failure to prevent throwing during compose and leaving in partial state
+  tryCompose(rhs: IOTResource): boolean
+
 	// apply this edit to an existing value, returning new value (if underlying type is mutable, may modify input)
 	apply(startValue: any): any;
 
@@ -79,12 +84,24 @@ export class OTResourceBase implements IOTResource
 			throw "OTResourceBase.transform must be overridden in subclass";
 		}
 
+  // Test if transform would succeed, false on failure
+  tryTransform(rhs: OTResourceBase, bPriorIsServer: boolean): boolean
+    {
+      return true;
+    }
+
 	// compose two edit actions
 	compose(rhs: OTResourceBase): void
 		{
 			throw "OTResourceBase.compose must be overridden in subclass";
 		}
 
+  // test compose
+  tryCompose(rhs: OTResourceBase): boolean
+    {
+      return true;
+    }
+
 	// apply this edit to an existing value, returning new value (if underlying type is mutable, may modify input)
 	apply(startValue: any): any
 		{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dra2020/baseclient",
-  "version": "1.0.122",
+  "version": "1.0.124",
   "description": "Utility functions for Javascript projects.",
   "main": "dist/baseclient.js",
   "types": "./dist/all/all.d.ts",