@dra2020/baseclient 1.0.173 → 1.0.175

package/dist/baseclient.js

@@ -2261,6 +2261,8 @@ class FsmManager {
         this.bTickSet = false;
         this.theTickList = new Set();
         this.theBusyLoopCount = 0;
+        this.theExceptionCount = 0;
+        this.onException = (fsm, err) => { console.error(`Fsm(${fsm.constructor.name}): exception in tick:`, err); };
         this.doTick = this.doTick.bind(this);
     }
     forceTick(fsm) {
@@ -2277,7 +2279,14 @@ class FsmManager {
             nLoops++;
             let thisTickList = this.theTickList;
             this.theTickList = new Set();
-            thisTickList.forEach((f) => f.tick());
+            thisTickList.forEach((f) => {
+                try {
+                    f.tick();
+                }
+                catch (err) {
+                    this.tickException(f, err);
+                }
+            });
         }
         if (this.theTickList.size == 0)
             this.theBusyLoopCount = 0;
@@ -2285,6 +2294,27 @@ class FsmManager {
             this.theBusyLoopCount++;
         this.theEpoch++;
     }
+    // An exception escaping a tick would otherwise unwind out of setImmediate and take down the whole
+    // process (or, in the browser, leave the tick loop wedged). Instead, report it and let the Fsm
+    // fail itself so anything waiting on it sees a dependent error rather than hanging forever.
+    tickException(f, err) {
+        this.theExceptionCount++;
+        try {
+            this.onException(f, err);
+        }
+        catch (e) { }
+        try {
+            f.tickException(err);
+        }
+        catch (e) {
+            try {
+                this.onException(f, e);
+            }
+            catch (e2) { }
+            if (!f.done)
+                f.setState(exports.FSM_ERROR);
+        }
+    }
 }
 exports.FsmManager = FsmManager;
 class Fsm {
@@ -2364,6 +2394,12 @@ class Fsm {
     }
     tick() {
     }
+    // Called (after FsmManager.onException has reported it) when tick() throws. Override to clean up or
+    // respond, but make sure the Fsm ends up done.
+    tickException(err) {
+        if (!this.done)
+            this.setState(exports.FSM_ERROR);
+    }
 }
 exports.Fsm = Fsm;
 // Launches callback provided when the associated Fsm (or Fsm array) completes.
@@ -3451,6 +3487,16 @@ function reverseBlockMapping(bm) {
     Object.values(rev).forEach((a) => a.sort());
     return rev;
 }
+// A set of block mappings consulted as one, without copying any of them.
+//
+// Entries are either independent (e.g. one per state of a multi-state map, whose block ids never
+// overlap) or overlapping (a base mapping followed by overrides such as precinct updates). Overlapping
+// entries must be added in priority order: map() and rev() walk from the last entry back, so a later
+// entry wins.
+//
+// A full block mapping, and the reverse mapping computed from it, are large (TX has ~670K blocks), so
+// combining mappings shares them rather than copying: add() takes an already-computed reverse mapping,
+// and addFrom() takes both from another MultiBlockMapping.
 class MultiBlockMapping {
     constructor(tag, bm) {
         this.entries = [];
@@ -3458,16 +3504,30 @@ class MultiBlockMapping {
         if (tag && bm)
             this.entries.push({ tag, bm });
     }
-    add(tag, bm) {
-        this.entries.forEach(e => { if (e.tag === tag) {
+    // Adds or replaces the entry for tag. Pass rbm when the reverse mapping of bm is already computed,
+    // so it is shared rather than built again.
+    add(tag, bm, rbm) {
+        let e = this.entries.find(e => e.tag === tag);
+        if (e) {
             e.bm = bm;
-            delete e.rbm;
-            bm = null;
-        } });
-        if (bm)
-            this.entries.push({ tag, bm });
+            if (rbm)
+                e.rbm = rbm;
+            else
+                delete e.rbm;
+        }
+        else
+            this.entries.push(rbm ? { tag, bm, rbm } : { tag, bm });
         this.stamp++;
     }
+    // Adds the entry for tag from another mapping - or, with no tag, all of its entries in order - sharing
+    // both the block mapping and its reverse mapping. The reverse mapping is computed on the source first
+    // if need be, so that it is built once, there, and not separately in each mapping that shares it.
+    addFrom(src, tag) {
+        src.entries.forEach(e => {
+            if (tag === undefined || e.tag === tag)
+                this.add(e.tag, e.bm, src.rbmOf(e.tag));
+        });
+    }
     remove(tag) {
         for (let i = this.entries.length - 1; i >= 0; i--)
             if (this.entries[i].tag === tag) {
@@ -3475,6 +3535,9 @@ class MultiBlockMapping {
                 this.entries.splice(i, 1);
             }
     }
+    has(tag) {
+        return this.entries.some(e => e.tag === tag);
+    }
     map(blockid) {
         // Walk backwards to pick up overrides first
         for (let i = this.entries.length - 1; i >= 0; i--) {
@@ -3494,6 +3557,17 @@ class MultiBlockMapping {
         let e = this.entries.find(e => e.tag === tag);
         return e ? e.bm : null;
     }
+    // The reverse mapping of the entry for tag, computed on first use.
+    rbmOf(tag) {
+        let e = this.entries.find(e => e.tag === tag);
+        if (!e)
+            return null;
+        if (!e.rbm)
+            e.rbm = reverseBlockMapping(e.bm);
+        return e.rbm;
+    }
+    // Maps through the first entry only. Meaningful only where that entry is the base mapping and the
+    // rest are overrides; for independent entries (a multi-state mapping) use map().
     mapmain(blockid) {
         return this.entries.length ? this.entries[0].bm[blockid] : undefined;
     }
@@ -3507,10 +3581,18 @@ class MultiBlockMapping {
         }
         return undefined;
     }
-    // Just walks first map
-    forEach(cb) {
-        if (this.entries.length)
-            Object.keys(this.entries[0].bm).forEach(blockid => cb(blockid));
+    // Walks the blocks of one entry: the one for tag, or with no tag the first. This is the right walk
+    // over "all blocks" only when that entry is a base mapping covering them and the others are overrides
+    // of it - it sees nothing of a multi-state mapping but its first state. See forEachBlock.
+    forEachBase(cb, tag) {
+        let e = tag === undefined ? this.entries[0] : this.entries.find(e => e.tag === tag);
+        if (e)
+            Object.keys(e.bm).forEach(blockid => cb(blockid));
+    }
+    // Walks the blocks of every entry. A block mapped by several entries (a base and its overrides) is
+    // visited once for each of them; independent entries (a multi-state mapping) never repeat a block.
+    forEachBlock(cb) {
+        this.entries.forEach(e => Object.keys(e.bm).forEach(blockid => cb(blockid)));
     }
     // Walk maps in reverse order, careful to not invoke on same geoid
     forEachRev(cb) {