@dra2020/baseclient 1.0.173 → 1.0.175

package/dist/fsm/fsm.d.ts

@@ -15,15 +15,19 @@ export declare const FSM_CUSTOM7: number;
 export declare const FSM_CUSTOM8: number;
 export declare const FSM_CUSTOM9: number;
 export type FsmIndex = Set<Fsm>;
+export type FsmExceptionHandler = (fsm: Fsm, err: any) => void;
 export declare class FsmManager {
     theId: number;
     theEpoch: number;
     bTickSet: boolean;
     theTickList: FsmIndex;
     theBusyLoopCount: number;
+    theExceptionCount: number;
+    onException: FsmExceptionHandler;
     constructor();
     forceTick(fsm: Fsm): void;
     doTick(): void;
+    tickException(f: Fsm, err: any): void;
 }
 export interface FsmEnvironment {
     fsmManager: FsmManager;
@@ -55,6 +59,7 @@ export declare class Fsm {
     waitOnCompleted(f: Fsm): void;
     _completed(f: Fsm): void;
     tick(): void;
+    tickException(err: any): void;
 }
 export declare class FsmOnDone extends Fsm {
     cb: any;

package/dist/geo/multiblockmapping.d.ts

@@ -14,14 +14,18 @@ export declare class MultiBlockMapping {
     entries: Entry[];
     stamp: number;
     constructor(tag?: string, bm?: BlockMapping);
-    add(tag: string, bm: BlockMapping): void;
+    add(tag: string, bm: BlockMapping, rbm?: ReverseBlockMapping): void;
+    addFrom(src: MultiBlockMapping, tag?: string): void;
     remove(tag: string): void;
+    has(tag: string): boolean;
     map(blockid: string): string;
     multimap(blockid: string): string[];
     bmOf(tag: string): BlockMapping;
+    rbmOf(tag: string): ReverseBlockMapping;
     mapmain(blockid: string): string;
     rev(geoid: string): string[];
-    forEach(cb: (blockid: string) => void): void;
+    forEachBase(cb: (blockid: string) => void, tag?: string): void;
+    forEachBlock(cb: (blockid: string) => void): void;
     forEachRev(cb: (geoidid: string, blocks: string[]) => void): void;
 }
 export {};

package/lib/fsm/fsm.ts

@@ -53,6 +53,8 @@ function FsmStateToString(state: number): string
 
 export type FsmIndex = Set<Fsm>;
 
+export type FsmExceptionHandler = (fsm: Fsm, err: any) => void;
+
 export class FsmManager
 {
   theId: number;
@@ -60,6 +62,8 @@ export class FsmManager
   bTickSet: boolean;
   theTickList: FsmIndex;
   theBusyLoopCount: number;
+  theExceptionCount: number;
+  onException: FsmExceptionHandler;
 
   constructor()
   {
@@ -68,6 +72,8 @@ export class FsmManager
     this.bTickSet = false;
     this.theTickList = new Set<Fsm>();
     this.theBusyLoopCount = 0;
+    this.theExceptionCount = 0;
+    this.onException = (fsm: Fsm, err: any) => { console.error(`Fsm(${fsm.constructor.name}): exception in tick:`, err) };
     this.doTick = this.doTick.bind(this);
   }
 
@@ -92,7 +98,16 @@ export class FsmManager
       let thisTickList = this.theTickList;
       this.theTickList = new Set<Fsm>();
 
-      thisTickList.forEach((f: Fsm) => f.tick());
+      thisTickList.forEach((f: Fsm) => {
+          try
+          {
+            f.tick();
+          }
+          catch (err)
+          {
+            this.tickException(f, err);
+          }
+        });
     }
 
     if (this.theTickList.size == 0)
@@ -102,6 +117,29 @@ export class FsmManager
 
     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: Fsm, err: any): void
+  {
+    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(FSM_ERROR);
+    }
+  }
 }
 
 export interface FsmEnvironment
@@ -225,6 +263,14 @@ export class Fsm
   tick(): void
   {
   }
+
+  // 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: any): void
+  {
+    if (! this.done)
+      this.setState(FSM_ERROR);
+  }
 }
 
 // Launches callback provided when the associated Fsm (or Fsm array) completes.

package/lib/geo/multiblockmapping.ts

@@ -21,6 +21,16 @@ export function reverseBlockMapping(bm: BlockMapping): ReverseBlockMapping
   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.
 export class MultiBlockMapping
 {
   entries: Entry[];
@@ -34,14 +44,32 @@ export class MultiBlockMapping
       this.entries.push({ tag, bm });
   }
 
-  add(tag: string, bm: BlockMapping): void
+  // 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: string, bm: BlockMapping, rbm?: ReverseBlockMapping): void
   {
-    this.entries.forEach(e => { if (e.tag === tag) { e.bm = bm; delete e.rbm; bm = null } });
-    if (bm)
-      this.entries.push({ tag, bm });
+    let e = this.entries.find(e => e.tag === tag);
+    if (e)
+    {
+      e.bm = 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: MultiBlockMapping, tag?: string): void
+  {
+    src.entries.forEach(e => {
+        if (tag === undefined || e.tag === tag)
+          this.add(e.tag, e.bm, src.rbmOf(e.tag));
+      });
+  }
+
   remove(tag: string): void
   {
     for (let i = this.entries.length-1; i >= 0; i--)
@@ -52,6 +80,11 @@ export class MultiBlockMapping
       }
   }
 
+  has(tag: string): boolean
+  {
+    return this.entries.some(e => e.tag === tag);
+  }
+
   map(blockid: string): string
   {
     // Walk backwards to pick up overrides first
@@ -77,6 +110,17 @@ export class MultiBlockMapping
     return e ? e.bm : null;
   }
 
+  // The reverse mapping of the entry for tag, computed on first use.
+  rbmOf(tag: string): ReverseBlockMapping
+  {
+    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: string): string
   {
     return this.entries.length ? this.entries[0].bm[blockid] : undefined;
@@ -95,11 +139,21 @@ export class MultiBlockMapping
     return undefined;
   }
 
-  // Just walks first map
-  forEach(cb: (blockid: string) => void): void
+  // 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: (blockid: string) => void, tag?: string): void
+  {
+    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: (blockid: string) => void): void
   {
-    if (this.entries.length)
-      Object.keys(this.entries[0].bm).forEach(blockid => cb(blockid));
+    this.entries.forEach(e => Object.keys(e.bm).forEach(blockid => cb(blockid)));
   }
 
   // Walk maps in reverse order, careful to not invoke on same geoid

package/package.json

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