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

package/dist/schema/convert-arrow-schema.js

@@ -1,259 +1,272 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// 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 serializeArrowSchema(arrowSchema) {
-  return {
-    fields: arrowSchema.fields.map(arrowField => serializeArrowField(arrowField)),
-    metadata: serializeArrowMetadata(arrowSchema.metadata)
-  };
+    return {
+        fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
+        metadata: serializeArrowMetadata(arrowSchema.metadata)
+    };
 }
+/** Convert a serialized Schema (plain data) to an Apache Arrow Schema (class instance) */
 export function deserializeArrowSchema(schema) {
-  return new arrow.Schema(schema.fields.map(field => deserializeArrowField(field)), deserializeArrowMetadata(schema.metadata));
+    return new arrow.Schema(schema.fields.map((field) => deserializeArrowField(field)), deserializeArrowMetadata(schema.metadata));
 }
+/** Convert Apache Arrow Schema metadata (Map<string, string>) to serialized metadata (Record<string, string> */
 export function serializeArrowMetadata(arrowMetadata) {
-  return Object.fromEntries(arrowMetadata);
+    return Object.fromEntries(arrowMetadata);
 }
+/** Convert serialized metadata (Record<string, string> to Apache Arrow Schema metadata (Map<string, string>) to */
 export function deserializeArrowMetadata(metadata) {
-  return metadata ? new Map(Object.entries(metadata)) : new Map();
+    return metadata ? new Map(Object.entries(metadata)) : new Map();
 }
+/** Convert Apache Arrow Field (class instance) to serialized Field (plain data) */
 export function serializeArrowField(field) {
-  return {
-    name: field.name,
-    type: serializeArrowType(field.type),
-    nullable: field.nullable,
-    metadata: serializeArrowMetadata(field.metadata)
-  };
+    return {
+        name: field.name,
+        type: serializeArrowType(field.type),
+        nullable: field.nullable,
+        metadata: serializeArrowMetadata(field.metadata)
+    };
 }
+/** Convert a serialized Field (plain data) to an Apache Arrow Field (class instance)*/
 export function deserializeArrowField(field) {
-  return new arrow.Field(field.name, deserializeArrowType(field.type), field.nullable, deserializeArrowMetadata(field.metadata));
+    return new arrow.Field(field.name, deserializeArrowType(field.type), field.nullable, deserializeArrowMetadata(field.metadata));
 }
+/** Converts a serializable loaders.gl data type to hydrated arrow data type */
+// eslint-disable-next-line complexity
 export function serializeArrowType(arrowType) {
-  switch (arrowType.constructor) {
-    case arrow.Null:
-      return 'null';
-    case arrow.Binary:
-      return 'binary';
-    case arrow.Bool:
-      return 'bool';
-    case arrow.Int:
-      const intType = arrowType;
-      return `${intType.isSigned ? 'u' : ''}int${intType.bitWidth}`;
-    case arrow.Int8:
-      return 'int8';
-    case arrow.Int16:
-      return 'int16';
-    case arrow.Int32:
-      return 'int32';
-    case arrow.Int64:
-      return 'int64';
-    case arrow.Uint8:
-      return 'uint8';
-    case arrow.Uint16:
-      return 'uint16';
-    case arrow.Uint32:
-      return 'uint32';
-    case arrow.Uint64:
-      return 'uint64';
-    case arrow.Float:
-      const precision = arrowType.precision;
-      switch (precision) {
-        case arrow.Precision.HALF:
-          return 'float16';
-        case arrow.Precision.SINGLE:
-          return 'float32';
-        case arrow.Precision.DOUBLE:
-          return 'float64';
+    switch (arrowType.constructor) {
+        case arrow.Null:
+            return 'null';
+        case arrow.Binary:
+            return 'binary';
+        case arrow.Bool:
+            return 'bool';
+        case arrow.Int:
+            const intType = arrowType;
+            return `${intType.isSigned ? 'u' : ''}int${intType.bitWidth}`;
+        case arrow.Int8:
+            return 'int8';
+        case arrow.Int16:
+            return 'int16';
+        case arrow.Int32:
+            return 'int32';
+        case arrow.Int64:
+            return 'int64';
+        case arrow.Uint8:
+            return 'uint8';
+        case arrow.Uint16:
+            return 'uint16';
+        case arrow.Uint32:
+            return 'uint32';
+        case arrow.Uint64:
+            return 'uint64';
+        case arrow.Float:
+            const precision = arrowType.precision;
+            // return `float(precision + 1) * 16`;
+            switch (precision) {
+                case arrow.Precision.HALF:
+                    return 'float16';
+                case arrow.Precision.SINGLE:
+                    return 'float32';
+                case arrow.Precision.DOUBLE:
+                    return 'float64';
+                default:
+                    return 'float16';
+            }
+        case arrow.Float16:
+            return 'float16';
+        case arrow.Float32:
+            return 'float32';
+        case arrow.Float64:
+            return 'float64';
+        case arrow.Utf8:
+            return 'utf8';
+        case arrow.Decimal:
+            const decimal = arrowType;
+            return {
+                type: 'decimal',
+                bitWidth: decimal.bitWidth,
+                precision: decimal.precision,
+                scale: decimal.scale
+            };
+        case arrow.Date_:
+            const dateUnit = arrowType.unit;
+            return dateUnit === arrow.DateUnit.DAY ? 'date-day' : 'date-millisecond';
+        case arrow.DateDay:
+            return 'date-day';
+        case arrow.DateMillisecond:
+            return 'date-millisecond';
+        case arrow.Time:
+            const timeUnit = arrowType.unit;
+            switch (timeUnit) {
+                case arrow.TimeUnit.SECOND:
+                    return 'time-second';
+                case arrow.TimeUnit.MILLISECOND:
+                    return 'time-millisecond';
+                case arrow.TimeUnit.MICROSECOND:
+                    return 'time-microsecond';
+                case arrow.TimeUnit.NANOSECOND:
+                    return 'time-nanosecond';
+                default:
+                    return 'time-second';
+            }
+        case arrow.TimeMillisecond:
+            return 'time-millisecond';
+        case arrow.TimeSecond:
+            return 'time-second';
+        case arrow.TimeMicrosecond:
+            return 'time-microsecond';
+        case arrow.TimeNanosecond:
+            return 'time-nanosecond';
+        case arrow.Timestamp:
+            const timeStampUnit = arrowType.unit;
+            switch (timeStampUnit) {
+                case arrow.TimeUnit.SECOND:
+                    return 'timestamp-second';
+                case arrow.TimeUnit.MILLISECOND:
+                    return 'timestamp-millisecond';
+                case arrow.TimeUnit.MICROSECOND:
+                    return 'timestamp-microsecond';
+                case arrow.TimeUnit.NANOSECOND:
+                    return 'timestamp-nanosecond';
+                default:
+                    return 'timestamp-second';
+            }
+        case arrow.TimestampSecond:
+            return 'timestamp-second';
+        case arrow.TimestampMillisecond:
+            return 'timestamp-millisecond';
+        case arrow.TimestampMicrosecond:
+            return 'timestamp-microsecond';
+        case arrow.TimestampNanosecond:
+            return 'timestamp-nanosecond';
+        case arrow.Interval:
+            const intervalUnit = arrowType.unit;
+            switch (intervalUnit) {
+                case arrow.IntervalUnit.DAY_TIME:
+                    return 'interval-daytime';
+                case arrow.IntervalUnit.YEAR_MONTH:
+                    return 'interval-yearmonth';
+                default:
+                    return 'interval-daytime';
+            }
+        case arrow.IntervalDayTime:
+            return 'interval-daytime';
+        case arrow.IntervalYearMonth:
+            return 'interval-yearmonth';
+        case arrow.Map_:
+            const mapType = arrowType;
+            return {
+                type: 'map',
+                keysSorted: mapType.keysSorted,
+                children: mapType.children.map((arrowField) => serializeArrowField(arrowField))
+            };
+        case arrow.List:
+            const listType = arrowType;
+            const listField = listType.valueField;
+            return {
+                type: 'list',
+                children: [serializeArrowField(listField)]
+            };
+        case arrow.FixedSizeList:
+            const fixedSizeList = arrowType;
+            return {
+                type: 'fixed-size-list',
+                listSize: fixedSizeList.listSize,
+                children: [serializeArrowField(fixedSizeList.children[0])]
+            };
+        case arrow.Struct:
+            const structType = arrowType;
+            return {
+                type: 'struct',
+                children: structType.children.map((arrowField) => serializeArrowField(arrowField))
+            };
         default:
-          return 'float16';
-      }
-    case arrow.Float16:
-      return 'float16';
-    case arrow.Float32:
-      return 'float32';
-    case arrow.Float64:
-      return 'float64';
-    case arrow.Utf8:
-      return 'utf8';
-    case arrow.Decimal:
-      const decimal = arrowType;
-      return {
-        type: 'decimal',
-        bitWidth: decimal.bitWidth,
-        precision: decimal.precision,
-        scale: decimal.scale
-      };
-    case arrow.Date_:
-      const dateUnit = arrowType.unit;
-      return dateUnit === arrow.DateUnit.DAY ? 'date-day' : 'date-millisecond';
-    case arrow.DateDay:
-      return 'date-day';
-    case arrow.DateMillisecond:
-      return 'date-millisecond';
-    case arrow.Time:
-      const timeUnit = arrowType.unit;
-      switch (timeUnit) {
-        case arrow.TimeUnit.SECOND:
-          return 'time-second';
-        case arrow.TimeUnit.MILLISECOND:
-          return 'time-millisecond';
-        case arrow.TimeUnit.MICROSECOND:
-          return 'time-microsecond';
-        case arrow.TimeUnit.NANOSECOND:
-          return 'time-nanosecond';
-        default:
-          return 'time-second';
-      }
-    case arrow.TimeMillisecond:
-      return 'time-millisecond';
-    case arrow.TimeSecond:
-      return 'time-second';
-    case arrow.TimeMicrosecond:
-      return 'time-microsecond';
-    case arrow.TimeNanosecond:
-      return 'time-nanosecond';
-    case arrow.Timestamp:
-      const timeStampUnit = arrowType.unit;
-      switch (timeStampUnit) {
-        case arrow.TimeUnit.SECOND:
-          return 'timestamp-second';
-        case arrow.TimeUnit.MILLISECOND:
-          return 'timestamp-millisecond';
-        case arrow.TimeUnit.MICROSECOND:
-          return 'timestamp-microsecond';
-        case arrow.TimeUnit.NANOSECOND:
-          return 'timestamp-nanosecond';
-        default:
-          return 'timestamp-second';
-      }
-    case arrow.TimestampSecond:
-      return 'timestamp-second';
-    case arrow.TimestampMillisecond:
-      return 'timestamp-millisecond';
-    case arrow.TimestampMicrosecond:
-      return 'timestamp-microsecond';
-    case arrow.TimestampNanosecond:
-      return 'timestamp-nanosecond';
-    case arrow.Interval:
-      const intervalUnit = arrowType.unit;
-      switch (intervalUnit) {
-        case arrow.IntervalUnit.DAY_TIME:
-          return 'interval-daytime';
-        case arrow.IntervalUnit.YEAR_MONTH:
-          return 'interval-yearmonth';
-        default:
-          return 'interval-daytime';
-      }
-    case arrow.IntervalDayTime:
-      return 'interval-daytime';
-    case arrow.IntervalYearMonth:
-      return 'interval-yearmonth';
-    case arrow.Map_:
-      const mapType = arrowType;
-      return {
-        type: 'map',
-        keysSorted: mapType.keysSorted,
-        children: mapType.children.map(arrowField => serializeArrowField(arrowField))
-      };
-    case arrow.List:
-      const listType = arrowType;
-      const listField = listType.valueField;
-      return {
-        type: 'list',
-        children: [serializeArrowField(listField)]
-      };
-    case arrow.FixedSizeList:
-      const fixedSizeList = arrowType;
-      return {
-        type: 'fixed-size-list',
-        listSize: fixedSizeList.listSize,
-        children: [serializeArrowField(fixedSizeList.children[0])]
-      };
-    case arrow.Struct:
-      const structType = arrowType;
-      return {
-        type: 'struct',
-        children: structType.children.map(arrowField => serializeArrowField(arrowField))
-      };
-    default:
-      throw new Error(`arrow type not supported: ${arrowType.constructor.name}`);
-  }
+            throw new Error(`arrow type not supported: ${arrowType.constructor.name}`);
+    }
 }
+/** Converts a serializable loaders.gl data type to hydrated arrow data type */
+// eslint-disable-next-line complexity
 export function deserializeArrowType(dataType) {
-  if (typeof dataType === 'object') {
-    switch (dataType.type) {
-      case 'decimal':
-        return new arrow.Decimal(dataType.precision, dataType.scale, dataType.bitWidth);
-      case 'map':
-        let children = dataType.children.map(arrowField => deserializeArrowField(arrowField));
-        return new arrow.Map_(children, dataType.keysSorted);
-      case 'list':
-        const field = deserializeArrowField(dataType.children[0]);
-        return new arrow.List(field);
-      case 'fixed-size-list':
-        const child = deserializeArrowField(dataType.children[0]);
-        return new arrow.FixedSizeList(dataType.listSize, child);
-      case 'struct':
-        children = dataType.children.map(arrowField => deserializeArrowField(arrowField));
-        return new arrow.Struct(children);
-      default:
-        throw new Error('array type not supported');
+    if (typeof dataType === 'object') {
+        switch (dataType.type) {
+            case 'decimal':
+                return new arrow.Decimal(dataType.precision, dataType.scale, dataType.bitWidth);
+            case 'map':
+                let children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
+                return new arrow.Map_(children, dataType.keysSorted);
+            case 'list':
+                const field = deserializeArrowField(dataType.children[0]);
+                return new arrow.List(field);
+            case 'fixed-size-list':
+                const child = deserializeArrowField(dataType.children[0]);
+                return new arrow.FixedSizeList(dataType.listSize, child);
+            case 'struct':
+                children = dataType.children.map((arrowField) => deserializeArrowField(arrowField));
+                return new arrow.Struct(children);
+            default:
+                throw new Error('array type not supported');
+        }
+    }
+    switch (dataType) {
+        case 'null':
+            return new arrow.Null();
+        case 'binary':
+            return new arrow.Binary();
+        case 'bool':
+            return new arrow.Bool();
+        case 'int8':
+            return new arrow.Int8();
+        case 'int16':
+            return new arrow.Int16();
+        case 'int32':
+            return new arrow.Int32();
+        case 'int64':
+            return new arrow.Int64();
+        case 'uint8':
+            return new arrow.Uint8();
+        case 'uint16':
+            return new arrow.Uint16();
+        case 'uint32':
+            return new arrow.Uint32();
+        case 'uint64':
+            return new arrow.Uint64();
+        case 'float16':
+            return new arrow.Float16();
+        case 'float32':
+            return new arrow.Float32();
+        case 'float64':
+            return new arrow.Float64();
+        case 'utf8':
+            return new arrow.Utf8();
+        case 'date-day':
+            return new arrow.DateDay();
+        case 'date-millisecond':
+            return new arrow.DateMillisecond();
+        case 'time-second':
+            return new arrow.TimeSecond();
+        case 'time-millisecond':
+            return new arrow.TimeMillisecond();
+        case 'time-microsecond':
+            return new arrow.TimeMicrosecond();
+        case 'time-nanosecond':
+            return new arrow.TimeNanosecond();
+        case 'timestamp-second':
+            return new arrow.TimestampSecond();
+        case 'timestamp-millisecond':
+            return new arrow.TimestampMillisecond();
+        case 'timestamp-microsecond':
+            return new arrow.TimestampMicrosecond();
+        case 'timestamp-nanosecond':
+            return new arrow.TimestampNanosecond();
+        case 'interval-daytime':
+            return new arrow.IntervalDayTime();
+        case 'interval-yearmonth':
+            return new arrow.IntervalYearMonth();
+        default:
+            throw new Error('array type not supported');
     }
-  }
-  switch (dataType) {
-    case 'null':
-      return new arrow.Null();
-    case 'binary':
-      return new arrow.Binary();
-    case 'bool':
-      return new arrow.Bool();
-    case 'int8':
-      return new arrow.Int8();
-    case 'int16':
-      return new arrow.Int16();
-    case 'int32':
-      return new arrow.Int32();
-    case 'int64':
-      return new arrow.Int64();
-    case 'uint8':
-      return new arrow.Uint8();
-    case 'uint16':
-      return new arrow.Uint16();
-    case 'uint32':
-      return new arrow.Uint32();
-    case 'uint64':
-      return new arrow.Uint64();
-    case 'float16':
-      return new arrow.Float16();
-    case 'float32':
-      return new arrow.Float32();
-    case 'float64':
-      return new arrow.Float64();
-    case 'utf8':
-      return new arrow.Utf8();
-    case 'date-day':
-      return new arrow.DateDay();
-    case 'date-millisecond':
-      return new arrow.DateMillisecond();
-    case 'time-second':
-      return new arrow.TimeSecond();
-    case 'time-millisecond':
-      return new arrow.TimeMillisecond();
-    case 'time-microsecond':
-      return new arrow.TimeMicrosecond();
-    case 'time-nanosecond':
-      return new arrow.TimeNanosecond();
-    case 'timestamp-second':
-      return new arrow.TimestampSecond();
-    case 'timestamp-millisecond':
-      return new arrow.TimestampMillisecond();
-    case 'timestamp-microsecond':
-      return new arrow.TimestampMicrosecond();
-    case 'timestamp-nanosecond':
-      return new arrow.TimestampNanosecond();
-    case 'interval-daytime':
-      return new arrow.IntervalDayTime();
-    case 'interval-yearmonth':
-      return new arrow.IntervalYearMonth();
-    default:
-      throw new Error('array type not supported');
-  }
 }
-//# sourceMappingURL=convert-arrow-schema.js.map

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

@@ -1,5 +1,5 @@
 import type { ColumnarTable } from '@loaders.gl/schema';
-import type { ArrowTable } from '../lib/arrow-table';
+import type { ArrowTable } from "../lib/arrow-table.js";
 /**
  * Convert an Apache Arrow table to a ColumnarTable
  * @note Currently does not convert schema

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

@@ -1 +1 @@
-{"version":3,"file":"convert-arrow-to-columnar-table.d.ts","sourceRoot":"","sources":["../../src/tables/convert-arrow-to-columnar-table.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAEnD;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,UAAU,GAAG,aAAa,CAmB5E"}
+{"version":3,"file":"convert-arrow-to-columnar-table.d.ts","sourceRoot":"","sources":["../../src/tables/convert-arrow-to-columnar-table.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,oBAAoB,CAAC;AACtD,OAAO,KAAK,EAAC,UAAU,EAAC,8BAA2B;AAEnD;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,UAAU,GAAG,aAAa,CAmB5E"}

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

@@ -1,15 +1,24 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
+/**
+ * Convert an Apache Arrow table to a ColumnarTable
+ * @note Currently does not convert schema
+ */
 export function convertArrowToColumnarTable(table) {
-  const arrowTable = table.data;
-  const columnarTable = {};
-  for (const field of arrowTable.schema.fields) {
-    const arrowColumn = arrowTable.getChild(field.name);
-    const values = arrowColumn === null || arrowColumn === void 0 ? void 0 : arrowColumn.toArray();
-    columnarTable[field.name] = values;
-  }
-  return {
-    shape: 'columnar-table',
-    schema: table.schema,
-    data: columnarTable
-  };
+    // TODO - avoid calling `getColumn` on columns we are not interested in?
+    // Add options object?
+    const arrowTable = table.data;
+    const columnarTable = {};
+    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();
+        columnarTable[field.name] = values;
+    }
+    return {
+        shape: 'columnar-table',
+        schema: table.schema,
+        data: columnarTable
+    };
 }
-//# sourceMappingURL=convert-arrow-to-columnar-table.js.map

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

@@ -1,6 +1,6 @@
 import type { GeoJSONTable } from '@loaders.gl/schema';
 import * as arrow from 'apache-arrow';
-import type { ArrowTable } from '../lib/arrow-table';
+import type { ArrowTable } from "../lib/arrow-table.js";
 /**
  * Wrap an apache arrow table in a loaders.gl table wrapper.
  * From this additional conversions are available.

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

@@ -1 +1 @@
-{"version":3,"file":"convert-arrow-to-geojson-table.d.ts","sourceRoot":"","sources":["../../src/tables/convert-arrow-to-geojson-table.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAU,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAC9D,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAInD;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAAC,UAAU,EAAE,KAAK,CAAC,KAAK,GAAG,UAAU,CAMlF;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,UAAU,GAAG,YAAY,CAqC1E"}
+{"version":3,"file":"convert-arrow-to-geojson-table.d.ts","sourceRoot":"","sources":["../../src/tables/convert-arrow-to-geojson-table.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAU,YAAY,EAAC,MAAM,oBAAoB,CAAC;AAC9D,OAAO,KAAK,KAAK,MAAM,cAAc,CAAC;AACtC,OAAO,KAAK,EAAC,UAAU,EAAC,8BAA2B;AAInD;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAAC,UAAU,EAAE,KAAK,CAAC,KAAK,GAAG,UAAU,CAMlF;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,UAAU,GAAG,YAAY,CAqC1E"}

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

@@ -1,39 +1,54 @@
+// loaders.gl
+// SPDX-License-Identifier: MIT
+// Copyright (c) vis.gl contributors
 import { serializeArrowSchema, parseGeometryFromArrow } from '@loaders.gl/arrow';
 import { getGeometryColumnsFromSchema } from '@loaders.gl/gis';
+/**
+ * Wrap an apache arrow table in a loaders.gl table wrapper.
+ * From this additional conversions are available.
+ * @param arrowTable
+ * @returns
+ */
 export function convertApacheArrowToArrowTable(arrowTable) {
-  return {
-    shape: 'arrow-table',
-    schema: serializeArrowSchema(arrowTable.schema),
-    data: arrowTable
-  };
+    return {
+        shape: 'arrow-table',
+        schema: serializeArrowSchema(arrowTable.schema),
+        data: arrowTable
+    };
 }
+/**
+ * Convert an Apache Arrow table to a GeoJSONTable
+ * @note Currently does not convert schema
+ */
 export function convertArrowToGeoJSONTable(table) {
-  const arrowTable = table.data;
-  const schema = serializeArrowSchema(arrowTable.schema);
-  const geometryColumns = getGeometryColumnsFromSchema(schema);
-  const encoding = geometryColumns.geometry.encoding;
-  const features = [];
-  const propertyColumnNames = arrowTable.schema.fields.map(field => field.name).filter(name => !(name in geometryColumns));
-  const propertiesTable = arrowTable.select(propertyColumnNames);
-  const arrowGeometryColumn = arrowTable.getChild('geometry');
-  for (let row = 0; row < arrowTable.numRows; row++) {
-    const arrowGeometry = arrowGeometryColumn === null || arrowGeometryColumn === void 0 ? void 0 : arrowGeometryColumn.get(row);
-    const feature = parseGeometryFromArrow(arrowGeometry, encoding);
-    if (feature) {
-      var _propertiesTable$get;
-      const properties = ((_propertiesTable$get = propertiesTable.get(row)) === null || _propertiesTable$get === void 0 ? void 0 : _propertiesTable$get.toJSON()) || {};
-      features.push({
-        type: 'Feature',
-        geometry: feature,
-        properties
-      });
+    const arrowTable = table.data;
+    const schema = serializeArrowSchema(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: table.schema,
-    features
-  };
+    return {
+        shape: 'geojson-table',
+        type: 'FeatureCollection',
+        schema: table.schema,
+        features
+    };
 }
-//# sourceMappingURL=convert-arrow-to-geojson-table.js.map