@loaders.gl/arrow 4.2.0-alpha.4 → 4.2.0-alpha.6

package/dist/geoarrow/convert-geoarrow-to-geojson-geometry.js

@@ -1,149 +1,176 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { binaryToGeometry } from '@loaders.gl/gis';
 import { WKBLoader, WKTLoader } from '@loaders.gl/wkt';
+/**
+ * parse geometry from arrow data that is returned from processArrowData()
+ * NOTE: this function could be deduplicated with the binaryToFeature() in deck.gl,
+ * it is currently used for deck.gl picking because currently deck.gl returns only the index of the feature
+ *
+ * @param data data extraced from arrow vector representing a geometry
+ * @param encoding the geoarrow encoding of the geometry column
+ * @returns Feature or null
+ */
 export function parseGeometryFromArrow(arrowCellValue, encoding) {
-  var _encoding;
-  encoding = (_encoding = encoding) === null || _encoding === void 0 ? void 0 : _encoding.toLowerCase();
-  if (!encoding || !arrowCellValue) {
-    return null;
-  }
-  let geometry;
-  switch (encoding) {
-    case 'geoarrow.multipolygon':
-      geometry = arrowMultiPolygonToFeature(arrowCellValue);
-      break;
-    case 'geoarrow.polygon':
-      geometry = arrowPolygonToFeature(arrowCellValue);
-      break;
-    case 'geoarrow.multipoint':
-      geometry = arrowMultiPointToFeature(arrowCellValue);
-      break;
-    case 'geoarrow.point':
-      geometry = arrowPointToFeature(arrowCellValue);
-      break;
-    case 'geoarrow.multilinestring':
-      geometry = arrowMultiLineStringToFeature(arrowCellValue);
-      break;
-    case 'geoarrow.linestring':
-      geometry = arrowLineStringToFeature(arrowCellValue);
-      break;
-    case 'geoarrow.wkb':
-      geometry = arrowWKBToFeature(arrowCellValue);
-      break;
-    case 'geoarrow.wkt':
-      geometry = arrowWKTToFeature(arrowCellValue);
-      break;
-    default:
-      {
-        throw Error(`GeoArrow encoding not supported ${encoding}`);
-      }
-  }
-  return geometry;
+    // sanity
+    encoding = encoding?.toLowerCase();
+    if (!encoding || !arrowCellValue) {
+        return null;
+    }
+    let geometry;
+    switch (encoding) {
+        case 'geoarrow.multipolygon':
+            geometry = arrowMultiPolygonToFeature(arrowCellValue);
+            break;
+        case 'geoarrow.polygon':
+            geometry = arrowPolygonToFeature(arrowCellValue);
+            break;
+        case 'geoarrow.multipoint':
+            geometry = arrowMultiPointToFeature(arrowCellValue);
+            break;
+        case 'geoarrow.point':
+            geometry = arrowPointToFeature(arrowCellValue);
+            break;
+        case 'geoarrow.multilinestring':
+            geometry = arrowMultiLineStringToFeature(arrowCellValue);
+            break;
+        case 'geoarrow.linestring':
+            geometry = arrowLineStringToFeature(arrowCellValue);
+            break;
+        case 'geoarrow.wkb':
+            geometry = arrowWKBToFeature(arrowCellValue);
+            break;
+        case 'geoarrow.wkt':
+            geometry = arrowWKTToFeature(arrowCellValue);
+            break;
+        default: {
+            throw Error(`GeoArrow encoding not supported ${encoding}`);
+        }
+    }
+    return geometry;
 }
 function arrowWKBToFeature(arrowCellValue) {
-  var _WKBLoader$parseSync;
-  const arrayBuffer = arrowCellValue.buffer.slice(arrowCellValue.byteOffset, arrowCellValue.byteOffset + arrowCellValue.byteLength);
-  const binaryGeometry = (_WKBLoader$parseSync = WKBLoader.parseSync) === null || _WKBLoader$parseSync === void 0 ? void 0 : _WKBLoader$parseSync.call(WKBLoader, arrayBuffer);
-  const geometry = binaryToGeometry(binaryGeometry);
-  return geometry;
+    // The actual WKB array buffer starts from byteOffset and ends at byteOffset + byteLength
+    const arrayBuffer = arrowCellValue.buffer.slice(arrowCellValue.byteOffset, arrowCellValue.byteOffset + arrowCellValue.byteLength);
+    const binaryGeometry = WKBLoader.parseSync?.(arrayBuffer);
+    const geometry = binaryToGeometry(binaryGeometry);
+    return geometry;
 }
 function arrowWKTToFeature(arrowCellValue) {
-  var _WKTLoader$parseTextS;
-  const string = arrowCellValue;
-  return (_WKTLoader$parseTextS = WKTLoader.parseTextSync) === null || _WKTLoader$parseTextS === void 0 ? void 0 : _WKTLoader$parseTextS.call(WKTLoader, string);
+    const string = arrowCellValue;
+    return WKTLoader.parseTextSync?.(string);
 }
+/**
+ * convert Arrow MultiPolygon to geojson Feature
+ */
 function arrowMultiPolygonToFeature(arrowMultiPolygon) {
-  const multiPolygon = [];
-  for (let m = 0; m < arrowMultiPolygon.length; m++) {
-    const arrowPolygon = arrowMultiPolygon.get(m);
-    const polygon = [];
-    for (let i = 0; arrowPolygon && i < (arrowPolygon === null || arrowPolygon === void 0 ? void 0 : arrowPolygon.length); i++) {
-      const arrowRing = arrowPolygon === null || arrowPolygon === void 0 ? void 0 : arrowPolygon.get(i);
-      const ring = [];
-      for (let j = 0; arrowRing && j < arrowRing.length; j++) {
-        const arrowCoord = arrowRing.get(j);
-        const coord = Array.from(arrowCoord);
-        ring.push(coord);
-      }
-      polygon.push(ring);
+    const multiPolygon = [];
+    for (let m = 0; m < arrowMultiPolygon.length; m++) {
+        const arrowPolygon = arrowMultiPolygon.get(m);
+        const polygon = [];
+        for (let i = 0; arrowPolygon && i < arrowPolygon?.length; i++) {
+            const arrowRing = arrowPolygon?.get(i);
+            const ring = [];
+            for (let j = 0; arrowRing && j < arrowRing.length; j++) {
+                const arrowCoord = arrowRing.get(j);
+                const coord = Array.from(arrowCoord);
+                ring.push(coord);
+            }
+            polygon.push(ring);
+        }
+        multiPolygon.push(polygon);
     }
-    multiPolygon.push(polygon);
-  }
-  const geometry = {
-    type: 'MultiPolygon',
-    coordinates: multiPolygon
-  };
-  return geometry;
+    const geometry = {
+        type: 'MultiPolygon',
+        coordinates: multiPolygon
+    };
+    return geometry;
 }
+/**
+ * convert Arrow Polygon to geojson Feature
+ */
 function arrowPolygonToFeature(arrowPolygon) {
-  const polygon = [];
-  for (let i = 0; arrowPolygon && i < arrowPolygon.length; i++) {
-    const arrowRing = arrowPolygon.get(i);
-    const ring = [];
-    for (let j = 0; arrowRing && j < arrowRing.length; j++) {
-      const arrowCoord = arrowRing.get(j);
-      const coords = Array.from(arrowCoord);
-      ring.push(coords);
+    const polygon = [];
+    for (let i = 0; arrowPolygon && i < arrowPolygon.length; i++) {
+        const arrowRing = arrowPolygon.get(i);
+        const ring = [];
+        for (let j = 0; arrowRing && j < arrowRing.length; j++) {
+            const arrowCoord = arrowRing.get(j);
+            const coords = Array.from(arrowCoord);
+            ring.push(coords);
+        }
+        polygon.push(ring);
     }
-    polygon.push(ring);
-  }
-  const geometry = {
-    type: 'Polygon',
-    coordinates: polygon
-  };
-  return geometry;
+    const geometry = {
+        type: 'Polygon',
+        coordinates: polygon
+    };
+    return geometry;
 }
+/**
+ * convert Arrow MultiPoint to geojson MultiPoint
+ */
 function arrowMultiPointToFeature(arrowMultiPoint) {
-  const multiPoint = [];
-  for (let i = 0; arrowMultiPoint && i < arrowMultiPoint.length; i++) {
-    const arrowPoint = arrowMultiPoint.get(i);
-    if (arrowPoint) {
-      const coord = Array.from(arrowPoint);
-      multiPoint.push(coord);
+    const multiPoint = [];
+    for (let i = 0; arrowMultiPoint && i < arrowMultiPoint.length; i++) {
+        const arrowPoint = arrowMultiPoint.get(i);
+        if (arrowPoint) {
+            const coord = Array.from(arrowPoint);
+            multiPoint.push(coord);
+        }
     }
-  }
-  return {
-    type: 'MultiPoint',
-    coordinates: multiPoint
-  };
+    return {
+        type: 'MultiPoint',
+        coordinates: multiPoint
+    };
 }
+/**
+ * convert Arrow Point to geojson Point
+ */
 function arrowPointToFeature(arrowPoint) {
-  const point = Array.from(arrowPoint);
-  return {
-    type: 'Point',
-    coordinates: point
-  };
+    const point = Array.from(arrowPoint);
+    return {
+        type: 'Point',
+        coordinates: point
+    };
 }
+/**
+ * convert Arrow MultiLineString to geojson MultiLineString
+ */
 function arrowMultiLineStringToFeature(arrowMultiLineString) {
-  const multiLineString = [];
-  for (let i = 0; arrowMultiLineString && i < arrowMultiLineString.length; i++) {
-    const arrowLineString = arrowMultiLineString.get(i);
-    const lineString = [];
-    for (let j = 0; arrowLineString && j < arrowLineString.length; j++) {
-      const arrowCoord = arrowLineString.get(j);
-      if (arrowCoord) {
-        const coords = Array.from(arrowCoord);
-        lineString.push(coords);
-      }
+    const multiLineString = [];
+    for (let i = 0; arrowMultiLineString && i < arrowMultiLineString.length; i++) {
+        const arrowLineString = arrowMultiLineString.get(i);
+        const lineString = [];
+        for (let j = 0; arrowLineString && j < arrowLineString.length; j++) {
+            const arrowCoord = arrowLineString.get(j);
+            if (arrowCoord) {
+                const coords = Array.from(arrowCoord);
+                lineString.push(coords);
+            }
+        }
+        multiLineString.push(lineString);
     }
-    multiLineString.push(lineString);
-  }
-  return {
-    type: 'MultiLineString',
-    coordinates: multiLineString
-  };
+    return {
+        type: 'MultiLineString',
+        coordinates: multiLineString
+    };
 }
+/**
+ * convert Arrow LineString to geojson LineString
+ */
 function arrowLineStringToFeature(arrowLineString) {
-  const lineString = [];
-  for (let i = 0; arrowLineString && i < arrowLineString.length; i++) {
-    const arrowCoord = arrowLineString.get(i);
-    if (arrowCoord) {
-      const coords = Array.from(arrowCoord);
-      lineString.push(coords);
+    const lineString = [];
+    for (let i = 0; arrowLineString && i < arrowLineString.length; i++) {
+        const arrowCoord = arrowLineString.get(i);
+        if (arrowCoord) {
+            const coords = Array.from(arrowCoord);
+            lineString.push(coords);
+        }
     }
-  }
-  return {
-    type: 'LineString',
-    coordinates: lineString
-  };
+    return {
+        type: 'LineString',
+        coordinates: lineString
+    };
 }
-//# sourceMappingURL=convert-geoarrow-to-geojson-geometry.js.map

package/dist/geoarrow/get-arrow-bounds.js

@@ -1,24 +1,34 @@
-export function updateBoundsFromGeoArrowSamples(flatCoords, nDim, bounds) {
-  let sampleSize = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 100;
-  const numberOfFeatures = flatCoords.length / nDim;
-  const sampleStep = Math.max(Math.floor(numberOfFeatures / sampleSize), 1);
-  const newBounds = [...bounds];
-  for (let i = 0; i < numberOfFeatures; i += sampleStep) {
-    const lng = flatCoords[i * nDim];
-    const lat = flatCoords[i * nDim + 1];
-    if (lng < newBounds[0]) {
-      newBounds[0] = lng;
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/**
+ *  Update bounds from geoarrow sample data
+ *
+ * @param flatCoords the flattend coordinates array from one chunk of geoarrow column
+ * @param nDim the number of dimensions of the coordinates
+ * @param bounds the bounds to be updated
+ * @param sampleSize how many samples to be used to update the bounds, default is 1000 per chunk
+ * @returns the updated bounds
+ */
+export function updateBoundsFromGeoArrowSamples(flatCoords, nDim, bounds, sampleSize = 100) {
+    const numberOfFeatures = flatCoords.length / nDim;
+    const sampleStep = Math.max(Math.floor(numberOfFeatures / sampleSize), 1);
+    const newBounds = [...bounds];
+    for (let i = 0; i < numberOfFeatures; i += sampleStep) {
+        const lng = flatCoords[i * nDim];
+        const lat = flatCoords[i * nDim + 1];
+        if (lng < newBounds[0]) {
+            newBounds[0] = lng;
+        }
+        if (lat < newBounds[1]) {
+            newBounds[1] = lat;
+        }
+        if (lng > newBounds[2]) {
+            newBounds[2] = lng;
+        }
+        if (lat > newBounds[3]) {
+            newBounds[3] = lat;
+        }
     }
-    if (lat < newBounds[1]) {
-      newBounds[1] = lat;
-    }
-    if (lng > newBounds[2]) {
-      newBounds[2] = lng;
-    }
-    if (lat > newBounds[3]) {
-      newBounds[3] = lat;
-    }
-  }
-  return newBounds;
+    return newBounds;
 }
-//# sourceMappingURL=get-arrow-bounds.js.map

package/dist/geoarrow-loader.d.ts

@@ -1,6 +1,6 @@
 import type { Loader, LoaderWithParser, LoaderOptions } from '@loaders.gl/loader-utils';
 import type { GeoJSONTable, GeoJSONTableBatch, BinaryGeometry } from '@loaders.gl/schema';
-import type { ArrowTable, ArrowTableBatch } from './lib/arrow-table';
+import type { ArrowTable, ArrowTableBatch } from "./lib/arrow-table.js";
 export type GeoArrowLoaderOptions = LoaderOptions & {
     arrow?: {
         shape: 'arrow-table' | 'binary-geometry';

package/dist/geoarrow-loader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geoarrow-loader.d.ts","sourceRoot":"","sources":["../src/geoarrow-loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,MAAM,EAAE,gBAAgB,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAEtF,OAAO,KAAK,EAAC,YAAY,EAAE,iBAAiB,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AACxF,OAAO,KAAK,EAAC,UAAU,EAAE,eAAe,EAAC,MAAM,mBAAmB,CAAC;AAInE,MAAM,MAAM,qBAAqB,GAAG,aAAa,GAAG;IAClD,KAAK,CAAC,EAAE;QACN,KAAK,EAAE,aAAa,GAAG,iBAAiB,CAAC;KAC1C,CAAC;CACH,CAAC;AAEF,2BAA2B;AAC3B,eAAO,MAAM,oBAAoB,EAAE,MAAM,CACvC,UAAU,GAAG,cAAc,EAC3B,KAAK,EACL,qBAAqB,CAQtB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,gBAAgB,CAC3C,UAAU,GAAG,YAAY,EAAE,oBAAoB;AAC/C,AAD2B,oBAAoB;AAC/C,eAAe,GAAG,iBAAiB,EAAE,oBAAoB;AACzD,qBAAqB,CAatB,CAAC"}
+{"version":3,"file":"geoarrow-loader.d.ts","sourceRoot":"","sources":["../src/geoarrow-loader.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,MAAM,EAAE,gBAAgB,EAAE,aAAa,EAAC,MAAM,0BAA0B,CAAC;AAEtF,OAAO,KAAK,EAAC,YAAY,EAAE,iBAAiB,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AACxF,OAAO,KAAK,EAAC,UAAU,EAAE,eAAe,EAAC,6BAA0B;AAInE,MAAM,MAAM,qBAAqB,GAAG,aAAa,GAAG;IAClD,KAAK,CAAC,EAAE;QACN,KAAK,EAAE,aAAa,GAAG,iBAAiB,CAAC;KAC1C,CAAC;CACH,CAAC;AAEF,2BAA2B;AAC3B,eAAO,MAAM,oBAAoB,EAAE,MAAM,CACvC,UAAU,GAAG,cAAc,EAC3B,KAAK,EACL,qBAAqB,CAQtB,CAAC;AAEF;;;GAGG;AACH,eAAO,MAAM,cAAc,EAAE,gBAAgB,CAC3C,UAAU,GAAG,YAAY,EAAE,oBAAoB;AAC/C,AAD2B,oBAAoB;AAC/C,eAAe,GAAG,iBAAiB,EAAE,oBAAoB;AACzD,qBAAqB,CAatB,CAAC"}

package/dist/geoarrow-loader.js

@@ -1,23 +1,30 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { ArrowWorkerLoader } from "./arrow-loader.js";
 import { parseGeoArrowSync } from "./parsers/parse-geoarrow-sync.js";
 import { parseGeoArrowInBatches } from "./parsers/parse-geoarrow-in-batches.js";
+/** ArrowJS table loader */
 export const GeoArrowWorkerLoader = {
-  ...ArrowWorkerLoader,
-  options: {
-    arrow: {
-      shape: 'arrow-table'
+    ...ArrowWorkerLoader,
+    options: {
+        arrow: {
+            shape: 'arrow-table'
+        }
     }
-  }
 };
+/**
+ * GeoArrowLoader loads an Apache Arrow table, parses GeoArrow type extension data
+ * to convert it to a GeoJSON table or a BinaryGeometry
+ */
 export const GeoArrowLoader = {
-  ...ArrowWorkerLoader,
-  options: {
-    arrow: {
-      shape: 'arrow-table'
-    }
-  },
-  parse: async (arraybuffer, options) => parseGeoArrowSync(arraybuffer, options === null || options === void 0 ? void 0 : options.arrow),
-  parseSync: (arraybuffer, options) => parseGeoArrowSync(arraybuffer, options === null || options === void 0 ? void 0 : options.arrow),
-  parseInBatches: parseGeoArrowInBatches
+    ...ArrowWorkerLoader,
+    options: {
+        arrow: {
+            shape: 'arrow-table'
+        }
+    },
+    parse: async (arraybuffer, options) => parseGeoArrowSync(arraybuffer, options?.arrow),
+    parseSync: (arraybuffer, options) => parseGeoArrowSync(arraybuffer, options?.arrow),
+    parseInBatches: parseGeoArrowInBatches
 };
-//# sourceMappingURL=geoarrow-loader.js.map

package/dist/geoarrow-writer.js

@@ -1,19 +1,28 @@
+// import type {} from '@loaders.gl/loader-utils';
 import { encodeGeoArrowSync } from "./lib/encode-geoarrow.js";
-const VERSION = typeof "4.2.0-alpha.4" !== 'undefined' ? "4.2.0-alpha.4" : 'latest';
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof "4.2.0-alpha.5" !== 'undefined' ? "4.2.0-alpha.5" : 'latest';
+/** Apache Arrow writer */
 export const GeoArrowWriter = {
-  name: 'Apache Arrow',
-  id: 'arrow',
-  module: 'arrow',
-  version: VERSION,
-  extensions: ['arrow', 'feather'],
-  mimeTypes: ['application/vnd.apache.arrow.file', 'application/vnd.apache.arrow.stream', 'application/octet-stream'],
-  binary: true,
-  options: {},
-  encode: async function encodeArrow(data, options) {
-    return encodeGeoArrowSync(data);
-  },
-  encodeSync(data, options) {
-    return encodeGeoArrowSync(data);
-  }
+    name: 'Apache Arrow',
+    id: 'arrow',
+    module: 'arrow',
+    version: VERSION,
+    extensions: ['arrow', 'feather'],
+    mimeTypes: [
+        'application/vnd.apache.arrow.file',
+        'application/vnd.apache.arrow.stream',
+        'application/octet-stream'
+    ],
+    binary: true,
+    options: {},
+    encode: async function encodeArrow(data, options) {
+        // @ts-expect-error
+        return encodeGeoArrowSync(data);
+    },
+    encodeSync(data, options) {
+        // @ts-expect-error
+        return encodeGeoArrowSync(data);
+    }
 };
-//# sourceMappingURL=geoarrow-writer.js.map