@dra2020/baseclient 1.0.122 → 1.0.124

package/dist/baseclient.js

@@ -1921,12 +1921,12 @@ class FsmManager {
         this.theId = 0;
         this.theEpoch = 0;
         this.bTickSet = false;
-        this.theTickList = {};
+        this.theTickList = new Set();
         this.theBusyLoopCount = 0;
         this.doTick = this.doTick.bind(this);
     }
     forceTick(fsm) {
-        this.theTickList[fsm.id] = fsm;
+        this.theTickList.add(fsm);
         if (!this.bTickSet) {
             this.bTickSet = true;
             doLater(this.doTick);
@@ -1935,18 +1935,13 @@ class FsmManager {
     doTick() {
         this.bTickSet = false;
         let nLoops = 0;
-        while (nLoops < 1 && !Util.isEmpty(this.theTickList)) {
+        while (nLoops < 1 && this.theTickList.size > 0) {
             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.theTickList = new Set();
+            thisTickList.forEach((f) => f.tick());
         }
-        if (Util.isEmpty(this.theTickList))
+        if (this.theTickList.size == 0)
             this.theBusyLoopCount = 0;
         else
             this.theBusyLoopCount++;
@@ -1961,49 +1956,28 @@ class Fsm {
         this.state = exports.FSM_STARTING;
         this.dependentError = false;
         this.epochDone = -1;
-        this._waitOn = null;
-        this._waitedOn = null;
+        this._waitOn = new Set();
+        this._waitedOn = new Set();
         this.manager.forceTick(this);
     }
     get env() { return this._env; }
     get manager() { return this.env.fsmManager; }
-    get done() {
-        return FsmDone(this.state);
-    }
-    get ready() {
-        return !this.done && this._waitOn == null;
-    }
-    get iserror() {
-        return (this.state === exports.FSM_ERROR || this.state === exports.FSM_CANCEL);
-    }
-    get isDependentError() {
-        return this.dependentError;
-    }
-    cancel() {
-        // Override if you need to do more than marking complete
-        this.setState(exports.FSM_CANCEL);
-    }
-    setDependentError() {
-        this.dependentError = true;
-    }
-    clearDependentError() {
-        this.dependentError = false;
-    }
-    get ticked() {
-        return this.done && this.manager.theEpoch > this.epochDone;
-    }
-    get nWaitOn() {
-        return Util.countKeys(this._waitOn);
-    }
-    get nWaitedOn() {
-        return Util.countKeys(this._waitedOn);
-    }
+    get done() { return FsmDone(this.state); }
+    get ready() { return !this.done && this.nWaitOn == 0; }
+    get iserror() { return this.state === exports.FSM_ERROR || this.state === exports.FSM_CANCEL; }
+    get isDependentError() { return this.dependentError; }
+    // Override if you need to do more than marking complete
+    cancel() { this.setState(exports.FSM_CANCEL); }
+    setDependentError() { this.dependentError = true; }
+    clearDependentError() { this.dependentError = false; }
+    get ticked() { return this.done && this.manager.theEpoch > this.epochDone; }
+    get nWaitOn() { return this._waitOn.size; }
+    get nWaitedOn() { return this._waitedOn.size; }
     waitOn(fsm) {
         if (fsm == null)
             return this;
         else if (Array.isArray(fsm)) {
-            for (let i = 0; i < fsm.length; i++)
-                this.waitOn(fsm[i]);
+            fsm.forEach((f) => this.waitOn(f));
         }
         else {
             if (fsm.done) {
@@ -2015,12 +1989,8 @@ class Fsm {
                     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;
@@ -2028,16 +1998,11 @@ class Fsm {
     setState(state) {
         this.state = state;
         if (this.done) {
-            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);
-                    }
+            // Loop because completion might add more to wait list
+            while (this.nWaitedOn) {
+                let waitedOn = this._waitedOn;
+                this._waitedOn = new Set();
+                waitedOn.forEach((f) => { f._completed(this); this.manager.forceTick(f); });
             }
             this.epochDone = this.manager.theEpoch;
         }
@@ -2047,21 +2012,17 @@ class Fsm {
     end(state = exports.FSM_DONE) {
         this.setState(state);
     }
-    // Cleans up _waitOn
-    preTick() {
-        if (this._waitOn == null)
-            return;
-        let bMore = 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;
+    // 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) { }
+    _completed(f) {
+        if (f.iserror)
+            this.setDependentError();
+        if (f.done && this._waitOn.has(f)) {
+            this._waitOn.delete(f);
+            this.waitOnCompleted(f);
+        }
     }
     tick() {
     }
@@ -4366,6 +4327,13 @@ class OTArrayLikeResource extends OT.OTResourceBase {
         this.edits = newA;
         this.coalesce();
     }
+    tryCompose(rhs) {
+        if (this.length == 0)
+            return true;
+        else if (rhs.edits.length == 0)
+            return true;
+        return this.finalLength() == rhs.originalLength();
+    }
     performTransformReorder(bForceRetainBeforeInsert, newA, iBegin, iEnd) {
         if (iBegin < 0 || iBegin > iEnd)
             return;
@@ -4421,6 +4389,11 @@ class OTArrayLikeResource extends OT.OTResourceBase {
                 (newA[i])[0] = exports.OpRetain;
         this.edits = newA;
     }
+    tryTransform(prior, bPriorIsService) {
+        if (this.length == 0 || prior.length == 0)
+            return true;
+        return this.originalLength() == prior.originalLength();
+    }
     transform(prior, bPriorIsService) {
         if (this.length == 0 || prior.length == 0)
             return;
@@ -5101,6 +5074,16 @@ class OTCompositeResource extends OT.OTResourceBase {
                 lhsEdit.transform(rhsEdit, bPriorIsService);
         }
     }
+    tryTransform(rhs, bPriorIsService) {
+        let bSucceed = true;
+        for (let i = 0; bSucceed && i < rhs.length; i++) {
+            let rhsEdit = rhs.edits[i];
+            let lhsEdit = this.findResource(rhsEdit.resourceName, rhsEdit.underlyingType, false);
+            if (lhsEdit)
+                bSucceed = lhsEdit.tryTransform(rhsEdit, bPriorIsService);
+        }
+        return bSucceed;
+    }
     // compose two edit actions
     compose(rhs) {
         for (let i = 0; i < rhs.length; i++) {
@@ -5112,6 +5095,16 @@ class OTCompositeResource extends OT.OTResourceBase {
         this.clock = rhs.clock;
         this.clientSequenceNo = rhs.clientSequenceNo;
     }
+    tryCompose(rhs) {
+        let bSucceed = true;
+        for (let i = 0; bSucceed && i < rhs.length; i++) {
+            let rhsEdit = rhs.edits[i];
+            let lhsEdit = 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) {
@@ -5718,8 +5711,35 @@ class OTServerEngine extends OTE.OTEngine {
                 let aPrior = this.logServer[i].copy();
                 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();
@@ -5933,10 +5953,18 @@ class OTResourceBase {
     transform(rhs, bPriorIsService) {
         throw "OTResourceBase.transform must be overridden in subclass";
     }
+    // Test if transform would succeed, false on failure
+    tryTransform(rhs, bPriorIsServer) {
+        return true;
+    }
     // compose two edit actions
     compose(rhs) {
         throw "OTResourceBase.compose must be overridden in subclass";
     }
+    // test compose
+    tryCompose(rhs) {
+        return true;
+    }
     // apply this edit to an existing value, returning new value (if underlying type is mutable, may modify input)
     apply(startValue) {
         throw "OTResourceBase.apply must be overridden in subclass";