@dra2020/baseclient 1.0.0 → 1.0.4

package/README.md

@@ -22,4 +22,5 @@ These libraries are used across both client and server:
 - [LogAbstract](./docs/logabstract.md): An abstract logging interface. Different implementations are used on client and server.
 - [LogClient](./docs/logclient.md): A client implementation of the logging abstract interface.
 - [OT](./docs/ot-js.md): An Operational Transformation implementation, used as the basis for all content editing.
-- [OTE](.docs/ot-editutil.md): A set of utility functions for creating OT edits.
+- [OTE](./docs/ot-editutil.md): A set of utility functions for creating OT edits.
+- [FilterExpr](./docs/filterexpr.md): A class for parsing and executing a filter expression against an array of objects.

package/dist/all/all.d.ts

@@ -16,3 +16,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/dist/baseclient.js

@@ -39,7 +39,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.FilterExpr = exports.OTE = exports.OT = exports.LogClient = exports.LogAbstract = exports.Poly = exports.FSM = exports.Context = exports.Util = void 0;
+exports.G = exports.FilterExpr = exports.OTE = exports.OT = exports.LogClient = exports.LogAbstract = exports.Poly = exports.FSM = exports.Context = exports.Util = void 0;
 // Client and Server
 const Util = __importStar(__webpack_require__(/*! ../util/all */ "./lib/util/all.ts"));
 exports.Util = Util;
@@ -59,6 +59,8 @@ const OTE = __importStar(__webpack_require__(/*! ../ot-editutil/all */ "./lib/ot
 exports.OTE = OTE;
 const all_1 = __webpack_require__(/*! ../filterexpr/all */ "./lib/filterexpr/all.ts");
 Object.defineProperty(exports, "FilterExpr", ({ enumerable: true, get: function () { return all_1.FilterExpr; } }));
+const G = __importStar(__webpack_require__(/*! ../geo/all */ "./lib/geo/all.ts"));
+exports.G = G;
 
 
 /***/ }),
@@ -1156,6 +1158,484 @@ class FsmArray extends Fsm {
 exports.FsmArray = FsmArray;
 
 
+/***/ }),
+
+/***/ "./lib/geo/all.ts":
+/*!************************!*\
+  !*** ./lib/geo/all.ts ***!
+  \************************/
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+__exportStar(__webpack_require__(/*! ./geo */ "./lib/geo/geo.ts"), exports);
+__exportStar(__webpack_require__(/*! ./vfeature */ "./lib/geo/vfeature.ts"), exports);
+
+
+/***/ }),
+
+/***/ "./lib/geo/geo.ts":
+/*!************************!*\
+  !*** ./lib/geo/geo.ts ***!
+  \************************/
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.geoIntersect = exports.geoIntersectOptions = exports.GeoMultiCollection = exports.geoMapEqual = exports.geoEqual = exports.geoTopoToCollection = exports.geoCollectionToTopo = exports.geoMapToCollection = exports.geoCollectionToMap = void 0;
+const Util = __importStar(__webpack_require__(/*! ../util/all */ "./lib/util/all.ts"));
+const Poly = __importStar(__webpack_require__(/*! ../poly/all */ "./lib/poly/all.ts"));
+function geoCollectionToMap(col) {
+    if (col == null)
+        return null;
+    let map = {};
+    col.features.forEach((f) => { map[String(f.properties.id)] = f; });
+    return map;
+}
+exports.geoCollectionToMap = geoCollectionToMap;
+function geoMapToCollection(map) {
+    if (map == null || Util.countKeys(map) == 0)
+        return null;
+    let col = { type: 'FeatureCollection', features: [] };
+    Object.keys(map).forEach((geoid) => { col.features.push(map[geoid]); });
+    return col;
+}
+exports.geoMapToCollection = geoMapToCollection;
+function geoCollectionToTopo(col) {
+    let topo = Poly.topoFromCollection(col);
+    Poly.topoPack(topo);
+    return topo;
+}
+exports.geoCollectionToTopo = geoCollectionToTopo;
+function geoTopoToCollection(topo) {
+    let col = Poly.topoToCollection(topo);
+    Poly.featurePack(col);
+    return col;
+}
+exports.geoTopoToCollection = geoTopoToCollection;
+function geoEqual(m1, m2) {
+    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;
+}
+exports.geoEqual = geoEqual;
+function geoMapEqual(m1, m2) {
+    if (m1 == null)
+        return Util.isEmpty(m2);
+    if (m2 == null)
+        return Util.isEmpty(m1);
+    let p;
+    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;
+}
+exports.geoMapEqual = geoMapEqual;
+class GeoMultiCollection {
+    constructor(tag, topo, col, map) {
+        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() { return Util.countKeys(this.entries); }
+    nthEntry(n) {
+        return Util.nthProperty(this.entries, n);
+    }
+    add(tag, topo, col, map) {
+        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) {
+        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) {
+        let entry = this.entries[tag];
+        if (entry) {
+            if (entry.topo || entry.col || entry.map)
+                this._onChange();
+            delete this.entries[tag];
+        }
+    }
+    _onChange() {
+        this.all = { tag: 'all' };
+        this.stamp++;
+    }
+    _col(e) {
+        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) {
+        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) {
+        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) { return this._col(this.entries[tag]); }
+    mapOf(tag) { return this._map(this.entries[tag]); }
+    topoOf(tag) { return this._topo(this.entries[tag]); }
+    forEachEntry(cb) {
+        Object.values(this.entries).forEach(cb);
+    }
+    allCol() {
+        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() {
+        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() {
+        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) {
+        if (id) {
+            if (typeof id === 'string')
+                this.hidden[id] = true;
+            else if (Array.isArray(id))
+                id.forEach((i) => { 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) {
+        if (id) {
+            if (typeof id === 'string')
+                delete this.hidden[id];
+            else if (Array.isArray(id))
+                id.forEach((i) => { 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() {
+        if (!Util.isEmpty(this.hidden)) {
+            this.hidden = {};
+            this._onChange();
+        }
+    }
+    get length() {
+        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) {
+        let found;
+        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, cb) {
+        let found;
+        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) {
+        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) {
+        let features = [];
+        this.forEach((f) => { features.push(cb(f)); });
+        return features;
+    }
+    isHidden(id) {
+        return this.hidden[id] !== undefined;
+    }
+    find(id) {
+        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) {
+        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;
+    }
+}
+exports.GeoMultiCollection = GeoMultiCollection;
+var geoIntersectOptions;
+(function (geoIntersectOptions) {
+    geoIntersectOptions[geoIntersectOptions["Intersects"] = 0] = "Intersects";
+    geoIntersectOptions[geoIntersectOptions["Bounds"] = 1] = "Bounds";
+    geoIntersectOptions[geoIntersectOptions["BoundsCenter"] = 2] = "BoundsCenter";
+})(geoIntersectOptions = exports.geoIntersectOptions || (exports.geoIntersectOptions = {}));
+;
+function geoBoxIntersect(x1, x2, opt) {
+    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;
+    }
+}
+function geoIntersect(multi, bbox, opt) {
+    let m = {};
+    let bboxPoly = Poly.boundboxPoly(bbox);
+    multi.forEach((f) => {
+        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;
+}
+exports.geoIntersect = geoIntersect;
+
+
+/***/ }),
+
+/***/ "./lib/geo/vfeature.ts":
+/*!*****************************!*\
+  !*** ./lib/geo/vfeature.ts ***!
+  \*****************************/
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.computeVFeature = void 0;
+const Util = __importStar(__webpack_require__(/*! ../util/all */ "./lib/util/all.ts"));
+const Poly = __importStar(__webpack_require__(/*! ../poly/all */ "./lib/poly/all.ts"));
+// Given the topology for a precinct, the bintrie mapping and the list of blocks, construct the
+// feature data for the virtual feature.
+//
+function computeVFeature(topoPrecinct, bintrie, blocks) {
+    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) => {
+                contiguity.set(id === 'OUT_OF_STATE' ? id : bintrie.get(id));
+            });
+            b.properties.contiguity.forEach((id) => {
+                block_contiguity.set(id);
+            });
+        }
+    });
+    f.properties.contiguity = contiguity.asArray();
+    f.properties.block_contiguity = block_contiguity.asArray();
+    f.properties.blocks = blocks;
+    return f;
+}
+exports.computeVFeature = computeVFeature;
+
+
 /***/ }),
 
 /***/ "./lib/logabstract/all.ts":
@@ -7744,7 +8224,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;
         }
@@ -7870,7 +8350,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", ({ value: true }));
-exports.FsmUnion = exports.polyIntersects = void 0;
+exports.FsmUnion = exports.polyDifference = exports.polyIntersects = void 0;
 const PC = __importStar(__webpack_require__(/*! polygon-clipping */ "polygon-clipping"));
 const Util = __importStar(__webpack_require__(/*! ../util/all */ "./lib/util/all.ts"));
 const FSM = __importStar(__webpack_require__(/*! ../fsm/all */ "./lib/fsm/all.ts"));
@@ -7929,6 +8409,20 @@ function polyIntersects(p1, p2) {
     return bIntersects;
 }
 exports.polyIntersects = polyIntersects;
+function polyDifference(main, parts) {
+    main = PP.polyUnpack(coords(main));
+    // need to explode multipolygon so that "exploded" is a valid multipolygon input to underlying difference routine
+    let exploded = [];
+    parts.forEach((p) => {
+        p = PP.polyUnpack(coords(p));
+        if (Util.depthof(p) == 5)
+            p.forEach((poly) => { exploded.push(poly); });
+        else
+            exploded.push(p);
+    });
+    return PR.polyRound(_difference(main, exploded));
+}
+exports.polyDifference = polyDifference;
 class FsmDifference extends FSM.Fsm {
     constructor(env, accum, polys) {
         super(env);