@dra2020/baseclient 1.0.173 → 1.0.174

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/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.174",
   "description": "Utility functions for Javascript projects.",
   "main": "dist/baseclient.js",
   "types": "./dist/all/all.d.ts",