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

package/dist/lib/geometry-converters/wkb/helpers/wkb-types.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Integer codes for geometry types in WKB and related formats
+ * @see: https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry#Well-known_binary
+ */
+export declare enum WKBGeometryType {
+    Point = 1,
+    LineString = 2,
+    Polygon = 3,
+    MultiPoint = 4,
+    MultiLineString = 5,
+    MultiPolygon = 6,
+    GeometryCollection = 7
+}
+/** Parsed WKB header */
+export type WKBHeader = {
+    /** WKB or TWKB */
+    type: 'wkb' | 'twkb';
+    /** WKB variant */
+    variant: 'wkb' | 'ewkb' | 'iso-wkb' | 'twkb';
+    /** geometry type encoded in this WKB: point, line, polygon etc */
+    geometryType: 1 | 2 | 3 | 4 | 5 | 6 | 7;
+    /** Number of dimensions for coordinate data */
+    dimensions: 2 | 3 | 4;
+    /** Coordinate names, Z and M are controlled by flags */
+    coordinates: 'xy' | 'xyz' | 'xym' | 'xyzm';
+    /** WKB Geometry has a spatial coordinate reference system id */
+    srid?: number;
+    /** true if binary data is stored as little endian */
+    littleEndian: boolean;
+    /** Offset to start of geometry */
+    byteOffset: number;
+};
+/**
+ * Options for writing WKB
+ */
+export type WKBOptions = {
+    /** Does the GeoJSON input have Z values? */
+    hasZ?: boolean;
+    /** Does the GeoJSON input have M values? */
+    hasM?: boolean;
+    /** Spatial reference for input GeoJSON */
+    srid?: any;
+};
+/** WKB Geometry has a z coordinate */
+export declare const EWKB_FLAG_Z = 2147483648;
+/** WKB Geometry has an m coordinate */
+export declare const EWKB_FLAG_M = 1073741824;
+/** WKB Geometry has a spatial coordinate reference system id */
+export declare const EWKB_FLAG_SRID = 536870912;
+/** @todo: Assume no more than 10K SRIDs are defined */
+export declare const MAX_SRID = 10000;
+/**
+ * @see: https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry#Well-known_binary
+ * @note Order matches WKBGeometryType enum (need to add 1)
+ * @note: We only support this "geojson" subset of the OGC simple features standard
+ */
+export declare const WKT_MAGIC_STRINGS: string[];
+/**
+ * @see: https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry#Well-known_binary
+ * @note Order matches WKBGeometryType enum (need to add 1)
+ * @note: We only support this "geojson" subset of the OGC simple features standard
+ */
+export declare const WKT_MAGIC_BYTES: Uint8Array[];
+//# sourceMappingURL=wkb-types.d.ts.map

package/dist/lib/geometry-converters/wkb/helpers/wkb-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wkb-types.d.ts","sourceRoot":"","sources":["../../../../../src/lib/geometry-converters/wkb/helpers/wkb-types.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,oBAAY,eAAe;IACzB,KAAK,IAAI;IACT,UAAU,IAAI;IACd,OAAO,IAAI;IACX,UAAU,IAAI;IACd,eAAe,IAAI;IACnB,YAAY,IAAI;IAChB,kBAAkB,IAAI;CACvB;AAED,wBAAwB;AACxB,MAAM,MAAM,SAAS,GAAG;IACtB,kBAAkB;IAClB,IAAI,EAAE,KAAK,GAAG,MAAM,CAAC;IACrB,kBAAkB;IAClB,OAAO,EAAE,KAAK,GAAG,MAAM,GAAG,SAAS,GAAG,MAAM,CAAC;IAC7C,kEAAkE;IAClE,YAAY,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACxC,+CAA+C;IAC/C,UAAU,EAAE,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;IACtB,wDAAwD;IACxD,WAAW,EAAE,IAAI,GAAG,KAAK,GAAG,KAAK,GAAG,MAAM,CAAC;IAC3C,gEAAgE;IAChE,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qDAAqD;IACrD,YAAY,EAAE,OAAO,CAAC;IACtB,kCAAkC;IAClC,UAAU,EAAE,MAAM,CAAC;CACpB,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,4CAA4C;IAC5C,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,4CAA4C;IAC5C,IAAI,CAAC,EAAE,OAAO,CAAC;IACf,0CAA0C;IAC1C,IAAI,CAAC,EAAE,GAAG,CAAC;CACZ,CAAC;AAEF,sCAAsC;AACtC,eAAO,MAAM,WAAW,aAAa,CAAC;AACtC,uCAAuC;AACvC,eAAO,MAAM,WAAW,aAAa,CAAC;AACtC,gEAAgE;AAChE,eAAO,MAAM,cAAc,YAAa,CAAC;AACzC,uDAAuD;AACvD,eAAO,MAAM,QAAQ,QAAQ,CAAC;AAE9B;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,UAQ7B,CAAC;AAIF;;;;GAIG;AACH,eAAO,MAAM,eAAe,cAAgE,CAAC"}

package/dist/lib/geometry-converters/wkb/helpers/wkb-types.js

@@ -0,0 +1,46 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/**
+ * Integer codes for geometry types in WKB and related formats
+ * @see: https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry#Well-known_binary
+ */
+export var WKBGeometryType;
+(function (WKBGeometryType) {
+    WKBGeometryType[WKBGeometryType["Point"] = 1] = "Point";
+    WKBGeometryType[WKBGeometryType["LineString"] = 2] = "LineString";
+    WKBGeometryType[WKBGeometryType["Polygon"] = 3] = "Polygon";
+    WKBGeometryType[WKBGeometryType["MultiPoint"] = 4] = "MultiPoint";
+    WKBGeometryType[WKBGeometryType["MultiLineString"] = 5] = "MultiLineString";
+    WKBGeometryType[WKBGeometryType["MultiPolygon"] = 6] = "MultiPolygon";
+    WKBGeometryType[WKBGeometryType["GeometryCollection"] = 7] = "GeometryCollection";
+})(WKBGeometryType || (WKBGeometryType = {}));
+/** WKB Geometry has a z coordinate */
+export const EWKB_FLAG_Z = 0x80000000;
+/** WKB Geometry has an m coordinate */
+export const EWKB_FLAG_M = 0x40000000;
+/** WKB Geometry has a spatial coordinate reference system id */
+export const EWKB_FLAG_SRID = 0x20000000;
+/** @todo: Assume no more than 10K SRIDs are defined */
+export const MAX_SRID = 10000;
+/**
+ * @see: https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry#Well-known_binary
+ * @note Order matches WKBGeometryType enum (need to add 1)
+ * @note: We only support this "geojson" subset of the OGC simple features standard
+ */
+export const WKT_MAGIC_STRINGS = [
+    'POINT(',
+    'LINESTRING(',
+    'POLYGON(',
+    'MULTIPOINT(',
+    'MULTILINESTRING(',
+    'MULTIPOLYGON(',
+    'GEOMETRYCOLLECTION('
+];
+const textEncoder = new TextEncoder();
+/**
+ * @see: https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry#Well-known_binary
+ * @note Order matches WKBGeometryType enum (need to add 1)
+ * @note: We only support this "geojson" subset of the OGC simple features standard
+ */
+export const WKT_MAGIC_BYTES = WKT_MAGIC_STRINGS.map((string) => textEncoder.encode(string));

package/dist/lib/geometry-converters/wkb/helpers/wkb-utils.d.ts

@@ -0,0 +1,21 @@
+import type { WKBOptions } from "./wkb-types.js";
+import { WKBGeometryType } from "./wkb-types.js";
+declare const WKBGeometryTypeNames: {
+    readonly Point: WKBGeometryType.Point;
+    readonly LineString: WKBGeometryType.LineString;
+    readonly Polygon: WKBGeometryType.Polygon;
+    readonly MultiPoint: WKBGeometryType.MultiPoint;
+    readonly MultiLineString: WKBGeometryType.MultiLineString;
+    readonly MultiPolygon: WKBGeometryType.MultiPolygon;
+    readonly GeometryCollection: WKBGeometryType.GeometryCollection;
+};
+/** Convert a WKB geometry type integer to GeoJSON style geometry type string*/
+export declare function getGeometryTypeFromWKBType(wkbGeometryType: WKBGeometryType): keyof typeof WKBGeometryTypeNames;
+/** Convert a GeoJSON style geometry type string to a WKB geometry type integer*/
+export declare function getWKBTypeFromGeometryType(geometryType: keyof typeof WKBGeometryTypeNames): WKBGeometryType;
+/** Sanity: Adjust Z/M dimensions with actual point size */
+export declare function matchWKBOptionsToPointSize(pointSize: number, options?: WKBOptions): Required<WKBOptions>;
+/** Get coordinate size given Z/M dimensions */
+export declare function getCoordinateByteSize(options?: WKBOptions): number;
+export {};
+//# sourceMappingURL=wkb-utils.d.ts.map

package/dist/lib/geometry-converters/wkb/helpers/wkb-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wkb-utils.d.ts","sourceRoot":"","sources":["../../../../../src/lib/geometry-converters/wkb/helpers/wkb-utils.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,UAAU,EAAC,uBAAoB;AAC5C,OAAO,EAAC,eAAe,EAAC,uBAAoB;AAE5C,QAAA,MAAM,oBAAoB;;;;;;;;CAQ0B,CAAC;AAErD,+EAA+E;AAC/E,wBAAgB,0BAA0B,CACxC,eAAe,EAAE,eAAe,GAC/B,MAAM,OAAO,oBAAoB,CAOnC;AAED,iFAAiF;AACjF,wBAAgB,0BAA0B,CACxC,YAAY,EAAE,MAAM,OAAO,oBAAoB,GAC9C,eAAe,CAEjB;AAED,2DAA2D;AAC3D,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,MAAM,EACjB,OAAO,CAAC,EAAE,UAAU,GACnB,QAAQ,CAAC,UAAU,CAAC,CA8BtB;AAED,+CAA+C;AAC/C,wBAAgB,qBAAqB,CAAC,OAAO,CAAC,EAAE,UAAU,GAAG,MAAM,CAWlE"}

package/dist/lib/geometry-converters/wkb/helpers/wkb-utils.js

@@ -0,0 +1,64 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import { WKBGeometryType } from "./wkb-types.js";
+const WKBGeometryTypeNames = {
+    Point: WKBGeometryType.Point,
+    LineString: WKBGeometryType.LineString,
+    Polygon: WKBGeometryType.Polygon,
+    MultiPoint: WKBGeometryType.MultiPoint,
+    MultiLineString: WKBGeometryType.MultiLineString,
+    MultiPolygon: WKBGeometryType.MultiPolygon,
+    GeometryCollection: WKBGeometryType.GeometryCollection
+};
+/** Convert a WKB geometry type integer to GeoJSON style geometry type string*/
+export function getGeometryTypeFromWKBType(wkbGeometryType) {
+    for (const key in WKBGeometryTypeNames) {
+        if (WKBGeometryTypeNames[key] === wkbGeometryType) {
+            return key;
+        }
+    }
+    throw new Error(String(wkbGeometryType));
+}
+/** Convert a GeoJSON style geometry type string to a WKB geometry type integer*/
+export function getWKBTypeFromGeometryType(geometryType) {
+    return WKBGeometryTypeNames[geometryType];
+}
+/** Sanity: Adjust Z/M dimensions with actual point size */
+export function matchWKBOptionsToPointSize(pointSize, options) {
+    const wkbOptions = { hasZ: false, hasM: false, srid: undefined, ...options };
+    // Align options with actual point size
+    switch (pointSize) {
+        case 4:
+            wkbOptions.hasZ = true;
+            wkbOptions.hasM = true;
+            break;
+        case 3:
+            // Prefer Z over M
+            if (wkbOptions.hasZ && wkbOptions.hasM) {
+                wkbOptions.hasM = false;
+            }
+            if (!wkbOptions.hasZ && !wkbOptions.hasM) {
+                wkbOptions.hasZ = true;
+            }
+            break;
+        case 2:
+            wkbOptions.hasZ = false;
+            wkbOptions.hasM = false;
+            break;
+        default:
+        // ignore - broken input data?
+    }
+    return wkbOptions;
+}
+/** Get coordinate size given Z/M dimensions */
+export function getCoordinateByteSize(options) {
+    let coordinateByteSize = 16;
+    if (options?.hasZ) {
+        coordinateByteSize += 8;
+    }
+    if (options?.hasM) {
+        coordinateByteSize += 8;
+    }
+    return coordinateByteSize;
+}

package/dist/lib/geometry-converters/wkb/helpers/write-wkb-header.d.ts

@@ -0,0 +1,8 @@
+import { BinaryWriter } from "../../../utils/binary-writer.js";
+import type { WKBOptions } from "./wkb-types.js";
+/**
+ * Construct and write WKB integer code
+ * Reference: https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry#Well-known_binary
+ */
+export declare function writeWkbHeader(writer: BinaryWriter, geometryType: number, options?: WKBOptions): void;
+//# sourceMappingURL=write-wkb-header.d.ts.map

package/dist/lib/geometry-converters/wkb/helpers/write-wkb-header.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"write-wkb-header.d.ts","sourceRoot":"","sources":["../../../../../src/lib/geometry-converters/wkb/helpers/write-wkb-header.ts"],"names":[],"mappings":"AAIA,OAAO,EAAC,YAAY,EAAC,wCAAqC;AAC1D,OAAO,KAAK,EAAC,UAAU,EAAC,uBAAoB;AAE5C;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,MAAM,EAAE,YAAY,EACpB,YAAY,EAAE,MAAM,EACpB,OAAO,CAAC,EAAE,UAAU,GACnB,IAAI,CAyBN"}

package/dist/lib/geometry-converters/wkb/helpers/write-wkb-header.js

@@ -0,0 +1,33 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/**
+ * Construct and write WKB integer code
+ * Reference: https://en.wikipedia.org/wiki/Well-known_text_representation_of_geometry#Well-known_binary
+ */
+export function writeWkbHeader(writer, geometryType, options) {
+    // little endian
+    writer.writeInt8(1);
+    const { hasZ, hasM, srid } = options || {};
+    let dimensionType = 0;
+    if (!srid) {
+        if (hasZ && hasM) {
+            dimensionType += 3000;
+        }
+        else if (hasZ) {
+            dimensionType += 1000;
+        }
+        else if (hasM) {
+            dimensionType += 2000;
+        }
+    }
+    else {
+        if (hasZ) {
+            dimensionType |= 0x80000000;
+        }
+        if (hasM) {
+            dimensionType |= 0x40000000;
+        }
+    }
+    writer.writeUInt32LE((dimensionType + geometryType) >>> 0);
+}

package/dist/lib/table-converters/convert-geoarrow-table.d.ts

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

package/dist/lib/table-converters/convert-geoarrow-table.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-geoarrow-table.d.ts","sourceRoot":"","sources":["../../../src/lib/table-converters/convert-geoarrow-table.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,EACV,KAAK,EACL,aAAa,EACb,aAAa,EACb,cAAc,EACd,YAAY,EACZ,UAAU,EAEX,MAAM,oBAAoB,CAAC;AAa5B;;;;;;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;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,aAAa,GAAG,UAAU,CAAC;AAC7F,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,gBAAgB,GAAG,aAAa,CAAC;AACnG,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,KAAK,CAAC,KAAK,EAClB,KAAK,EAAE,kBAAkB,GACxB,cAAc,CAAC;AAClB,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,iBAAiB,GAAG,aAAa,CAAC;AACpG,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,eAAe,GAAG,YAAY,CAAC;AACjG,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,gBAAgB,GAAG,aAAa,CAAC;AACnG,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,KAAK,CAAC,KAAK,EAAE,KAAK,EAAE,KAAK,CAAC,OAAO,CAAC,GAAG,KAAK,CAAC"}

package/dist/lib/table-converters/convert-geoarrow-table.js

@@ -0,0 +1,154 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import * as arrow from 'apache-arrow';
+import { convertTable, convertArrowToSchema, convertSchemaToArrow, getTableLength, getTableNumCols, getTableCellAt } from '@loaders.gl/schema-utils';
+import { getGeometryColumnsFromSchema } from '@loaders.gl/geoarrow';
+import { convertGeoArrowGeometryToGeoJSON } from "../geometry-converters/convert-geoarrow-to-geojson.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 = convertSchemaToArrow(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());
+}
+/**
+ * Convert an Apache Arrow table to a loaders.gl Table
+ * @note Currently does not convert schema
+ */
+export function convertGeoArrowToTable(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 = convertGeoArrowGeometryToGeoJSON(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/table-converters/convert-wkb-table-to-geojson.d.ts

@@ -0,0 +1,4 @@
+import type { ArrayRowTable, GeoJSONTable, ObjectRowTable, Schema } from '@loaders.gl/schema';
+/** TODO - move to loaders.gl/gis? */
+export declare function convertWKBTableToGeoJSON(table: ArrayRowTable | ObjectRowTable, schema: Schema): GeoJSONTable;
+//# sourceMappingURL=convert-wkb-table-to-geojson.d.ts.map

package/dist/lib/table-converters/convert-wkb-table-to-geojson.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"convert-wkb-table-to-geojson.d.ts","sourceRoot":"","sources":["../../../src/lib/table-converters/convert-wkb-table-to-geojson.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EACV,aAAa,EACb,YAAY,EACZ,cAAc,EACd,MAAM,EAGP,MAAM,oBAAoB,CAAC;AAM5B,qCAAqC;AACrC,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,aAAa,GAAG,cAAc,EACrC,MAAM,EAAE,MAAM,GACb,YAAY,CAoBd"}

package/dist/lib/{tables/convert-table-to-geojson.js → table-converters/convert-wkb-table-to-geojson.js}

@@ -1,11 +1,13 @@
 // loaders.gl
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
-import { getTableLength, getTableRowAsObject } from '@loaders.gl/schema';
-import { getGeoMetadata } from "../geo/geoparquet-metadata.js";
+import { getTableLength, getTableRowAsObject } from '@loaders.gl/schema-utils';
+import { getGeoMetadata } from '@loaders.gl/geoarrow';
+import { convertWKBToGeometry } from "../geometry-converters/wkb/convert-wkb-to-geometry.js";
+import { convertWKTToGeometry } from "../geometry-converters/wkb/convert-wkt-to-geometry.js";
 /** TODO - move to loaders.gl/gis? */
-export function convertWKBTableToGeoJSON(table, schema, loaders) {
-    const geoMetadata = getGeoMetadata(schema);
+export function convertWKBTableToGeoJSON(table, schema) {
+    const geoMetadata = getGeoMetadata(schema.metadata);
     const primaryColumn = geoMetadata?.primary_column;
     if (!primaryColumn) {
         throw new Error('no geometry column');
@@ -15,30 +17,22 @@ export function convertWKBTableToGeoJSON(table, schema, loaders) {
     const length = getTableLength(table);
     for (let rowIndex = 0; rowIndex < length; rowIndex++) {
         const row = getTableRowAsObject(table, rowIndex);
-        const geometry = parseGeometry(row[primaryColumn], columnMetadata, loaders);
+        const geometry = parseGeometry(row[primaryColumn], columnMetadata);
         delete row[primaryColumn];
         const feature = { type: 'Feature', geometry: geometry, properties: row };
         features.push(feature);
     }
     return { shape: 'geojson-table', schema, type: 'FeatureCollection', features };
 }
-function parseGeometry(geometry, columnMetadata, loaders) {
+function parseGeometry(geometry, columnMetadata) {
     switch (columnMetadata.encoding) {
         case 'wkt':
-            const wktLoader = loaders.find((loader) => loader.id === 'wkt');
-            return wktLoader?.parseTextSync?.(geometry) || null;
+            return convertWKTToGeometry(geometry) || null;
         case 'wkb':
         default:
-            const wkbLoader = loaders.find((loader) => loader.id === 'wkb');
             const arrayBuffer = ArrayBuffer.isView(geometry)
                 ? geometry.buffer.slice(geometry.byteOffset, geometry.byteOffset + geometry.byteLength)
                 : geometry;
-            const geojson = wkbLoader?.parseSync?.(arrayBuffer, {
-                wkb: { shape: 'geojson-geometry' }
-            });
-            return geojson; // binaryGeometry ? binaryToGeometry(binaryGeometry) : null;
-        // const binaryGeometry = WKBLoader.parseSync?.(geometry);
-        // ts-ignore
-        // return binaryGeometry ? binaryToGeometry(binaryGeometry) : null;
+            return convertWKBToGeometry(arrayBuffer);
     }
 }

package/dist/lib/table-converters/make-arrow-batch-iterator.d.ts

@@ -0,0 +1,6 @@
+import * as arrow from 'apache-arrow';
+import type { Table } from '@loaders.gl/schema';
+export declare function makeTableToArrowBatchesIterator(table: Table, options?: {
+    batchSize?: number;
+}): IterableIterator<arrow.RecordBatch>;
+//# sourceMappingURL=make-arrow-batch-iterator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"make-arrow-batch-iterator.d.ts","sourceRoot":"","sources":["../../../src/lib/table-converters/make-arrow-batch-iterator.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,EAAC,KAAK,EAAC,MAAM,oBAAoB,CAAC;AAQ9C,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/table-converters/make-arrow-batch-iterator.js

@@ -0,0 +1,35 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+import * as arrow from 'apache-arrow';
+import { convertSchemaToArrow, getTableLength, getTableNumCols, getTableCellAt } from '@loaders.gl/schema-utils';
+export function* makeTableToArrowBatchesIterator(table, options) {
+    const arrowSchema = convertSchemaToArrow(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/utils/base64-encoder.d.ts

@@ -0,0 +1,5 @@
+export declare class Base64Encoder {
+    getDecodedLength(array: Uint8Array): number;
+    decode(array: Uint8Array, target?: ArrayBuffer): void;
+}
+//# sourceMappingURL=base64-encoder.d.ts.map

package/dist/lib/utils/base64-encoder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base64-encoder.d.ts","sourceRoot":"","sources":["../../../src/lib/utils/base64-encoder.ts"],"names":[],"mappings":"AA0BA,qBAAa,aAAa;IACxB,gBAAgB,CAAC,KAAK,EAAE,UAAU,GAAG,MAAM;IAI3C,MAAM,CAAC,KAAK,EAAE,UAAU,EAAE,MAAM,CAAC,EAAE,WAAW;CAC/C"}