@dra2020/baseclient 1.0.167 → 1.0.168

package/dist/geo/geo.d.ts

@@ -13,6 +13,9 @@ export type GeoCentroidMap = {
 export type HideMap = {
     [id: string]: boolean;
 };
+export interface GeoFeatureMap {
+    [id: string]: GeoFeature;
+}
 export declare function dumpMetrics(): void;
 export declare function hidemapConcat(...args: HideMap[]): HideMap;
 export interface NormalizeOptions {
@@ -32,9 +35,11 @@ export declare function geoCollectionToTopo(col: GeoFeatureCollection): Poly.Top
 export declare function geoCollectionToTopoNonNull(col: GeoFeatureCollection): Poly.Topo;
 export declare function geoTopoToCollection(topo: Poly.Topo): GeoFeatureCollection;
 export declare function geoTopoToCollectionNonNull(topo: Poly.Topo): GeoFeatureCollection;
-export interface GeoFeatureMap {
-    [id: string]: GeoFeature;
-}
+export type GeoFilterFunc = (s: string) => boolean | undefined;
+export declare function geoFilterFromHidden(hidden: any): GeoFilterFunc;
+export declare function geoFilteredTopo(topo: Poly.Topo, filter: GeoFilterFunc): Poly.Topo;
+export declare function geoFilteredCollection(col: GeoFeatureCollection, filter: GeoFilterFunc): GeoFeatureCollection;
+export declare function geoFilteredMap(map: GeoFeatureMap, filter: GeoFilterFunc): GeoFeatureMap;
 export type FeatureFunc = (f: GeoFeature) => void;
 interface GeoEntry {
     tag: string;
@@ -87,6 +92,7 @@ export declare class GeoMultiCollection {
     findNoHide(id: string): GeoFeature;
     find(id: string): GeoFeature;
     filter(test: (f: GeoFeature) => boolean): GeoMultiCollection;
+    someHidden(): boolean;
 }
 export declare enum geoIntersectOptions {
     Intersects = 0,

package/dist/poly/topovalidate.d.ts

@@ -0,0 +1,146 @@
+type Point = [number, number];
+/**
+ * Minimal shape this validator needs. A real topology from
+ * `topojson-specification` satisfies this. We require both `packed.arcs`
+ * (the segment data) and `packed.arcindices` + `objects` (so we can walk
+ * only the arcs reachable from the live object set, matching
+ * topojson-client's `validateneighbors.js` semantics via `forAllArcPoints`
+ * with `onlyOnce: true`).
+ */
+export interface PackedTopologyLike {
+    objects: {
+        [id: string]: PackedObject;
+    };
+    packed: {
+        arcs: Float64Array | number[];
+        arcindices: Int32Array | number[];
+        /** Per-topology map from object reference to its offset into `packed.arcindices`.
+         *  Kept here (not on the object) so the same object can appear in more than one
+         *  packed topology — see topojson-client/src/packarcindices.js. */
+        objectArcs: WeakMap<object, number>;
+    };
+}
+interface PackedObject {
+    type: string;
+}
+/** A line segment found in more than one arc. Endpoints are reported in their
+ *  lexicographic-canonical order (smaller endpoint first). */
+export interface DuplicateArcSegment {
+    segment: {
+        s: Point;
+        e: Point;
+    };
+    /** Arc indices (into `topology.packed.arcs`) that contain this segment, ascending. */
+    arcs: number[];
+}
+export interface ValidateArcSegmentsOptions {
+    /**
+     * Subset of object IDs to validate. If undefined, every object in
+     * `topology.objects` is walked (matching `validateneighbors.js` default,
+     * which uses `params.topology.objects` when no `objects` field is given).
+     *
+     * Accepts either a hash whose keys are the object IDs to include (same
+     * shape as `topology.objects`), or a Set of IDs.
+     */
+    objects?: {
+        [id: string]: unknown;
+    } | Set<string>;
+}
+export interface ValidateArcSegmentsResult {
+    ok: boolean;
+    duplicates: DuplicateArcSegment[];
+    /** Number of unique arcs actually inspected (reachable from the object set). */
+    arcsInspected: number;
+    /** Total (arc, consecutive-point-pair) segments inspected across reachable arcs. */
+    totalSegments: number;
+}
+/**
+ * Verify that no two arcs of a packed TopoJSON topology contain the same line
+ * segment — i.e. the same pair of consecutive points, in either direction.
+ *
+ * Semantics mirror topojson-client's `validateneighbors.js`:
+ *   - Only arcs **reachable from the current object set** are inspected;
+ *     orphaned arcs in the packed buffer are ignored.
+ *   - Each reachable arc is visited at most once (the `onlyOnce: true` flag
+ *     in the upstream `forAllArcPoints` walker).
+ *   - Equality is exact Float64 (no epsilon), matching `splice.js`'s
+ *     `dedup`/`equalArcs`. Endpoint order is normalized lexicographically
+ *     before keying, so segment `(P→Q)` in one arc and `(Q→P)` in another
+ *     are treated as the same segment.
+ *   - Within-arc segment repeats (the same arc containing the same segment
+ *     twice) are ignored — only cross-arc duplicates are reported.
+ *
+ * Expected packed layout (same as topojson-client's `forAllArcPoints` / `splice`):
+ *   topology.packed.arcs (Float64Array)
+ *     [0]              = narcs
+ *     [1 + 2*a]        = npoints for arc `a`
+ *     [1 + 2*a + 1]    = pointoffset for arc `a` (index into the same buffer)
+ *     at pointoffset:  interleaved x, y, x, y, ... (2 floats per point)
+ *   topology.packed.arcindices (Int32Array)
+ *     starting at object.packedarcs:
+ *       Polygon      : [nring][narc][arc...]...
+ *       MultiPolygon : [npoly][nring][narc][arc...]...
+ *
+ * O(total reachable points) time, O(total reachable unique segments) space.
+ */
+export declare function validateNoDuplicateArcSegments(topology: PackedTopologyLike, options?: ValidateArcSegmentsOptions): ValidateArcSegmentsResult;
+/** One offending point: shared between arcs in a way that violates
+ *  `ptsToArcs`'s "interior set once" invariant. */
+export interface InteriorPointSharing {
+    point: Point;
+    /** Arcs in which this point is INTERIOR (not the first or last point). */
+    interiorInArcs: number[];
+    /** Arcs in which this point is an ENDPOINT (first or last point). */
+    endpointInArcs: number[];
+}
+export interface InteriorPointSharingResult {
+    ok: boolean;
+    /** Points that, in this single topology, are shared across arcs in a way that
+     *  causes `ptsToArcs` (inside topojson-client's splice) to silently overwrite
+     *  its `map.set(here, …)` record for that point.
+     *
+     *  Two failure modes are flagged:
+     *
+     *    a) **Interior in 2+ arcs.** `ptsToArcs` says "Interior points will by
+     *       definition only be set once." If that invariant doesn't hold,
+     *       whichever arc walks last wins the `map.set`; the earlier arc's
+     *       record at that point is lost. `newJunctions` then can't detect that
+     *       the lost arc needed cutting against another topology, so it stays
+     *       whole and may produce duplicate segments after splice.
+     *
+     *    b) **Interior in one arc AND endpoint in another.** The same overwrite
+     *       happens regardless of which one walks last:
+     *         - If the endpoint write lands last, the interior record is lost
+     *           and the interior arc never gets its junction check.
+     *         - If the interior write lands last, the endpoint's
+     *           junction-forcing role at that point is lost.
+     *       The `ptsToArcs` comment says endpoint overwrites are OK "since ANY
+     *       endpoint forces a junction" — that only holds when *all* the
+     *       overwrites are endpoint-on-endpoint. As soon as an interior is in
+     *       the mix, the invariant is broken.
+     */
+    offenses: InteriorPointSharing[];
+    /** Number of unique arcs actually inspected (reachable from objects). */
+    arcsInspected: number;
+}
+/**
+ * Diagnose whether a single input topology to `splice` violates the
+ * `ptsToArcs` "interior set once" invariant. This is a candidate explanation
+ * for the case where the input topologies report no duplicated arc segments
+ * (per `validateNoDuplicateArcSegments`) but the spliced output does — i.e.
+ * the inputs share an interior point across arcs, so within ONE topology the
+ * pointMap built by `ptsToArcs` silently loses the loser of the overwrite,
+ * `newJunctions` then can't find every cut it needs, arcs aren't broken at
+ * the right places, and `dedup` (which only catches full-arc matches) can't
+ * fuse the resulting partial overlaps.
+ *
+ * Implementation mirrors `validateNoDuplicateArcSegments`: walk reachable
+ * arcs only (matching `forAllArcPoints({onlyOnce: true})`), then for each
+ * point of each reachable arc classify it as start, interior, or end and
+ * accumulate the per-point arc sets.
+ *
+ * Exact float equality (no epsilon) — same coordinate semantics as
+ * `splice.js`'s `equalArcs`/`pointEqual`.
+ */
+export declare function findCrossArcInteriorPointSharing(topology: PackedTopologyLike, options?: ValidateArcSegmentsOptions): InteriorPointSharingResult;
+export {};

package/lib/geo/geo.ts

@@ -8,6 +8,8 @@ export type GeoFeatureArray = GeoFeature[];
 export type GeoFeatureCollection = geojson.FeatureCollection;
 export type GeoCentroidMap = { [geoid: string]: { x: number, y: number } };
 export type HideMap = { [id: string]: boolean };
+export interface GeoFeatureMap { [id: string]: GeoFeature }
+
 
 // Tracing/debugging aid
 let metrics: { [action: string]: { count: number, total: number } } = {};
@@ -230,9 +232,43 @@ export function geoTopoToCollectionNonNull(topo: Poly.Topo): GeoFeatureCollectio
   return geoTopoToCollection(topo);
 }
 
-export interface GeoFeatureMap
+export type GeoFilterFunc = (s: string) => boolean | undefined;
+
+export function geoFilterFromHidden(hidden: any): GeoFilterFunc
 {
-  [id: string]: GeoFeature;  // Maps id to GeoFeature
+  if (Util.isEmpty(hidden)) return undefined;
+  return (s: string) => { return !hidden[s] }
+}
+
+export function geoFilteredTopo(topo: Poly.Topo, filter: GeoFilterFunc): Poly.Topo
+{
+  if (!topo || !filter)
+    return topo;
+  let copy: Poly.Topo = Util.shallowCopy(topo);
+  copy.objects = {};
+  Object.keys(topo.objects).forEach(geoid => {
+      if (filter(geoid))
+        copy.objects[geoid] = topo.objects[geoid];
+    });
+  return copy;
+}
+
+export function geoFilteredCollection(col: GeoFeatureCollection, filter: GeoFilterFunc): GeoFeatureCollection
+{
+  if (!col || !filter)
+    return col
+  let copy: GeoFeatureCollection = Util.shallowCopy(col);
+  copy.features = col.features.filter(f => filter(f.properties.id));
+  return copy;
+}
+
+export function geoFilteredMap(map: GeoFeatureMap, filter: GeoFilterFunc): GeoFeatureMap
+{
+  if (!map || !filter)
+    return map;
+  let copy: GeoFeatureMap = {};
+  Object.keys(map).forEach(geoid => { if (filter(geoid)) copy[geoid] = map[geoid] });
+  return copy;
 }
 
 export type FeatureFunc = (f: GeoFeature) => void;
@@ -326,8 +362,11 @@ export 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();
+      }
     }
   }
 
@@ -344,12 +383,17 @@ export class GeoMultiCollection
         // 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)
+          // Make sure at least one all entry is built, preferably topo if there is a base topo
+          let e = multi.entries['main'] ?? multi.nthEntry(0);
           if (nEntries > 1)
-            multi.allCol();
+          {
+            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;
@@ -538,21 +582,21 @@ export class GeoMultiCollection
     {
       // 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: GeoEntry) => this._length(e) > 0)
           .map((e: GeoEntry) => { return { topology: this._topo(e), filterout } });
         this.all.topo = topoarray.length == 0 ? null : topoarray.length == 1 ? topoarray[0].topology : Poly.topoSplice(topoarray);
@@ -726,6 +770,11 @@ export class GeoMultiCollection
       });
     return m;
   }
+
+  someHidden(): boolean
+  {
+    return !Util.isEmpty(this.hidden)
+  }
 }
 
 export enum geoIntersectOptions { Intersects, Bounds, BoundsCenter };

package/lib/poly/polybin.ts

@@ -166,8 +166,21 @@ export function topoToBuffer(coder: Util.Coder, topo: any): ArrayBuffer
   // 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: any[] = [];
+  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);
@@ -215,5 +228,19 @@ export function topoFromBuffer(coder: Util.Coder, ab: ArrayBuffer): any
   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<object, number>();
+  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;
 }