@dra2020/baseclient 1.0.163 → 1.0.165

package/dist/baseclient.js

@@ -6633,12 +6633,14 @@ __exportStar(__webpack_require__(/*! ./blend */ "./lib/poly/blend.ts"), exports)
 __exportStar(__webpack_require__(/*! ./cartesian */ "./lib/poly/cartesian.ts"), exports);
 __exportStar(__webpack_require__(/*! ./minbound */ "./lib/poly/minbound.ts"), exports);
 __exportStar(__webpack_require__(/*! ./polyround */ "./lib/poly/polyround.ts"), exports);
+__exportStar(__webpack_require__(/*! ./polyconvert */ "./lib/poly/polyconvert.ts"), exports);
 __exportStar(__webpack_require__(/*! ./topo */ "./lib/poly/topo.ts"), exports);
 __exportStar(__webpack_require__(/*! ./selfintersect */ "./lib/poly/selfintersect.ts"), exports);
 __exportStar(__webpack_require__(/*! ./shamos */ "./lib/poly/shamos.ts"), exports);
 __exportStar(__webpack_require__(/*! ./pointinpoly */ "./lib/poly/pointinpoly.ts"), exports);
 __exportStar(__webpack_require__(/*! ./mapto */ "./lib/poly/mapto.ts"), exports);
 __exportStar(__webpack_require__(/*! ./featurecleanholes */ "./lib/poly/featurecleanholes.ts"), exports);
+__exportStar(__webpack_require__(/*! ./polyhash */ "./lib/poly/polyhash.ts"), exports);
 
 
 /***/ }),
@@ -9067,6 +9069,245 @@ function topoFromBuffer(coder, ab) {
 }
 
 
+/***/ }),
+
+/***/ "./lib/poly/polyconvert.ts":
+/*!*********************************!*\
+  !*** ./lib/poly/polyconvert.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;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.polyConvert = polyConvert;
+exports.polyFrom32614 = polyFrom32614;
+exports.colValidateCRS = colValidateCRS;
+exports.utm14ToLonLat = utm14ToLonLat;
+const PP = __importStar(__webpack_require__(/*! ./polypack */ "./lib/poly/polypack.ts"));
+// Convert geometry given point conversion function. Takes any form of feature, collection or coordinate array(s)
+function polyConvert(o, cvt) {
+    if (o) {
+        if (Array.isArray(o)) {
+            if (o.length && typeof o[0] === 'number') {
+                for (let i = 0; i < o.length; i += 2) {
+                    const p = cvt([o[i], o[i + 1]]);
+                    o[i] = p[0];
+                    o[i + 1] = p[1];
+                }
+            }
+            else
+                o.forEach((e) => { polyConvert(e, cvt); });
+        }
+        else if (o.features !== undefined && Array.isArray(o.features))
+            o.features.forEach((f) => { polyConvert(f, cvt); });
+        else if (o.geometry !== undefined && o.geometry.coordinates !== undefined)
+            polyConvert(o.geometry.coordinates, cvt);
+        else if (o.geometry !== undefined && o.geometry.packed !== undefined)
+            PP.polyPackEachPoint(o.geometry.packed, (b, iPoly, iRing, iOffset) => {
+                const p = cvt([b[iOffset], b[iOffset + 1]]);
+                b[iOffset] = p[0];
+                b[iOffset + 1] = p[1];
+            });
+    }
+    return o;
+}
+function polyFrom32614(o) {
+    return polyConvert(o, utm14ToLonLat);
+}
+// If coordinates in 32614 format, convert to WGS84 (GeoJSON standard format)
+//
+function colValidateCRS(o) {
+    // "crs": { "type": "name", "properties": { "name": "urn:ogc:def:crs:EPSG::32614" } },
+    var _a, _b;
+    if (((_b = (_a = o === null || o === void 0 ? void 0 : o.crs) === null || _a === void 0 ? void 0 : _a.properties) === null || _b === void 0 ? void 0 : _b.name) === 'urn:ogc:def:crs:EPSG::32614') {
+        delete o.crs;
+        return polyFrom32614(o);
+    }
+    return o;
+}
+/**
+ * Convert UTM Zone 14N (EPSG:32614) coordinates to WGS84 lon/lat.
+ * Input:  [easting, northing] in meters
+ * Output: [longitude, latitude] in degrees
+ */
+function utm14ToLonLat([E, N]) {
+    // WGS84 parameters
+    const a = 6378137.0;
+    const f = 1 / 298.257223563;
+    const k0 = 0.9996;
+    const e = Math.sqrt(f * (2 - f)); // eccentricity
+    const e1sq = e * e / (1 - e * e);
+    // UTM zone parameters
+    const zone = 14;
+    const lonOrigin = (zone - 1) * 6 - 180 + 3; // central meridian
+    const falseEasting = 500000;
+    // Remove false northing for northern hemisphere (EPSG:326xx always north)
+    const x = E - falseEasting;
+    const y = N;
+    // Footpoint latitude
+    const M = y / k0;
+    const mu = M / (a * (1 - e * e / 4 - 3 * Math.pow(e, 4) / 64 - 5 * Math.pow(e, 6) / 256));
+    const e1 = (1 - Math.sqrt(1 - e * e)) / (1 + Math.sqrt(1 - e * e));
+    const J1 = (3 * e1 / 2 - 27 * Math.pow(e1, 3) / 32);
+    const J2 = (21 * Math.pow(e1, 2) / 16 - 55 * Math.pow(e1, 4) / 32);
+    const J3 = (151 * Math.pow(e1, 3) / 96);
+    const J4 = (1097 * Math.pow(e1, 4) / 512);
+    const fp = mu
+        + J1 * Math.sin(2 * mu)
+        + J2 * Math.sin(4 * mu)
+        + J3 * Math.sin(6 * mu)
+        + J4 * Math.sin(8 * mu);
+    // Precompute trig functions
+    const sinfp = Math.sin(fp);
+    const cosfp = Math.cos(fp);
+    const tanfp = Math.tan(fp);
+    const C1 = e1sq * Math.pow(cosfp, 2);
+    const T1 = Math.pow(tanfp, 2);
+    const R1 = a * (1 - e * e) / Math.pow(1 - e * e * Math.pow(sinfp, 2), 3 / 2);
+    const N1 = a / Math.sqrt(1 - e * e * Math.pow(sinfp, 2));
+    const D = x / (N1 * k0);
+    // Latitude (φ)
+    const lat = fp
+        - (N1 * tanfp / R1) *
+            (Math.pow(D, 2) / 2
+                - (5 + 3 * T1 + 10 * C1 - 4 * Math.pow(C1, 2) - 9 * e1sq) * Math.pow(D, 4) / 24
+                + (61 + 90 * T1 + 298 * C1 + 45 * Math.pow(T1, 2) - 252 * e1sq - 3 * Math.pow(C1, 2)) * Math.pow(D, 6) / 720);
+    // Longitude (λ)
+    const lon = (D
+        - (1 + 2 * T1 + C1) * Math.pow(D, 3) / 6
+        + (5 - 2 * C1 + 28 * T1 - 3 * Math.pow(C1, 2) + 8 * e1sq + 24 * Math.pow(T1, 2)) * Math.pow(D, 5) / 120) / cosfp;
+    // Convert to degrees and apply central meridian offset
+    const latitude = lat * (180 / Math.PI);
+    const longitude = lonOrigin + lon * (180 / Math.PI);
+    return [longitude, latitude];
+}
+
+
+/***/ }),
+
+/***/ "./lib/poly/polyhash.ts":
+/*!******************************!*\
+  !*** ./lib/poly/polyhash.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;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (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 () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", ({ value: true }));
+exports.polyHash32 = polyHash32;
+const P = __importStar(__webpack_require__(/*! ./poly */ "./lib/poly/poly.ts"));
+const PP = __importStar(__webpack_require__(/*! ./polypack */ "./lib/poly/polypack.ts"));
+// Hash coordinates to 32 bit number in order to produce a fast (and a little sloppy) equivalence test.
+// Note that this depends on ordering, so an equivalent polygon with different coordinate ordering would
+// not test as equivalent. As a 32 bit number, you can expect collisions when used for large numbers of
+// polygons (e.g. a 700k block set might expect ~57 collisions - TX at 660K gets 62 collisions, e.g.).
+//
+function polyHash32(poly, seed = 0) {
+    let pp = P.polyNormalize(poly);
+    if (!pp)
+        return 0;
+    let h = (seed | 0) ^ 0x9e3779b9;
+    const buf = new ArrayBuffer(8);
+    const dv = new DataView(buf);
+    function mix32(x) {
+        x ^= x >>> 16;
+        x = Math.imul(x, 0x7feb352d);
+        x ^= x >>> 15;
+        x = Math.imul(x, 0x846ca68b);
+        x ^= x >>> 16;
+        return x | 0;
+    }
+    let l = 0;
+    PP.polyPackEachRing(pp, (b, iPoly, iRing, iOffset, nPoints) => {
+        let iEnd = iOffset + (nPoints * 2);
+        for (; iOffset < iEnd; iOffset++) {
+            const x = b[iOffset];
+            if (Number.isNaN(x)) {
+                dv.setUint32(0, 0x7ff80001, true);
+                dv.setUint32(4, 0, true);
+            }
+            else
+                dv.setFloat64(0, x, true);
+            const lo = dv.getUint32(0, true) | 0;
+            const hi = dv.getUint32(4, true) | 0;
+            let z = mix32(lo ^ Math.imul(hi, 0x9e3779b9) ^ Math.imul(l + 1, 0x85ebca6b));
+            h ^= z;
+            h = mix32(h);
+            l++;
+        }
+    });
+    h ^= l | 0;
+    h = mix32(h);
+    // return as unsigned 32-bit in a JS number
+    return h >>> 0;
+}
+
+
 /***/ }),
 
 /***/ "./lib/poly/polylabel.ts":