@loaders.gl/arrow 4.3.0-alpha.7 → 4.3.0-beta.1

package/src/exports/arrow-loader.ts

@@ -0,0 +1,49 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {Loader, LoaderOptions} from '@loaders.gl/loader-utils';
+import type {ArrowTable} from '../schema/arrow-table-type';
+
+// __VERSION__ is injected by babel-plugin-version-inline
+// @ts-ignore TS2304: Cannot find name '__VERSION__'.
+const VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';
+
+/** ArrowLoader options */
+export type ArrowLoaderOptions = LoaderOptions & {
+  /** ArrowLoader options */
+  arrow?: {
+    /** Shape of returned data */
+    shape: 'arrow-table' | 'columnar-table' | 'array-row-table' | 'object-row-table';
+    /** Debounce time between batches (prevent excessive numbers of small batches) */
+    batchDebounceMs?: number;
+    /** Override the URL to the worker bundle (by default loads from unpkg.com) */
+    workerUrl?: string;
+  };
+};
+
+/** ArrowJS table loader */
+export const ArrowWorkerLoader = {
+  dataType: null as unknown as ArrowTable,
+  batchType: null as never,
+
+  name: 'Apache Arrow',
+  id: 'arrow',
+  module: 'arrow',
+  version: VERSION,
+  // worker: true,
+  category: 'table',
+  extensions: ['arrow', 'feather'],
+  mimeTypes: [
+    'application/vnd.apache.arrow.file',
+    'application/vnd.apache.arrow.stream',
+    'application/octet-stream'
+  ],
+  binary: true,
+  tests: ['ARROW'],
+  options: {
+    arrow: {
+      shape: 'columnar-table'
+    }
+  }
+} as const satisfies Loader<ArrowTable, never, ArrowLoaderOptions>;

package/src/exports/geoarrow-loader.ts

@@ -0,0 +1,24 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {Loader, LoaderOptions} from '@loaders.gl/loader-utils';
+import {ArrowWorkerLoader} from './arrow-loader';
+import type {BinaryGeometry} from '@loaders.gl/schema';
+import type {ArrowTable, ArrowTableBatch} from '../schema/arrow-table-type';
+
+export type GeoArrowLoaderOptions = LoaderOptions & {
+  arrow?: {
+    shape?: 'arrow-table' | 'binary-geometry';
+  };
+};
+
+/** ArrowJS table loader */
+export const GeoArrowWorkerLoader = {
+  ...ArrowWorkerLoader,
+  options: {
+    arrow: {
+      shape: 'arrow-table'
+    }
+  }
+} as const satisfies Loader<ArrowTable | BinaryGeometry, ArrowTableBatch, GeoArrowLoaderOptions>;

package/src/geoarrow-loader.ts

@@ -2,28 +2,12 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {Loader, LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
-import {ArrowWorkerLoader} from './arrow-loader';
-import type {GeoJSONTable, GeoJSONTableBatch, BinaryGeometry} from '@loaders.gl/schema';
-import type {ArrowTable, ArrowTableBatch} from './lib/arrow-table';
-import {parseGeoArrowSync} from './parsers/parse-geoarrow-sync';
-import {parseGeoArrowInBatches} from './parsers/parse-geoarrow-in-batches';
-
-export type GeoArrowLoaderOptions = LoaderOptions & {
-  arrow?: {
-    shape?: 'arrow-table' | 'binary-geometry';
-  };
-};
-
-/** ArrowJS table loader */
-export const GeoArrowWorkerLoader = {
-  ...ArrowWorkerLoader,
-  options: {
-    arrow: {
-      shape: 'arrow-table'
-    }
-  }
-} as const satisfies Loader<ArrowTable | BinaryGeometry, never, GeoArrowLoaderOptions>;
+import type {LoaderWithParser} from '@loaders.gl/loader-utils';
+import type {GeoJSONTable, GeoJSONTableBatch} from '@loaders.gl/schema';
+import type {ArrowTable, ArrowTableBatch} from './schema/arrow-table-type';
+import {parseGeoArrowSync, parseGeoArrowInBatches} from './lib/parsers/parse-geoarrow';
+import type {GeoArrowLoaderOptions} from './exports/geoarrow-loader';
+import {GeoArrowWorkerLoader} from './exports/geoarrow-loader';
 
 /**
  * GeoArrowLoader loads an Apache Arrow table, parses GeoArrow type extension data

package/src/geoarrow-writer.ts

@@ -2,7 +2,7 @@
 
 import type {WriterWithEncoder, WriterOptions} from '@loaders.gl/loader-utils';
 import {GeoJSONTable, BinaryGeometry} from '@loaders.gl/schema';
-import {encodeGeoArrowSync} from './lib/encode-geoarrow';
+import {encodeGeoArrowSync} from './lib/encoders/encode-geoarrow';
 
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.

package/src/index.ts

@@ -2,35 +2,33 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {ArrowLoaderOptions} from './arrow-loader';
-import {TableBatchBuilder} from '@loaders.gl/schema';
-import {ArrowTableBatchAggregator} from './lib/arrow-table-batch';
+// Types
+export type {ArrowTable, ArrowTableBatch} from './schema/arrow-table-type';
+export {VECTOR_TYPES} from './lib/types';
+import {ArrowTableBatchAggregator} from './schema/arrow-table-batch';
 
 // Make the ArrowBatch type available
+import {TableBatchBuilder} from '@loaders.gl/schema';
 TableBatchBuilder.ArrowBatch = ArrowTableBatchAggregator;
 
-// TYPES
-
-export {getArrowType} from './schema/arrow-type-utils';
-
-// SCHEMA
-
-// Types
-export type {ArrowTable, ArrowTableBatch} from './lib/arrow-table';
-export {VECTOR_TYPES} from './types';
-
 // Arrow loader / Writer
 
-export type {ArrowLoaderOptions};
-export {ArrowLoader, ArrowWorkerLoader} from './arrow-loader';
+export type {ArrowLoaderOptions} from './exports/arrow-loader';
+export {ArrowWorkerLoader} from './exports/arrow-loader';
+export {ArrowLoader} from './arrow-loader';
 
 export {ArrowWriter} from './arrow-writer';
 
 // Geoarrow loader
-export {GeoArrowLoader, GeoArrowWorkerLoader} from './geoarrow-loader';
+export {GeoArrowWorkerLoader} from './exports/geoarrow-loader';
+export {GeoArrowLoader} from './geoarrow-loader';
 
 // Schema utils
 export {
+  convertArrowToSchema,
+  convertSchemaToArrow,
+
+  // DETAILED FUNCTIONS
   serializeArrowSchema,
   deserializeArrowSchema,
   serializeArrowMetadata,
@@ -39,7 +37,11 @@ export {
   deserializeArrowField,
   serializeArrowType,
   deserializeArrowType
-} from './schema/convert-arrow-schema';
+} from './lib//tables/convert-arrow-schema';
+
+// Table utils
+export {convertArrowToTable} from './lib/tables/convert-arrow-to-table';
+export {convertTableToArrow} from './lib/tables/convert-table-to-arrow';
 
 // EXPERIMENTAL
 
@@ -51,19 +53,17 @@ export type {GeoArrowEncoding} from '@loaders.gl/gis';
 export type {
   BinaryDataFromGeoArrow,
   BinaryGeometriesFromArrowOptions
-} from './geoarrow/convert-geoarrow-to-binary-geometry';
+} from './lib/geoarrow/convert-geoarrow-to-binary-geometry';
 export {
   getBinaryGeometryTemplate,
   getBinaryGeometriesFromArrow,
   getTriangleIndices,
   getMeanCentersFromBinaryGeometries
-} from './geoarrow/convert-geoarrow-to-binary-geometry';
-
-export {updateBoundsFromGeoArrowSamples} from './geoarrow/get-arrow-bounds';
+} from './lib/geoarrow/convert-geoarrow-to-binary-geometry';
 
-export {parseGeometryFromArrow} from './geoarrow/convert-geoarrow-to-geojson-geometry';
+export {updateBoundsFromGeoArrowSamples} from './lib/geoarrow/get-arrow-bounds';
 
-export {convertArrowToGeoJSONTable} from './tables/convert-arrow-to-geojson-table';
+export {parseGeometryFromArrow} from './lib/geoarrow/convert-geoarrow-to-geojson-geometry';
 
 // EXPERIMENTAL WORKER
 export {hardClone} from './workers/hard-clone';

package/src/{parsers/parse-arrow-in-batches.ts → lib/parsers/parse-arrow.ts}

@@ -2,13 +2,19 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {ArrowTableBatch} from '../lib/arrow-table';
 import * as arrow from 'apache-arrow';
-import {ArrowLoaderOptions} from '../arrow-loader';
-// import {isIterable} from '@loaders.gl/core';
+import type {Table} from '@loaders.gl/schema';
+import type {ArrowTableBatch} from '../../schema/arrow-table-type';
+import {ArrowLoaderOptions} from '../../exports/arrow-loader';
+import {convertArrowToTable} from '../tables/convert-arrow-to-table';
+
+/** Parses arrow to a loaders.gl table. Defaults to `arrow-table` */
+export function parseArrowSync(arrayBuffer, options?: {shape?: Table['shape']}): Table {
+  const shape = options?.shape || 'arrow-table';
+  const arrowTable = arrow.tableFromIPC([new Uint8Array(arrayBuffer)]);
+  return convertArrowToTable(arrowTable, shape);
+}
 
-/**
- */
 export function parseArrowInBatches(
   asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>,
   options?: ArrowLoaderOptions

package/src/lib/parsers/parse-geoarrow.ts

@@ -0,0 +1,32 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import type {GeoJSONTable, GeoJSONTableBatch} from '@loaders.gl/schema';
+import type {ArrowTable, ArrowTableBatch} from '../../schema/arrow-table-type';
+import {parseArrowSync, parseArrowInBatches} from './parse-arrow';
+import {convertArrowToTable} from '../tables/convert-arrow-to-table';
+
+// Parses arrow to a columnar table
+export function parseGeoArrowSync(
+  arrayBuffer,
+  options?: {shape?: 'arrow-table' | 'geojson-table' | 'binary-geometry'}
+): ArrowTable | GeoJSONTable {
+  // | BinaryGeometry
+  const table = parseArrowSync(arrayBuffer, {shape: 'arrow-table'}) as ArrowTable;
+  switch (options?.shape) {
+    case 'geojson-table':
+      return convertArrowToTable(table.data, 'geojson-table');
+    default:
+      return table;
+  }
+}
+
+/**
+ */
+export function parseGeoArrowInBatches(
+  asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>
+): AsyncIterable<ArrowTableBatch | GeoJSONTableBatch> {
+  // | BinaryGeometry
+  return parseArrowInBatches(asyncIterator);
+}

package/src/{schema → lib/tables}/convert-arrow-schema.ts

@@ -5,6 +5,16 @@
 import type {DataType, Field, Schema, SchemaMetadata} from '@loaders.gl/schema';
 import * as arrow from 'apache-arrow';
 
+/** Convert Apache Arrow Schema (class instance) to a serialized Schema (plain data) */
+export function convertArrowToSchema(arrowSchema: arrow.Schema): Schema {
+  return serializeArrowSchema(arrowSchema);
+}
+
+/** Convert Apache Arrow Schema (class instance) to a serialized Schema (plain data) */
+export function convertSchemaToArrow(schema: Schema): arrow.Schema {
+  return deserializeArrowSchema(schema);
+}
+
 /** Convert Apache Arrow Schema (class instance) to a serialized Schema (plain data) */
 export function serializeArrowSchema(arrowSchema: arrow.Schema): Schema {
   return {

package/src/lib/tables/convert-arrow-to-table.ts

@@ -0,0 +1,144 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import * as arrow from 'apache-arrow';
+import type {
+  Table,
+  ArrayRowTable,
+  ColumnarTable,
+  ObjectRowTable,
+  GeoJSONTable,
+  Feature
+} from '@loaders.gl/schema';
+import type {ArrowTable} from '../../schema/arrow-table-type';
+
+import {convertTable} from '@loaders.gl/schema';
+import {getGeometryColumnsFromSchema} from '@loaders.gl/gis';
+import {convertArrowToSchema} from '../tables/convert-arrow-schema';
+import {parseGeometryFromArrow} from '../geoarrow/convert-geoarrow-to-geojson-geometry';
+
+/**
+ * Convert an Apache Arrow table to a loaders.gl Table
+ * @note Currently does not convert schema
+ */
+export function convertArrowToTable(arrow: arrow.Table, shape: 'arrow-table'): ArrowTable;
+export function convertArrowToTable(arrow: arrow.Table, shape: 'columnar-table'): ColumnarTable;
+export function convertArrowToTable(arrow: arrow.Table, shape: 'object-row-table'): ObjectRowTable;
+export function convertArrowToTable(arrow: arrow.Table, shape: 'array-row-table'): ArrayRowTable;
+export function convertArrowToTable(arrow: arrow.Table, shape: 'geojson-table'): GeoJSONTable;
+export function convertArrowToTable(arrow: arrow.Table, shape: 'columnar-table'): ColumnarTable;
+export function convertArrowToTable(arrow: arrow.Table, shape: Table['shape']): Table;
+
+/**
+ * Convert an Apache Arrow table to a loaders.gl Table
+ * @note Currently does not convert schema
+ */
+export function convertArrowToTable(arrowTable: arrow.Table, shape: Table['shape']): Table {
+  switch (shape) {
+    case 'arrow-table':
+      return convertArrowToArrowTable(arrowTable);
+    case 'array-row-table':
+      return convertArrowToArrayRowTable(arrowTable);
+    case 'object-row-table':
+      return convertArrowToObjectRowTable(arrowTable);
+    case 'columnar-table':
+      return convertArrowToColumnarTable(arrowTable);
+    case 'geojson-table':
+      return convertArrowToGeoJSONTable(arrowTable);
+    default:
+      throw new Error(shape);
+  }
+}
+
+/**
+ * Wrap an apache arrow table in a loaders.gl table wrapper.
+ * From this additional conversions are available.
+ * @param arrowTable
+ * @returns
+ */
+function convertArrowToArrowTable(arrowTable: arrow.Table): ArrowTable {
+  return {
+    shape: 'arrow-table',
+    schema: convertArrowToSchema(arrowTable.schema),
+    data: arrowTable
+  };
+}
+
+function convertArrowToArrayRowTable(arrowTable: arrow.Table): Table {
+  const columnarTable = convertArrowToColumnarTable(arrowTable);
+  return convertTable(columnarTable, 'array-row-table');
+}
+
+function convertArrowToObjectRowTable(arrowTable: arrow.Table): Table {
+  const columnarTable = convertArrowToColumnarTable(arrowTable);
+  return convertTable(columnarTable, 'object-row-table');
+}
+
+/**
+ * Convert an Apache Arrow table to a ColumnarTable
+ * @note Currently does not convert schema
+ */
+function convertArrowToColumnarTable(arrowTable: arrow.Table): ColumnarTable {
+  // TODO - avoid calling `getColumn` on columns we are not interested in?
+  // Add options object?
+
+  const columns: ColumnarTable['data'] = {};
+
+  for (const field of arrowTable.schema.fields) {
+    // This (is intended to) coalesce all record batches into a single typed array
+    const arrowColumn = arrowTable.getChild(field.name);
+    const values = arrowColumn?.toArray();
+    columns[field.name] = values;
+  }
+
+  const schema = convertArrowToSchema(arrowTable.schema);
+
+  return {
+    shape: 'columnar-table',
+    schema,
+    data: columns
+  };
+}
+
+/**
+ * Convert an Apache Arrow table to a GeoJSONTable
+ * @note Currently does not convert schema
+ */
+function convertArrowToGeoJSONTable(arrowTable: arrow.Table): GeoJSONTable {
+  const schema = convertArrowToSchema(arrowTable.schema);
+  const geometryColumns = getGeometryColumnsFromSchema(schema);
+
+  // get encoding from geometryColumns['geometry']
+  const encoding = geometryColumns.geometry.encoding;
+
+  const features: Feature[] = [];
+
+  // Remove geometry columns
+  const propertyColumnNames = arrowTable.schema.fields
+    .map((field) => field.name)
+    // TODO - this deletes all geometry columns
+    .filter((name) => !(name in geometryColumns));
+  const propertiesTable = arrowTable.select(propertyColumnNames);
+
+  const arrowGeometryColumn = arrowTable.getChild('geometry');
+
+  for (let row = 0; row < arrowTable.numRows; row++) {
+    // get the geometry value from arrow geometry column
+    // Note that type can vary
+    const arrowGeometry = arrowGeometryColumn?.get(row);
+    // parse arrow geometry to geojson feature
+    const feature = parseGeometryFromArrow(arrowGeometry, encoding);
+    if (feature) {
+      const properties = propertiesTable.get(row)?.toJSON() || {};
+      features.push({type: 'Feature', geometry: feature, properties});
+    }
+  }
+
+  return {
+    shape: 'geojson-table',
+    type: 'FeatureCollection',
+    schema,
+    features
+  };
+}

package/src/lib/tables/convert-table-to-arrow.ts

@@ -0,0 +1,72 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+
+import * as arrow from 'apache-arrow';
+import {Table, getTableLength, getTableNumCols, getTableCellAt} from '@loaders.gl/schema';
+import {deserializeArrowSchema} from '../tables/convert-arrow-schema';
+
+/**
+ * * Convert a loaders.gl Table to an Apache Arrow Table
+ * @param mesh
+ * @param metadata
+ * @param batchSize
+ * @returns
+ */
+export function convertTableToArrow(table: Table, options?: {batchSize?: number}): arrow.Table {
+  switch (table.shape) {
+    case 'arrow-table':
+      return table.data as arrow.Table;
+
+    case 'columnar-table':
+    // TODO - optimized implementation is possible
+    // return convertColumnarTableToArrow(table, options);
+
+    // fall through
+
+    default:
+      const arrowBatchIterator = makeTableToArrowBatchesIterator(table, options);
+      return new arrow.Table(arrowBatchIterator);
+  }
+}
+
+export function* makeTableToArrowBatchesIterator(
+  table: Table,
+  options?: {batchSize?: number}
+): IterableIterator<arrow.RecordBatch> {
+  const arrowSchema = deserializeArrowSchema(table.schema!);
+
+  const length = getTableLength(table);
+  const numColumns = getTableNumCols(table);
+  const batchSize = options?.batchSize || length;
+
+  const builders = arrowSchema?.fields.map((arrowField) => arrow.makeBuilder(arrowField));
+  const structField = new arrow.Struct(arrowSchema.fields);
+
+  let batchLength = 0;
+  for (let rowIndex = 0; rowIndex < length; rowIndex++) {
+    for (let columnIndex = 0; columnIndex < numColumns; ++columnIndex) {
+      const value = getTableCellAt(table, rowIndex, columnIndex);
+
+      const builder = builders[columnIndex];
+      builder.append(value);
+      batchLength++;
+
+      if (batchLength >= batchSize) {
+        const datas = builders.map((builder) => builder.flush());
+        const structData = new arrow.Data(structField, 0, batchLength, 0, undefined, datas);
+        yield new arrow.RecordBatch(arrowSchema, structData);
+        batchLength = 0;
+      }
+    }
+  }
+
+  if (batchLength > 0) {
+    const datas = builders.map((builder) => builder.flush());
+    const structData = new arrow.Data(structField, 0, batchLength, 0, undefined, datas);
+    yield new arrow.RecordBatch(arrowSchema, structData);
+    batchLength = 0;
+  }
+
+  builders.map((builder) => builder.finish());
+}

package/src/{lib → schema}/arrow-table-batch.ts

@@ -3,9 +3,10 @@
 // Copyright (c) vis.gl contributors
 
 import {ColumnarTableBatchAggregator} from '@loaders.gl/schema';
-import type {ArrowTableBatch} from './arrow-table';
+import type {ArrowTableBatch} from './arrow-table-type';
 import * as arrow from 'apache-arrow';
 
+/** @note Should be part of @loaders.gl/schema - kept separate to avoid hard arrow dependency */
 export class ArrowTableBatchAggregator extends ColumnarTableBatchAggregator {
   arrowSchema: arrow.Schema | null;
 

package/src/{lib/arrow-table.ts → schema/arrow-table-type.ts}

@@ -8,6 +8,7 @@ import type * as arrow from 'apache-arrow';
 /**
  * A table organized as an Apache Arrow table
  * @note This is a variant of the type from loaders.gl/schema
+ * @note Should be part of @loaders.gl/schema - kept separate to avoid hard arrow dependency
  */
 export type ArrowTable = {
   shape: 'arrow-table';
@@ -18,6 +19,7 @@ export type ArrowTable = {
 /**
  * Batch for a table organized as an Apache Arrow table
  * @note This is a variant of the type from loaders.gl/schema
+ * @note Should be part of @loaders.gl/schema - kept separate to avoid hard arrow dependency
  */
 export type ArrowTableBatch = Batch & {
   shape: 'arrow-table';

package/src/workers/triangulation-worker.ts

@@ -8,7 +8,7 @@ import {
   getTriangleIndices,
   getBinaryGeometriesFromArrow,
   BinaryDataFromGeoArrow
-} from '../geoarrow/convert-geoarrow-to-binary-geometry';
+} from '../lib/geoarrow/convert-geoarrow-to-binary-geometry';
 import type {
   TriangulationWorkerInput,
   TriangulateInput,

package/dist/geoarrow/convert-geoarrow-to-binary-geometry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"convert-geoarrow-to-binary-geometry.d.ts","sourceRoot":"","sources":["../../src/geoarrow/convert-geoarrow-to-binary-geometry.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,OAAO,EAAC,uBAAuB,IAAI,cAAc,EAAC,MAAM,oBAAoB,CAAC;AAC7E,OAAO,EAAC,gBAAgB,EAAC,MAAM,iBAAiB,CAAC;AAajD;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,oEAAoE;IACpE,gBAAgB,EAAE,cAAc,EAAE,CAAC;IACnC,wCAAwC;IACxC,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,6CAA6C;IAC7C,YAAY,EAAE;QAAC,OAAO,EAAE,OAAO,CAAC;QAAC,KAAK,EAAE,OAAO,CAAC;QAAC,IAAI,EAAE,OAAO,CAAA;KAAC,CAAC;IAChE,kFAAkF;IAClF,WAAW,CAAC,EAAE,MAAM,EAAE,EAAE,CAAC;CAC1B,CAAC;AAsBF;;GAEG;AACH,wBAAgB,yBAAyB;;;;;;;;;;;;;;;EAQxC;AAED,MAAM,MAAM,gCAAgC,GAAG;IAC7C,6FAA6F;IAC7F,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,mHAAmH;IACnH,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,wEAAwE;IACxE,oBAAoB,CAAC,EAAE,OAAO,CAAC;IAC/B,qEAAqE;IACrE,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB,CAAC;AAEF;;;;;;;GAOG;AACH,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,KAAK,CAAC,MAAM,EACvB,WAAW,EAAE,gBAAgB,EAC7B,OAAO,CAAC,EAAE,gCAAgC,GACzC,sBAAsB,CAiFxB;AAED;;;;GAIG;AACH,wBAAgB,kCAAkC,CAAC,gBAAgB,EAAE,cAAc,EAAE,GAAG,MAAM,EAAE,EAAE,CAiCjG;AA2ED;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAChC,cAAc,EAAE,WAAW,EAC3B,uBAAuB,EAAE,UAAU,EACnC,mBAAmB,EAAE,YAAY,EACjC,IAAI,EAAE,MAAM,GACX,WAAW,GAAG,IAAI,CAyCpB"}

package/dist/geoarrow/convert-geoarrow-to-geojson-geometry.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"convert-geoarrow-to-geojson-geometry.d.ts","sourceRoot":"","sources":["../../src/geoarrow/convert-geoarrow-to-geojson-geometry.ts"],"names":[],"mappings":"AAKA,OAAO,EAQL,QAAQ,EAET,MAAM,oBAAoB,CAAC;AAC5B,OAAO,EAAmB,KAAK,gBAAgB,EAAC,MAAM,iBAAiB,CAAC;AAGxE;;;;;;;;GAQG;AACH,wBAAgB,sBAAsB,CACpC,cAAc,EAAE,GAAG,EACnB,QAAQ,CAAC,EAAE,gBAAgB,GAC1B,QAAQ,GAAG,IAAI,CAwCjB"}

package/dist/geoarrow/get-arrow-bounds.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"get-arrow-bounds.d.ts","sourceRoot":"","sources":["../../src/geoarrow/get-arrow-bounds.ts"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,wBAAgB,+BAA+B,CAC7C,UAAU,EAAE,YAAY,EACxB,IAAI,EAAE,MAAM,EACZ,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,EACxC,UAAU,GAAE,MAAY,GACvB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAsBlC"}

package/dist/lib/arrow-table-batch.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"arrow-table-batch.d.ts","sourceRoot":"","sources":["../../src/lib/arrow-table-batch.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,4BAA4B,EAAC,MAAM,oBAAoB,CAAC;AAChE,OAAO,KAAK,EAAC,eAAe,EAAC,yBAAsB;AACnD,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,qBAAa,yBAA0B,SAAQ,4BAA4B;IACzE,WAAW,EAAE,KAAK,CAAC,MAAM,GAAG,IAAI,CAAC;gBAErB,MAAM,KAAA,EAAE,OAAO,KAAA;IAK3B,QAAQ,IAAI,eAAe,GAAG,IAAI;CA4BnC"}

package/dist/lib/arrow-table.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"arrow-table.d.ts","sourceRoot":"","sources":["../../src/lib/arrow-table.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,KAAK,EAAE,MAAM,EAAC,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAC;AAE3C;;;GAGG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,aAAa,CAAC;IACrB,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC;CACnB,CAAC;AAEF;;;GAGG;AACH,MAAM,MAAM,eAAe,GAAG,KAAK,GAAG;IACpC,KAAK,EAAE,aAAa,CAAC;IACrB,UAAU,CAAC,EAAE,UAAU,GAAG,SAAS,CAAC;IACpC,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,IAAI,EAAE,KAAK,CAAC,KAAK,CAAC;IAClB,MAAM,EAAE,MAAM,CAAC;CAChB,CAAC"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"encode-arrow.d.ts","sourceRoot":"","sources":["../../src/lib/encode-arrow.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,YAAY,EAAe,oBAAiB;AAEpD,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,YAAY,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd,EAAE,CAAC;AAEJ;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,aAAa,GAAG,WAAW,CAShE"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"encode-geoarrow.d.ts","sourceRoot":"","sources":["../../src/lib/encode-geoarrow.ts"],"names":[],"mappings":"AAKA,OAAO,EAAC,YAAY,EAAe,oBAAiB;AAEpD,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,YAAY,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;CACd,EAAE,CAAC;AAEJ;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,aAAa,GAAG,WAAW,CASnE"}

package/dist/parsers/parse-arrow-in-batches.d.ts

@@ -1,6 +0,0 @@
-import type { ArrowTableBatch } from "../lib/arrow-table.js";
-import { ArrowLoaderOptions } from "../arrow-loader.js";
-/**
- */
-export declare function parseArrowInBatches(asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>, options?: ArrowLoaderOptions): AsyncIterable<ArrowTableBatch>;
-//# sourceMappingURL=parse-arrow-in-batches.d.ts.map

package/dist/parsers/parse-arrow-in-batches.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse-arrow-in-batches.d.ts","sourceRoot":"","sources":["../../src/parsers/parse-arrow-in-batches.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,eAAe,EAAC,8BAA2B;AAExD,OAAO,EAAC,kBAAkB,EAAC,2BAAwB;AAGnD;GACG;AACH,wBAAgB,mBAAmB,CACjC,aAAa,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,QAAQ,CAAC,WAAW,CAAC,EACjE,OAAO,CAAC,EAAE,kBAAkB,GAC3B,aAAa,CAAC,eAAe,CAAC,CA0ChC"}

package/dist/parsers/parse-arrow-sync.d.ts

@@ -1,6 +0,0 @@
-import type { ArrayRowTable, ColumnarTable, ObjectRowTable } from '@loaders.gl/schema';
-import type { ArrowTable } from "../lib/arrow-table.js";
-export declare function parseArrowSync(arrayBuffer: any, options?: {
-    shape?: 'arrow-table' | 'columnar-table' | 'object-row-table' | 'array-row-table';
-}): ArrowTable | ColumnarTable | ObjectRowTable | ArrayRowTable;
-//# sourceMappingURL=parse-arrow-sync.d.ts.map

package/dist/parsers/parse-arrow-sync.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse-arrow-sync.d.ts","sourceRoot":"","sources":["../../src/parsers/parse-arrow-sync.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,aAAa,EAAE,aAAa,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AACrF,OAAO,KAAK,EAAC,UAAU,EAAC,8BAA2B;AAOnD,wBAAgB,cAAc,CAC5B,WAAW,KAAA,EACX,OAAO,CAAC,EAAE;IAAC,KAAK,CAAC,EAAE,aAAa,GAAG,gBAAgB,GAAG,kBAAkB,GAAG,iBAAiB,CAAA;CAAC,GAC5F,UAAU,GAAG,aAAa,GAAG,cAAc,GAAG,aAAa,CA4B7D"}

package/dist/parsers/parse-arrow-sync.js

@@ -1,32 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-import { convertTable } from '@loaders.gl/schema';
-import * as arrow from 'apache-arrow';
-import { convertArrowToColumnarTable } from "../tables/convert-arrow-to-columnar-table.js";
-import { serializeArrowSchema } from "../schema/convert-arrow-schema.js";
-// Parses arrow to a columnar table
-export function parseArrowSync(arrayBuffer, options) {
-    const apacheArrowTable = arrow.tableFromIPC([new Uint8Array(arrayBuffer)]);
-    const arrowTable = {
-        shape: 'arrow-table',
-        schema: serializeArrowSchema(apacheArrowTable.schema),
-        data: apacheArrowTable
-    };
-    const shape = options?.shape || 'arrow-table';
-    switch (shape) {
-        case 'arrow-table':
-            return arrowTable;
-        case 'columnar-table':
-            return convertArrowToColumnarTable(arrowTable);
-        case 'object-row-table':
-            let columnarTable = convertArrowToColumnarTable(arrowTable);
-            return convertTable(columnarTable, 'object-row-table');
-        case 'array-row-table':
-            columnarTable = convertArrowToColumnarTable(arrowTable);
-            return convertTable(columnarTable, 'array-row-table');
-        default:
-            // TODO
-            throw new Error(shape);
-    }
-}

package/dist/parsers/parse-geoarrow-in-batches.d.ts

@@ -1,6 +0,0 @@
-import type { GeoJSONTableBatch } from '@loaders.gl/schema';
-import type { ArrowTableBatch } from "../lib/arrow-table.js";
-/**
- */
-export declare function parseGeoArrowInBatches(asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>): AsyncIterable<ArrowTableBatch | GeoJSONTableBatch>;
-//# sourceMappingURL=parse-geoarrow-in-batches.d.ts.map

package/dist/parsers/parse-geoarrow-in-batches.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parse-geoarrow-in-batches.d.ts","sourceRoot":"","sources":["../../src/parsers/parse-geoarrow-in-batches.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,iBAAiB,EAAC,MAAM,oBAAoB,CAAC;AAC1D,OAAO,KAAK,EAAC,eAAe,EAAC,8BAA2B;AAGxD;GACG;AACH,wBAAgB,sBAAsB,CACpC,aAAa,EAAE,aAAa,CAAC,WAAW,CAAC,GAAG,QAAQ,CAAC,WAAW,CAAC,GAChE,aAAa,CAAC,eAAe,GAAG,iBAAiB,CAAC,CAGpD"}

package/dist/parsers/parse-geoarrow-in-batches.js

@@ -1,10 +0,0 @@
-// loaders.gl
-// SPDX-License-Identifier: MIT
-// Copyright (c) vis.gl contributors
-import { parseArrowInBatches } from "./parse-arrow-in-batches.js";
-/**
- */
-export function parseGeoArrowInBatches(asyncIterator) {
-    // | BinaryGeometry
-    return parseArrowInBatches(asyncIterator);
-}