@loaders.gl/gis 4.3.2 → 4.4.0-alpha.1

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

@@ -0,0 +1,136 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// Forked from https://github.com/cschwarz/wkx under MIT license, Copyright (c) 2013 Christian Schwarz
+
+import {TypedArray} from '@math.gl/types';
+
+const LE = true;
+const BE = false;
+
+export class BinaryWriter {
+  arrayBuffer: ArrayBuffer;
+  dataView: DataView;
+  byteOffset: number = 0;
+  allowResize: boolean = false;
+
+  constructor(size: number, allowResize?: boolean) {
+    this.arrayBuffer = new ArrayBuffer(size);
+    this.dataView = new DataView(this.arrayBuffer);
+    this.byteOffset = 0;
+    this.allowResize = allowResize || false;
+  }
+
+  writeUInt8(value: number): void {
+    this._ensureSize(1);
+    this.dataView.setUint8(this.byteOffset, value);
+    this.byteOffset += 1;
+  }
+  writeUInt16LE(value: number): void {
+    this._ensureSize(2);
+    this.dataView.setUint16(this.byteOffset, value, LE);
+    this.byteOffset += 2;
+  }
+  writeUInt16BE(value: number): void {
+    this._ensureSize(2);
+    this.dataView.setUint16(this.byteOffset, value, BE);
+    this.byteOffset += 2;
+  }
+  writeUInt32LE(value: number): void {
+    this._ensureSize(4);
+    this.dataView.setUint32(this.byteOffset, value, LE);
+    this.byteOffset += 4;
+  }
+  writeUInt32BE(value: number): void {
+    this._ensureSize(4);
+    this.dataView.setUint32(this.byteOffset, value, BE);
+    this.byteOffset += 4;
+  }
+  writeInt8(value: number): void {
+    this._ensureSize(1);
+    this.dataView.setInt8(this.byteOffset, value);
+    this.byteOffset += 1;
+  }
+  writeInt16LE(value: number): void {
+    this._ensureSize(2);
+    this.dataView.setInt16(this.byteOffset, value, LE);
+    this.byteOffset += 2;
+  }
+  writeInt16BE(value: number): void {
+    this._ensureSize(2);
+    this.dataView.setInt16(this.byteOffset, value, BE);
+    this.byteOffset += 2;
+  }
+  writeInt32LE(value: number): void {
+    this._ensureSize(4);
+    this.dataView.setInt32(this.byteOffset, value, LE);
+    this.byteOffset += 4;
+  }
+  writeInt32BE(value: number): void {
+    this._ensureSize(4);
+    this.dataView.setInt32(this.byteOffset, value, BE);
+    this.byteOffset += 4;
+  }
+  writeFloatLE(value: number): void {
+    this._ensureSize(4);
+    this.dataView.setFloat32(this.byteOffset, value, LE);
+    this.byteOffset += 4;
+  }
+  writeFloatBE(value: number): void {
+    this._ensureSize(4);
+    this.dataView.setFloat32(this.byteOffset, value, BE);
+    this.byteOffset += 4;
+  }
+  writeDoubleLE(value: number): void {
+    this._ensureSize(8);
+    this.dataView.setFloat64(this.byteOffset, value, LE);
+    this.byteOffset += 8;
+  }
+  writeDoubleBE(value: number): void {
+    this._ensureSize(8);
+    this.dataView.setFloat64(this.byteOffset, value, BE);
+    this.byteOffset += 8;
+  }
+
+  /** A varint uses a variable number of bytes */
+  writeVarInt(value: number): number {
+    // TODO - ensure size?
+    let length = 1;
+    while ((value & 0xffffff80) !== 0) {
+      this.writeUInt8((value & 0x7f) | 0x80);
+      value >>>= 7;
+      length++;
+    }
+    this.writeUInt8(value & 0x7f);
+    return length;
+  }
+
+  writeTypedArray(typedArray: TypedArray) {
+    this._ensureSize(typedArray.byteLength);
+    const tempArray = new Uint8Array(this.arrayBuffer);
+    tempArray.set(typedArray, this.byteOffset);
+    this.byteOffset += typedArray.byteLength;
+  }
+
+  /** Append another ArrayBuffer to this ArrayBuffer */
+  writeBuffer(arrayBuffer: ArrayBuffer): void {
+    this._ensureSize(arrayBuffer.byteLength);
+    const tempArray = new Uint8Array(this.arrayBuffer);
+    tempArray.set(new Uint8Array(arrayBuffer), this.byteOffset);
+    this.byteOffset += arrayBuffer.byteLength;
+  }
+
+  /** Resizes this.arrayBuffer if not enough space */
+  _ensureSize(size: number) {
+    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');
+      }
+    }
+  }
+}

package/src/lib/utils/concat-typed-arrays.ts

@@ -0,0 +1,24 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import type {TypedArray} from '@loaders.gl/schema';
+
+// TODO: remove copy; import from typed-array-utils
+// modules/math/src/geometry/typed-arrays/typed-array-utils.js
+export function concatTypedArrays(arrays: TypedArray[]): TypedArray {
+  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/src/lib/utils/hex-encoder.ts

@@ -0,0 +1,60 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+/**
+ * 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,54 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+// 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/lib/wkt-crs/encode-wkt-crs.ts

@@ -0,0 +1,41 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// parse-wkt-crs was forked from https://github.com/DanielJDufour/wkt-crs under Creative Commons CC0 1.0 license.
+
+import type {WKTCRS} from './parse-wkt-crs';
+
+export type EncodeWKTCRSOptions = {
+  debug?: boolean;
+};
+
+/**
+ * convert JSON representation of Well-Known Text
+ * back to standard Well-Known Text
+ */
+export function encodeWKTCRS(wkt: WKTCRS, options?: EncodeWKTCRSOptions): string {
+  if (Array.isArray(wkt) && wkt.length === 1 && Array.isArray(wkt[0])) {
+    wkt = wkt[0]; // ignore first extra wrapper array
+  }
+
+  const [kw, ...attrs] = wkt;
+  const str = `${kw}[${attrs
+    .map((attr) => {
+      if (Array.isArray(attr)) {
+        return encodeWKTCRS(attr, options);
+      } else if (typeof attr === 'number') {
+        return attr.toString();
+      } else if (typeof attr === 'string') {
+        // can't automatically convert all caps to varibale
+        // because EPSG is string in AUTHORITY["EPSG", ...]
+        if (attr.startsWith('raw:')) {
+          // convert "raw:NORTH" to NORTH
+          return attr.replace('raw:', '');
+        }
+        return `"${attr}"`;
+      }
+      throw new Error(`[wktcrs] unexpected attribute "${attr}"`);
+    })
+    .join(',')}]`;
+  return str;
+}

package/src/lib/wkt-crs/parse-wkt-crs.ts

@@ -0,0 +1,149 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+// parse-wkt-crs was forked from https://github.com/DanielJDufour/wkt-crs under Creative Commons CC0 1.0 license.
+
+/* eslint-disable no-console */ // TODO switch to options.log
+
+export type ParseWKTCRSOptions = {
+  sort?: boolean;
+  keywords?: string[];
+  raw?: boolean;
+  debug?: boolean;
+};
+
+export type WKTCRS = any;
+
+/**
+ *
+ * @param wkt
+ * @param options
+ * @returns
+ */
+export function parseWKTCRS(wkt: string, options?: ParseWKTCRSOptions): WKTCRS {
+  if (options?.debug) {
+    console.log('[wktcrs] parse starting with\n', wkt);
+  }
+
+  // move all keywords into first array item slot
+  // from PARAM[12345, 67890] to ["PARAM", 12345, 67890]
+  wkt = wkt.replace(/[A-Z][A-Z\d_]+\[/gi, (match) => `["${match.substr(0, match.length - 1)}",`);
+
+  // wrap variables in strings
+  // from [...,NORTH] to [...,"NORTH"]
+  wkt = wkt.replace(/, ?([A-Z][A-Z\d_]+[,\]])/gi, (match, p1) => {
+    const varname = p1.substr(0, p1.length - 1);
+    return ',' + `"${options?.raw ? 'raw:' : ''}${varname}"${p1[p1.length - 1]}`;
+  });
+
+  if (options?.raw) {
+    // replace all numbers with strings
+    wkt = wkt.replace(/, {0,2}(-?[\.\d]+)(?=,|\])/g, function (match, p1) {
+      return ',' + `"${options?.raw ? 'raw:' : ''}${p1}"`;
+    });
+  }
+
+  // str should now be valid JSON
+  if (options?.debug) {
+    console.log(`[wktcrs] json'd wkt: '${wkt}'`);
+  }
+
+  let data;
+  try {
+    data = JSON.parse(wkt);
+  } catch (error) {
+    console.error(`[wktcrs] failed to parse '${wkt}'`);
+    throw error;
+  }
+
+  if (options?.debug) {
+    console.log(`[wktcrs] json parsed: '${wkt}'`);
+  }
+
+  function process(data, parent) {
+    const kw = data[0];
+
+    // after removing the first element with .shift()
+    // data is now just an array of attributes
+
+    data.forEach(function (it) {
+      if (Array.isArray(it)) {
+        process(it, data);
+      }
+    });
+
+    const kwarr = `MULTIPLE_${kw}`;
+
+    if (kwarr in parent) {
+      parent[kwarr].push(data);
+    } else if (kw in parent) {
+      parent[kwarr] = [parent[kw], data];
+      delete parent[kw];
+    } else {
+      parent[kw] = data;
+    }
+    return parent;
+  }
+
+  const result = process(data, [data]);
+  if (options?.debug) {
+    console.log('[wktcrs] parse returning', result);
+  }
+
+  if (options?.sort) {
+    sort(result, options);
+  }
+
+  return result;
+}
+
+function sort(data: string[], options?: {keywords?: string[]}) {
+  const keys = Object.keys(data).filter((k) => !/\d+/.test(k));
+
+  const keywords: string[] = options?.keywords || [];
+  if (!options?.keywords) {
+    // try to find multiples
+    const counts = {};
+    if (Array.isArray(data)) {
+      data.forEach((it) => {
+        if (Array.isArray(it) && it.length >= 2 && typeof it[1] === 'string') {
+          const k = it[0];
+          if (!counts[k]) counts[k] = 0;
+          counts[k]++;
+        }
+      });
+      for (const k in counts) {
+        if (counts[k] > 0) keywords.push(k);
+      }
+    }
+  }
+
+  keys.forEach((key) => {
+    data[key] = sort(data[key]);
+  });
+
+  keywords.forEach((key) => {
+    const indices: number[] = [];
+    const params: string[] = [];
+
+    data.forEach((item, i) => {
+      if (Array.isArray(item) && item[0] === key) {
+        indices.push(i);
+        params.push(item);
+      }
+    });
+
+    params.sort((a, b) => {
+      a = a[1].toString();
+      b = b[1].toString();
+      return a < b ? -1 : a > b ? 1 : 0;
+    });
+
+    // replace in order
+    params.forEach((param, i) => {
+      data[indices[i]] = param;
+    });
+  });
+
+  return data;
+}

package/dist/lib/binary-features/binary-to-geojson.d.ts

@@ -1,18 +0,0 @@
-import type { BinaryGeometry, BinaryGeometryType, BinaryFeatureCollection, Feature, Geometry } from '@loaders.gl/schema';
-type BinaryToGeoJsonOptions = {
-    type?: BinaryGeometryType;
-    globalFeatureId?: number;
-};
-/**
- * Convert binary geometry representation to GeoJSON
- * @param data   geometry data in binary representation
- * @param options
- * @param options.type  Input data type: Point, LineString, or Polygon
- * @param options.featureId  Global feature id. If specified, only a single feature is extracted
- * @return GeoJSON objects
- */
-export declare function binaryToGeojson(data: BinaryFeatureCollection, options?: BinaryToGeoJsonOptions): Feature[] | Feature;
-/** Parse input binary data and return a valid GeoJSON geometry object */
-export declare function binaryToGeometry(data: BinaryGeometry, startIndex?: number, endIndex?: number): Geometry;
-export {};
-//# sourceMappingURL=binary-to-geojson.d.ts.map

package/dist/lib/binary-features/binary-to-geojson.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"binary-to-geojson.d.ts","sourceRoot":"","sources":["../../../src/lib/binary-features/binary-to-geojson.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,cAAc,EACd,kBAAkB,EAIlB,uBAAuB,EAMvB,OAAO,EACP,QAAQ,EAST,MAAM,oBAAoB,CAAC;AAK5B,KAAK,sBAAsB,GAAG;IAC5B,IAAI,CAAC,EAAE,kBAAkB,CAAC;IAC1B,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,uBAAuB,EAC7B,OAAO,CAAC,EAAE,sBAAsB,GAC/B,OAAO,EAAE,GAAG,OAAO,CAMrB;AAwCD,yEAAyE;AACzE,wBAAgB,gBAAgB,CAC9B,IAAI,EAAE,cAAc,EACpB,UAAU,CAAC,EAAE,MAAM,EACnB,QAAQ,CAAC,EAAE,MAAM,GAChB,QAAQ,CAYV"}

package/dist/lib/binary-features/extract-geometry-info.d.ts

@@ -1,8 +0,0 @@
-import { Feature, GeojsonGeometryInfo } from '@loaders.gl/schema';
-/**
- *  Initial scan over GeoJSON features
- *  Counts number of coordinates of each geometry type and
- *  keeps track of the max coordinate dimensions
- */
-export declare function extractGeometryInfo(features: Feature[]): GeojsonGeometryInfo;
-//# sourceMappingURL=extract-geometry-info.d.ts.map

package/dist/lib/binary-features/extract-geometry-info.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"extract-geometry-info.d.ts","sourceRoot":"","sources":["../../../src/lib/binary-features/extract-geometry-info.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,OAAO,EAAE,mBAAmB,EAAC,MAAM,oBAAoB,CAAC;AAEhE;;;;GAIG;AAEH,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,OAAO,EAAE,GAAG,mBAAmB,CA4F5E"}

package/dist/lib/binary-features/flat-geojson-to-binary-types.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flat-geojson-to-binary-types.d.ts","sourceRoot":"","sources":["../../../src/lib/binary-features/flat-geojson-to-binary-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAEnD;;GAEG;AACH,MAAM,MAAM,oBAAoB,GAC5B,uBAAuB,GACvB,uBAAuB,GACvB,gBAAgB,CAAC;AAErB;;GAEG;AACH,MAAM,MAAM,MAAM,GAAG;IACnB,IAAI,EAAE,OAAO,CAAC;IACd,SAAS,EAAE,YAAY,GAAG,YAAY,CAAC;IACvC,gBAAgB,EAAE,WAAW,GAAG,WAAW,CAAC;IAC5C,UAAU,EAAE,WAAW,GAAG,WAAW,CAAC;IACtC,YAAY,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;KAAC,CAAC;IAC1C,UAAU,EAAE,EAAE,EAAE,CAAC;IACjB,MAAM,EAAE;QACN,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;KACtB,EAAE,CAAC;CACL,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,KAAK,GAAG;IAClB,IAAI,EAAE,YAAY,CAAC;IACnB,SAAS,EAAE,YAAY,GAAG,YAAY,CAAC;IACvC,WAAW,EAAE,WAAW,GAAG,WAAW,CAAC;IACvC,gBAAgB,EAAE,WAAW,GAAG,WAAW,CAAC;IAC5C,UAAU,EAAE,WAAW,GAAG,WAAW,CAAC;IACtC,YAAY,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;KAAC,CAAC;IAC1C,UAAU,EAAE,EAAE,EAAE,CAAC;IACjB,MAAM,EAAE;QACN,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;KACtB,EAAE,CAAC;CACL,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,QAAQ,GAAG;IACrB,IAAI,EAAE,SAAS,CAAC;IAChB,SAAS,EAAE,YAAY,GAAG,YAAY,CAAC;IACvC,cAAc,EAAE,WAAW,GAAG,WAAW,CAAC;IAC1C,uBAAuB,EAAE,WAAW,GAAG,WAAW,CAAC;IACnD,SAAS,CAAC,EAAE,MAAM,EAAE,CAAC;IACrB,gBAAgB,EAAE,WAAW,GAAG,WAAW,CAAC;IAC5C,UAAU,EAAE,WAAW,GAAG,WAAW,CAAC;IACtC,YAAY,EAAE;QAAC,CAAC,GAAG,EAAE,MAAM,GAAG,UAAU,CAAA;KAAC,CAAC;IAC1C,UAAU,EAAE,EAAE,EAAE,CAAC;IACjB,MAAM,EAAE;QACN,EAAE,CAAC,EAAE,MAAM,GAAG,MAAM,CAAC;KACtB,EAAE,CAAC;CACL,CAAC"}

package/dist/lib/binary-features/flat-geojson-to-binary-types.js

@@ -1 +0,0 @@
-export {};

package/dist/lib/binary-features/flat-geojson-to-binary.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flat-geojson-to-binary.d.ts","sourceRoot":"","sources":["../../../src/lib/binary-features/flat-geojson-to-binary.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAEV,uBAAuB,EAEvB,WAAW,EAIX,mBAAmB,EAEpB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAC,oBAAoB,EAA0B,0CAAuC;AAE7F;;;;;;;;;;;;GAYG;AACH,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,WAAW,EAAE,EACvB,YAAY,EAAE,mBAAmB,EACjC,OAAO,CAAC,EAAE,0BAA0B,2BAgBrC;AAED;;GAEG;AACH,MAAM,MAAM,0BAA0B,GAAG;IACvC,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,gBAAgB,CAAC,EAAE,uBAAuB,GAAG,uBAAuB,CAAC;IACrE,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF,eAAO,MAAM,YAAY;;CAExB,CAAC;AAEF;;;;;GAKG;AACH,iBAAS,uBAAuB,CAAC,QAAQ,EAAE,WAAW,EAAE,GAAG;IACzD,CAAC,GAAG,EAAE,MAAM,GAAG,oBAAoB,CAAC;CACrC,CAgBA"}

package/dist/lib/binary-features/geojson-to-binary.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"geojson-to-binary.d.ts","sourceRoot":"","sources":["../../../src/lib/binary-features/geojson-to-binary.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,OAAO,EAAE,uBAAuB,EAAC,MAAM,oBAAoB,CAAC;AAMzE;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,cAAc,EAAE,OAAO,CAAC;IACxB,eAAe,CAAC,EAAE,MAAM,EAAE,CAAC;IAC3B,gBAAgB,CAAC,EAAE,uBAAuB,GAAG,uBAAuB,CAAC;IACrE,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF;;;;;;GAMG;AACH,wBAAgB,eAAe,CAC7B,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,GAAE,sBAAkE,GAC1E,uBAAuB,CAUzB"}

package/dist/lib/binary-features/geojson-to-binary.js

@@ -1,21 +0,0 @@
-import { extractGeometryInfo } from "./extract-geometry-info.js";
-import { geojsonToFlatGeojson } from "./geojson-to-flat-geojson.js";
-import { flatGeojsonToBinary } from "./flat-geojson-to-binary.js";
-/**
- * Convert GeoJSON features to flat binary arrays
- *
- * @param features
- * @param options
- * @returns features in binary format, grouped by geometry type
- */
-export function geojsonToBinary(features, options = { fixRingWinding: true, triangulate: true }) {
-    const geometryInfo = extractGeometryInfo(features);
-    const coordLength = geometryInfo.coordLength;
-    const { fixRingWinding } = options;
-    const flatFeatures = geojsonToFlatGeojson(features, { coordLength, fixRingWinding });
-    return flatGeojsonToBinary(flatFeatures, geometryInfo, {
-        numericPropKeys: options.numericPropKeys,
-        PositionDataType: options.PositionDataType || Float32Array,
-        triangulate: options.triangulate
-    });
-}

package/dist/lib/binary-features/geojson-to-flat-geojson.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"geojson-to-flat-geojson.d.ts","sourceRoot":"","sources":["../../../src/lib/binary-features/geojson-to-flat-geojson.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,OAAO,EAAY,WAAW,EAAC,MAAM,oBAAoB,CAAC;AAElE;;GAEG;AACH,MAAM,MAAM,2BAA2B,GAAG;IACxC,WAAW,EAAE,MAAM,CAAC;IACpB,cAAc,EAAE,OAAO,CAAC;CACzB,CAAC;AASF;;;;;;GAMG;AACH,wBAAgB,oBAAoB,CAClC,QAAQ,EAAE,OAAO,EAAE,EACnB,OAAO,GAAE,2BAAoE,GAC5E,WAAW,EAAE,CAEf"}

package/dist/lib/binary-features/transform.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"transform.d.ts","sourceRoot":"","sources":["../../../src/lib/binary-features/transform.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,uBAAuB,EAAkB,OAAO,EAAC,MAAM,oBAAoB,CAAC;AAEzF,KAAK,mBAAmB,GAAG,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,CAAC;AAEzD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CACnC,cAAc,EAAE,uBAAuB,EACvC,mBAAmB,EAAE,mBAAmB,GACvC,uBAAuB,CAWzB;AAcD;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CACpC,QAAQ,EAAE,OAAO,EAAE,EACnB,EAAE,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,KAAK,MAAM,EAAE,GAChC,OAAO,EAAE,CAMX"}

package/dist/lib/geo/geoarrow-metadata.d.ts

@@ -1,27 +0,0 @@
-import { Schema, Field } from '@loaders.gl/schema';
-export type GeoArrowEncoding = 'geoarrow.multipolygon' | 'geoarrow.polygon' | 'geoarrow.multilinestring' | 'geoarrow.linestring' | 'geoarrow.multipoint' | 'geoarrow.point' | 'geoarrow.wkb' | 'geoarrow.wkt';
-/**
- * Geospatial metadata for one column, extracted from Apache Arrow metadata
- * @see https://github.com/geoarrow/geoarrow/blob/main/extension-types.md
- */
-export type GeoArrowMetadata = {
-    /** Encoding of geometry in this column */
-    encoding?: GeoArrowEncoding;
-    /** CRS in [PROJJSON](https://proj.org/specifications/projjson.html). Omitted if producer has no information about CRS */
-    crs?: Record<string, unknown>;
-    /** Edges are either spherical or omitted */
-    edges?: 'spherical';
-    [key: string]: unknown;
-};
-/**
- * get geometry columns from arrow table
- */
-export declare function getGeometryColumnsFromSchema(schema: Schema): Record<string, GeoArrowMetadata>;
-/**
- * Extracts GeoArrow metadata from a field
- * @param field
- * @returns
- * @see https://github.com/geoarrow/geoarrow/blob/d2f56704414d9ae71e8a5170a8671343ed15eefe/extension-types.md
- */
-export declare function getGeometryMetadataForField(field: Field): GeoArrowMetadata | null;
-//# sourceMappingURL=geoarrow-metadata.d.ts.map

package/dist/lib/geo/geoarrow-metadata.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"geoarrow-metadata.d.ts","sourceRoot":"","sources":["../../../src/lib/geo/geoarrow-metadata.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,MAAM,EAAE,KAAK,EAAC,MAAM,oBAAoB,CAAC;AAEjD,MAAM,MAAM,gBAAgB,GACxB,uBAAuB,GACvB,kBAAkB,GAClB,0BAA0B,GAC1B,qBAAqB,GACrB,qBAAqB,GACrB,gBAAgB,GAChB,cAAc,GACd,cAAc,CAAC;AAiBnB;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,0CAA0C;IAC1C,QAAQ,CAAC,EAAE,gBAAgB,CAAC;IAC5B,yHAAyH;IACzH,GAAG,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,4CAA4C;IAC5C,KAAK,CAAC,EAAE,WAAW,CAAC;IACpB,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC;CACxB,CAAC;AAEF;;GAEG;AACH,wBAAgB,4BAA4B,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,EAAE,gBAAgB,CAAC,CAS7F;AACD;;;;;GAKG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,KAAK,GAAG,gBAAgB,GAAG,IAAI,CAmCjF"}

package/dist/lib/geo/geoarrow-metadata.js

@@ -1,70 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-/** Array containing all encodings */
-const GEOARROW_ENCODINGS = [
-    'geoarrow.multipolygon',
-    'geoarrow.polygon',
-    'geoarrow.multilinestring',
-    'geoarrow.linestring',
-    'geoarrow.multipoint',
-    'geoarrow.point',
-    'geoarrow.wkb',
-    'geoarrow.wkt'
-];
-const GEOARROW_COLUMN_METADATA_ENCODING = 'ARROW:extension:name';
-const GEOARROW_COLUMN_METADATA_METADATA = 'ARROW:extension:metadata';
-/**
- * get geometry columns from arrow table
- */
-export function getGeometryColumnsFromSchema(schema) {
-    const geometryColumns = {};
-    for (const field of schema.fields) {
-        const metadata = getGeometryMetadataForField(field);
-        if (metadata) {
-            geometryColumns[field.name] = metadata;
-        }
-    }
-    return geometryColumns;
-}
-/**
- * Extracts GeoArrow metadata from a field
- * @param field
- * @returns
- * @see https://github.com/geoarrow/geoarrow/blob/d2f56704414d9ae71e8a5170a8671343ed15eefe/extension-types.md
- */
-export function getGeometryMetadataForField(field) {
-    let metadata = null;
-    // Check for GeoArrow column encoding
-    let geoEncoding = field.metadata?.[GEOARROW_COLUMN_METADATA_ENCODING];
-    if (geoEncoding) {
-        geoEncoding = geoEncoding.toLowerCase();
-        // at time of testing, ogr2ogr uses WKB/WKT for encoding.
-        if (geoEncoding === 'wkb') {
-            geoEncoding = 'geoarrow.wkb';
-        }
-        if (geoEncoding === 'wkt') {
-            geoEncoding = 'geoarrow.wkt';
-        }
-        if (!GEOARROW_ENCODINGS.includes(geoEncoding)) {
-            // eslint-disable-next-line no-console
-            console.warn(`Invalid GeoArrow encoding: ${geoEncoding}`);
-        }
-        else {
-            metadata = metadata || {};
-            metadata.encoding = geoEncoding;
-        }
-    }
-    // Check for GeoArrow metadata
-    const columnMetadata = field.metadata?.[GEOARROW_COLUMN_METADATA_METADATA];
-    if (columnMetadata) {
-        try {
-            metadata = JSON.parse(columnMetadata);
-        }
-        catch (error) {
-            // eslint-disable-next-line no-console
-            console.warn('Failed to parse GeoArrow metadata', error);
-        }
-    }
-    return metadata || null;
-}