@dra2020/baseclient 1.0.15 → 1.0.18

package/lib/geo/geo.ts

@@ -0,0 +1,467 @@
+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 geoEnsureID(col: GeoFeatureCollection): void
+{
+  let prop: string;
+  const props = ['id', 'GEOID', 'GEOID10', 'GEOID20', 'GEOID30' ];
+
+  if (col && col.features && col.features.length > 0)
+  {
+    let f = col.features[0];
+    if (f.properties.id !== undefined) return;
+    props.forEach(p => { if (prop === undefined && f.properties[p] !== undefined) prop = p; });
+    if (prop)
+      col.features.forEach(f => { f.properties.id = f.properties[prop] });
+  }
+}
+
+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
+        // Going from map to collection guarantees that any duplicates are removed
+        this.all.col = geoMapToCollection(this.allMap());
+    }
+    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
+      {
+        let map: GeoFeatureMap = {};
+        this.all.map = map;
+        this.forEach(f => { map[String(f.properties.id)] = f });
+      }
+    }
+    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/ot-js/otsession.ts

@@ -23,7 +23,8 @@ export const FilterRecent: number = 3;
 export const FilterTrash: number = 4;
 export const FilterPublic: number = 5;
 export const FilterOfficial: number = 6;
-export const FilterCount: number = 7;
+export const FilterCOI: number = 7;
+export const FilterCount: number = 8;
 export type Filter = number;
 
 // Permissions
@@ -111,6 +112,8 @@ export interface SessionProps
 	loadFailed: boolean;
   accessMap: AccessMap;
   revisions: RevisionList;
+  expunged?: boolean;
+  expungeDate?: string;
   xprops?: { [prop: string]: string };
 }
 

package/lib/poly/hash.ts

@@ -1,4 +1,4 @@
-import * as objectHash from 'object-hash';
+import objectHash from 'object-hash';
 
 export function qhash(o: any, keys?: any): any
 {

package/lib/poly/polybin.ts

@@ -54,9 +54,10 @@ export function packCollection(coder: Util.Coder, col: any): ArrayBuffer
 {
   // Compute size
   let pp = PP.featurePack(col) as PP.PolyPack;
-  let buffer: any = col.features.length ? col.features[0].geometry.packed.buffer : null;  // to restore, below
+  let f: any = col.features.find((f: any) => { return f.geometry.packed ? f.geometry.packed.buffer : null });
+  let buffer: any = f ? f.geometry.packed.buffer : null;
   let size = 16; // int endiness, offset to coordinates, float endiness
-  col.features.forEach((f: any) => { delete f.geometry.packed.buffer; }); // reconstructed when unpacking
+  col.features.forEach((f: any) => { if (f.geometry.packed) delete f.geometry.packed.buffer; }); // reconstructed when unpacking
   let j = JSON.stringify(col);
   size += sizeOfString(coder, j);
   size += pad(size, 8);
@@ -84,7 +85,7 @@ export function packCollection(coder: Util.Coder, col: any): ArrayBuffer
     buf64[foff++] = buf[i];
 
   // Now restore
-  col.features.forEach((f: any) => { f.geometry.packed.buffer = buffer; });
+  col.features.forEach((f: any) => { if (f.geometry.packed) f.geometry.packed.buffer = buffer; });
   PP.featureUnpack(col);
 
   return ab;
@@ -144,7 +145,7 @@ export function unpackCollection(coder: Util.Coder, ab: ArrayBuffer): any
   let offset = 16;
   let j = unpackString(coder, buf8, buf32, offset);
   col = JSON.parse(j);
-  col.features.forEach((f: any) => { f.geometry.packed.buffer = buf64 });
+  col.features.forEach((f: any) => { if (f.geometry.packed) f.geometry.packed.buffer = buf64 });
   return col;
 }
 

package/lib/poly/polypack.ts

@@ -221,7 +221,8 @@ export function polyPack(coords: any, prepack?: PolyPack): PolyPack
 
   // Transparently handle polygon or multi-polygon
   let depth = Util.depthof(coords);
-  if (depth == 3) coords = [ [ coords ] ];
+  if (depth == 2) coords = [ [ [ coords ] ] ];
+  else if (depth == 3) coords = [ [ coords ] ];
   else if (depth == 4) coords = [ coords ];
 
   let nFloats = polyPackSize(coords);
@@ -325,7 +326,7 @@ export function polyUnpack(prepack: any): any
 
 export function featurePackSize(f: any): number
 {
-  if (f && f.geometry && f.geometry.coordinates)
+  if (f && f.geometry && f.geometry.coordinates && f.geometry.type !== 'Point')
     return polyPackSize(f.geometry.coordinates);
   return 0;
 }
@@ -334,7 +335,9 @@ export function featurePack(f: any, prepack?: PolyPack): any
 {
   if (f && f.type === 'Feature')
   {
-    if (f.geometry && f.geometry.coordinates)
+    if (f.geometry && f.geometry.type === 'Point')
+      return prepack ? { offset: prepack.offset, length: 0, buffer: prepack.buffer } : { offset: 0, length: 0, buffer: null };
+    else if (f.geometry && f.geometry.coordinates)
     {
       f.geometry.packed = polyPack(f.geometry.coordinates, prepack);
       delete f.geometry.coordinates;
@@ -374,9 +377,18 @@ export function featureUnpack(f: any): any
   if (f && f.geometry && f.geometry.packed !== undefined)
   {
     f.geometry.coordinates = polyUnpack(f.geometry.packed);
+    let depth = Util.depthof(f.geometry.coordinates);
     // Check for oops, optimized away the multipolygon in polyUnpack
-    if (f.geometry.type === 'MultiPolygon' && Util.depthof(f.geometry.coordinates) === 4)
+    if (f.geometry.type === 'MultiPolygon' && depth === 4)
       f.geometry.coordinates = [ f.geometry.coordinates ];
+    else if (f.geometry.type === 'Point' && depth != 2)
+    {
+      while (depth > 2)
+      {
+        f.geometry.coordinates = f.geometry.coordinates[0];
+        depth = Util.depthof(f.geometry.coordinates);
+      }
+    }
     delete f.geometry.packed;
   }
   else if (f.type && f.type === 'FeatureCollection' && f.features)