@dra2020/baseclient 1.0.170 → 1.0.172

package/dist/baseclient.js

@@ -8994,19 +8994,79 @@ function unpackString(coder, buf8, buf32, offset) {
     let s = Util.u82s(coder, buf8, offset + 4, size);
     return s;
 }
-function packCollection(coder, col) {
-    // Compute size
-    let pp = PP.featurePack(col);
-    let f = col.features.find((f) => { return f.geometry.packed ? f.geometry.packed.buffer : null; });
-    let buffer = f ? f.geometry.packed.buffer : null;
-    let size = 16; // int endiness, offset to coordinates, float endiness
-    col.features.forEach((f) => { if (f.geometry.packed)
-        delete f.geometry.packed.buffer; }); // reconstructed when unpacking
+function collectOmitted(col, omit) {
+    let saved = [];
+    if (!omit || omit.length === 0)
+        return saved;
+    const take = (o) => {
+        if (!o)
+            return;
+        omit.forEach(name => {
+            if (o[name] !== undefined) {
+                saved.push({ o, name, value: o[name] });
+                delete o[name];
+            }
+        });
+    };
+    take(col);
+    if (col.features)
+        col.features.forEach((f) => { take(f); take(f.properties); });
+    return saved;
+}
+function restoreOmitted(saved) {
+    saved.forEach(s => { s.o[s.name] = s.value; });
+}
+/**
+ * Serialize a collection to the geopack format.
+ *
+ * The file wants one contiguous coordinate section with every feature's offset an index into it, and
+ * that used to be arranged by requiring the whole collection to already sit in ONE buffer at exactly
+ * those offsets - packCollection simply blitted that buffer across whole. Which held only as long as
+ * nothing had touched the collection since: pack a collection, add a feature, pack again, and the
+ * second pack either redid all the work or produced offsets into a buffer that no longer described it.
+ *
+ * So the coordinates are gathered feature by feature instead. Each one is given its place in the
+ * output, and its floats are copied from wherever they happen to live now - one buffer or several. The
+ * work is the same (every float is copied either way), the assumption is gone, and featurePack is free
+ * to leave already-packed features alone.
+ *
+ * THE FORMAT IS UNCHANGED. Offsets are assigned in feature order from zero, which is exactly what a
+ * single shared buffer produced, so files written before and after this are byte-identical and each
+ * reads under the other.
+ *
+ * `omit` names properties to leave out of the serialized JSON - see the note on collectOmitted.
+ */
+function packCollection(coder, col, omit) {
+    // Which features arrive unpacked, so they can be left that way. Packing is how the coordinates get
+    // written; it is not something the caller asked for, and a caller that handed over an unpacked
+    // collection and got a packed one back would find its own coordinates gone. Equally, a caller whose
+    // collection was ALREADY packed must not have it unpacked - that rebuilds every coordinate array
+    // for nothing, which on a large collection is the memory this change exists to stop spending.
+    let wasUnpacked = [];
+    if (col.features)
+        col.features.forEach((f) => { if (!PP.featureIsPacked(f))
+            wasUnpacked.push(f); });
+    PP.featurePack(col);
+    // Where every feature's coordinates are now, and where they will be in the file.
+    let slots = [];
+    let nFloats = 0;
+    col.features.forEach((f) => {
+        const packed = f.geometry ? f.geometry.packed : null;
+        if (!packed)
+            return;
+        slots.push({ packed, buffer: packed.buffer, fromOffset: packed.offset, toOffset: nFloats,
+            length: packed.length });
+        nFloats += packed.length;
+    });
+    // The JSON carries each feature's offset, so the offsets have to be the file's before it is built.
+    // Buffers come out because they are reconstructed on the way back in.
+    slots.forEach(s => { s.packed.offset = s.toOffset; delete s.packed.buffer; });
+    const omitted = collectOmitted(col, omit);
+    let size = 16; // int endianness, offset to coordinates, float endianness
     let j = JSON.stringify(col);
     size += sizeOfString(coder, j);
     size += pad(size, 8);
-    let fullsize = size + pp.length * 8; // add space for coordinates
-    // Now pack it
+    let fullsize = size + nFloats * 8;
     let ab = new ArrayBuffer(fullsize);
     let buf8 = new Uint8Array(ab);
     let buf32 = new Int32Array(ab);
@@ -9022,14 +9082,20 @@ function packCollection(coder, col) {
     offset += pad(offset, 8);
     if (offset != size)
         throw 'Oops, packing error.';
-    let foff = offset >> 3;
-    let buf = pp.buffer;
-    for (let i = 0; i < pp.length; i++)
-        buf64[foff++] = buf[i];
-    // Now restore
-    col.features.forEach((f) => { if (f.geometry.packed)
-        f.geometry.packed.buffer = buffer; });
-    PP.featureUnpack(col);
+    const foff = offset >> 3;
+    slots.forEach(s => {
+        const src = s.buffer;
+        if (!src)
+            return; // no coordinates: points, and features with no geometry
+        let to = foff + s.toOffset;
+        let from = s.fromOffset;
+        for (let i = 0; i < s.length; i++)
+            buf64[to++] = src[from++];
+    });
+    // Put the collection back exactly as it was found.
+    slots.forEach(s => { s.packed.offset = s.fromOffset; s.packed.buffer = s.buffer; });
+    restoreOmitted(omitted);
+    wasUnpacked.forEach(f => PP.featureUnpack(f));
     return ab;
 }
 function reverse(buf8, s, n) {
@@ -9749,7 +9815,9 @@ exports.polyPackTopoArcs = polyPackTopoArcs;
 exports.polyPack = polyPack;
 exports.polyPackCopy = polyPackCopy;
 exports.polyUnpack = polyUnpack;
+exports.featureIsPacked = featureIsPacked;
 exports.featurePackSize = featurePackSize;
+exports.repairPackedBuffers = repairPackedBuffers;
 exports.featurePack = featurePack;
 exports.featureUnpack = featureUnpack;
 exports.featureUnpackTemporarily = featureUnpackTemporarily;
@@ -10038,12 +10106,55 @@ function polyUnpack(prepack) {
     }
     return coords.length > 1 ? coords : coords[0];
 }
+/** Whether this feature's coordinates are already in packed form. */
+function featureIsPacked(f) {
+    return !!(f && f.geometry && f.geometry.packed !== undefined);
+}
+/**
+ * Floats this feature would ADD to a buffer if packed now: zero if it is already packed, and zero for
+ * the shapes that carry no packed coordinates at all (points, and features with no geometry).
+ */
 function featurePackSize(f) {
+    if (featureIsPacked(f))
+        return 0;
     if (f && f.geometry && f.geometry.coordinates && f.geometry.type !== 'Point')
         return polyPackSize(f.geometry.coordinates);
     return 0;
 }
-function featurePack(f, prepack) {
+/**
+ * Repair packed buffers that have been through JSON and come back as plain objects.
+ *
+ * A Float64Array does not survive JSON.stringify/parse - it comes back as {"0":n,"1":n,...} - so a
+ * collection that has been round-tripped through JSON while packed arrives with something that looks
+ * packed but cannot be read. This puts the numbers back into a real Float64Array.
+ *
+ * Split out of featurePack, where it used to sit inline in the middle of the packing path, because it
+ * is not packing: it is a repair for a specific way collections arrive damaged, it applies to
+ * collections that are ALREADY packed, and burying it inside meant featurePack had to return early
+ * with a different kind of value to signal it had happened. Returns whether anything was repaired.
+ */
+function repairPackedBuffers(col) {
+    if (!col || !col.features || col.features.length === 0)
+        return false;
+    let ff = col.features[0];
+    if (!featureIsPacked(ff) || ArrayBuffer.isView(ff.geometry.packed.buffer))
+        return false;
+    // One buffer is shared by every feature of a collection, so recovering the first recovers all.
+    let o = ff.geometry.packed.buffer;
+    let b = new Float64Array(Util.countKeys(o));
+    for (const i in o)
+        b[Number(i)] = o[i];
+    col.features.forEach((f) => { if (featureIsPacked(f))
+        f.geometry.packed.buffer = b; });
+    return true;
+}
+/**
+ * Pack ONE feature's coordinates, into `prepack`'s buffer when given one. Returns the PolyPack that
+ * describes where they went, which is how the collection path below advances its offset.
+ *
+ * Internal: featurePack is the public entry and always answers with the object it was handed.
+ */
+function packOne(f, prepack) {
     if (f && f.type === 'Feature') {
         if (f.geometry && f.geometry.type === 'Point')
             return prepack ? { offset: prepack.offset, length: 0, buffer: prepack.buffer } : { offset: 0, length: 0, buffer: null };
@@ -10057,41 +10168,52 @@ function featurePack(f, prepack) {
         }
         return f.geometry.packed;
     }
+    return null;
+}
+/**
+ * Ensure a feature or collection is fully packed, and answer with the object handed in.
+ *
+ * ALWAYS the same object, whatever was passed and whatever it had to do. The previous signature
+ * returned three different things - a PolyPack for a feature, a PolyPack for a collection it packed,
+ * and the collection itself for one that was already packed - so a caller could not use the result
+ * without knowing which case it had fallen into, and every caller but one ignored it. The one that
+ * did not assigned a PolyPack to geometry.coordinates.
+ *
+ * A collection packs its UNPACKED features into one new buffer and leaves packed ones where they are.
+ * That is what stops a second call re-packing work already done, which for a large collection means
+ * allocating and copying the whole coordinate set again for nothing. Features already packed keep
+ * whatever buffer they were in - the collection may end up spanning several - and packCollection no
+ * longer minds, because it copies feature by feature rather than assuming one buffer holds them all.
+ */
+function featurePack(f) {
+    if (f && f.type === 'Feature') {
+        if (!featureIsPacked(f))
+            packOne(f);
+        return f;
+    }
     else if (f && f.type === 'FeatureCollection' && f.features) {
-        // Empty?
-        if (f.features.length == 0)
+        if (f.features.length === 0)
             return f;
-        // Already packed or packed incorrectly?
-        let ff = f.features[0];
-        if (ff && ff.geometry && ff.geometry.packed) {
-            // Already packed
-            if (ArrayBuffer.isView(ff.geometry.packed.buffer))
-                return f;
-            // Improperly packed (buffer converted to object - convert back to buffer
-            let o = ff.geometry.packed.buffer;
-            let b = new Float64Array(Util.countKeys(o));
-            for (const i in o)
-                b[Number(i)] = o[i];
-            f.features.forEach((ff) => ff.geometry.packed.buffer = b);
-            return f;
-        }
-        // Allocate one large buffer
+        // Before measuring anything: a collection in this state looks packed but is not readable.
+        repairPackedBuffers(f);
+        // One buffer for everything still unpacked. Sized first so it is allocated exactly once.
         let nFloats = 0;
         let i;
         for (i = 0; i < f.features.length; i++)
             nFloats += featurePackSize(f.features[i]);
-        let ab = new ArrayBuffer(nFloats * 8);
-        prepack = { offset: 0, length: nFloats, buffer: new Float64Array(ab) };
-        // Now pack
+        let prepack = { offset: 0, length: nFloats,
+            buffer: new Float64Array(new ArrayBuffer(nFloats * 8)) };
         for (i = 0; i < f.features.length; i++) {
-            let postpack = featurePack(f.features[i], prepack);
+            if (featureIsPacked(f.features[i]))
+                continue;
+            let postpack = packOne(f.features[i], prepack);
             prepack.offset += postpack ? postpack.length : 0;
         }
         if (prepack.offset != nFloats)
             throw 'oops, packing bug';
-        return prepack;
+        return f;
     }
-    return null;
+    return f;
 }
 function featureUnpack(f) {
     if (f && f.geometry && f.geometry.packed !== undefined) {
@@ -11082,6 +11204,8 @@ Object.defineProperty(exports, "__esModule", ({ value: true }));
 exports.FsmTopoUnion = void 0;
 exports.topoFromCollection = topoFromCollection;
 exports.topoContiguity = topoContiguity;
+exports.topoFeatureCacheStats = topoFeatureCacheStats;
+exports.topoFeatureCacheReset = topoFeatureCacheReset;
 exports.topoToFeature = topoToFeature;
 exports.topoSplice = topoSplice;
 exports.topoToCollection = topoToCollection;
@@ -11099,6 +11223,7 @@ const TopoServer = __importStar(__webpack_require__(/*! @dra2020/topojson-server
 const TopoSimplify = __importStar(__webpack_require__(/*! @dra2020/topojson-simplify */ "@dra2020/topojson-simplify"));
 const Util = __importStar(__webpack_require__(/*! ../util/all */ "./lib/util/all.ts"));
 const FSM = __importStar(__webpack_require__(/*! ../fsm/all */ "./lib/fsm/all.ts"));
+const G = __importStar(__webpack_require__(/*! ../geo/all */ "./lib/geo/all.ts"));
 const P = __importStar(__webpack_require__(/*! ./poly */ "./lib/poly/poly.ts"));
 const PP = __importStar(__webpack_require__(/*! ./polypack */ "./lib/poly/polypack.ts"));
 const PL = __importStar(__webpack_require__(/*! ./polylabel */ "./lib/poly/polylabel.ts"));
@@ -11121,6 +11246,18 @@ function getGEOID(f) {
 function topoFromCollection(col) {
     if (col == null)
         return null;
+    // The objects map below is keyed per feature, so every feature needs an id that is present, unique
+    // and a string - and the topology is meaningless without one. A collection that has no usable id
+    // would otherwise key EVERY feature to undefined and collapse the whole thing onto a single object,
+    // silently: the topology comes back with one object in it and nothing anywhere reports a problem.
+    // An imported GeoJSON file is the ordinary way to arrive here in that state, because GeoJSON puts a
+    // feature's id at the TOP level and most exporters write it there rather than in properties.
+    //
+    // geoEnsureID also NORMALIZES, which matters as much: it copies GEOID/GEOID10 into properties.id,
+    // so the key used here is properties.id whatever the collection called it. Callers that read the
+    // objects map back - topoSimplifyCollection does, by properties.id - would otherwise be looking up
+    // a key this function never used.
+    G.geoEnsureID(col);
     let save = PP.featureUnpackTemporarily(col);
     let prop = getGEOID(col);
     let objects = {};
@@ -11170,8 +11307,64 @@ function topoContiguity(topo) {
     });
     return result;
 }
+/**
+ * Resolved polygon geometry, keyed on the TOPOLOGY OBJECT and held at module level.
+ *
+ * The two things a topology object stands for have opposite natures, and the split matters:
+ *
+ *   ARCS are a property of the topology the object appears in. The same object shares different arcs
+ *   in different topologies - a precinct and a block do not break at the same places - which is why
+ *   arc offsets live in a per-topology WeakMap (topology.packed.objectArcs) rather than on the object.
+ *
+ *   GEOMETRY is not. The points are the same wherever the object appears. It may end up PACKED into
+ *   different buffers depending on which collection packed it, but the coordinates are identical, and
+ *   a collection packed from several buffers is fine by construction (see packCollection).
+ *
+ * So geometry can be cached once, globally, for the life of the object. Module level rather than a
+ * field on the object precisely to avoid the project-then-strip dance that packedarcs still needs
+ * around JSON.stringify in topoToBuffer - a trick that has produced real bugs by leaving values
+ * persisted where they should not be. A WeakMap is invisible to serialization and dies with the
+ * object.
+ *
+ * THE RULE THAT KEEPS THIS CORRECT. Any operation that changes an object's resolved geometry must
+ * produce a NEW object; operations that preserve geometry may share identity. Both hold today: splice
+ * renumbers and subdivides arcs, neither of which moves a point, and it now shares objects
+ * deliberately; simplification goes through topoFromCollection and so builds new objects. DRA
+ * topologies are unquantized, so there is no transform that could decode the same arcs differently.
+ */
+const builtGeometry = new WeakMap();
+let cacheHits = 0;
+let cacheMisses = 0;
+/** Hits are geometry that would otherwise have been rebuilt from arcs; misses are the rebuilds that
+ *  were actually necessary. That distinction is the point - a raw conversion count cannot tell them
+ *  apart. Call as Poly.topoFeatureCacheStats() from the console. */
+function topoFeatureCacheStats() {
+    const total = cacheHits + cacheMisses;
+    return { hits: cacheHits, misses: cacheMisses, pct: total ? Math.round((cacheHits / total) * 100) : 0 };
+}
+function topoFeatureCacheReset() { cacheHits = 0; cacheMisses = 0; }
 function topoToFeature(topo, geoid) {
-    return correctGeometry(TopoClient.feature(topo, topo.objects[geoid]));
+    const o = topo.objects[geoid];
+    const geometry = o == null ? undefined : builtGeometry.get(o);
+    if (geometry !== undefined) {
+        cacheHits++;
+        // A fresh Feature wrapper each call, matching what TopoClient.feature returns - including sharing
+        // the properties object with the topology object, which it already did. Only the geometry, the
+        // expensive and immutable part, is reused.
+        const f = { type: 'Feature', properties: o.properties == null ? {} : o.properties, geometry };
+        if (o.id != null)
+            f.id = o.id;
+        if (o.bbox != null)
+            f.bbox = o.bbox;
+        return f;
+    }
+    cacheMisses++;
+    const built = correctGeometry(TopoClient.feature(topo, o));
+    // Cached AFTER correctGeometry, so every later reader gets the rewound rings rather than repeating
+    // the correction.
+    if (o != null && built && built.geometry)
+        builtGeometry.set(o, built.geometry);
+    return built;
 }
 function topoSplice(topoarray) {
     if (topoarray)
@@ -11305,6 +11498,13 @@ function topoSimplifyCollection(col, options) {
         col.features.forEach((f) => {
             let oOld = topo.objects[f.properties.id];
             let oNew = testtopo.objects[f.properties.id];
+            // Every feature must have found its own object. topoFromCollection guarantees it, so reaching
+            // here means the keying has diverged - and the two ways that goes wrong are both silent or
+            // worse: a collection with no ids used to put every feature on ONE object and come back
+            // simplified to a single feature, and a mismatched key dereferences undefined a few lines
+            // below. Neither is worth guessing through, so stop and leave the collection alone.
+            if (oOld === undefined || oNew === undefined)
+                throw `topoSimplifyCollection: feature id ${f.properties.id} has no topology object`;
             // Ignore points
             if (f.geometry && f.geometry.type === 'Point')
                 keepTiny.set(f, f);