@dra2020/baseclient 1.0.0 → 1.0.4

package/dist/geo/all.d.ts

@@ -0,0 +1,2 @@
+export * from './geo';
+export * from './vfeature';

package/dist/geo/geo.d.ts

@@ -0,0 +1,67 @@
+import * as geojson from 'geojson';
+import * as Poly from '../poly/all';
+export declare type GeoProperties = geojson.GeoJsonProperties;
+export declare type GeoFeature = geojson.Feature;
+export declare type GeoFeatureArray = GeoFeature[];
+export declare type GeoFeatureCollection = geojson.FeatureCollection;
+export declare function geoCollectionToMap(col: GeoFeatureCollection): GeoFeatureMap;
+export declare function geoMapToCollection(map: GeoFeatureMap): GeoFeatureCollection;
+export declare function geoCollectionToTopo(col: GeoFeatureCollection): Poly.Topo;
+export declare function geoTopoToCollection(topo: Poly.Topo): GeoFeatureCollection;
+export interface GeoFeatureMap {
+    [id: string]: GeoFeature;
+}
+export declare type FeatureFunc = (f: GeoFeature) => void;
+interface GeoEntry {
+    tag: string;
+    col?: GeoFeatureCollection;
+    map?: GeoFeatureMap;
+    topo?: Poly.Topo;
+}
+declare type GeoEntryMap = {
+    [tag: string]: GeoEntry;
+};
+export declare function geoEqual(m1: GeoMultiCollection, m2: GeoMultiCollection): boolean;
+export declare function geoMapEqual(m1: GeoFeatureMap, m2: GeoFeatureMap): boolean;
+export declare class GeoMultiCollection {
+    entries: GeoEntryMap;
+    all: GeoEntry;
+    hidden: any;
+    stamp: number;
+    constructor(tag?: string, topo?: Poly.Topo, col?: GeoFeatureCollection, map?: GeoFeatureMap);
+    empty(): void;
+    get nEntries(): number;
+    nthEntry(n: number): GeoEntry;
+    add(tag: string, topo: Poly.Topo, col: GeoFeatureCollection, map: GeoFeatureMap): void;
+    addMulti(multi: GeoMultiCollection): void;
+    remove(tag: string): void;
+    _onChange(): void;
+    _col(e: GeoEntry): GeoFeatureCollection;
+    _map(e: GeoEntry): GeoFeatureMap;
+    _topo(e: GeoEntry): Poly.Topo;
+    colOf(tag: string): GeoFeatureCollection;
+    mapOf(tag: string): GeoFeatureMap;
+    topoOf(tag: string): Poly.Topo;
+    forEachEntry(cb: (e: GeoEntry) => void): void;
+    allCol(): GeoFeatureCollection;
+    allMap(): GeoFeatureMap;
+    allTopo(): Poly.Topo;
+    hide(id: any): void;
+    show(id: any): void;
+    showAll(): void;
+    get length(): number;
+    nthFeature(n: number): GeoFeature;
+    nthFilteredFeature(n: number, cb: (f: GeoFeature) => boolean): GeoFeature;
+    forEach(cb: FeatureFunc): void;
+    map(cb: (f: GeoFeature) => GeoFeature): GeoFeature[];
+    isHidden(id: string): boolean;
+    find(id: string): GeoFeature;
+    filter(test: (f: GeoFeature) => boolean): GeoMultiCollection;
+}
+export declare enum geoIntersectOptions {
+    Intersects = 0,
+    Bounds = 1,
+    BoundsCenter = 2
+}
+export declare function geoIntersect(multi: GeoMultiCollection, bbox: Poly.BoundBox, opt: geoIntersectOptions): GeoMultiCollection;
+export {};

package/dist/geo/vfeature.d.ts

@@ -0,0 +1,4 @@
+import * as Util from '../util/all';
+import * as Poly from '../poly/all';
+import * as G from './geo';
+export declare function computeVFeature(topoPrecinct: Poly.Topo, bintrie: Util.BinTrie, blocks: string[]): G.GeoFeature;

package/dist/poly/union.d.ts

@@ -2,6 +2,7 @@ import * as FSM from '../fsm/all';
 import * as Poly from './poly';
 import * as Q from './quad';
 export declare function polyIntersects(p1: any, p2: any): boolean;
+export declare function polyDifference(main: any, parts: any[]): any;
 declare class FsmDifference extends FSM.Fsm {
     accum: any;
     polys: any[];

package/docs/filterexpr.md

@@ -0,0 +1,22 @@
+# filterexpr
+Simple utility class for applying a user-provided filtering expression against an object.
+
+## FilterExpr
+
+Optionally initialize with expression to test against.
+Or call `set(expr: string)` to set the expression.
+The function `test(o: any)` will test the object against the expression.
+
+## Expression syntax
+
+The simplest expression is just a string of text. If any field in the object contains the string, the pattern matches.
+All comparisons are case-insensitive.
+
+A quoted string can be used to hide special characters. Single or double quotes are allowed.
+
+Expressions can be combined with `not`, `and`, and `or`. Precedence is in that order.
+
+Expressions can be surrounded by parens to force a precedence interpretation.
+
+A field name can be specified to limit the comparison to a specific field. An example is `state: ma`. Field names are case-insensitive.
+Field name is lowest precedence, so `state: ma or tx` would constrain both strings to the `state` property.

package/lib/all/all.ts

@@ -17,3 +17,5 @@ import * as OTE from '../ot-editutil/all';
 export { OTE };
 import { FilterExpr } from '../filterexpr/all';
 export { FilterExpr }
+import * as G from '../geo/all';
+export { G };

package/lib/geo/all.ts

@@ -0,0 +1,2 @@
+export * from './geo';
+export * from './vfeature';

package/lib/geo/geo.ts

@@ -0,0 +1,450 @@
+import * as geojson from 'geojson';
+import * as Util from '../util/all'
+import * as Poly from '../poly/all'
+
+export type GeoProperties = geojson.GeoJsonProperties;
+export type GeoFeature = geojson.Feature;
+export type GeoFeatureArray = GeoFeature[];
+export type GeoFeatureCollection = geojson.FeatureCollection;
+
+export function geoCollectionToMap(col: GeoFeatureCollection): GeoFeatureMap
+{
+  if (col == null) return null;
+  let map: GeoFeatureMap = {};
+  col.features.forEach((f: GeoFeature) => { map[String(f.properties.id)] = f; });
+  return map;
+}
+
+export function geoMapToCollection(map: GeoFeatureMap): GeoFeatureCollection
+{
+  if (map == null || Util.countKeys(map) == 0) return null;
+  let col: GeoFeatureCollection = { type: 'FeatureCollection', features: [] };
+  Object.keys(map).forEach((geoid: string) => { col.features.push(map[geoid]) });
+  return col;
+}
+
+export function geoCollectionToTopo(col: GeoFeatureCollection): Poly.Topo
+{
+  let topo = Poly.topoFromCollection(col);
+  Poly.topoPack(topo);
+  return topo;
+}
+
+export function geoTopoToCollection(topo: Poly.Topo): GeoFeatureCollection
+{
+  let col = Poly.topoToCollection(topo);
+  Poly.featurePack(col);
+  return col;
+}
+
+export interface GeoFeatureMap
+{
+  [id: string]: GeoFeature;  // Maps id to GeoFeature
+}
+
+export type FeatureFunc = (f: GeoFeature) => void;
+
+interface GeoEntry
+{
+  tag: string;
+  col?: GeoFeatureCollection;
+  map?: GeoFeatureMap;
+  topo?: Poly.Topo;
+}
+type GeoEntryMap = { [tag: string]: GeoEntry };
+
+export function geoEqual(m1: GeoMultiCollection, m2: GeoMultiCollection): boolean
+{
+  let n1 = m1 ? m1.length : 0;
+  let n2 = m2 ? m2.length : 0;
+  
+  if (n1 != n2) return false;
+  if (n1 == 0) return true;
+
+  let n = 0;
+  let eq = true;
+  m1.forEach(f => { if (eq && !m2.find(f.properties.id)) eq = false });
+  return eq;
+}
+
+export function geoMapEqual(m1: GeoFeatureMap, m2: GeoFeatureMap): boolean
+{
+  if (m1 == null) return Util.isEmpty(m2);
+  if (m2 == null) return Util.isEmpty(m1);
+  let p: string;
+  for (p in m1) if (m1.hasOwnProperty(p))
+    if (m1[p] !== m2[p])
+      return false;
+  for (p in m2) if (m2.hasOwnProperty(p))
+    if (m1[p] === undefined)
+      return false;
+  return true;
+}
+
+export class GeoMultiCollection
+{
+  entries: GeoEntryMap;
+  all: GeoEntry;
+  hidden: any;
+  stamp: number;
+
+  constructor(tag?: string, topo?: Poly.Topo, col?: GeoFeatureCollection, map?: GeoFeatureMap)
+  {
+    this.stamp = Math.trunc(Math.random() * Number.MAX_SAFE_INTEGER / 2);
+    this.empty();
+    if (tag)
+      this.add(tag, topo, col, map);
+  }
+
+  empty()
+  {
+    this.entries = {};
+    this.hidden = {};
+    this._onChange();
+  }
+
+  get nEntries(): number { return Util.countKeys(this.entries) }
+
+  nthEntry(n: number): GeoEntry
+  {
+    return Util.nthProperty(this.entries, n) as GeoEntry;
+  }
+
+  add(tag: string, topo: Poly.Topo, col: GeoFeatureCollection, map: GeoFeatureMap): void
+  {
+    let entry = this.entries[tag];
+    if (entry === undefined) entry = { tag: tag }, this.entries[tag] = entry;
+    if ((topo && entry.topo !== topo) || (col && entry.col !== col) || (map && entry.map !== map))
+    {
+      entry.topo = topo;
+      entry.col = col;
+      entry.map = map;
+      this._onChange();
+    }
+    else if (topo == null && col == null && map == null)
+      this.remove(tag);
+  }
+
+  addMulti(multi: GeoMultiCollection): void
+  {
+    multi.forEachEntry(e => {
+        this.add(e.tag, e.topo, e.col, e.map);
+      });
+    for (let p in multi.hidden) if (multi.hidden.hasOwnProperty(p))
+    {
+      this.hidden[p] = true;
+      this._onChange();
+    }
+  }
+
+  remove(tag: string): void
+  {
+    let entry = this.entries[tag];
+    if (entry)
+    {
+      if (entry.topo || entry.col || entry.map)
+        this._onChange();
+      delete this.entries[tag];
+    }
+  }
+
+  _onChange(): void
+  {
+    this.all = { tag: 'all' };
+    this.stamp++;
+  }
+
+  _col(e: GeoEntry): GeoFeatureCollection
+  {
+    if (e == null) return null;
+    if (! e.col)
+    {
+      if (e.map)
+        e.col = geoMapToCollection(e.map);
+      else if (e.topo)
+        e.col = geoTopoToCollection(e.topo);
+    }
+    return e.col;
+  }
+
+  _map(e: GeoEntry): GeoFeatureMap
+  {
+    if (e == null) return null;
+    if (! e.map)
+    {
+      if (e.col)
+        e.map = geoCollectionToMap(e.col);
+      else if (e.topo)
+      {
+        e.col = geoTopoToCollection(e.topo);
+        e.map = geoCollectionToMap(e.col);
+      }
+    }
+    return e.map;
+  }
+
+  _topo(e: GeoEntry): Poly.Topo
+  {
+    if (e == null) return null;
+    if (! e.topo)
+    {
+      if (e.col)
+        e.topo = geoCollectionToTopo(e.col);
+      else if (e.map)
+      {
+        e.col = geoMapToCollection(e.map);
+        e.topo = geoCollectionToTopo(e.col);
+      }
+    }
+    return e.topo;
+  }
+
+  colOf(tag: string): GeoFeatureCollection { return this._col(this.entries[tag]); }
+  mapOf(tag: string): GeoFeatureMap { return this._map(this.entries[tag]); }
+  topoOf(tag: string): Poly.Topo { return this._topo(this.entries[tag]); }
+
+  forEachEntry(cb: (e: GeoEntry) => void): void
+  {
+    Object.values(this.entries).forEach(cb);
+  }
+
+  allCol(): GeoFeatureCollection
+  {
+    if (this.nEntries == 0) return null;
+    if (! this.all.col)
+    {
+      // optimise case where one entry
+      let n = this.nEntries;
+      if (n == 1)
+        this.all.col = this._col(this.nthEntry(0));
+      else
+      {
+        this.all.col = { type: 'FeatureCollection', features: [] };
+        this.forEach(f => { this.all.col.features.push(f) });
+      }
+    }
+    return this.all.col;
+  }
+
+  allMap(): GeoFeatureMap
+  {
+    if (this.nEntries == 0) return null;
+    if (! this.all.map)
+    {
+      // optimise case where one entry
+      let n = this.nEntries;
+      if (n == 1)
+        this.all.map = this._map(this.nthEntry(0));
+      else
+        this.all.map = geoCollectionToMap(this.allCol());
+    }
+    return this.all.map;
+  }
+
+  allTopo(): Poly.Topo
+  {
+    if (this.nEntries == 0) return null;
+    if (! this.all.topo)
+    {
+      // optimise case where one entry
+      let n = this.nEntries;
+      if (n == 1)
+        this.all.topo = this._topo(this.nthEntry(0));
+      else
+        this.all.topo = geoCollectionToTopo(this.allCol());
+    }
+    return this.all.topo;
+  }
+
+  hide(id: any): void
+  {
+    if (id)
+    {
+      if (typeof id === 'string')
+        this.hidden[id] = true;
+      else if (Array.isArray(id))
+        id.forEach((i: string) => { this.hidden[i] = true })
+      else if (typeof id === 'object')
+        for (let p in id) if (id.hasOwnProperty(p)) this.hidden[p] = true;
+      this._onChange();
+    }
+  }
+
+  show(id: any): void
+  {
+    if (id)
+    {
+      if (typeof id === 'string')
+        delete this.hidden[id];
+      else if (Array.isArray(id))
+        id.forEach((i: string) => { delete this.hidden[i] })
+      else if (typeof id === 'object')
+        for (let p in id) if (id.hasOwnProperty(p)) delete this.hidden[p];
+      this._onChange();
+    }
+  }
+
+  showAll(): void
+  {
+    if (! Util.isEmpty(this.hidden))
+    {
+      this.hidden = {};
+      this._onChange();
+    }
+  }
+
+  get length(): number
+  {
+    let n = 0;
+    this.forEachEntry(e => {
+        if (e.col)
+          n += e.col.features.length;
+        else if (e.map)
+          n += Util.countKeys(e.map);
+        else if (e.topo)
+          n += Util.countKeys(e.topo.objects);
+      });
+    return n;
+  }
+
+  // Use forEach in preference to iteration using this function
+  nthFeature(n: number): GeoFeature
+  {
+    let found: GeoFeature;
+
+    if (n >= 0)
+      this.forEachEntry(e => {
+          if (found) return;
+          let col = this._col(e);
+          if (col)
+            if (n > col.features.length)
+              n -= col.features.length;
+            else
+              found = col.features[n];
+        });
+    return found;
+  }
+
+  nthFilteredFeature(n: number, cb: (f: GeoFeature) => boolean)
+  {
+    let found: GeoFeature;
+
+    this.forEachEntry(e => {
+        if (found) return;
+        let col = this._col(e);
+        if (col)
+          for (let i = 0; !found && i < col.features.length; i++)
+          {
+            let f = col.features[i];
+            if (this.hidden[f.properties.id] === undefined && cb(f))
+            {
+              if (n === 0)
+              {
+                found = f;
+                break;
+              }
+              n--;
+            }
+          }
+      });
+    return found;
+  }
+
+  forEach(cb: FeatureFunc): void
+  {
+    this.forEachEntry(e => {
+        let col = this._col(e);
+        if (e.col)
+          e.col.features.forEach(f => { if (this.hidden[f.properties.id] === undefined) cb(f) })
+      });
+  }
+
+  map(cb: (f: GeoFeature) => GeoFeature): GeoFeature[]
+  {
+    let features: GeoFeature[] = [];
+    this.forEach((f: GeoFeature) => { features.push(cb(f)) });
+    return features;
+  }
+
+  isHidden(id: string): boolean
+  {
+    return this.hidden[id] !== undefined;
+  }
+
+  find(id: string): GeoFeature
+  {
+    if (this.hidden[id] !== undefined)
+      return undefined;
+
+    let entries = Object.values(this.entries);
+    for (let i = 0; i < entries.length; i++)
+    {
+      let map = this._map(entries[i]);
+      if (map[id])
+        return map[id];
+    }
+
+    return undefined;
+  }
+
+  filter(test: (f: GeoFeature) => boolean): GeoMultiCollection
+  {
+    let m = new GeoMultiCollection();
+    this.forEachEntry(e => {
+        let col = this._col(e);
+        let features = col ? col.features.filter(test) : null;
+        if (features && features.length)
+          m.add(e.tag, null, { type: 'FeatureCollection', features: features }, null);
+      });
+    return m;
+  }
+}
+
+export enum geoIntersectOptions { Intersects, Bounds, BoundsCenter };
+
+function geoBoxIntersect(x1: Poly.BoundBox, x2: Poly.BoundBox, opt: geoIntersectOptions): boolean
+{
+  if (x1.left === undefined || x2.left === undefined) return false;
+
+  let l1 = x1.left;
+  let l2 = x2.left;
+  let r1 = x1.right;
+  let r2 = x2.right;
+  let b1 = x1.top;  // flip
+  let b2 = x2.top;  // flip
+  let t1 = x1.bottom;  // flip
+  let t2 = x2.bottom;  // flip
+  let cx2 = l2 + (r2 - l2) / 2;
+  let cy2 = t2 + (b2 - t2) / 2;
+
+  // Note I flipped top and bottom above when extracting,
+  // in order to make below logic work for normal y axis alignment (0 at top).
+  switch (opt)
+  {
+    case geoIntersectOptions.Intersects:
+      return !(l2 > r1 || r2 < l1 || t2 > b1 || b2 < t1);
+    case geoIntersectOptions.Bounds:
+      return l1 <= l2 && t1 <= t2 && r1 >= r2 && b1 >= b2;
+    case geoIntersectOptions.BoundsCenter:
+      return l1 <= cx2 && t1 <= cy2 && r1 >= cx2 && b1 >= cy2;
+  }
+}
+
+export function geoIntersect(multi: GeoMultiCollection, bbox: Poly.BoundBox, opt: geoIntersectOptions): GeoMultiCollection
+{
+  let m: GeoFeatureMap = {};
+  let bboxPoly = Poly.boundboxPoly(bbox);
+
+  multi.forEach((f: GeoFeature) => {
+      let box = Poly.boundbox(f);
+      if (geoBoxIntersect(bbox, box, opt))
+      {
+        if (opt !== geoIntersectOptions.Intersects || Poly.polyIntersects(bboxPoly, f))
+          m[f.properties.id] = f;
+      }
+    });
+
+  let result = new GeoMultiCollection();
+  result.add('result', null, null, m);
+  return result;
+}

package/lib/geo/vfeature.ts

@@ -0,0 +1,34 @@
+import * as geojson from 'geojson';
+import * as Util from '../util/all'
+import * as Poly from '../poly/all'
+import * as G from './geo';
+
+// Given the topology for a precinct, the bintrie mapping and the list of blocks, construct the
+// feature data for the virtual feature.
+//
+
+export function computeVFeature(topoPrecinct: Poly.Topo, bintrie: Util.BinTrie, blocks: string[]): G.GeoFeature
+{
+  let contiguity = new Util.IndexedArray();
+  let block_contiguity = new Util.IndexedArray();
+  let f = Poly.topoMerge(topoPrecinct, blocks);
+  f.properties.datasets = {};
+  blocks.forEach(blockid => {
+      let b = topoPrecinct.objects[blockid];
+      if (b.properties.datasets)
+        Util.deepAccum(f.properties.datasets, b.properties.datasets);
+      if (b.properties.contiguity)
+      {
+        b.properties.contiguity.forEach((id: string) => {
+            contiguity.set(id === 'OUT_OF_STATE' ? id : bintrie.get(id));
+          });
+        b.properties.contiguity.forEach((id: string) => {
+            block_contiguity.set(id);
+          });
+      }
+    });
+  f.properties.contiguity = contiguity.asArray();
+  f.properties.block_contiguity = block_contiguity.asArray();
+  f.properties.blocks = blocks;
+  return f;
+}

package/lib/poly/topo.ts

@@ -392,7 +392,7 @@ class FsmIncrementalUnion extends FSM.Fsm
       let values = Object.values(map);
       this.work = { nUnion: values.length, nDifference: 0, ms: 0 };
       let elapsed = new Util.Elapsed();
-      this.result = topoMergeFeatures(this.key.topo, values);
+      this.result = topoMergeFeatures(this.key.multi.allTopo(), values);
       this.work.ms = elapsed.ms();
       this.map = map;
     }

package/lib/poly/union.ts

@@ -59,6 +59,23 @@ export function polyIntersects(p1: any, p2: any): boolean
   return bIntersects;
 }
 
+export function polyDifference(main: any, parts: any[]): any
+{
+  main = PP.polyUnpack(coords(main));
+
+  // need to explode multipolygon so that "exploded" is a valid multipolygon input to underlying difference routine
+  let exploded: any[] = [];
+  parts.forEach((p: any) => {
+      p = PP.polyUnpack(coords(p));
+      if (Util.depthof(p) == 5)
+        p.forEach((poly: any) => { exploded.push(poly) });
+      else
+        exploded.push(p);
+    });
+
+  return PR.polyRound(_difference(main, exploded));
+}
+
 class FsmDifference extends FSM.Fsm
 {
   accum: any;

package/package.json

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