@loaders.gl/wkt 4.0.0-alpha.9 → 4.0.0-beta.1

package/src/lib/utils/binary-reader.ts

@@ -0,0 +1,72 @@
+/** A DataView that tracks byte offset when reading. */
+export class BinaryReader {
+  arrayBuffer: ArrayBuffer;
+  dataView: DataView;
+  byteOffset: number;
+  littleEndian: boolean;
+
+  constructor(arrayBuffer: ArrayBuffer, isBigEndian: boolean = false) {
+    this.arrayBuffer = arrayBuffer;
+    this.dataView = new DataView(arrayBuffer);
+    this.byteOffset = 0;
+    this.littleEndian = !isBigEndian;
+  }
+
+  readUInt8() {
+    const value = this.dataView.getUint8(this.byteOffset);
+    this.byteOffset += 1;
+    return value;
+  }
+  readUInt16() {
+    const value = this.dataView.getUint16(this.byteOffset, this.littleEndian);
+    this.byteOffset += 2;
+    return value;
+  }
+  readUInt32() {
+    const value = this.dataView.getUint32(this.byteOffset, this.littleEndian);
+    this.byteOffset += 4;
+    return value;
+  }
+  readInt8() {
+    const value = this.dataView.getInt8(this.byteOffset);
+    this.byteOffset += 1;
+    return value;
+  }
+  readInt16() {
+    const value = this.dataView.getInt16(this.byteOffset, this.littleEndian);
+    this.byteOffset += 2;
+    return value;
+  }
+  readInt32() {
+    const value = this.dataView.getInt32(this.byteOffset, this.littleEndian);
+    this.byteOffset += 4;
+    return value;
+  }
+  readFloat() {
+    const value = this.dataView.getFloat32(this.byteOffset, this.littleEndian);
+    this.byteOffset += 4;
+    return value;
+  }
+  readDouble() {
+    const value = this.dataView.getFloat64(this.byteOffset, this.littleEndian);
+    this.byteOffset += 8;
+    return value;
+  }
+
+  readVarInt() {
+    let result = 0;
+    let bytesRead = 0;
+
+    let nextByte;
+    do {
+      // TODO - this needs to be accessed via data view?
+      nextByte = this.dataView.getUint8(this.byteOffset + bytesRead);
+      result += (nextByte & 0x7f) << (7 * bytesRead);
+      bytesRead++;
+    } while (nextByte >= 0x80);
+
+    this.byteOffset += bytesRead;
+
+    return result;
+  }
+}

package/src/lib/utils/binary-writer.ts

@@ -4,7 +4,7 @@
 const LE = true;
 const BE = false;
 
-export default class BinaryWriter {
+export class BinaryWriter {
   arrayBuffer: ArrayBuffer;
   dataView: DataView;
   byteOffset: number = 0;

package/src/lib/utils/hex-encoder.ts

@@ -0,0 +1,58 @@
+// loaders.gl, MIT license
+
+/**
+ * Simple helper to decode and encode "hex encoded" binary buffers
+ * without first converting to string.
+ */
+export class HexEncoder {
+  /** Get length in bytes required to store encoded data */
+  getEncodedLength(array: Uint8Array): number {
+    return array.byteLength * 2;
+  }
+
+  /** Get length in bytes required to store decoded data */
+  getDecodedLength(array: Uint8Array): number {
+    return Math.ceil(array.byteLength / 2);
+  }
+
+  /** Decode hexadecimal */
+  decode(array: Uint8Array, result: Uint8Array): Uint8Array {
+    for (let i = 0; i < array.byteLength / 2; ++i) {
+      const halfByte1 = hexDecode(array[i]);
+      const halfByte2 = hexDecode(array[i + 1]);
+      result[i] = halfByte1 * 16 + halfByte2;
+    }
+    // Check if final half byte (is that legal?)
+    // if (array.byteLength % 2) {
+    //   const halfByte1 = hexDecode(array[i]);
+    // }
+    return result;
+  }
+
+  /** Encode hexadecimal */
+  encode(array: Uint8Array, result: Uint8Array): Uint8Array {
+    for (let i = 0; i < array.byteLength; ++i) {
+      const byte = array[i];
+      result[i * 2] = hexEncode(byte & 0x0f);
+      result[i * 2 + 1] = hexEncode(byte & 0xf0);
+    }
+    return result;
+  }
+}
+
+function hexEncode(value: number): number {
+  if (value < 10) {
+    return value + 48; // ASCII of 0
+  }
+  return value - 10 + 65; // ASCII of capital A
+}
+
+function hexDecode(value: number): number {
+  if (value >= 65) {
+    return value - 65 + 10; // ASCII of A
+  }
+  if (value >= 97) {
+    return value - 97 + 10; // ASCII of a
+  }
+  return value - 48; // ASCII of 0
+}

package/src/lib/utils/hex-transcoder.ts

@@ -0,0 +1,50 @@
+// Forked from https://github.com/jessetane/hex-transcoder under MIT license
+
+const alphabet = '0123456789abcdef';
+const encodeLookup: string[] = [];
+const decodeLookup: number[] = [];
+
+for (let i = 0; i < 256; i++) {
+  encodeLookup[i] = alphabet[(i >> 4) & 0xf] + alphabet[i & 0xf];
+  if (i < 16) {
+    if (i < 10) {
+      decodeLookup[0x30 + i] = i;
+    } else {
+      decodeLookup[0x61 - 10 + i] = i;
+    }
+  }
+}
+
+/**
+ * Encode a Uint8Array to a hex string
+ *
+ * @param  array Bytes to encode to string
+ * @return hex string
+ */
+export function encodeHex(array: Uint8Array): string {
+  const length = array.length;
+  let string = '';
+  let i = 0;
+  while (i < length) {
+    string += encodeLookup[array[i++]];
+  }
+  return string;
+}
+
+/**
+ * Decodes a hex string to a Uint8Array
+ *
+ * @param string hex string to decode to Uint8Array
+ * @return Uint8Array
+ */
+export function decodeHex(string: string): Uint8Array {
+  const sizeof = string.length >> 1;
+  const length = sizeof << 1;
+  const array = new Uint8Array(sizeof);
+  let n = 0;
+  let i = 0;
+  while (i < length) {
+    array[n++] = (decodeLookup[string.charCodeAt(i++)] << 4) | decodeLookup[string.charCodeAt(i++)];
+  }
+  return array;
+}

package/src/twkb-loader.ts

@@ -0,0 +1,42 @@
+// loaders.gl, MIT license
+
+import type {Loader, LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
+import {BinaryGeometry, Geometry} from '@loaders.gl/schema';
+import {VERSION} from './lib/utils/version';
+import {parseTWKBGeometry, isTWKB} from './lib/parse-twkb';
+
+export type WKBLoaderOptions = LoaderOptions & {
+  wkb?: {
+    shape: 'binary-geometry' | 'geometry';
+  };
+};
+
+/**
+ * Worker loader for WKB (Well-Known Binary)
+ */
+export const TWKBWorkerLoader: Loader<Geometry, never, WKBLoaderOptions> = {
+  name: 'TWKB (Tiny Well-Known Binary)',
+  id: 'twkb',
+  module: 'wkt',
+  version: VERSION,
+  worker: true,
+  category: 'geometry',
+  extensions: ['twkb'],
+  mimeTypes: [],
+  // TODO can we define static, serializable tests, eg. some binary strings?
+  tests: [isTWKB],
+  options: {
+    wkb: {
+      shape: 'binary-geometry'
+    }
+  }
+};
+
+/**
+ * Loader for WKB (Well-Known Binary)
+ */
+export const TWKBLoader: LoaderWithParser<BinaryGeometry | Geometry, never, WKBLoaderOptions> = {
+  ...TWKBWorkerLoader,
+  parse: async (arrayBuffer: ArrayBuffer) => parseTWKBGeometry(arrayBuffer),
+  parseSync: parseTWKBGeometry
+};

package/src/twkb-writer.ts

@@ -0,0 +1,25 @@
+// loaders.gl, MIT license
+
+import type {Writer, WriterOptions} from '@loaders.gl/loader-utils';
+import {VERSION} from './lib/utils/version';
+import {encodeTWKB} from './lib/encode-twkb';
+import {BinaryGeometry} from '@loaders.gl/schema';
+
+/**
+ * WKB exporter
+ */
+export const TWKBWriter: Writer<BinaryGeometry, never, WriterOptions> = {
+  name: 'TWKB (Tiny Well Known Binary)',
+  id: 'twkb',
+  module: 'wkt',
+  version: VERSION,
+  extensions: ['twkb'],
+  // @ts-expect-error not implemented yet
+  encodeSync: async (data: BinaryGeometry, options) => encodeTWKB,
+  options: {
+    twkb: {
+      // hasZ: false,
+      // hasM: false
+    }
+  }
+};

package/src/wkb-loader.ts

@@ -1,11 +1,21 @@
-import type {Loader, LoaderWithParser} from '@loaders.gl/loader-utils';
+// loaders.gl, MIT license
+
+import type {Loader, LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
+import {BinaryGeometry, Geometry} from '@loaders.gl/schema';
 import {VERSION} from './lib/utils/version';
-import parseWKB from './lib/parse-wkb';
+import {parseWKB} from './lib/parse-wkb';
+import {isWKB} from './lib/parse-wkb-header';
+
+export type WKBLoaderOptions = LoaderOptions & {
+  wkb?: {
+    shape: 'binary-geometry' | 'geometry';
+  };
+};
 
 /**
  * Worker loader for WKB (Well-Known Binary)
  */
-export const WKBWorkerLoader = {
+export const WKBWorkerLoader: Loader<BinaryGeometry | Geometry, never, WKBLoaderOptions> = {
   name: 'WKB',
   id: 'wkb',
   module: 'wkt',
@@ -14,19 +24,20 @@ export const WKBWorkerLoader = {
   category: 'geometry',
   extensions: ['wkb'],
   mimeTypes: [],
+  // TODO can we define static, serializable tests, eg. some binary strings?
+  tests: [isWKB],
   options: {
-    wkb: {}
+    wkb: {
+      shape: 'binary-geometry'
+    }
   }
 };
 
 /**
  * Loader for WKB (Well-Known Binary)
  */
-export const WKBLoader = {
+export const WKBLoader: LoaderWithParser<BinaryGeometry | Geometry, never, WKBLoaderOptions> = {
   ...WKBWorkerLoader,
   parse: async (arrayBuffer: ArrayBuffer) => parseWKB(arrayBuffer),
   parseSync: parseWKB
 };
-
-export const _typecheckWKBWorkerLoader: Loader = WKBWorkerLoader;
-export const _typecheckWKBLoader: LoaderWithParser = WKBLoader;

package/src/wkb-writer.ts

@@ -1,17 +1,19 @@
-import type {Writer} from '@loaders.gl/loader-utils';
+// loaders.gl, MIT license
+
+import type {Writer, WriterOptions} from '@loaders.gl/loader-utils';
 import {VERSION} from './lib/utils/version';
-import encodeWKB from './lib/encode-wkb';
+import {encodeWKB} from './lib/encode-wkb';
+import type {Geometry, Feature} from '@loaders.gl/schema';
 
 /**
  * WKB exporter
  */
-export const WKBWriter: Writer = {
+export const WKBWriter: Writer<Geometry | Feature, never, WriterOptions> = {
   name: 'WKB (Well Known Binary)',
   id: 'wkb',
   module: 'wkt',
   version: VERSION,
   extensions: ['wkb'],
-  // @ts-ignore
   encodeSync: encodeWKB,
   options: {
     wkb: {

package/src/wkt-crs-loader.ts

@@ -0,0 +1,33 @@
+// loaders.gl, MIT license
+
+import type {LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
+import {VERSION} from './lib/utils/version';
+import type {ParseWKTCRSOptions, WKTCRS} from './lib/parse-wkt-crs';
+import {parseWKTCRS} from './lib/parse-wkt-crs';
+
+export type WKTCRSLoaderOptions = LoaderOptions & {
+  'wkt-crs'?: ParseWKTCRSOptions;
+};
+
+/**
+ * Well-Known text CRS loader
+ * @see OGC Standard: https://www.ogc.org/standards/wkt-crs
+ * @see Wikipedia Page: https://en.wikipedia.org/wiki/Well-known_text_representation_of_coordinate_reference_systems
+ */
+export const WKTCRSLoader: LoaderWithParser<WKTCRS, never, WKTCRSLoaderOptions> = {
+  name: 'WKT CRS (Well-Known Text Coordinate Reference System)',
+  id: 'wkt-crs',
+  module: 'wkt-crs',
+  version: VERSION,
+  worker: true,
+  extensions: [],
+  mimeTypes: ['text/plain'],
+  category: 'json',
+  text: true,
+  options: {
+    'wkt-crs': {}
+  },
+  parse: async (arrayBuffer, options) =>
+    parseWKTCRS(new TextDecoder().decode(arrayBuffer), options?.['wkt-crs']),
+  parseTextSync: (string, options) => parseWKTCRS(string, options?.['wkt-crs'])
+};

package/src/wkt-crs-writer.ts

@@ -0,0 +1,37 @@
+// loaders.gl, MIT license
+
+import type {Writer, WriterOptions} from '@loaders.gl/loader-utils';
+import {VERSION} from './lib/utils/version';
+
+import type {WKTCRS} from './lib/parse-wkt-crs';
+import type {EncodeWKTCRSOptions} from './lib/encode-wkt-crs';
+import {encodeWKTCRS} from './lib/encode-wkt-crs';
+
+export type WKTCRSWriterOptions = WriterOptions & {
+  'wkt-crs'?: EncodeWKTCRSOptions;
+};
+
+/**
+ * Well-Known text CRS loader
+ * @see OGC Standard: https://www.ogc.org/standards/wkt-crs
+ * @see Wikipedia Page: https://en.wikipedia.org/wiki/Well-known_text_representation_of_coordinate_reference_systems
+ */
+export const WKTCRSWriter: Writer<WKTCRS, never, WKTCRSWriterOptions> = {
+  name: 'WKT CRS (Well-Known Text Coordinate Reference System)',
+  id: 'wkt-crs',
+  module: 'wkt-crs',
+  version: VERSION,
+  worker: true,
+  extensions: [],
+  mimeTypes: ['text/plain'],
+  // category: 'json',
+  text: true,
+  options: {
+    'wkt-crs': {}
+  },
+  encode: async (wktcrs, options) =>
+    new TextEncoder().encode(encodeWKTCRS(wktcrs, options?.['wkt-crs'])),
+  encodeSync: (wktcrs, options) =>
+    new TextEncoder().encode(encodeWKTCRS(wktcrs, options?.['wkt-crs'])),
+  encodeTextSync: (wktcrs, options) => encodeWKTCRS(wktcrs, options?.['wkt-crs'])
+};

package/src/wkt-loader.ts

@@ -1,11 +1,23 @@
-import type {Loader, LoaderWithParser} from '@loaders.gl/loader-utils';
+// loaders.gl, MIT license
+
+import type {Loader, LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
 import {VERSION} from './lib/utils/version';
-import parseWKT from './lib/parse-wkt';
+import {parseWKT} from './lib/parse-wkt';
+import {Geometry} from '@loaders.gl/schema';
+import {isWKT, WKT_MAGIC_STRINGS} from './lib/parse-wkt';
+
+export type WKTLoaderOptions = LoaderOptions & {
+  /** Options for the WKT parser */
+  wkt?: {
+    /** Whether to add any CRS, if found, as undocumented CRS property on the return geometry */
+    crs?: boolean;
+  };
+};
 
 /**
  * Well-Known text loader
  */
-export const WKTWorkerLoader: Loader = {
+export const WKTWorkerLoader: Loader<Geometry, never, WKTLoaderOptions> = {
   name: 'WKT (Well-Known Text)',
   id: 'wkt',
   module: 'wkt',
@@ -15,16 +27,20 @@ export const WKTWorkerLoader: Loader = {
   mimeTypes: ['text/plain'],
   category: 'geometry',
   text: true,
+  tests: WKT_MAGIC_STRINGS,
+  testText: isWKT,
   options: {
-    wkt: {}
+    wkt: {
+      crs: true
+    }
   }
 };
 
 /**
  * Well-Known text loader
  */
-export const WKTLoader: LoaderWithParser = {
+export const WKTLoader: LoaderWithParser<Geometry, never, WKTLoaderOptions> = {
   ...WKTWorkerLoader,
-  parse: async (arrayBuffer) => parseWKT(new TextDecoder().decode(arrayBuffer)),
+  parse: async (arrayBuffer, options) => parseWKT(new TextDecoder().decode(arrayBuffer), options),
   parseTextSync: parseWKT
 };

package/src/wkt-writer.ts

@@ -1,18 +1,25 @@
-import type {Writer} from '@loaders.gl/loader-utils';
+// loaders.gl, MIT license
+
+import type {Writer, WriterOptions} from '@loaders.gl/loader-utils';
 import {VERSION} from './lib/utils/version';
-import encodeWKT from './lib/encode-wkt';
+import {encodeWKT} from './lib/encode-wkt';
+import {Geometry} from '@loaders.gl/schema';
+
+export type WKTWriterOptions = WriterOptions & {
+  wkt?: {};
+};
 
 /**
  * WKT exporter
  */
-export const WKTWriter: Writer = {
+export const WKTWriter: Writer<Geometry, never, WKTWriterOptions> = {
   name: 'WKT (Well Known Text)',
   id: 'wkt',
   module: 'wkt',
   version: VERSION,
   extensions: ['wkt'],
-  // @ts-ignore
-  encode: encodeWKT,
+  // @ts-expect-error
+  encodeSync: encodeWKT,
   options: {
     wkt: {}
   }

package/src/workers/wkb-worker.ts

@@ -1,3 +1,5 @@
+// loaders.gl, MIT license
+
 import {createLoaderWorker} from '@loaders.gl/loader-utils';
 import {WKBLoader} from '../wkb-loader';
 

package/src/workers/wkt-worker.ts

@@ -1,3 +1,5 @@
+// loaders.gl, MIT license
+
 import {createLoaderWorker} from '@loaders.gl/loader-utils';
 import {WKTLoader} from '../wkt-loader';
 

package/dist/bundle.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bundle.d.ts","sourceRoot":"","sources":["../src/bundle.ts"],"names":[],"mappings":"AACA,QAAA,MAAM,aAAa,KAAqB,CAAC"}

package/dist/bundle.js

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

package/dist/index.d.ts

@@ -1,5 +0,0 @@
-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 +0,0 @@
-{"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,13 +0,0 @@
-"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; } });

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

@@ -1 +0,0 @@
-{"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,4CAA4C;IAC5C,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf,4CAA4C;IAC5C,IAAI,CAAC,EAAE,OAAO,CAAC;IAEf,0CAA0C;IAC1C,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ;AAED;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,SAAS,CAC/B,QAAQ,EAAE,QAAQ,GAAG,OAAO,EAC5B,OAAO,GAAE,UAAU,GAAG;IAAC,GAAG,EAAE,UAAU,CAAA;CAAM,GAC3C,WAAW,CA8Bb"}