@loaders.gl/wkt 3.1.3 → 4.0.0-alpha.5

package/dist/bundle.js

@@ -1,5 +1,5 @@
-"use strict";
-// @ts-nocheck
 const moduleExports = require('./index');
+
 globalThis.loaders = globalThis.loaders || {};
 module.exports = Object.assign(globalThis.loaders, moduleExports);
+//# sourceMappingURL=bundle.js.map

package/dist/bundle.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/bundle.ts"],"names":["moduleExports","require","globalThis","loaders","module","exports","Object","assign"],"mappings":"AACA,MAAMA,aAAa,GAAGC,OAAO,CAAC,SAAD,CAA7B;;AACAC,UAAU,CAACC,OAAX,GAAqBD,UAAU,CAACC,OAAX,IAAsB,EAA3C;AACAC,MAAM,CAACC,OAAP,GAAiBC,MAAM,CAACC,MAAP,CAAcL,UAAU,CAACC,OAAzB,EAAkCH,aAAlC,CAAjB","sourcesContent":["// @ts-nocheck\nconst moduleExports = require('./index');\nglobalThis.loaders = globalThis.loaders || {};\nmodule.exports = Object.assign(globalThis.loaders, moduleExports);\n"],"file":"bundle.js"}

package/dist/index.js

@@ -1,13 +1,5 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.WKBWriter = exports.WKTWriter = exports.WKTWorkerLoader = exports.WKTLoader = exports.WKBWorkerLoader = exports.WKBLoader = void 0;
-var wkb_loader_1 = require("./wkb-loader");
-Object.defineProperty(exports, "WKBLoader", { enumerable: true, get: function () { return wkb_loader_1.WKBLoader; } });
-Object.defineProperty(exports, "WKBWorkerLoader", { enumerable: true, get: function () { return wkb_loader_1.WKBWorkerLoader; } });
-var wkt_loader_1 = require("./wkt-loader");
-Object.defineProperty(exports, "WKTLoader", { enumerable: true, get: function () { return wkt_loader_1.WKTLoader; } });
-Object.defineProperty(exports, "WKTWorkerLoader", { enumerable: true, get: function () { return wkt_loader_1.WKTWorkerLoader; } });
-var wkt_writer_1 = require("./wkt-writer");
-Object.defineProperty(exports, "WKTWriter", { enumerable: true, get: function () { return wkt_writer_1.WKTWriter; } });
-var wkb_writer_1 = require("./wkb-writer");
-Object.defineProperty(exports, "WKBWriter", { enumerable: true, get: function () { return wkb_writer_1.WKBWriter; } });
+export { WKBLoader, WKBWorkerLoader } from './wkb-loader';
+export { WKTLoader, WKTWorkerLoader } from './wkt-loader';
+export { WKTWriter } from './wkt-writer';
+export { WKBWriter } from './wkb-writer';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"names":["WKBLoader","WKBWorkerLoader","WKTLoader","WKTWorkerLoader","WKTWriter","WKBWriter"],"mappings":"AAAA,SAAQA,SAAR,EAAmBC,eAAnB,QAAyC,cAAzC;AACA,SAAQC,SAAR,EAAmBC,eAAnB,QAAyC,cAAzC;AACA,SAAQC,SAAR,QAAwB,cAAxB;AACA,SAAQC,SAAR,QAAwB,cAAxB","sourcesContent":["export {WKBLoader, WKBWorkerLoader} from './wkb-loader';\nexport {WKTLoader, WKTWorkerLoader} from './wkt-loader';\nexport {WKTWriter} from './wkt-writer';\nexport {WKBWriter} from './wkb-writer';\n"],"file":"index.js"}

package/dist/lib/encode-wkb.js

@@ -1,290 +1,323 @@
-"use strict";
-// loaders.gl, MIT license
-// Forked from https://github.com/cschwarz/wkx under MIT license, Copyright (c) 2013 Christian Schwarz
-// Reference: https://www.ogc.org/standards/sfa
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const binary_writer_1 = __importDefault(require("./utils/binary-writer"));
-/**
- * Integer code for geometry type
- * Reference: https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry#Well-known_binary
- */
+import BinaryWriter from './utils/binary-writer';
 var WKB;
+
 (function (WKB) {
-    WKB[WKB["Point"] = 1] = "Point";
-    WKB[WKB["LineString"] = 2] = "LineString";
-    WKB[WKB["Polygon"] = 3] = "Polygon";
-    WKB[WKB["MultiPoint"] = 4] = "MultiPoint";
-    WKB[WKB["MultiLineString"] = 5] = "MultiLineString";
-    WKB[WKB["MultiPolygon"] = 6] = "MultiPolygon";
-    WKB[WKB["GeometryCollection"] = 7] = "GeometryCollection";
+  WKB[WKB["Point"] = 1] = "Point";
+  WKB[WKB["LineString"] = 2] = "LineString";
+  WKB[WKB["Polygon"] = 3] = "Polygon";
+  WKB[WKB["MultiPoint"] = 4] = "MultiPoint";
+  WKB[WKB["MultiLineString"] = 5] = "MultiLineString";
+  WKB[WKB["MultiPolygon"] = 6] = "MultiPolygon";
+  WKB[WKB["GeometryCollection"] = 7] = "GeometryCollection";
 })(WKB || (WKB = {}));
-/**
- * Encodes a GeoJSON object into WKB
- * @param geojson A GeoJSON Feature or Geometry
- * @returns string
- */
-function encodeWKB(geometry, options = { hasZ: false, hasM: false }) {
-    if (geometry.type === 'Feature') {
-        geometry = geometry.geometry;
-    }
-    switch (geometry.type) {
-        case 'Point':
-            return encodePoint(geometry.coordinates, options);
-        case 'LineString':
-            return encodeLineString(geometry.coordinates, options);
-        case 'Polygon':
-            return encodePolygon(geometry.coordinates, options);
-        case 'MultiPoint':
-            return encodeMultiPoint(geometry, options);
-        case 'MultiPolygon':
-            return encodeMultiPolygon(geometry, options);
-        case 'MultiLineString':
-            return encodeMultiLineString(geometry, options);
-        case 'GeometryCollection':
-            return encodeGeometryCollection(geometry, options);
-        default:
-            const exhaustiveCheck = geometry;
-            throw new Error(`Unhandled case: ${exhaustiveCheck}`);
-    }
+
+export default function encodeWKB(geometry, options = {
+  hasZ: false,
+  hasM: false
+}) {
+  if (geometry.type === 'Feature') {
+    geometry = geometry.geometry;
+  }
+
+  switch (geometry.type) {
+    case 'Point':
+      return encodePoint(geometry.coordinates, options);
+
+    case 'LineString':
+      return encodeLineString(geometry.coordinates, options);
+
+    case 'Polygon':
+      return encodePolygon(geometry.coordinates, options);
+
+    case 'MultiPoint':
+      return encodeMultiPoint(geometry, options);
+
+    case 'MultiPolygon':
+      return encodeMultiPolygon(geometry, options);
+
+    case 'MultiLineString':
+      return encodeMultiLineString(geometry, options);
+
+    case 'GeometryCollection':
+      return encodeGeometryCollection(geometry, options);
+
+    default:
+      const exhaustiveCheck = geometry;
+      throw new Error("Unhandled case: ".concat(exhaustiveCheck));
+  }
 }
-exports.default = encodeWKB;
-/** Calculate the binary size (in the WKB encoding) of a specific GeoJSON geometry */
+
 function getGeometrySize(geometry, options) {
-    switch (geometry.type) {
-        case 'Point':
-            return getPointSize(options);
-        case 'LineString':
-            return getLineStringSize(geometry.coordinates, options);
-        case 'Polygon':
-            return getPolygonSize(geometry.coordinates, options);
-        case 'MultiPoint':
-            return getMultiPointSize(geometry, options);
-        case 'MultiPolygon':
-            return getMultiPolygonSize(geometry, options);
-        case 'MultiLineString':
-            return getMultiLineStringSize(geometry, options);
-        case 'GeometryCollection':
-            return getGeometryCollectionSize(geometry, options);
-        default:
-            const exhaustiveCheck = geometry;
-            throw new Error(`Unhandled case: ${exhaustiveCheck}`);
-    }
+  switch (geometry.type) {
+    case 'Point':
+      return getPointSize(options);
+
+    case 'LineString':
+      return getLineStringSize(geometry.coordinates, options);
+
+    case 'Polygon':
+      return getPolygonSize(geometry.coordinates, options);
+
+    case 'MultiPoint':
+      return getMultiPointSize(geometry, options);
+
+    case 'MultiPolygon':
+      return getMultiPolygonSize(geometry, options);
+
+    case 'MultiLineString':
+      return getMultiLineStringSize(geometry, options);
+
+    case 'GeometryCollection':
+      return getGeometryCollectionSize(geometry, options);
+
+    default:
+      const exhaustiveCheck = geometry;
+      throw new Error("Unhandled case: ".concat(exhaustiveCheck));
+  }
 }
-/** Encode Point geometry as WKB ArrayBuffer */
+
 function encodePoint(coordinates, options) {
-    const writer = new binary_writer_1.default(getPointSize(options));
-    writer.writeInt8(1);
-    writeWkbType(writer, WKB.Point, options);
-    // I believe this special case is to handle writing Point(NaN, NaN) correctly
-    if (typeof coordinates[0] === 'undefined' && typeof coordinates[1] === 'undefined') {
-        writer.writeDoubleLE(NaN);
-        writer.writeDoubleLE(NaN);
-        if (options.hasZ) {
-            writer.writeDoubleLE(NaN);
-        }
-        if (options.hasM) {
-            writer.writeDoubleLE(NaN);
-        }
-    }
-    else {
-        writeCoordinate(writer, coordinates, options);
-    }
-    return writer.arrayBuffer;
-}
-/** Write coordinate to buffer */
-function writeCoordinate(writer, coordinate, options) {
-    writer.writeDoubleLE(coordinate[0]);
-    writer.writeDoubleLE(coordinate[1]);
+  const writer = new BinaryWriter(getPointSize(options));
+  writer.writeInt8(1);
+  writeWkbType(writer, WKB.Point, options);
+
+  if (typeof coordinates[0] === 'undefined' && typeof coordinates[1] === 'undefined') {
+    writer.writeDoubleLE(NaN);
+    writer.writeDoubleLE(NaN);
+
     if (options.hasZ) {
-        writer.writeDoubleLE(coordinate[2]);
+      writer.writeDoubleLE(NaN);
     }
+
     if (options.hasM) {
-        writer.writeDoubleLE(coordinate[3]);
+      writer.writeDoubleLE(NaN);
     }
+  } else {
+    writeCoordinate(writer, coordinates, options);
+  }
+
+  return writer.arrayBuffer;
 }
-/** Get encoded size of Point geometry */
+
+function writeCoordinate(writer, coordinate, options) {
+  writer.writeDoubleLE(coordinate[0]);
+  writer.writeDoubleLE(coordinate[1]);
+
+  if (options.hasZ) {
+    writer.writeDoubleLE(coordinate[2]);
+  }
+
+  if (options.hasM) {
+    writer.writeDoubleLE(coordinate[3]);
+  }
+}
+
 function getPointSize(options) {
-    const coordinateSize = getCoordinateSize(options);
-    return 1 + 4 + coordinateSize;
+  const coordinateSize = getCoordinateSize(options);
+  return 1 + 4 + coordinateSize;
 }
-/** Encode LineString geometry as WKB ArrayBuffer */
+
 function encodeLineString(coordinates, options) {
-    const size = getLineStringSize(coordinates, options);
-    const writer = new binary_writer_1.default(size);
-    writer.writeInt8(1);
-    writeWkbType(writer, WKB.LineString, options);
-    writer.writeUInt32LE(coordinates.length);
-    for (const coordinate of coordinates) {
-        writeCoordinate(writer, coordinate, options);
-    }
-    return writer.arrayBuffer;
+  const size = getLineStringSize(coordinates, options);
+  const writer = new BinaryWriter(size);
+  writer.writeInt8(1);
+  writeWkbType(writer, WKB.LineString, options);
+  writer.writeUInt32LE(coordinates.length);
+
+  for (const coordinate of coordinates) {
+    writeCoordinate(writer, coordinate, options);
+  }
+
+  return writer.arrayBuffer;
 }
-/** Get encoded size of LineString geometry */
+
 function getLineStringSize(coordinates, options) {
-    const coordinateSize = getCoordinateSize(options);
-    return 1 + 4 + 4 + coordinates.length * coordinateSize;
+  const coordinateSize = getCoordinateSize(options);
+  return 1 + 4 + 4 + coordinates.length * coordinateSize;
 }
-/** Encode Polygon geometry as WKB ArrayBuffer */
+
 function encodePolygon(coordinates, options) {
-    const writer = new binary_writer_1.default(getPolygonSize(coordinates, options));
-    writer.writeInt8(1);
-    writeWkbType(writer, WKB.Polygon, options);
-    const [exteriorRing, ...interiorRings] = coordinates;
-    if (exteriorRing.length > 0) {
-        writer.writeUInt32LE(1 + interiorRings.length);
-        writer.writeUInt32LE(exteriorRing.length);
-    }
-    else {
-        writer.writeUInt32LE(0);
+  const writer = new BinaryWriter(getPolygonSize(coordinates, options));
+  writer.writeInt8(1);
+  writeWkbType(writer, WKB.Polygon, options);
+  const [exteriorRing, ...interiorRings] = coordinates;
+
+  if (exteriorRing.length > 0) {
+    writer.writeUInt32LE(1 + interiorRings.length);
+    writer.writeUInt32LE(exteriorRing.length);
+  } else {
+    writer.writeUInt32LE(0);
+  }
+
+  for (const coordinate of exteriorRing) {
+    writeCoordinate(writer, coordinate, options);
+  }
+
+  for (const interiorRing of interiorRings) {
+    writer.writeUInt32LE(interiorRing.length);
+
+    for (const coordinate of interiorRing) {
+      writeCoordinate(writer, coordinate, options);
     }
-    for (const coordinate of exteriorRing) {
-        writeCoordinate(writer, coordinate, options);
-    }
-    for (const interiorRing of interiorRings) {
-        writer.writeUInt32LE(interiorRing.length);
-        for (const coordinate of interiorRing) {
-            writeCoordinate(writer, coordinate, options);
-        }
-    }
-    return writer.arrayBuffer;
+  }
+
+  return writer.arrayBuffer;
 }
-/** Get encoded size of Polygon geometry */
+
 function getPolygonSize(coordinates, options) {
-    const coordinateSize = getCoordinateSize(options);
-    const [exteriorRing, ...interiorRings] = coordinates;
-    let size = 1 + 4 + 4;
-    if (exteriorRing.length > 0) {
-        size += 4 + exteriorRing.length * coordinateSize;
-    }
-    for (const interiorRing of interiorRings) {
-        size += 4 + interiorRing.length * coordinateSize;
-    }
-    return size;
+  const coordinateSize = getCoordinateSize(options);
+  const [exteriorRing, ...interiorRings] = coordinates;
+  let size = 1 + 4 + 4;
+
+  if (exteriorRing.length > 0) {
+    size += 4 + exteriorRing.length * coordinateSize;
+  }
+
+  for (const interiorRing of interiorRings) {
+    size += 4 + interiorRing.length * coordinateSize;
+  }
+
+  return size;
 }
-/** Encode MultiPoint geometry as WKB ArrayBufer */
+
 function encodeMultiPoint(multiPoint, options) {
-    const writer = new binary_writer_1.default(getMultiPointSize(multiPoint, options));
-    const points = multiPoint.coordinates;
-    writer.writeInt8(1);
-    writeWkbType(writer, WKB.MultiPoint, options);
-    writer.writeUInt32LE(points.length);
-    for (const point of points) {
-        // TODO: add srid to this options object? {srid: multiPoint.srid}
-        const arrayBuffer = encodePoint(point, options);
-        writer.writeBuffer(arrayBuffer);
-    }
-    return writer.arrayBuffer;
+  const writer = new BinaryWriter(getMultiPointSize(multiPoint, options));
+  const points = multiPoint.coordinates;
+  writer.writeInt8(1);
+  writeWkbType(writer, WKB.MultiPoint, options);
+  writer.writeUInt32LE(points.length);
+
+  for (const point of points) {
+    const arrayBuffer = encodePoint(point, options);
+    writer.writeBuffer(arrayBuffer);
+  }
+
+  return writer.arrayBuffer;
 }
-/** Get encoded size of MultiPoint geometry */
+
 function getMultiPointSize(multiPoint, options) {
-    let coordinateSize = getCoordinateSize(options);
-    const points = multiPoint.coordinates;
-    // This is because each point has a 5-byte header?
-    coordinateSize += 5;
-    return 1 + 4 + 4 + points.length * coordinateSize;
+  let coordinateSize = getCoordinateSize(options);
+  const points = multiPoint.coordinates;
+  coordinateSize += 5;
+  return 1 + 4 + 4 + points.length * coordinateSize;
 }
-/** Encode MultiLineString geometry as WKB ArrayBufer */
+
 function encodeMultiLineString(multiLineString, options) {
-    const writer = new binary_writer_1.default(getMultiLineStringSize(multiLineString, options));
-    const lineStrings = multiLineString.coordinates;
-    writer.writeInt8(1);
-    writeWkbType(writer, WKB.MultiLineString, options);
-    writer.writeUInt32LE(lineStrings.length);
-    for (const lineString of lineStrings) {
-        // TODO: Handle srid?
-        const encodedLineString = encodeLineString(lineString, options);
-        writer.writeBuffer(encodedLineString);
-    }
-    return writer.arrayBuffer;
+  const writer = new BinaryWriter(getMultiLineStringSize(multiLineString, options));
+  const lineStrings = multiLineString.coordinates;
+  writer.writeInt8(1);
+  writeWkbType(writer, WKB.MultiLineString, options);
+  writer.writeUInt32LE(lineStrings.length);
+
+  for (const lineString of lineStrings) {
+    const encodedLineString = encodeLineString(lineString, options);
+    writer.writeBuffer(encodedLineString);
+  }
+
+  return writer.arrayBuffer;
 }
-/** Get encoded size of MultiLineString geometry */
+
 function getMultiLineStringSize(multiLineString, options) {
-    let size = 1 + 4 + 4;
-    const lineStrings = multiLineString.coordinates;
-    for (const lineString of lineStrings) {
-        size += getLineStringSize(lineString, options);
-    }
-    return size;
+  let size = 1 + 4 + 4;
+  const lineStrings = multiLineString.coordinates;
+
+  for (const lineString of lineStrings) {
+    size += getLineStringSize(lineString, options);
+  }
+
+  return size;
 }
+
 function encodeMultiPolygon(multiPolygon, options) {
-    const writer = new binary_writer_1.default(getMultiPolygonSize(multiPolygon, options));
-    const polygons = multiPolygon.coordinates;
-    writer.writeInt8(1);
-    writeWkbType(writer, WKB.MultiPolygon, options);
-    writer.writeUInt32LE(polygons.length);
-    for (const polygon of polygons) {
-        const encodedPolygon = encodePolygon(polygon, options);
-        writer.writeBuffer(encodedPolygon);
-    }
-    return writer.arrayBuffer;
+  const writer = new BinaryWriter(getMultiPolygonSize(multiPolygon, options));
+  const polygons = multiPolygon.coordinates;
+  writer.writeInt8(1);
+  writeWkbType(writer, WKB.MultiPolygon, options);
+  writer.writeUInt32LE(polygons.length);
+
+  for (const polygon of polygons) {
+    const encodedPolygon = encodePolygon(polygon, options);
+    writer.writeBuffer(encodedPolygon);
+  }
+
+  return writer.arrayBuffer;
 }
+
 function getMultiPolygonSize(multiPolygon, options) {
-    let size = 1 + 4 + 4;
-    const polygons = multiPolygon.coordinates;
-    for (const polygon of polygons) {
-        size += getPolygonSize(polygon, options);
-    }
-    return size;
+  let size = 1 + 4 + 4;
+  const polygons = multiPolygon.coordinates;
+
+  for (const polygon of polygons) {
+    size += getPolygonSize(polygon, options);
+  }
+
+  return size;
 }
+
 function encodeGeometryCollection(collection, options) {
-    const writer = new binary_writer_1.default(getGeometryCollectionSize(collection, options));
-    writer.writeInt8(1);
-    writeWkbType(writer, WKB.GeometryCollection, options);
-    writer.writeUInt32LE(collection.geometries.length);
-    for (const geometry of collection.geometries) {
-        // TODO: handle srid? {srid: collection.srid}
-        const arrayBuffer = encodeWKB(geometry, options);
-        writer.writeBuffer(arrayBuffer);
-    }
-    return writer.arrayBuffer;
+  const writer = new BinaryWriter(getGeometryCollectionSize(collection, options));
+  writer.writeInt8(1);
+  writeWkbType(writer, WKB.GeometryCollection, options);
+  writer.writeUInt32LE(collection.geometries.length);
+
+  for (const geometry of collection.geometries) {
+    const arrayBuffer = encodeWKB(geometry, options);
+    writer.writeBuffer(arrayBuffer);
+  }
+
+  return writer.arrayBuffer;
 }
+
 function getGeometryCollectionSize(collection, options) {
-    let size = 1 + 4 + 4;
-    for (const geometry of collection.geometries) {
-        size += getGeometrySize(geometry, options);
-    }
-    return size;
+  let size = 1 + 4 + 4;
+
+  for (const geometry of collection.geometries) {
+    size += getGeometrySize(geometry, options);
+  }
+
+  return size;
 }
-// HELPERS
-/**
- * Construct and write WKB integer code
- * Reference: https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry#Well-known_binary
- */
+
 function writeWkbType(writer, geometryType, options) {
-    const { hasZ, hasM, srid } = options;
-    let dimensionType = 0;
-    if (!srid) {
-        if (hasZ && hasM) {
-            dimensionType += 3000;
-        }
-        else if (hasZ) {
-            dimensionType += 1000;
-        }
-        else if (hasM) {
-            dimensionType += 2000;
-        }
+  const {
+    hasZ,
+    hasM,
+    srid
+  } = options;
+  let dimensionType = 0;
+
+  if (!srid) {
+    if (hasZ && hasM) {
+      dimensionType += 3000;
+    } else if (hasZ) {
+      dimensionType += 1000;
+    } else if (hasM) {
+      dimensionType += 2000;
+    }
+  } else {
+    if (hasZ) {
+      dimensionType |= 0x80000000;
     }
-    else {
-        if (hasZ) {
-            dimensionType |= 0x80000000;
-        }
-        if (hasM) {
-            dimensionType |= 0x40000000;
-        }
+
+    if (hasM) {
+      dimensionType |= 0x40000000;
     }
-    writer.writeUInt32LE((dimensionType + geometryType) >>> 0);
+  }
+
+  writer.writeUInt32LE(dimensionType + geometryType >>> 0);
 }
-/** Get coordinate size given Z/M dimensions */
+
 function getCoordinateSize(options) {
-    let coordinateSize = 16;
-    if (options.hasZ) {
-        coordinateSize += 8;
-    }
-    if (options.hasM) {
-        coordinateSize += 8;
-    }
-    return coordinateSize;
+  let coordinateSize = 16;
+
+  if (options.hasZ) {
+    coordinateSize += 8;
+  }
+
+  if (options.hasM) {
+    coordinateSize += 8;
+  }
+
+  return coordinateSize;
 }
+//# sourceMappingURL=encode-wkb.js.map