@loaders.gl/wkt 3.1.1 → 3.1.5

package/dist/esm/lib/encode-wkt.js

@@ -1,54 +1,52 @@
-export default function encodeWKT(gj) {
-  if (gj.type === 'Feature') {
-    gj = gj.geometry;
+export default function encodeWKT(geometry) {
+  if (geometry.type === 'Feature') {
+    geometry = geometry.geometry;
   }
 
-  function pairWKT(c) {
-    return c.join(' ');
-  }
-
-  function ringWKT(r) {
-    return r.map(pairWKT).join(', ');
-  }
-
-  function ringsWKT(r) {
-    return r.map(ringWKT).map(wrapParens).join(', ');
-  }
-
-  function multiRingsWKT(r) {
-    return r.map(ringsWKT).map(wrapParens).join(', ');
-  }
-
-  function wrapParens(s) {
-    return "(".concat(s, ")");
-  }
-
-  switch (gj.type) {
+  switch (geometry.type) {
     case 'Point':
-      return "POINT ".concat(wrapParens(pairWKT(gj.coordinates)));
+      return "POINT ".concat(wrapParens(pairWKT(geometry.coordinates)));
 
     case 'LineString':
-      return "LINESTRING ".concat(wrapParens(ringWKT(gj.coordinates)));
+      return "LINESTRING ".concat(wrapParens(ringWKT(geometry.coordinates)));
 
     case 'Polygon':
-      return "POLYGON ".concat(wrapParens(ringsWKT(gj.coordinates)));
+      return "POLYGON ".concat(wrapParens(ringsWKT(geometry.coordinates)));
 
     case 'MultiPoint':
-      return "MULTIPOINT ".concat(wrapParens(ringWKT(gj.coordinates)));
+      return "MULTIPOINT ".concat(wrapParens(ringWKT(geometry.coordinates)));
 
     case 'MultiPolygon':
-      return "MULTIPOLYGON ".concat(wrapParens(multiRingsWKT(gj.coordinates)));
+      return "MULTIPOLYGON ".concat(wrapParens(multiRingsWKT(geometry.coordinates)));
 
     case 'MultiLineString':
-      return "MULTILINESTRING ".concat(wrapParens(ringsWKT(gj.coordinates)));
+      return "MULTILINESTRING ".concat(wrapParens(ringsWKT(geometry.coordinates)));
 
     case 'GeometryCollection':
-      return "GEOMETRYCOLLECTION ".concat(wrapParens(gj.geometries.map(encodeWKT).join(', ')));
+      return "GEOMETRYCOLLECTION ".concat(wrapParens(geometry.geometries.map(encodeWKT).join(', ')));
 
     default:
-      return (_x => {
-        throw new Error('stringify requires a valid GeoJSON Feature or geometry object as input');
-      })(gj);
+      throw new Error('stringify requires a valid GeoJSON Feature or geometry object as input');
   }
 }
+
+function pairWKT(c) {
+  return c.join(' ');
+}
+
+function ringWKT(r) {
+  return r.map(pairWKT).join(', ');
+}
+
+function ringsWKT(r) {
+  return r.map(ringWKT).map(wrapParens).join(', ');
+}
+
+function multiRingsWKT(r) {
+  return r.map(ringsWKT).map(wrapParens).join(', ');
+}
+
+function wrapParens(s) {
+  return "(".concat(s, ")");
+}
 //# sourceMappingURL=encode-wkt.js.map

package/dist/esm/lib/encode-wkt.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../../src/lib/encode-wkt.ts"],"names":["encodeWKT","gj","type","geometry","pairWKT","c","join","ringWKT","r","map","ringsWKT","wrapParens","multiRingsWKT","s","coordinates","geometries","_x","Error"],"mappings":"AASA,eAAe,SAASA,SAAT,CAAmBC,EAAnB,EAAmD;AAChE,MAAIA,EAAE,CAACC,IAAH,KAAY,SAAhB,EAA2B;AACzBD,IAAAA,EAAE,GAAGA,EAAE,CAACE,QAAR;AACD;;AAED,WAASC,OAAT,CAAiBC,CAAjB,EAA8B;AAC5B,WAAOA,CAAC,CAACC,IAAF,CAAO,GAAP,CAAP;AACD;;AAED,WAASC,OAAT,CAAiBC,CAAjB,EAAgC;AAC9B,WAAOA,CAAC,CAACC,GAAF,CAAML,OAAN,EAAeE,IAAf,CAAoB,IAApB,CAAP;AACD;;AAED,WAASI,QAAT,CAAkBF,CAAlB,EAAmC;AACjC,WAAOA,CAAC,CAACC,GAAF,CAAMF,OAAN,EAAeE,GAAf,CAAmBE,UAAnB,EAA+BL,IAA/B,CAAoC,IAApC,CAAP;AACD;;AAED,WAASM,aAAT,CAAuBJ,CAAvB,EAA0C;AACxC,WAAOA,CAAC,CAACC,GAAF,CAAMC,QAAN,EAAgBD,GAAhB,CAAoBE,UAApB,EAAgCL,IAAhC,CAAqC,IAArC,CAAP;AACD;;AAED,WAASK,UAAT,CAAoBE,CAApB,EAA+B;AAC7B,sBAAWA,CAAX;AACD;;AAED,UAAQZ,EAAE,CAACC,IAAX;AACE,SAAK,OAAL;AACE,6BAAgBS,UAAU,CAACP,OAAO,CAACH,EAAE,CAACa,WAAJ,CAAR,CAA1B;;AACF,SAAK,YAAL;AACE,kCAAqBH,UAAU,CAACJ,OAAO,CAACN,EAAE,CAACa,WAAJ,CAAR,CAA/B;;AACF,SAAK,SAAL;AACE,+BAAkBH,UAAU,CAACD,QAAQ,CAACT,EAAE,CAACa,WAAJ,CAAT,CAA5B;;AACF,SAAK,YAAL;AACE,kCAAqBH,UAAU,CAACJ,OAAO,CAACN,EAAE,CAACa,WAAJ,CAAR,CAA/B;;AACF,SAAK,cAAL;AACE,oCAAuBH,UAAU,CAACC,aAAa,CAACX,EAAE,CAACa,WAAJ,CAAd,CAAjC;;AACF,SAAK,iBAAL;AACE,uCAA0BH,UAAU,CAACD,QAAQ,CAACT,EAAE,CAACa,WAAJ,CAAT,CAApC;;AACF,SAAK,oBAAL;AACE,0CAA6BH,UAAU,CAACV,EAAE,CAACc,UAAH,CAAcN,GAAd,CAAkBT,SAAlB,EAA6BM,IAA7B,CAAkC,IAAlC,CAAD,CAAvC;;AACF;AACE,aAAO,CAAEU,EAAD,IAAsB;AAC5B,cAAM,IAAIC,KAAJ,CAAU,wEAAV,CAAN;AACD,OAFM,EAEJhB,EAFI,CAAP;AAhBJ;AAoBD","sourcesContent":["// Fork of https://github.com/mapbox/wellknown under ISC license (MIT/BSD-2-clause equivalent)\n// eslint-disable-next-line import/no-unresolved\nimport type {Feature, Geometry} from 'geojson';\n/**\n * Stringifies a GeoJSON object into WKT\n * @param geojson\n * @returns string\n */\n\nexport default function encodeWKT(gj: Geometry | Feature): string {\n  if (gj.type === 'Feature') {\n    gj = gj.geometry;\n  }\n\n  function pairWKT(c: number[]) {\n    return c.join(' ');\n  }\n\n  function ringWKT(r: number[][]) {\n    return r.map(pairWKT).join(', ');\n  }\n\n  function ringsWKT(r: number[][][]) {\n    return r.map(ringWKT).map(wrapParens).join(', ');\n  }\n\n  function multiRingsWKT(r: number[][][][]) {\n    return r.map(ringsWKT).map(wrapParens).join(', ');\n  }\n\n  function wrapParens(s: string) {\n    return `(${s})`;\n  }\n\n  switch (gj.type) {\n    case 'Point':\n      return `POINT ${wrapParens(pairWKT(gj.coordinates))}`;\n    case 'LineString':\n      return `LINESTRING ${wrapParens(ringWKT(gj.coordinates))}`;\n    case 'Polygon':\n      return `POLYGON ${wrapParens(ringsWKT(gj.coordinates))}`;\n    case 'MultiPoint':\n      return `MULTIPOINT ${wrapParens(ringWKT(gj.coordinates))}`;\n    case 'MultiPolygon':\n      return `MULTIPOLYGON ${wrapParens(multiRingsWKT(gj.coordinates))}`;\n    case 'MultiLineString':\n      return `MULTILINESTRING ${wrapParens(ringsWKT(gj.coordinates))}`;\n    case 'GeometryCollection':\n      return `GEOMETRYCOLLECTION ${wrapParens(gj.geometries.map(encodeWKT).join(', '))}`;\n    default:\n      return ((_x: never): never => {\n        throw new Error('stringify requires a valid GeoJSON Feature or geometry object as input');\n      })(gj);\n  }\n}\n"],"file":"encode-wkt.js"}
+{"version":3,"sources":["../../../src/lib/encode-wkt.ts"],"names":["encodeWKT","geometry","type","wrapParens","pairWKT","coordinates","ringWKT","ringsWKT","multiRingsWKT","geometries","map","join","Error","c","r","s"],"mappings":"AASA,eAAe,SAASA,SAAT,CAAmBC,QAAnB,EAAyD;AACtE,MAAIA,QAAQ,CAACC,IAAT,KAAkB,SAAtB,EAAiC;AAC/BD,IAAAA,QAAQ,GAAGA,QAAQ,CAACA,QAApB;AACD;;AAED,UAAQA,QAAQ,CAACC,IAAjB;AACE,SAAK,OAAL;AACE,6BAAgBC,UAAU,CAACC,OAAO,CAACH,QAAQ,CAACI,WAAV,CAAR,CAA1B;;AACF,SAAK,YAAL;AACE,kCAAqBF,UAAU,CAACG,OAAO,CAACL,QAAQ,CAACI,WAAV,CAAR,CAA/B;;AACF,SAAK,SAAL;AACE,+BAAkBF,UAAU,CAACI,QAAQ,CAACN,QAAQ,CAACI,WAAV,CAAT,CAA5B;;AACF,SAAK,YAAL;AACE,kCAAqBF,UAAU,CAACG,OAAO,CAACL,QAAQ,CAACI,WAAV,CAAR,CAA/B;;AACF,SAAK,cAAL;AACE,oCAAuBF,UAAU,CAACK,aAAa,CAACP,QAAQ,CAACI,WAAV,CAAd,CAAjC;;AACF,SAAK,iBAAL;AACE,uCAA0BF,UAAU,CAACI,QAAQ,CAACN,QAAQ,CAACI,WAAV,CAAT,CAApC;;AACF,SAAK,oBAAL;AACE,0CAA6BF,UAAU,CAACF,QAAQ,CAACQ,UAAT,CAAoBC,GAApB,CAAwBV,SAAxB,EAAmCW,IAAnC,CAAwC,IAAxC,CAAD,CAAvC;;AACF;AACE,YAAM,IAAIC,KAAJ,CAAU,wEAAV,CAAN;AAhBJ;AAkBD;;AAED,SAASR,OAAT,CAAiBS,CAAjB,EAAsC;AACpC,SAAOA,CAAC,CAACF,IAAF,CAAO,GAAP,CAAP;AACD;;AAED,SAASL,OAAT,CAAiBQ,CAAjB,EAAwC;AACtC,SAAOA,CAAC,CAACJ,GAAF,CAAMN,OAAN,EAAeO,IAAf,CAAoB,IAApB,CAAP;AACD;;AAED,SAASJ,QAAT,CAAkBO,CAAlB,EAA2C;AACzC,SAAOA,CAAC,CAACJ,GAAF,CAAMJ,OAAN,EAAeI,GAAf,CAAmBP,UAAnB,EAA+BQ,IAA/B,CAAoC,IAApC,CAAP;AACD;;AAED,SAASH,aAAT,CAAuBM,CAAvB,EAAkD;AAChD,SAAOA,CAAC,CAACJ,GAAF,CAAMH,QAAN,EAAgBG,GAAhB,CAAoBP,UAApB,EAAgCQ,IAAhC,CAAqC,IAArC,CAAP;AACD;;AAED,SAASR,UAAT,CAAoBY,CAApB,EAAuC;AACrC,oBAAWA,CAAX;AACD","sourcesContent":["// Fork of https://github.com/mapbox/wellknown under ISC license (MIT/BSD-2-clause equivalent)\n// eslint-disable-next-line import/no-unresolved\nimport type {Feature, Geometry} from '@loaders.gl/schema';\n\n/**\n * Stringifies a GeoJSON object into WKT\n * @param geojson\n * @returns string\n */\nexport default function encodeWKT(geometry: Geometry | Feature): string {\n  if (geometry.type === 'Feature') {\n    geometry = geometry.geometry;\n  }\n\n  switch (geometry.type) {\n    case 'Point':\n      return `POINT ${wrapParens(pairWKT(geometry.coordinates))}`;\n    case 'LineString':\n      return `LINESTRING ${wrapParens(ringWKT(geometry.coordinates))}`;\n    case 'Polygon':\n      return `POLYGON ${wrapParens(ringsWKT(geometry.coordinates))}`;\n    case 'MultiPoint':\n      return `MULTIPOINT ${wrapParens(ringWKT(geometry.coordinates))}`;\n    case 'MultiPolygon':\n      return `MULTIPOLYGON ${wrapParens(multiRingsWKT(geometry.coordinates))}`;\n    case 'MultiLineString':\n      return `MULTILINESTRING ${wrapParens(ringsWKT(geometry.coordinates))}`;\n    case 'GeometryCollection':\n      return `GEOMETRYCOLLECTION ${wrapParens(geometry.geometries.map(encodeWKT).join(', '))}`;\n    default:\n      throw new Error('stringify requires a valid GeoJSON Feature or geometry object as input');\n  }\n}\n\nfunction pairWKT(c: number[]): string {\n  return c.join(' ');\n}\n\nfunction ringWKT(r: number[][]): string {\n  return r.map(pairWKT).join(', ');\n}\n\nfunction ringsWKT(r: number[][][]): string {\n  return r.map(ringWKT).map(wrapParens).join(', ');\n}\n\nfunction multiRingsWKT(r: number[][][][]): string {\n  return r.map(ringsWKT).map(wrapParens).join(', ');\n}\n\nfunction wrapParens(s: string): string {\n  return `(${s})`;\n}\n"],"file":"encode-wkt.js"}

package/dist/esm/lib/utils/binary-writer.js

@@ -0,0 +1,153 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+const LE = true;
+const BE = false;
+export default class BinaryWriter {
+  constructor(size, allowResize) {
+    _defineProperty(this, "arrayBuffer", void 0);
+
+    _defineProperty(this, "dataView", void 0);
+
+    _defineProperty(this, "byteOffset", 0);
+
+    _defineProperty(this, "allowResize", false);
+
+    this.arrayBuffer = new ArrayBuffer(size);
+    this.dataView = new DataView(this.arrayBuffer);
+    this.byteOffset = 0;
+    this.allowResize = allowResize || false;
+  }
+
+  writeUInt8(value) {
+    this._ensureSize(1);
+
+    this.dataView.setUint8(this.byteOffset, value);
+    this.byteOffset += 1;
+  }
+
+  writeUInt16LE(value) {
+    this._ensureSize(2);
+
+    this.dataView.setUint16(this.byteOffset, value, LE);
+    this.byteOffset += 2;
+  }
+
+  writeUInt16BE(value) {
+    this._ensureSize(2);
+
+    this.dataView.setUint16(this.byteOffset, value, BE);
+    this.byteOffset += 2;
+  }
+
+  writeUInt32LE(value) {
+    this._ensureSize(4);
+
+    this.dataView.setUint32(this.byteOffset, value, LE);
+    this.byteOffset += 4;
+  }
+
+  writeUInt32BE(value) {
+    this._ensureSize(4);
+
+    this.dataView.setUint32(this.byteOffset, value, BE);
+    this.byteOffset += 4;
+  }
+
+  writeInt8(value) {
+    this._ensureSize(1);
+
+    this.dataView.setInt8(this.byteOffset, value);
+    this.byteOffset += 1;
+  }
+
+  writeInt16LE(value) {
+    this._ensureSize(2);
+
+    this.dataView.setInt16(this.byteOffset, value, LE);
+    this.byteOffset += 2;
+  }
+
+  writeInt16BE(value) {
+    this._ensureSize(2);
+
+    this.dataView.setInt16(this.byteOffset, value, BE);
+    this.byteOffset += 2;
+  }
+
+  writeInt32LE(value) {
+    this._ensureSize(4);
+
+    this.dataView.setInt32(this.byteOffset, value, LE);
+    this.byteOffset += 4;
+  }
+
+  writeInt32BE(value) {
+    this._ensureSize(4);
+
+    this.dataView.setInt32(this.byteOffset, value, BE);
+    this.byteOffset += 4;
+  }
+
+  writeFloatLE(value) {
+    this._ensureSize(4);
+
+    this.dataView.setFloat32(this.byteOffset, value, LE);
+    this.byteOffset += 4;
+  }
+
+  writeFloatBE(value) {
+    this._ensureSize(4);
+
+    this.dataView.setFloat32(this.byteOffset, value, BE);
+    this.byteOffset += 4;
+  }
+
+  writeDoubleLE(value) {
+    this._ensureSize(8);
+
+    this.dataView.setFloat64(this.byteOffset, value, LE);
+    this.byteOffset += 8;
+  }
+
+  writeDoubleBE(value) {
+    this._ensureSize(8);
+
+    this.dataView.setFloat64(this.byteOffset, value, BE);
+    this.byteOffset += 8;
+  }
+
+  writeVarInt(value) {
+    let length = 1;
+
+    while ((value & 0xffffff80) !== 0) {
+      this.writeUInt8(value & 0x7f | 0x80);
+      value >>>= 7;
+      length++;
+    }
+
+    this.writeUInt8(value & 0x7f);
+    return length;
+  }
+
+  writeBuffer(arrayBuffer) {
+    this._ensureSize(arrayBuffer.byteLength);
+
+    const tempArray = new Uint8Array(this.arrayBuffer);
+    tempArray.set(new Uint8Array(arrayBuffer), this.byteOffset);
+    this.byteOffset += arrayBuffer.byteLength;
+  }
+
+  _ensureSize(size) {
+    if (this.arrayBuffer.byteLength < this.byteOffset + size) {
+      if (this.allowResize) {
+        const newArrayBuffer = new ArrayBuffer(this.byteOffset + size);
+        const tempArray = new Uint8Array(newArrayBuffer);
+        tempArray.set(new Uint8Array(this.arrayBuffer));
+        this.arrayBuffer = newArrayBuffer;
+      } else {
+        throw new Error('BinaryWriter overflow');
+      }
+    }
+  }
+
+}
+//# sourceMappingURL=binary-writer.js.map

package/dist/esm/lib/utils/binary-writer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/utils/binary-writer.ts"],"names":["LE","BE","BinaryWriter","constructor","size","allowResize","arrayBuffer","ArrayBuffer","dataView","DataView","byteOffset","writeUInt8","value","_ensureSize","setUint8","writeUInt16LE","setUint16","writeUInt16BE","writeUInt32LE","setUint32","writeUInt32BE","writeInt8","setInt8","writeInt16LE","setInt16","writeInt16BE","writeInt32LE","setInt32","writeInt32BE","writeFloatLE","setFloat32","writeFloatBE","writeDoubleLE","setFloat64","writeDoubleBE","writeVarInt","length","writeBuffer","byteLength","tempArray","Uint8Array","set","newArrayBuffer","Error"],"mappings":"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","sourcesContent":["// loaders.gl, MIT license\n// Forked from https://github.com/cschwarz/wkx under MIT license, Copyright (c) 2013 Christian Schwarz\n\nconst LE = true;\nconst BE = false;\n\nexport default class BinaryWriter {\n  arrayBuffer: ArrayBuffer;\n  dataView: DataView;\n  byteOffset: number = 0;\n  allowResize: boolean = false;\n\n  constructor(size: number, allowResize?: boolean) {\n    this.arrayBuffer = new ArrayBuffer(size);\n    this.dataView = new DataView(this.arrayBuffer);\n    this.byteOffset = 0;\n    this.allowResize = allowResize || false;\n  }\n\n  writeUInt8(value: number): void {\n    this._ensureSize(1);\n    this.dataView.setUint8(this.byteOffset, value);\n    this.byteOffset += 1;\n  }\n  writeUInt16LE(value: number): void {\n    this._ensureSize(2);\n    this.dataView.setUint16(this.byteOffset, value, LE);\n    this.byteOffset += 2;\n  }\n  writeUInt16BE(value: number): void {\n    this._ensureSize(2);\n    this.dataView.setUint16(this.byteOffset, value, BE);\n    this.byteOffset += 2;\n  }\n  writeUInt32LE(value: number): void {\n    this._ensureSize(4);\n    this.dataView.setUint32(this.byteOffset, value, LE);\n    this.byteOffset += 4;\n  }\n  writeUInt32BE(value: number): void {\n    this._ensureSize(4);\n    this.dataView.setUint32(this.byteOffset, value, BE);\n    this.byteOffset += 4;\n  }\n  writeInt8(value: number): void {\n    this._ensureSize(1);\n    this.dataView.setInt8(this.byteOffset, value);\n    this.byteOffset += 1;\n  }\n  writeInt16LE(value: number): void {\n    this._ensureSize(2);\n    this.dataView.setInt16(this.byteOffset, value, LE);\n    this.byteOffset += 2;\n  }\n  writeInt16BE(value: number): void {\n    this._ensureSize(2);\n    this.dataView.setInt16(this.byteOffset, value, BE);\n    this.byteOffset += 2;\n  }\n  writeInt32LE(value: number): void {\n    this._ensureSize(4);\n    this.dataView.setInt32(this.byteOffset, value, LE);\n    this.byteOffset += 4;\n  }\n  writeInt32BE(value: number): void {\n    this._ensureSize(4);\n    this.dataView.setInt32(this.byteOffset, value, BE);\n    this.byteOffset += 4;\n  }\n  writeFloatLE(value: number): void {\n    this._ensureSize(4);\n    this.dataView.setFloat32(this.byteOffset, value, LE);\n    this.byteOffset += 4;\n  }\n  writeFloatBE(value: number): void {\n    this._ensureSize(4);\n    this.dataView.setFloat32(this.byteOffset, value, BE);\n    this.byteOffset += 4;\n  }\n  writeDoubleLE(value: number): void {\n    this._ensureSize(8);\n    this.dataView.setFloat64(this.byteOffset, value, LE);\n    this.byteOffset += 8;\n  }\n  writeDoubleBE(value: number): void {\n    this._ensureSize(8);\n    this.dataView.setFloat64(this.byteOffset, value, BE);\n    this.byteOffset += 8;\n  }\n\n  /** A varint uses a variable number of bytes */\n  writeVarInt(value: number): number {\n    // TODO - ensure size?\n    let length = 1;\n    while ((value & 0xffffff80) !== 0) {\n      this.writeUInt8((value & 0x7f) | 0x80);\n      value >>>= 7;\n      length++;\n    }\n    this.writeUInt8(value & 0x7f);\n    return length;\n  }\n\n  /** Append another ArrayBuffer to this ArrayBuffer */\n  writeBuffer(arrayBuffer: ArrayBuffer): void {\n    this._ensureSize(arrayBuffer.byteLength);\n    const tempArray = new Uint8Array(this.arrayBuffer);\n    tempArray.set(new Uint8Array(arrayBuffer), this.byteOffset);\n    this.byteOffset += arrayBuffer.byteLength;\n  }\n\n  /** Resizes this.arrayBuffer if not enough space */\n  _ensureSize(size: number) {\n    if (this.arrayBuffer.byteLength < this.byteOffset + size) {\n      if (this.allowResize) {\n        const newArrayBuffer = new ArrayBuffer(this.byteOffset + size);\n        const tempArray = new Uint8Array(newArrayBuffer);\n        tempArray.set(new Uint8Array(this.arrayBuffer));\n        this.arrayBuffer = newArrayBuffer;\n      } else {\n        throw new Error('BinaryWriter overflow');\n      }\n    }\n  }\n}\n"],"file":"binary-writer.js"}

package/dist/esm/lib/utils/version.js

@@ -1,2 +1,2 @@
-export const VERSION = typeof "3.1.1" !== 'undefined' ? "3.1.1" : 'latest';
+export const VERSION = typeof "3.1.5" !== 'undefined' ? "3.1.5" : 'latest';
 //# sourceMappingURL=version.js.map

package/dist/esm/wkb-writer.js

@@ -0,0 +1,14 @@
+import { VERSION } from './lib/utils/version';
+import encodeWKB from './lib/encode-wkb';
+export const WKBWriter = {
+  name: 'WKB (Well Known Binary)',
+  id: 'wkb',
+  module: 'wkt',
+  version: VERSION,
+  extensions: ['wkb'],
+  encode: encodeWKB,
+  options: {
+    wkt: {}
+  }
+};
+//# sourceMappingURL=wkb-writer.js.map

package/dist/esm/wkb-writer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/wkb-writer.ts"],"names":["VERSION","encodeWKB","WKBWriter","name","id","module","version","extensions","encode","options","wkt"],"mappings":"AACA,SAAQA,OAAR,QAAsB,qBAAtB;AACA,OAAOC,SAAP,MAAsB,kBAAtB;AAKA,OAAO,MAAMC,SAAiB,GAAG;AAC/BC,EAAAA,IAAI,EAAE,yBADyB;AAE/BC,EAAAA,EAAE,EAAE,KAF2B;AAG/BC,EAAAA,MAAM,EAAE,KAHuB;AAI/BC,EAAAA,OAAO,EAAEN,OAJsB;AAK/BO,EAAAA,UAAU,EAAE,CAAC,KAAD,CALmB;AAO/BC,EAAAA,MAAM,EAAEP,SAPuB;AAQ/BQ,EAAAA,OAAO,EAAE;AACPC,IAAAA,GAAG,EAAE;AADE;AARsB,CAA1B","sourcesContent":["import type {Writer} from '@loaders.gl/loader-utils';\nimport {VERSION} from './lib/utils/version';\nimport encodeWKB from './lib/encode-wkb';\n\n/**\n * WKT exporter\n */\nexport const WKBWriter: Writer = {\n  name: 'WKB (Well Known Binary)',\n  id: 'wkb',\n  module: 'wkt',\n  version: VERSION,\n  extensions: ['wkb'],\n  // @ts-ignore\n  encode: encodeWKB,\n  options: {\n    wkt: {}\n  }\n};\n"],"file":"wkb-writer.js"}

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 export { WKBLoader, WKBWorkerLoader } from './wkb-loader';
 export { WKTLoader, WKTWorkerLoader } from './wkt-loader';
 export { WKTWriter } from './wkt-writer';
+export { WKBWriter } from './wkb-writer';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAE,eAAe,EAAC,MAAM,cAAc,CAAC;AACxD,OAAO,EAAC,SAAS,EAAE,eAAe,EAAC,MAAM,cAAc,CAAC;AACxD,OAAO,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,SAAS,EAAE,eAAe,EAAC,MAAM,cAAc,CAAC;AACxD,OAAO,EAAC,SAAS,EAAE,eAAe,EAAC,MAAM,cAAc,CAAC;AACxD,OAAO,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC;AACvC,OAAO,EAAC,SAAS,EAAC,MAAM,cAAc,CAAC"}

package/dist/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.WKTWriter = exports.WKTWorkerLoader = exports.WKTLoader = exports.WKBWorkerLoader = exports.WKBLoader = void 0;
+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; } });
@@ -9,3 +9,5 @@ Object.defineProperty(exports, "WKTLoader", { enumerable: true, get: function ()
 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; } });

package/dist/lib/encode-wkb.d.ts

@@ -0,0 +1,17 @@
+import type { Feature, Geometry } from '@loaders.gl/schema';
+/**
+ * Options for encodeWKB
+ */
+interface WKBOptions {
+    hasZ?: boolean;
+    hasM?: boolean;
+    srid?: any;
+}
+/**
+ * Encodes a GeoJSON object into WKB
+ * @param geojson A GeoJSON Feature or Geometry
+ * @returns string
+ */
+export default function encodeWKB(geometry: Geometry | Feature, options?: WKBOptions): ArrayBuffer;
+export {};
+//# sourceMappingURL=encode-wkb.d.ts.map

package/dist/lib/encode-wkb.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"encode-wkb.d.ts","sourceRoot":"","sources":["../../src/lib/encode-wkb.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,OAAO,EACP,QAAQ,EAQT,MAAM,oBAAoB,CAAC;AAkB5B;;GAEG;AACH,UAAU,UAAU;IAClB,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ;AAED;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,QAAQ,EAAE,QAAQ,GAAG,OAAO,EAC5B,OAAO,GAAE,UAAuC,GAC/C,WAAW,CAwBb"}

package/dist/lib/encode-wkb.js

@@ -0,0 +1,290 @@
+"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
+ */
+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 = {}));
+/**
+ * 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}`);
+    }
+}
+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}`);
+    }
+}
+/** 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]);
+    if (options.hasZ) {
+        writer.writeDoubleLE(coordinate[2]);
+    }
+    if (options.hasM) {
+        writer.writeDoubleLE(coordinate[3]);
+    }
+}
+/** Get encoded size of Point geometry */
+function getPointSize(options) {
+    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;
+}
+/** Get encoded size of LineString geometry */
+function getLineStringSize(coordinates, options) {
+    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);
+    }
+    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;
+}
+/** 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;
+}
+/** 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;
+}
+/** 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;
+}
+/** 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;
+}
+/** 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;
+}
+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;
+}
+function getMultiPolygonSize(multiPolygon, options) {
+    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;
+}
+function getGeometryCollectionSize(collection, options) {
+    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;
+        }
+    }
+    else {
+        if (hasZ) {
+            dimensionType |= 0x80000000;
+        }
+        if (hasM) {
+            dimensionType |= 0x40000000;
+        }
+    }
+    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;
+}

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

@@ -1,8 +1,8 @@
-import type { Feature, Geometry } from 'geojson';
+import type { Feature, Geometry } from '@loaders.gl/schema';
 /**
  * Stringifies a GeoJSON object into WKT
  * @param geojson
  * @returns string
  */
-export default function encodeWKT(gj: Geometry | Feature): string;
+export default function encodeWKT(geometry: Geometry | Feature): string;
 //# sourceMappingURL=encode-wkt.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"encode-wkt.d.ts","sourceRoot":"","sources":["../../src/lib/encode-wkt.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,OAAO,EAAE,QAAQ,EAAC,MAAM,SAAS,CAAC;AAC/C;;;;GAIG;AAEH,MAAM,CAAC,OAAO,UAAU,SAAS,CAAC,EAAE,EAAE,QAAQ,GAAG,OAAO,GAAG,MAAM,CA6ChE"}
+{"version":3,"file":"encode-wkt.d.ts","sourceRoot":"","sources":["../../src/lib/encode-wkt.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,OAAO,EAAE,QAAQ,EAAC,MAAM,oBAAoB,CAAC;AAE1D;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,CAAC,QAAQ,EAAE,QAAQ,GAAG,OAAO,GAAG,MAAM,CAuBtE"}