@loaders.gl/wkt 3.1.0-alpha.4 → 3.1.0-beta.3

package/dist/lib/parse-wkb.js

@@ -0,0 +1,236 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const NUM_DIMENSIONS = {
+    0: 2,
+    1: 3,
+    2: 3,
+    3: 4 // 4D (ZM)
+};
+function parseWKB(arrayBuffer) {
+    const view = new DataView(arrayBuffer);
+    let offset = 0;
+    // Check endianness of data
+    const littleEndian = view.getUint8(offset) === 1;
+    offset++;
+    // 4-digit code representing dimension and type of geometry
+    const geometryCode = view.getUint32(offset, littleEndian);
+    offset += 4;
+    const geometryType = geometryCode % 1000;
+    const type = ((geometryCode - geometryType) / 1000);
+    const dimension = NUM_DIMENSIONS[type];
+    switch (geometryType) {
+        case 1:
+            const point = parsePoint(view, offset, dimension, littleEndian);
+            return point.geometry;
+        case 2:
+            const line = parseLineString(view, offset, dimension, littleEndian);
+            return line.geometry;
+        case 3:
+            const polygon = parsePolygon(view, offset, dimension, littleEndian);
+            return polygon.geometry;
+        case 4:
+            const multiPoint = parseMultiPoint(view, offset, dimension, littleEndian);
+            multiPoint.type = 'Point';
+            return multiPoint;
+        case 5:
+            const multiLine = parseMultiLineString(view, offset, dimension, littleEndian);
+            multiLine.type = 'LineString';
+            return multiLine;
+        case 6:
+            const multiPolygon = parseMultiPolygon(view, offset, dimension, littleEndian);
+            multiPolygon.type = 'Polygon';
+            return multiPolygon;
+        // case 7:
+        // TODO: handle GeometryCollections
+        // return parseGeometryCollection(view, offset, dimension, littleEndian);
+        default:
+            throw new Error(`WKB: Unsupported geometry type: ${geometryType}`);
+    }
+}
+exports.default = parseWKB;
+// Primitives; parse point and linear ring
+function parsePoint(view, offset, dimension, littleEndian) {
+    const positions = new Float64Array(dimension);
+    for (let i = 0; i < dimension; i++) {
+        positions[i] = view.getFloat64(offset, littleEndian);
+        offset += 8;
+    }
+    return {
+        geometry: { type: 'Point', positions: { value: positions, size: dimension } },
+        offset
+    };
+}
+function parseLineString(view, offset, dimension, littleEndian) {
+    const nPoints = view.getUint32(offset, littleEndian);
+    offset += 4;
+    // Instantiate array
+    const positions = new Float64Array(nPoints * dimension);
+    for (let i = 0; i < nPoints * dimension; i++) {
+        positions[i] = view.getFloat64(offset, littleEndian);
+        offset += 8;
+    }
+    const pathIndices = [0];
+    if (nPoints > 0) {
+        pathIndices.push(nPoints);
+    }
+    return {
+        geometry: {
+            type: 'LineString',
+            positions: { value: positions, size: dimension },
+            pathIndices: { value: new Uint16Array(pathIndices), size: 1 }
+        },
+        offset
+    };
+}
+// https://stackoverflow.com/a/55261098
+const cumulativeSum = (sum) => (value) => (sum += value);
+function parsePolygon(view, offset, dimension, littleEndian) {
+    const nRings = view.getUint32(offset, littleEndian);
+    offset += 4;
+    const rings = [];
+    for (let i = 0; i < nRings; i++) {
+        const parsed = parseLineString(view, offset, dimension, littleEndian);
+        const { positions } = parsed.geometry;
+        offset = parsed.offset;
+        rings.push(positions.value);
+    }
+    const concatenatedPositions = new Float64Array(concatTypedArrays(rings).buffer);
+    const polygonIndices = [0];
+    if (concatenatedPositions.length > 0) {
+        polygonIndices.push(concatenatedPositions.length / dimension);
+    }
+    const primitivePolygonIndices = rings.map((l) => l.length / dimension).map(cumulativeSum(0));
+    primitivePolygonIndices.unshift(0);
+    return {
+        geometry: {
+            type: 'Polygon',
+            positions: { value: concatenatedPositions, size: dimension },
+            polygonIndices: {
+                value: new Uint16Array(polygonIndices),
+                size: 1
+            },
+            primitivePolygonIndices: { value: new Uint16Array(primitivePolygonIndices), size: 1 }
+        },
+        offset
+    };
+}
+function parseMultiPoint(view, offset, dimension, littleEndian) {
+    const nPoints = view.getUint32(offset, littleEndian);
+    offset += 4;
+    const binaryPointGeometries = [];
+    for (let i = 0; i < nPoints; i++) {
+        // Byte order for point
+        const littleEndianPoint = view.getUint8(offset) === 1;
+        offset++;
+        // Assert point type
+        if (view.getUint32(offset, littleEndianPoint) % 1000 !== 1) {
+            throw new Error('WKB: Inner geometries of MultiPoint not of type Point');
+        }
+        offset += 4;
+        const parsed = parsePoint(view, offset, dimension, littleEndianPoint);
+        offset = parsed.offset;
+        binaryPointGeometries.push(parsed.geometry);
+    }
+    return concatenateBinaryPointGeometries(binaryPointGeometries, dimension);
+}
+function parseMultiLineString(view, offset, dimension, littleEndian) {
+    const nLines = view.getUint32(offset, littleEndian);
+    offset += 4;
+    const binaryLineGeometries = [];
+    for (let i = 0; i < nLines; i++) {
+        // Byte order for line
+        const littleEndianLine = view.getUint8(offset) === 1;
+        offset++;
+        // Assert type LineString
+        if (view.getUint32(offset, littleEndianLine) % 1000 !== 2) {
+            throw new Error('WKB: Inner geometries of MultiLineString not of type LineString');
+        }
+        offset += 4;
+        const parsed = parseLineString(view, offset, dimension, littleEndianLine);
+        offset = parsed.offset;
+        binaryLineGeometries.push(parsed.geometry);
+    }
+    return concatenateBinaryLineGeometries(binaryLineGeometries, dimension);
+}
+function parseMultiPolygon(view, offset, dimension, littleEndian) {
+    const nPolygons = view.getUint32(offset, littleEndian);
+    offset += 4;
+    const binaryPolygonGeometries = [];
+    for (let i = 0; i < nPolygons; i++) {
+        // Byte order for polygon
+        const littleEndianPolygon = view.getUint8(offset) === 1;
+        offset++;
+        // Assert type Polygon
+        if (view.getUint32(offset, littleEndianPolygon) % 1000 !== 3) {
+            throw new Error('WKB: Inner geometries of MultiPolygon not of type Polygon');
+        }
+        offset += 4;
+        const parsed = parsePolygon(view, offset, dimension, littleEndianPolygon);
+        offset = parsed.offset;
+        binaryPolygonGeometries.push(parsed.geometry);
+    }
+    return concatenateBinaryPolygonGeometries(binaryPolygonGeometries, dimension);
+}
+// TODO - move to loaders.gl/schema/gis
+function concatenateBinaryPointGeometries(binaryPointGeometries, dimension) {
+    const positions = binaryPointGeometries.map((geometry) => geometry.positions.value);
+    const concatenatedPositions = new Float64Array(concatTypedArrays(positions).buffer);
+    return {
+        type: 'Point',
+        positions: { value: concatenatedPositions, size: dimension }
+    };
+}
+function concatenateBinaryLineGeometries(binaryLineGeometries, dimension) {
+    const lines = binaryLineGeometries.map((geometry) => geometry.positions.value);
+    const concatenatedPositions = new Float64Array(concatTypedArrays(lines).buffer);
+    const pathIndices = lines.map((line) => line.length / dimension).map(cumulativeSum(0));
+    pathIndices.unshift(0);
+    return {
+        type: 'LineString',
+        positions: { value: concatenatedPositions, size: dimension },
+        pathIndices: { value: new Uint16Array(pathIndices), size: 1 }
+    };
+}
+function concatenateBinaryPolygonGeometries(binaryPolygonGeometries, dimension) {
+    const polygons = [];
+    const primitivePolygons = [];
+    for (const binaryPolygon of binaryPolygonGeometries) {
+        const { positions, primitivePolygonIndices } = binaryPolygon;
+        polygons.push(positions.value);
+        primitivePolygons.push(primitivePolygonIndices.value);
+    }
+    const concatenatedPositions = new Float64Array(concatTypedArrays(polygons).buffer);
+    const polygonIndices = polygons.map((p) => p.length / dimension).map(cumulativeSum(0));
+    polygonIndices.unshift(0);
+    // Combine primitivePolygonIndices from each individual polygon
+    const primitivePolygonIndices = [0];
+    for (const primitivePolygon of primitivePolygons) {
+        primitivePolygonIndices.push(...primitivePolygon
+            .filter((x) => x > 0)
+            .map((x) => x + primitivePolygonIndices[primitivePolygonIndices.length - 1]));
+    }
+    return {
+        type: 'Polygon',
+        positions: { value: concatenatedPositions, size: dimension },
+        polygonIndices: { value: new Uint16Array(polygonIndices), size: 1 },
+        primitivePolygonIndices: { value: new Uint16Array(primitivePolygonIndices), size: 1 }
+    };
+}
+// TODO: remove copy; import from typed-array-utils
+// modules/math/src/geometry/typed-arrays/typed-array-utils.js
+function concatTypedArrays(arrays) {
+    let byteLength = 0;
+    for (let i = 0; i < arrays.length; ++i) {
+        byteLength += arrays[i].byteLength;
+    }
+    const buffer = new Uint8Array(byteLength);
+    let byteOffset = 0;
+    for (let i = 0; i < arrays.length; ++i) {
+        const data = new Uint8Array(arrays[i].buffer);
+        byteLength = data.length;
+        for (let j = 0; j < byteLength; ++j) {
+            buffer[byteOffset++] = data[j];
+        }
+    }
+    return buffer;
+}

package/dist/lib/parse-wkt.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Parse WKT and return GeoJSON.
+ *
+ * @param {string} _ A WKT geometry
+ * @return {?Object} A GeoJSON geometry object
+ **/
+export default function parseWKT(input: any): any;
+//# sourceMappingURL=parse-wkt.d.ts.map

package/dist/lib/parse-wkt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-wkt.d.ts","sourceRoot":"","sources":["../../src/lib/parse-wkt.ts"],"names":[],"mappings":"AASA;;;;;IAKI;AACJ,MAAM,CAAC,OAAO,UAAU,QAAQ,CAAC,KAAK,KAAA,OA8MrC"}

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

@@ -0,0 +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

@@ -0,0 +1,39 @@
+import type { Loader, LoaderWithParser } from '@loaders.gl/loader-utils';
+import parseWKB from './lib/parse-wkb';
+/**
+ * Worker loader for WKB (Well-Known Binary)
+ */
+export declare const WKBWorkerLoader: {
+    name: string;
+    id: string;
+    module: string;
+    version: any;
+    worker: boolean;
+    category: string;
+    extensions: string[];
+    mimeTypes: never[];
+    options: {
+        wkb: {};
+    };
+};
+/**
+ * Loader for WKB (Well-Known Binary)
+ */
+export declare const WKBLoader: {
+    parse: (arrayBuffer: ArrayBuffer) => Promise<import("@loaders.gl/schema").BinaryGeometry>;
+    parseSync: typeof parseWKB;
+    name: string;
+    id: string;
+    module: string;
+    version: any;
+    worker: boolean;
+    category: string;
+    extensions: string[];
+    mimeTypes: never[];
+    options: {
+        wkb: {};
+    };
+};
+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

@@ -0,0 +1,10 @@
+import type { Loader, LoaderWithParser } from '@loaders.gl/loader-utils';
+/**
+ * Well-Known text loader
+ */
+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
+};