@loaders.gl/arrow 4.3.0-alpha.8 → 4.3.0-beta.2

package/dist/{parsers/parse-geoarrow-sync.js → lib/parsers/parse-geoarrow.js}

@@ -1,16 +1,22 @@
 // loaders.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { parseArrowSync } from "./parse-arrow-sync.js";
-import { convertArrowToGeoJSONTable } from "../tables/convert-arrow-to-geojson-table.js";
+import { parseArrowSync, parseArrowInBatches } from "./parse-arrow.js";
+import { convertArrowToTable } from "../tables/convert-arrow-to-table.js";
 // Parses arrow to a columnar table
 export function parseGeoArrowSync(arrayBuffer, options) {
     // | BinaryGeometry
     const table = parseArrowSync(arrayBuffer, { shape: 'arrow-table' });
     switch (options?.shape) {
         case 'geojson-table':
-            return convertArrowToGeoJSONTable(table);
+            return convertArrowToTable(table.data, 'geojson-table');
         default:
             return table;
     }
 }
+/**
+ */
+export function parseGeoArrowInBatches(asyncIterator) {
+    // | BinaryGeometry
+    return parseArrowInBatches(asyncIterator);
+}

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

@@ -1,6 +1,10 @@
 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 declare function convertArrowToSchema(arrowSchema: arrow.Schema): Schema;
+/** Convert Apache Arrow Schema (class instance) to a serialized Schema (plain data) */
+export declare function convertSchemaToArrow(schema: Schema): arrow.Schema;
+/** Convert Apache Arrow Schema (class instance) to a serialized Schema (plain data) */
 export declare function serializeArrowSchema(arrowSchema: arrow.Schema): Schema;
 /** Convert a serialized Schema (plain data) to an Apache Arrow Schema (class instance) */
 export declare function deserializeArrowSchema(schema: Schema): arrow.Schema;

package/dist/lib/tables/convert-arrow-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-arrow-schema.d.ts","sourceRoot":"","sources":["../../../src/lib/tables/convert-arrow-schema.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AAChF,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,uFAAuF;AACvF,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAEtE;AAED,uFAAuF;AACvF,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,CAEjE;AAED,uFAAuF;AACvF,wBAAgB,oBAAoB,CAAC,WAAW,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAKtE;AAED,0FAA0F;AAC1F,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC,MAAM,CAKnE;AAED,gHAAgH;AAChH,wBAAgB,sBAAsB,CAAC,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,cAAc,CAEzF;AAED,mHAAmH;AACnH,wBAAgB,wBAAwB,CAAC,QAAQ,CAAC,EAAE,cAAc,GAAG,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAEvF;AAED,mFAAmF;AACnF,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,GAAG,KAAK,CAO7D;AAED,uFAAuF;AACvF,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,KAAK,GAAG,KAAK,CAAC,KAAK,CAO/D;AAED,+EAA+E;AAE/E,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,KAAK,CAAC,QAAQ,GAAG,QAAQ,CAuJtE;AAED,+EAA+E;AAE/E,wBAAgB,oBAAoB,CAAC,QAAQ,EAAE,QAAQ,GAAG,KAAK,CAAC,QAAQ,CAgFvE"}

package/dist/{schema → lib/tables}/convert-arrow-schema.js

@@ -3,6 +3,14 @@
 // Copyright (c) vis.gl contributors
 import * as arrow from 'apache-arrow';
 /** Convert Apache Arrow Schema (class instance) to a serialized Schema (plain data) */
+export function convertArrowToSchema(arrowSchema) {
+    return serializeArrowSchema(arrowSchema);
+}
+/** Convert Apache Arrow Schema (class instance) to a serialized Schema (plain data) */
+export function convertSchemaToArrow(schema) {
+    return deserializeArrowSchema(schema);
+}
+/** Convert Apache Arrow Schema (class instance) to a serialized Schema (plain data) */
 export function serializeArrowSchema(arrowSchema) {
     return {
         fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),

package/dist/lib/tables/convert-arrow-to-table.d.ts

@@ -0,0 +1,15 @@
+import * as arrow from 'apache-arrow';
+import type { Table, ArrayRowTable, ColumnarTable, ObjectRowTable, GeoJSONTable } from '@loaders.gl/schema';
+import type { ArrowTable } from "../../schema/arrow-table-type.js";
+/**
+ * Convert an Apache Arrow table to a loaders.gl Table
+ * @note Currently does not convert schema
+ */
+export declare function convertArrowToTable(arrow: arrow.Table, shape: 'arrow-table'): ArrowTable;
+export declare function convertArrowToTable(arrow: arrow.Table, shape: 'columnar-table'): ColumnarTable;
+export declare function convertArrowToTable(arrow: arrow.Table, shape: 'object-row-table'): ObjectRowTable;
+export declare function convertArrowToTable(arrow: arrow.Table, shape: 'array-row-table'): ArrayRowTable;
+export declare function convertArrowToTable(arrow: arrow.Table, shape: 'geojson-table'): GeoJSONTable;
+export declare function convertArrowToTable(arrow: arrow.Table, shape: 'columnar-table'): ColumnarTable;
+export declare function convertArrowToTable(arrow: arrow.Table, shape: Table['shape']): Table;
+//# sourceMappingURL=convert-arrow-to-table.d.ts.map

package/dist/lib/tables/convert-arrow-to-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-arrow-to-table.d.ts","sourceRoot":"","sources":["../../../src/lib/tables/convert-arrow-to-table.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,EACV,KAAK,EACL,aAAa,EACb,aAAa,EACb,cAAc,EACd,YAAY,EAEb,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EAAC,UAAU,EAAC,yCAAsC;AAO9D;;;GAGG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,aAAa,GAAG,UAAU,CAAC;AAC1F,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,gBAAgB,GAAG,aAAa,CAAC;AAChG,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,kBAAkB,GAAG,cAAc,CAAC;AACnG,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,iBAAiB,GAAG,aAAa,CAAC;AACjG,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,eAAe,GAAG,YAAY,CAAC;AAC9F,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,gBAAgB,GAAG,aAAa,CAAC;AAChG,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,KAAK,CAAC"}

package/dist/lib/tables/convert-arrow-to-table.js

@@ -0,0 +1,104 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { convertTable } from '@loaders.gl/schema';
+import { getGeometryColumnsFromSchema } from '@loaders.gl/gis';
+import { convertArrowToSchema } from "../tables/convert-arrow-schema.js";
+import { parseGeometryFromArrow } from "../geoarrow/convert-geoarrow-to-geojson-geometry.js";
+/**
+ * Convert an Apache Arrow table to a loaders.gl Table
+ * @note Currently does not convert schema
+ */
+export function convertArrowToTable(arrowTable, shape) {
+    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) {
+    return {
+        shape: 'arrow-table',
+        schema: convertArrowToSchema(arrowTable.schema),
+        data: arrowTable
+    };
+}
+function convertArrowToArrayRowTable(arrowTable) {
+    const columnarTable = convertArrowToColumnarTable(arrowTable);
+    return convertTable(columnarTable, 'array-row-table');
+}
+function convertArrowToObjectRowTable(arrowTable) {
+    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) {
+    // TODO - avoid calling `getColumn` on columns we are not interested in?
+    // Add options object?
+    const columns = {};
+    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) {
+    const schema = convertArrowToSchema(arrowTable.schema);
+    const geometryColumns = getGeometryColumnsFromSchema(schema);
+    // get encoding from geometryColumns['geometry']
+    const encoding = geometryColumns.geometry.encoding;
+    const features = [];
+    // 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/dist/lib/tables/convert-table-to-arrow.d.ts

@@ -0,0 +1,16 @@
+import * as arrow from 'apache-arrow';
+import { Table } from '@loaders.gl/schema';
+/**
+ * * Convert a loaders.gl Table to an Apache Arrow Table
+ * @param mesh
+ * @param metadata
+ * @param batchSize
+ * @returns
+ */
+export declare function convertTableToArrow(table: Table, options?: {
+    batchSize?: number;
+}): arrow.Table;
+export declare function makeTableToArrowBatchesIterator(table: Table, options?: {
+    batchSize?: number;
+}): IterableIterator<arrow.RecordBatch>;
+//# sourceMappingURL=convert-table-to-arrow.d.ts.map

package/dist/lib/tables/convert-table-to-arrow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-table-to-arrow.d.ts","sourceRoot":"","sources":["../../../src/lib/tables/convert-table-to-arrow.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,EAAC,KAAK,EAAkD,MAAM,oBAAoB,CAAC;AAG1F;;;;;;GAMG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,KAAK,EAAE,OAAO,CAAC,EAAE;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAC,GAAG,KAAK,CAAC,KAAK,CAe7F;AAED,wBAAiB,+BAA+B,CAC9C,KAAK,EAAE,KAAK,EACZ,OAAO,CAAC,EAAE;IAAC,SAAS,CAAC,EAAE,MAAM,CAAA;CAAC,GAC7B,gBAAgB,CAAC,KAAK,CAAC,WAAW,CAAC,CAoCrC"}

package/dist/lib/tables/convert-table-to-arrow.js

@@ -0,0 +1,56 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import * as arrow from 'apache-arrow';
+import { getTableLength, getTableNumCols, getTableCellAt } from '@loaders.gl/schema';
+import { deserializeArrowSchema } from "../tables/convert-arrow-schema.js";
+/**
+ * * Convert a loaders.gl Table to an Apache Arrow Table
+ * @param mesh
+ * @param metadata
+ * @param batchSize
+ * @returns
+ */
+export function convertTableToArrow(table, options) {
+    switch (table.shape) {
+        case 'arrow-table':
+            return table.data;
+        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, options) {
+    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/dist/lib/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/lib/types.ts"],"names":[],"mappings":"AAIA,KAAK,aAAa,GAAG,SAAS,GAAG,UAAU,GAAG,UAAU,GAAG,WAAW,GAAG,UAAU,GAAG,WAAW,CAAC;AAElG,KAAK,eAAe,GAAG,YAAY,GAAG,YAAY,CAAC;AAEnD,KAAK,UAAU,GAAG,aAAa,GAAG,eAAe,CAAC;AAElD,MAAM,MAAM,YAAY,GAAG,KAAK,CAAC,GAAG,CAAC,GAAG,UAAU,CAAC;AAEnD,oBAAY,YAAY;IACtB,KAAK,IAAA;IACL,IAAI,IAAA;CACL"}

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

@@ -1,6 +1,7 @@
 import { ColumnarTableBatchAggregator } from '@loaders.gl/schema';
-import type { ArrowTableBatch } from "./arrow-table.js";
+import type { ArrowTableBatch } from "./arrow-table-type.js";
 import * as arrow from 'apache-arrow';
+/** @note Should be part of @loaders.gl/schema - kept separate to avoid hard arrow dependency */
 export declare class ArrowTableBatchAggregator extends ColumnarTableBatchAggregator {
     arrowSchema: arrow.Schema | null;
     constructor(schema: any, options: any);

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

@@ -0,0 +1 @@
+{"version":3,"file":"arrow-table-batch.d.ts","sourceRoot":"","sources":["../../src/schema/arrow-table-batch.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,4BAA4B,EAAC,MAAM,oBAAoB,CAAC;AAChE,OAAO,KAAK,EAAC,eAAe,EAAC,8BAA2B;AACxD,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AAEtC,gGAAgG;AAChG,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 → schema}/arrow-table-batch.js

@@ -3,6 +3,7 @@
 // Copyright (c) vis.gl contributors
 import { ColumnarTableBatchAggregator } from '@loaders.gl/schema';
 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;
     constructor(schema, options) {

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

@@ -3,6 +3,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';
@@ -12,6 +13,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';
@@ -20,4 +22,4 @@ export type ArrowTableBatch = Batch & {
     data: arrow.Table;
     length: number;
 };
-//# sourceMappingURL=arrow-table.d.ts.map
+//# sourceMappingURL=arrow-table-type.d.ts.map

package/dist/schema/arrow-table-type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrow-table-type.d.ts","sourceRoot":"","sources":["../../src/schema/arrow-table-type.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,KAAK,EAAE,MAAM,EAAC,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAC;AAE3C;;;;GAIG;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;;;;GAIG;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/triangulate-on-worker.js

@@ -4,7 +4,7 @@
 import { processOnWorker } from '@loaders.gl/worker-utils';
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
-const VERSION = typeof "4.3.0-alpha.7" !== 'undefined' ? "4.3.0-alpha.7" : 'latest';
+const VERSION = typeof "4.3.0-beta.1" !== 'undefined' ? "4.3.0-beta.1" : 'latest';
 /**
  * Worker for tessellating geometries. Normally called through triangulateOnWorker
  */

package/dist/triangulation-worker.js

@@ -67,16 +67,24 @@
     if (!Symbol.asyncIterator)
       throw new TypeError("Symbol.asyncIterator is not defined.");
     var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function() {
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function() {
       return this;
     }, i;
-    function verb(n) {
-      if (g[n])
+    function awaitReturn(f) {
+      return function(v) {
+        return Promise.resolve(v).then(f, reject);
+      };
+    }
+    function verb(n, f) {
+      if (g[n]) {
         i[n] = function(v) {
           return new Promise(function(a, b) {
             q.push([n, v, a, b]) > 1 || resume(n, v);
           });
         };
+        if (f)
+          i[n] = f(i[n]);
+      }
     }
     function resume(n, v) {
       try {
@@ -12444,7 +12452,7 @@ return true;`);
     }
   };
 
-  // src/geoarrow/get-arrow-bounds.ts
+  // src/lib/geoarrow/get-arrow-bounds.ts
   function updateBoundsFromGeoArrowSamples(flatCoords, nDim, bounds, sampleSize = 100) {
     const numberOfFeatures = flatCoords.length / nDim;
     const sampleStep = Math.max(Math.floor(numberOfFeatures / sampleSize), 1);
@@ -12468,7 +12476,7 @@ return true;`);
     return newBounds;
   }
 
-  // src/geoarrow/convert-geoarrow-to-binary-geometry.ts
+  // src/lib/geoarrow/convert-geoarrow-to-binary-geometry.ts
   function getBinaryGeometryTemplate() {
     return {
       globalFeatureIds: { value: new Uint32Array(0), size: 1 },

package/dist/workers/triangulation-worker.js

@@ -3,7 +3,7 @@
 // Copyright (c) vis.gl contributors
 import * as arrow from 'apache-arrow';
 import { createWorker } from '@loaders.gl/worker-utils';
-import { getTriangleIndices, getBinaryGeometriesFromArrow } from "../geoarrow/convert-geoarrow-to-binary-geometry.js";
+import { getTriangleIndices, getBinaryGeometriesFromArrow } from "../lib/geoarrow/convert-geoarrow-to-binary-geometry.js";
 createWorker(async (data, options = {}) => {
     const input = data;
     const operation = input?.operation;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/arrow",
-  "version": "4.3.0-alpha.8",
+  "version": "4.3.0-beta.2",
   "description": "Simple columnar table loader for the Apache Arrow format",
   "license": "MIT",
   "type": "module",
@@ -32,6 +32,10 @@
       "types": "./dist/index.d.ts",
       "import": "./dist/index.js",
       "require": "./dist/index.cjs"
+    },
+    "./exports/*": {
+      "types": "./dist/exports/*.d.ts",
+      "import": "./dist/exports/*.js"
     }
   },
   "sideEffects": false,
@@ -53,16 +57,16 @@
     "build-worker2": "esbuild src/workers/arrow-worker.ts --bundle --outfile=dist/arrow-worker.js --platform=browser --external:{stream}"
   },
   "dependencies": {
-    "@loaders.gl/gis": "4.3.0-alpha.8",
-    "@loaders.gl/loader-utils": "4.3.0-alpha.8",
-    "@loaders.gl/schema": "4.3.0-alpha.8",
-    "@loaders.gl/wkt": "4.3.0-alpha.8",
-    "@loaders.gl/worker-utils": "4.3.0-alpha.8",
+    "@loaders.gl/gis": "4.3.0-beta.2",
+    "@loaders.gl/loader-utils": "4.3.0-beta.2",
+    "@loaders.gl/schema": "4.3.0-beta.2",
+    "@loaders.gl/wkt": "4.3.0-beta.2",
+    "@loaders.gl/worker-utils": "4.3.0-beta.2",
     "@math.gl/polygon": "^4.1.0",
     "apache-arrow": ">= 15.0.0"
   },
   "peerDependencies": {
     "@loaders.gl/core": "^4.0.0"
   },
-  "gitHead": "c458e0c3a09543cd7c4a293d3c3f08c12acf78c0"
+  "gitHead": "a61003f2bb56acbdaef07a03bc39d4c7830afdcc"
 }

package/src/arrow-loader.ts

@@ -2,59 +2,12 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 
-import type {Loader, LoaderWithParser, LoaderOptions} from '@loaders.gl/loader-utils';
-import type {
-  ArrayRowTable,
-  ArrowTableBatch,
-  ColumnarTable,
-  ObjectRowTable
-} from '@loaders.gl/schema';
-import type {ArrowTable} from './lib/arrow-table';
-import {parseArrowSync} from './parsers/parse-arrow-sync';
-import {parseArrowInBatches} from './parsers/parse-arrow-in-batches';
+import type {LoaderWithParser} from '@loaders.gl/loader-utils';
+import type {Table, ArrowTableBatch} from '@loaders.gl/schema';
+import {parseArrowSync, parseArrowInBatches} from './lib/parsers/parse-arrow';
 
-// __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>;
+import type {ArrowLoaderOptions} from './exports/arrow-loader';
+import {ArrowWorkerLoader} from './exports/arrow-loader';
 
 /** ArrowJS table loader */
 export const ArrowLoader = {
@@ -64,8 +17,4 @@ export const ArrowLoader = {
   parseSync: (arraybuffer: ArrayBuffer, options?: ArrowLoaderOptions) =>
     parseArrowSync(arraybuffer, options?.arrow),
   parseInBatches: parseArrowInBatches
-} as const satisfies LoaderWithParser<
-  ArrowTable | ColumnarTable | ObjectRowTable | ArrayRowTable,
-  ArrowTableBatch,
-  ArrowLoaderOptions
->;
+} as const satisfies LoaderWithParser<Table, ArrowTableBatch, ArrowLoaderOptions>;

package/src/arrow-writer.ts

@@ -1,8 +1,7 @@
 // import type {} from '@loaders.gl/loader-utils';
 
 import type {WriterWithEncoder, WriterOptions} from '@loaders.gl/loader-utils';
-import {ColumnarTable} from './lib/encode-arrow';
-import {encodeArrowSync} from './lib/encode-arrow';
+import {ColumnarTable, encodeArrowSync} from './lib/encoders/encode-arrow';
 
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.

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__'.