@loaders.gl/wkt 3.1.0-alpha.5 → 3.1.0-beta.5

package/dist/lib/parse-wkt.js

@@ -0,0 +1,227 @@
+"use strict";
+// Fork of https://github.com/mapbox/wellknown under ISC license (MIT/BSD-2-clause equivalent)
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable */
+// @ts-nocheck
+const numberRegexp = /[-+]?([0-9]*\.[0-9]+|[0-9]+)([eE][-+]?[0-9]+)?/;
+// Matches sequences like '100 100' or '100 100 100'.
+const tuples = new RegExp('^' + numberRegexp.source + '(\\s' + numberRegexp.source + '){1,}');
+/**
+ * Parse WKT and return GeoJSON.
+ *
+ * @param {string} _ A WKT geometry
+ * @return {?Object} A GeoJSON geometry object
+ **/
+function parseWKT(input) {
+    const parts = input.split(';');
+    let _ = parts.pop();
+    const srid = (parts.shift() || '').split('=').pop();
+    let i = 0;
+    function $(re) {
+        const match = _.substring(i).match(re);
+        if (!match)
+            return null;
+        else {
+            i += match[0].length;
+            return match[0];
+        }
+    }
+    function crs(obj) {
+        if (obj && srid.match(/\d+/)) {
+            obj.crs = {
+                type: 'name',
+                properties: {
+                    name: 'urn:ogc:def:crs:EPSG::' + srid
+                }
+            };
+        }
+        return obj;
+    }
+    function white() {
+        $(/^\s*/);
+    }
+    function multicoords() {
+        white();
+        let depth = 0;
+        const rings = [];
+        const stack = [rings];
+        let pointer = rings;
+        let elem;
+        while ((elem = $(/^(\()/) || $(/^(\))/) || $(/^(,)/) || $(tuples))) {
+            if (elem === '(') {
+                stack.push(pointer);
+                pointer = [];
+                stack[stack.length - 1].push(pointer);
+                depth++;
+            }
+            else if (elem === ')') {
+                // For the case: Polygon(), ...
+                if (pointer.length === 0)
+                    return null;
+                // @ts-ignore
+                pointer = stack.pop();
+                // the stack was empty, input was malformed
+                if (!pointer)
+                    return null;
+                depth--;
+                if (depth === 0)
+                    break;
+            }
+            else if (elem === ',') {
+                pointer = [];
+                stack[stack.length - 1].push(pointer);
+            }
+            else if (!elem.split(/\s/g).some(isNaN)) {
+                Array.prototype.push.apply(pointer, elem.split(/\s/g).map(parseFloat));
+            }
+            else {
+                return null;
+            }
+            white();
+        }
+        if (depth !== 0)
+            return null;
+        return rings;
+    }
+    function coords() {
+        const list = [];
+        let item;
+        let pt;
+        while ((pt = $(tuples) || $(/^(,)/))) {
+            if (pt === ',') {
+                list.push(item);
+                item = [];
+            }
+            else if (!pt.split(/\s/g).some(isNaN)) {
+                if (!item)
+                    item = [];
+                Array.prototype.push.apply(item, pt.split(/\s/g).map(parseFloat));
+            }
+            white();
+        }
+        if (item)
+            list.push(item);
+        else
+            return null;
+        return list.length ? list : null;
+    }
+    function point() {
+        if (!$(/^(point(\sz)?)/i))
+            return null;
+        white();
+        if (!$(/^(\()/))
+            return null;
+        const c = coords();
+        if (!c)
+            return null;
+        white();
+        if (!$(/^(\))/))
+            return null;
+        return {
+            type: 'Point',
+            coordinates: c[0]
+        };
+    }
+    function multipoint() {
+        if (!$(/^(multipoint)/i))
+            return null;
+        white();
+        const newCoordsFormat = _.substring(_.indexOf('(') + 1, _.length - 1)
+            .replace(/\(/g, '')
+            .replace(/\)/g, '');
+        _ = 'MULTIPOINT (' + newCoordsFormat + ')';
+        const c = multicoords();
+        if (!c)
+            return null;
+        white();
+        return {
+            type: 'MultiPoint',
+            coordinates: c
+        };
+    }
+    function multilinestring() {
+        if (!$(/^(multilinestring)/i))
+            return null;
+        white();
+        const c = multicoords();
+        if (!c)
+            return null;
+        white();
+        return {
+            type: 'MultiLineString',
+            coordinates: c
+        };
+    }
+    function linestring() {
+        if (!$(/^(linestring(\sz)?)/i))
+            return null;
+        white();
+        if (!$(/^(\()/))
+            return null;
+        const c = coords();
+        if (!c)
+            return null;
+        if (!$(/^(\))/))
+            return null;
+        return {
+            type: 'LineString',
+            coordinates: c
+        };
+    }
+    function polygon() {
+        if (!$(/^(polygon(\sz)?)/i))
+            return null;
+        white();
+        const c = multicoords();
+        if (!c)
+            return null;
+        return {
+            type: 'Polygon',
+            coordinates: c
+        };
+    }
+    function multipolygon() {
+        if (!$(/^(multipolygon)/i))
+            return null;
+        white();
+        const c = multicoords();
+        if (!c)
+            return null;
+        return {
+            type: 'MultiPolygon',
+            coordinates: c
+        };
+    }
+    function geometrycollection() {
+        const geometries = [];
+        let geometry;
+        if (!$(/^(geometrycollection)/i))
+            return null;
+        white();
+        if (!$(/^(\()/))
+            return null;
+        while ((geometry = root())) {
+            geometries.push(geometry);
+            white();
+            $(/^(,)/);
+            white();
+        }
+        if (!$(/^(\))/))
+            return null;
+        return {
+            type: 'GeometryCollection',
+            geometries: geometries
+        };
+    }
+    function root() {
+        return (point() ||
+            linestring() ||
+            polygon() ||
+            multipoint() ||
+            multilinestring() ||
+            multipolygon() ||
+            geometrycollection());
+    }
+    return crs(root());
+}
+exports.default = parseWKT;

package/dist/lib/utils/version.d.ts

@@ -1 +1,2 @@
 export declare const VERSION: any;
+//# sourceMappingURL=version.d.ts.map

package/dist/lib/utils/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/version.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,OAAO,KAA8D,CAAC"}

package/dist/lib/utils/version.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VERSION = void 0;
+// Version constant cannot be imported, it needs to correspond to the build version of **this** module.
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+exports.VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';

package/dist/wkb-loader.d.ts

@@ -20,7 +20,7 @@ export declare const WKBWorkerLoader: {
  * Loader for WKB (Well-Known Binary)
  */
 export declare const WKBLoader: {
-    parse: (arrayBuffer: any) => Promise<import("modules/schema/dist").BinaryGeometry>;
+    parse: (arrayBuffer: ArrayBuffer) => Promise<import("@loaders.gl/schema").BinaryGeometry>;
     parseSync: typeof parseWKB;
     name: string;
     id: string;
@@ -36,3 +36,4 @@ export declare const WKBLoader: {
 };
 export declare const _typecheckWKBWorkerLoader: Loader;
 export declare const _typecheckWKBLoader: LoaderWithParser;
+//# sourceMappingURL=wkb-loader.d.ts.map

package/dist/wkb-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wkb-loader.d.ts","sourceRoot":"","sources":["../src/wkb-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAE,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAEvE,OAAO,QAAQ,MAAM,iBAAiB,CAAC;AAEvC;;GAEG;AACH,eAAO,MAAM,eAAe;;;;;;;;;;;;CAY3B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,SAAS;yBAEO,WAAW;;;;;;;;;;;;;CAEvC,CAAC;AAEF,eAAO,MAAM,yBAAyB,EAAE,MAAwB,CAAC;AACjE,eAAO,MAAM,mBAAmB,EAAE,gBAA4B,CAAC"}

package/dist/wkb-loader.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports._typecheckWKBLoader = exports._typecheckWKBWorkerLoader = exports.WKBLoader = exports.WKBWorkerLoader = void 0;
+const version_1 = require("./lib/utils/version");
+const parse_wkb_1 = __importDefault(require("./lib/parse-wkb"));
+/**
+ * Worker loader for WKB (Well-Known Binary)
+ */
+exports.WKBWorkerLoader = {
+    name: 'WKB',
+    id: 'wkb',
+    module: 'wkt',
+    version: version_1.VERSION,
+    worker: true,
+    category: 'geometry',
+    extensions: ['wkb'],
+    mimeTypes: [],
+    options: {
+        wkb: {}
+    }
+};
+/**
+ * Loader for WKB (Well-Known Binary)
+ */
+exports.WKBLoader = {
+    ...exports.WKBWorkerLoader,
+    parse: async (arrayBuffer) => (0, parse_wkb_1.default)(arrayBuffer),
+    parseSync: parse_wkb_1.default
+};
+exports._typecheckWKBWorkerLoader = exports.WKBWorkerLoader;
+exports._typecheckWKBLoader = exports.WKBLoader;

package/dist/wkt-loader.d.ts

@@ -7,3 +7,4 @@ export declare const WKTWorkerLoader: Loader;
  * Well-Known text loader
  */
 export declare const WKTLoader: LoaderWithParser;
+//# sourceMappingURL=wkt-loader.d.ts.map

package/dist/wkt-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wkt-loader.d.ts","sourceRoot":"","sources":["../src/wkt-loader.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAE,gBAAgB,EAAC,MAAM,0BAA0B,CAAC;AAIvE;;GAEG;AACH,eAAO,MAAM,eAAe,EAAE,MAa7B,CAAC;AAEF;;GAEG;AACH,eAAO,MAAM,SAAS,EAAE,gBAIvB,CAAC"}

package/dist/wkt-loader.js

@@ -0,0 +1,33 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WKTLoader = exports.WKTWorkerLoader = void 0;
+const version_1 = require("./lib/utils/version");
+const parse_wkt_1 = __importDefault(require("./lib/parse-wkt"));
+/**
+ * Well-Known text loader
+ */
+exports.WKTWorkerLoader = {
+    name: 'WKT (Well-Known Text)',
+    id: 'wkt',
+    module: 'wkt',
+    version: version_1.VERSION,
+    worker: true,
+    extensions: ['wkt'],
+    mimeTypes: ['text/plain'],
+    category: 'geometry',
+    text: true,
+    options: {
+        wkt: {}
+    }
+};
+/**
+ * Well-Known text loader
+ */
+exports.WKTLoader = {
+    ...exports.WKTWorkerLoader,
+    parse: async (arrayBuffer) => (0, parse_wkt_1.default)(new TextDecoder().decode(arrayBuffer)),
+    parseTextSync: parse_wkt_1.default
+};