@dra2020/baseclient 1.0.167 → 1.0.168

package/dist/baseclient.js

@@ -2768,6 +2768,10 @@ exports.geoCollectionToTopo = geoCollectionToTopo;
 exports.geoCollectionToTopoNonNull = geoCollectionToTopoNonNull;
 exports.geoTopoToCollection = geoTopoToCollection;
 exports.geoTopoToCollectionNonNull = geoTopoToCollectionNonNull;
+exports.geoFilterFromHidden = geoFilterFromHidden;
+exports.geoFilteredTopo = geoFilteredTopo;
+exports.geoFilteredCollection = geoFilteredCollection;
+exports.geoFilteredMap = geoFilteredMap;
 exports.geoEqual = geoEqual;
 exports.geoMapEqual = geoMapEqual;
 exports.geoIntersect = geoIntersect;
@@ -2944,6 +2948,37 @@ function geoTopoToCollection(topo) {
 function geoTopoToCollectionNonNull(topo) {
     return geoTopoToCollection(topo);
 }
+function geoFilterFromHidden(hidden) {
+    if (Util.isEmpty(hidden))
+        return undefined;
+    return (s) => { return !hidden[s]; };
+}
+function geoFilteredTopo(topo, filter) {
+    if (!topo || !filter)
+        return topo;
+    let copy = Util.shallowCopy(topo);
+    copy.objects = {};
+    Object.keys(topo.objects).forEach(geoid => {
+        if (filter(geoid))
+            copy.objects[geoid] = topo.objects[geoid];
+    });
+    return copy;
+}
+function geoFilteredCollection(col, filter) {
+    if (!col || !filter)
+        return col;
+    let copy = Util.shallowCopy(col);
+    copy.features = col.features.filter(f => filter(f.properties.id));
+    return copy;
+}
+function geoFilteredMap(map, filter) {
+    if (!map || !filter)
+        return map;
+    let copy = {};
+    Object.keys(map).forEach(geoid => { if (filter(geoid))
+        copy[geoid] = map[geoid]; });
+    return copy;
+}
 function geoEqual(m1, m2) {
     let n1 = m1 ? m1.length : 0;
     let n2 = m2 ? m2.length : 0;
@@ -3009,12 +3044,15 @@ class GeoMultiCollection {
         });
         for (let p in multi.hidden)
             if (multi.hidden.hasOwnProperty(p)) {
-                this.hidden[p] = true;
-                this._onChange();
+                if (!this.hidden[p]) {
+                    this.hidden[p] = true;
+                    this._onChange();
+                }
             }
     }
     // Add the "all" collection from the passed in multi, but do not force compute of any things not computed yet.
     addAll(tag, multi) {
+        var _a;
         if (multi == null || Util.isEmpty(multi.entries))
             this.remove(tag);
         else {
@@ -3022,11 +3060,15 @@ class GeoMultiCollection {
             if (nEntries) {
                 // Make sure all collection is created
                 if (!multi.all.topo && !multi.all.col && !multi.all.map) {
-                    // Create cheapest one (collection if I need to create, otherwise copy from single entry)
-                    if (nEntries > 1)
-                        multi.allCol();
+                    // Make sure at least one all entry is built, preferably topo if there is a base topo
+                    let e = (_a = multi.entries['main']) !== null && _a !== void 0 ? _a : multi.nthEntry(0);
+                    if (nEntries > 1) {
+                        if (e.topo)
+                            multi.allTopo();
+                        else
+                            multi.allCol();
+                    }
                     else {
-                        let e = multi.nthEntry(0);
                         multi.all.topo = e.topo;
                         multi.all.col = e.col;
                         multi.all.map = e.map;
@@ -3182,19 +3224,19 @@ class GeoMultiCollection {
         if (!this.all.topo) {
             // optimise case where one entry
             let n = this.nEntries;
-            let e = this.nthEntry(0);
+            let e = this.entries['main'] || this.nthEntry(0);
             if (n == 1) {
-                // Note that this is potentially invalid shortcut when some features are hidden from base geometry.
-                // Could test overall count of objects vs. this count to check.
-                this.all.topo = this._topo(e);
-                this.all.col = this.all.col || e.col;
-                this.all.map = this.all.map || e.map;
+                let filter = geoFilterFromHidden(this.hidden);
+                this.all.topo = geoFilteredTopo(this._topo(e), filter);
+                this.all.col = this.all.col || geoFilteredCollection(e.col, filter);
+                this.all.map = this.all.map || geoFilteredMap(e.map, filter);
             }
             else if (e.topo) {
-                // Old-style, goes through map (to filter hidden) and then collection
-                // this.all.topo = geoCollectionToTopoNonNull(this.allCol());
                 // New style, use splice on packed topologies
-                let filterout = Util.isEmpty(this.hidden) ? null : this.hidden; // splice function requires NULL for empty
+                let filterout = this.someHidden() ? this.hidden : null; // splice function requires NULL for empty
+                // DEBUGGING
+                filterout = null;
+                // DEBUGGING
                 let topoarray = Object.values(this.entries).filter((e) => this._length(e) > 0)
                     .map((e) => { return { topology: this._topo(e), filterout }; });
                 this.all.topo = topoarray.length == 0 ? null : topoarray.length == 1 ? topoarray[0].topology : Poly.topoSplice(topoarray);
@@ -3336,6 +3378,9 @@ class GeoMultiCollection {
         });
         return m;
     }
+    someHidden() {
+        return !Util.isEmpty(this.hidden);
+    }
 }
 exports.GeoMultiCollection = GeoMultiCollection;
 var geoIntersectOptions;
@@ -9055,8 +9100,23 @@ function topoToBuffer(coder, topo) {
     // Make sure we're packed
     T.topoPack(topo);
     let savepack = topo.packed;
+    // On-disk format predates the topology.packed.objectArcs WeakMap: each object
+    // carried its own `packedarcs: number` field in the serialized JSON. Preserve
+    // that format. We temporarily project the WeakMap entries back onto each object
+    // before stringifying, then strip them so the in-memory topology is unchanged.
+    let projected = [];
+    if (savepack.objectArcs)
+        for (let id in topo.objects) {
+            let o = topo.objects[id];
+            let off = savepack.objectArcs.get(o);
+            if (off !== undefined) {
+                o.packedarcs = off;
+                projected.push(o);
+            }
+        }
     delete topo.packed;
     let json = JSON.stringify(topo);
+    projected.forEach(o => { delete o.packedarcs; });
     let byteLength = HeaderSize; // 3 lengths + padding
     let stringLength = sizeOfString(coder, json);
     stringLength += pad(stringLength, 8);
@@ -9100,6 +9160,18 @@ function topoFromBuffer(coder, ab) {
     topo.packed = {};
     topo.packed.arcs = new Float64Array(ab, stringLength + HeaderSize, arcsByteLength / 8);
     topo.packed.arcindices = new Int32Array(ab, stringLength + HeaderSize + arcsByteLength, arcindicesByteLength / 4);
+    // Reconstruct the WeakMap from the legacy per-object `packedarcs` field, then
+    // strip the field so the object representation matches a freshly-packed one.
+    let objectArcs = new WeakMap();
+    if (topo.objects)
+        for (let id in topo.objects) {
+            let o = topo.objects[id];
+            if (o && o.packedarcs !== undefined) {
+                objectArcs.set(o, o.packedarcs);
+                delete o.packedarcs;
+            }
+        }
+    topo.packed.objectArcs = objectArcs;
     return topo;
 }