@loaders.gl/arrow 4.0.1 → 4.0.3

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

@@ -1,4 +1,4 @@
-import { Field as ArrowField, Schema as ArrowSchema, Null, Binary, Bool, Int, Int8, Int16, Int32, Int64, Uint8, Uint16, Uint32, Uint64, Float, Float16, Float32, Float64, Precision, Utf8, DateUnit, DateDay, DateMillisecond, Time, TimeMillisecond, TimeSecond, Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond, Interval, IntervalUnit, IntervalDayTime, IntervalYearMonth, FixedSizeList, Struct, TimeUnit, TimeMicrosecond, TimeNanosecond, List } from 'apache-arrow';
+import * as arrow from 'apache-arrow';
 export function serializeArrowSchema(arrowSchema) {
   return {
     fields: arrowSchema.fields.map(arrowField => serializeArrowField(arrowField)),
@@ -6,7 +6,7 @@ export function serializeArrowSchema(arrowSchema) {
   };
 }
 export function deserializeArrowSchema(schema) {
-  return new ArrowSchema(schema.fields.map(field => deserializeArrowField(field)), deserializeArrowMetadata(schema.metadata));
+  return new arrow.Schema(schema.fields.map(field => deserializeArrowField(field)), deserializeArrowMetadata(schema.metadata));
 }
 export function serializeArrowMetadata(arrowMetadata) {
   return Object.fromEntries(arrowMetadata);
@@ -23,208 +23,235 @@ export function serializeArrowField(field) {
   };
 }
 export function deserializeArrowField(field) {
-  return new ArrowField(field.name, deserializeArrowType(field.type), field.nullable, deserializeArrowMetadata(field.metadata));
+  return new arrow.Field(field.name, deserializeArrowType(field.type), field.nullable, deserializeArrowMetadata(field.metadata));
 }
 export function serializeArrowType(arrowType) {
   switch (arrowType.constructor) {
-    case Null:
+    case arrow.Null:
       return 'null';
-    case Binary:
+    case arrow.Binary:
       return 'binary';
-    case Bool:
+    case arrow.Bool:
       return 'bool';
-    case Int:
+    case arrow.Int:
       const intType = arrowType;
       return `${intType.isSigned ? 'u' : ''}int${intType.bitWidth}`;
-    case Int8:
+    case arrow.Int8:
       return 'int8';
-    case Int16:
+    case arrow.Int16:
       return 'int16';
-    case Int32:
+    case arrow.Int32:
       return 'int32';
-    case Int64:
+    case arrow.Int64:
       return 'int64';
-    case Uint8:
+    case arrow.Uint8:
       return 'uint8';
-    case Uint16:
+    case arrow.Uint16:
       return 'uint16';
-    case Uint32:
+    case arrow.Uint32:
       return 'uint32';
-    case Uint64:
+    case arrow.Uint64:
       return 'uint64';
-    case Float:
+    case arrow.Float:
       const precision = arrowType.precision;
       switch (precision) {
-        case Precision.HALF:
+        case arrow.Precision.HALF:
           return 'float16';
-        case Precision.SINGLE:
+        case arrow.Precision.SINGLE:
           return 'float32';
-        case Precision.DOUBLE:
+        case arrow.Precision.DOUBLE:
           return 'float64';
         default:
           return 'float16';
       }
-    case Float16:
+    case arrow.Float16:
       return 'float16';
-    case Float32:
+    case arrow.Float32:
       return 'float32';
-    case Float64:
+    case arrow.Float64:
       return 'float64';
-    case Utf8:
+    case arrow.Utf8:
       return 'utf8';
-    case Date:
+    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 === DateUnit.DAY ? 'date-day' : 'date-millisecond';
-    case DateDay:
+      return dateUnit === arrow.DateUnit.DAY ? 'date-day' : 'date-millisecond';
+    case arrow.DateDay:
       return 'date-day';
-    case DateMillisecond:
+    case arrow.DateMillisecond:
       return 'date-millisecond';
-    case Time:
+    case arrow.Time:
       const timeUnit = arrowType.unit;
       switch (timeUnit) {
-        case TimeUnit.SECOND:
+        case arrow.TimeUnit.SECOND:
           return 'time-second';
-        case TimeUnit.MILLISECOND:
+        case arrow.TimeUnit.MILLISECOND:
           return 'time-millisecond';
-        case TimeUnit.MICROSECOND:
+        case arrow.TimeUnit.MICROSECOND:
           return 'time-microsecond';
-        case TimeUnit.NANOSECOND:
+        case arrow.TimeUnit.NANOSECOND:
           return 'time-nanosecond';
         default:
           return 'time-second';
       }
-    case TimeMillisecond:
+    case arrow.TimeMillisecond:
       return 'time-millisecond';
-    case TimeSecond:
+    case arrow.TimeSecond:
       return 'time-second';
-    case TimeMicrosecond:
+    case arrow.TimeMicrosecond:
       return 'time-microsecond';
-    case TimeNanosecond:
+    case arrow.TimeNanosecond:
       return 'time-nanosecond';
-    case Timestamp:
+    case arrow.Timestamp:
       const timeStampUnit = arrowType.unit;
       switch (timeStampUnit) {
-        case TimeUnit.SECOND:
+        case arrow.TimeUnit.SECOND:
           return 'timestamp-second';
-        case TimeUnit.MILLISECOND:
+        case arrow.TimeUnit.MILLISECOND:
           return 'timestamp-millisecond';
-        case TimeUnit.MICROSECOND:
+        case arrow.TimeUnit.MICROSECOND:
           return 'timestamp-microsecond';
-        case TimeUnit.NANOSECOND:
+        case arrow.TimeUnit.NANOSECOND:
           return 'timestamp-nanosecond';
         default:
           return 'timestamp-second';
       }
-    case TimestampSecond:
+    case arrow.TimestampSecond:
       return 'timestamp-second';
-    case TimestampMillisecond:
+    case arrow.TimestampMillisecond:
       return 'timestamp-millisecond';
-    case TimestampMicrosecond:
+    case arrow.TimestampMicrosecond:
       return 'timestamp-microsecond';
-    case TimestampNanosecond:
+    case arrow.TimestampNanosecond:
       return 'timestamp-nanosecond';
-    case Interval:
+    case arrow.Interval:
       const intervalUnit = arrowType.unit;
       switch (intervalUnit) {
-        case IntervalUnit.DAY_TIME:
+        case arrow.IntervalUnit.DAY_TIME:
           return 'interval-daytime';
-        case IntervalUnit.YEAR_MONTH:
+        case arrow.IntervalUnit.YEAR_MONTH:
           return 'interval-yearmonth';
         default:
           return 'interval-daytime';
       }
-    case IntervalDayTime:
+    case arrow.IntervalDayTime:
       return 'interval-daytime';
-    case IntervalYearMonth:
+    case arrow.IntervalYearMonth:
       return 'interval-yearmonth';
-    case List:
+    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 FixedSizeList:
+    case arrow.FixedSizeList:
+      const fixedSizeList = arrowType;
       return {
         type: 'fixed-size-list',
-        listSize: arrowType.listSize,
-        children: [serializeArrowField(arrowType.children[0])]
+        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('array type not supported');
+      throw new Error(`arrow type not supported: ${arrowType.constructor.name}`);
   }
 }
 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 List(field);
+        return new arrow.List(field);
       case 'fixed-size-list':
         const child = deserializeArrowField(dataType.children[0]);
-        return new FixedSizeList(dataType.listSize, child);
+        return new arrow.FixedSizeList(dataType.listSize, child);
       case 'struct':
-        const children = dataType.children.map(arrowField => deserializeArrowField(arrowField));
-        return new Struct(children);
+        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 Null();
+      return new arrow.Null();
     case 'binary':
-      return new Binary();
+      return new arrow.Binary();
     case 'bool':
-      return new Bool();
+      return new arrow.Bool();
     case 'int8':
-      return new Int8();
+      return new arrow.Int8();
     case 'int16':
-      return new Int16();
+      return new arrow.Int16();
     case 'int32':
-      return new Int32();
+      return new arrow.Int32();
     case 'int64':
-      return new Int64();
+      return new arrow.Int64();
     case 'uint8':
-      return new Uint8();
+      return new arrow.Uint8();
     case 'uint16':
-      return new Uint16();
+      return new arrow.Uint16();
     case 'uint32':
-      return new Uint32();
+      return new arrow.Uint32();
     case 'uint64':
-      return new Uint64();
+      return new arrow.Uint64();
     case 'float16':
-      return new Float16();
+      return new arrow.Float16();
     case 'float32':
-      return new Float32();
+      return new arrow.Float32();
     case 'float64':
-      return new Float64();
+      return new arrow.Float64();
     case 'utf8':
-      return new Utf8();
+      return new arrow.Utf8();
     case 'date-day':
-      return new DateDay();
+      return new arrow.DateDay();
     case 'date-millisecond':
-      return new DateMillisecond();
+      return new arrow.DateMillisecond();
     case 'time-second':
-      return new TimeSecond();
+      return new arrow.TimeSecond();
     case 'time-millisecond':
-      return new TimeMillisecond();
+      return new arrow.TimeMillisecond();
     case 'time-microsecond':
-      return new TimeMicrosecond();
+      return new arrow.TimeMicrosecond();
     case 'time-nanosecond':
-      return new TimeNanosecond();
+      return new arrow.TimeNanosecond();
     case 'timestamp-second':
-      return new TimestampSecond();
+      return new arrow.TimestampSecond();
     case 'timestamp-millisecond':
-      return new TimestampMillisecond();
+      return new arrow.TimestampMillisecond();
     case 'timestamp-microsecond':
-      return new TimestampMicrosecond();
+      return new arrow.TimestampMicrosecond();
     case 'timestamp-nanosecond':
-      return new TimestampNanosecond();
+      return new arrow.TimestampNanosecond();
     case 'interval-daytime':
-      return new IntervalDayTime();
+      return new arrow.IntervalDayTime();
     case 'interval-yearmonth':
-      return new IntervalYearMonth();
+      return new arrow.IntervalYearMonth();
     default:
       throw new Error('array type not supported');
   }

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

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

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

@@ -1,5 +1,5 @@
 import type { ColumnarTable, ObjectRowTable } from '@loaders.gl/schema';
-import type { Table as ApacheArrowTable } from 'apache-arrow';
+import type * as arrow from 'apache-arrow';
 import type { ArrowTable } from '../lib/arrow-table';
 /**
  * Wrap an apache arrow table in a loaders.gl table wrapper.
@@ -7,7 +7,7 @@ import type { ArrowTable } from '../lib/arrow-table';
  * @param arrowTable
  * @returns
  */
-export declare function convertApacheArrowToArrowTable(arrowTable: ApacheArrowTable): ArrowTable;
+export declare function convertApacheArrowToArrowTable(arrowTable: arrow.Table): ArrowTable;
 /**
  * Convert an Apache Arrow table to a ColumnarTable
  * @note Currently does not convert schema

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

@@ -1 +1 @@
-{"version":3,"file":"convert-arrow-to-table.d.ts","sourceRoot":"","sources":["../../src/tables/convert-arrow-to-table.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,aAAa,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AACtE,OAAO,KAAK,EAAC,KAAK,IAAI,gBAAgB,EAAC,MAAM,cAAc,CAAC;AAC5D,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAEnD;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAAC,UAAU,EAAE,gBAAgB,GAAG,UAAU,CAKvF;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,UAAU,GAAG,aAAa,CAkB5E;AAED;;;GAGG;AACH,wBAAgB,+BAA+B,CAAC,aAAa,EAAE,aAAa,GAAG,cAAc,CAmB5F"}
+{"version":3,"file":"convert-arrow-to-table.d.ts","sourceRoot":"","sources":["../../src/tables/convert-arrow-to-table.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,aAAa,EAAE,cAAc,EAAC,MAAM,oBAAoB,CAAC;AACtE,OAAO,KAAK,KAAK,KAAK,MAAM,cAAc,CAAC;AAC3C,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,oBAAoB,CAAC;AAEnD;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAAC,UAAU,EAAE,KAAK,CAAC,KAAK,GAAG,UAAU,CAKlF;AAED;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,KAAK,EAAE,UAAU,GAAG,aAAa,CAkB5E;AAED;;;GAGG;AACH,wBAAgB,+BAA+B,CAAC,aAAa,EAAE,aAAa,GAAG,cAAc,CAmB5F"}

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

@@ -1 +1 @@
-{"version":3,"file":"convert-arrow-to-table.js","names":["convertApacheArrowToArrowTable","arrowTable","shape","data","convertArrowToColumnarTable","table","columnarTable","field","schema","fields","arrowColumn","getChild","name","values","toArray","convertColumnarToRowFormatTable","tableKeys","Object","keys","tableRowsCount","length","rowFormatTable","index","tableItem","keyIndex","fieldName","push"],"sources":["../../src/tables/convert-arrow-to-table.ts"],"sourcesContent":["// loaders.gl, MIT license\n// Copyright (c) vis.gl contributors\n\nimport type {ColumnarTable, ObjectRowTable} from '@loaders.gl/schema';\nimport type {Table as ApacheArrowTable} from 'apache-arrow';\nimport type {ArrowTable} from '../lib/arrow-table';\n\n/**\n * Wrap an apache arrow table in a loaders.gl table wrapper.\n * From this additional conversions are available.\n * @param arrowTable\n * @returns\n */\nexport function convertApacheArrowToArrowTable(arrowTable: ApacheArrowTable): ArrowTable {\n  return {\n    shape: 'arrow-table',\n    data: arrowTable\n  };\n}\n\n/**\n * Convert an Apache Arrow table to a ColumnarTable\n * @note Currently does not convert schema\n */\nexport function convertArrowToColumnarTable(table: ArrowTable): ColumnarTable {\n  // TODO - avoid calling `getColumn` on columns we are not interested in?\n  // Add options object?\n\n  const arrowTable = table.data;\n  const columnarTable = {};\n\n  for (const field of arrowTable.schema.fields) {\n    // This (is intended to) coalesce all record batches into a single typed array\n    const arrowColumn = arrowTable.getChild(field.name);\n    const values = arrowColumn?.toArray();\n    columnarTable[field.name] = values;\n  }\n\n  return {\n    shape: 'columnar-table',\n    data: columnarTable\n  };\n}\n\n/**\n *\n * @note - should be part of schema module\n */\nexport function convertColumnarToRowFormatTable(columnarTable: ColumnarTable): ObjectRowTable {\n  const tableKeys = Object.keys(columnarTable);\n  const tableRowsCount = columnarTable[tableKeys[0]].length;\n\n  const rowFormatTable: {}[] = [];\n\n  for (let index = 0; index < tableRowsCount; index++) {\n    const tableItem = {};\n    for (let keyIndex = 0; keyIndex < tableKeys.length; keyIndex++) {\n      const fieldName = tableKeys[keyIndex];\n      tableItem[fieldName] = columnarTable[fieldName][index];\n    }\n    rowFormatTable.push(tableItem);\n  }\n\n  return {\n    shape: 'object-row-table',\n    data: rowFormatTable\n  };\n}\n"],"mappings":"AAaA,OAAO,SAASA,8BAA8BA,CAACC,UAA4B,EAAc;EACvF,OAAO;IACLC,KAAK,EAAE,aAAa;IACpBC,IAAI,EAAEF;EACR,CAAC;AACH;AAMA,OAAO,SAASG,2BAA2BA,CAACC,KAAiB,EAAiB;EAI5E,MAAMJ,UAAU,GAAGI,KAAK,CAACF,IAAI;EAC7B,MAAMG,aAAa,GAAG,CAAC,CAAC;EAExB,KAAK,MAAMC,KAAK,IAAIN,UAAU,CAACO,MAAM,CAACC,MAAM,EAAE;IAE5C,MAAMC,WAAW,GAAGT,UAAU,CAACU,QAAQ,CAACJ,KAAK,CAACK,IAAI,CAAC;IACnD,MAAMC,MAAM,GAAGH,WAAW,aAAXA,WAAW,uBAAXA,WAAW,CAAEI,OAAO,CAAC,CAAC;IACrCR,aAAa,CAACC,KAAK,CAACK,IAAI,CAAC,GAAGC,MAAM;EACpC;EAEA,OAAO;IACLX,KAAK,EAAE,gBAAgB;IACvBC,IAAI,EAAEG;EACR,CAAC;AACH;AAMA,OAAO,SAASS,+BAA+BA,CAACT,aAA4B,EAAkB;EAC5F,MAAMU,SAAS,GAAGC,MAAM,CAACC,IAAI,CAACZ,aAAa,CAAC;EAC5C,MAAMa,cAAc,GAAGb,aAAa,CAACU,SAAS,CAAC,CAAC,CAAC,CAAC,CAACI,MAAM;EAEzD,MAAMC,cAAoB,GAAG,EAAE;EAE/B,KAAK,IAAIC,KAAK,GAAG,CAAC,EAAEA,KAAK,GAAGH,cAAc,EAAEG,KAAK,EAAE,EAAE;IACnD,MAAMC,SAAS,GAAG,CAAC,CAAC;IACpB,KAAK,IAAIC,QAAQ,GAAG,CAAC,EAAEA,QAAQ,GAAGR,SAAS,CAACI,MAAM,EAAEI,QAAQ,EAAE,EAAE;MAC9D,MAAMC,SAAS,GAAGT,SAAS,CAACQ,QAAQ,CAAC;MACrCD,SAAS,CAACE,SAAS,CAAC,GAAGnB,aAAa,CAACmB,SAAS,CAAC,CAACH,KAAK,CAAC;IACxD;IACAD,cAAc,CAACK,IAAI,CAACH,SAAS,CAAC;EAChC;EAEA,OAAO;IACLrB,KAAK,EAAE,kBAAkB;IACzBC,IAAI,EAAEkB;EACR,CAAC;AACH"}
+{"version":3,"file":"convert-arrow-to-table.js","names":["convertApacheArrowToArrowTable","arrowTable","shape","data","convertArrowToColumnarTable","table","columnarTable","field","schema","fields","arrowColumn","getChild","name","values","toArray","convertColumnarToRowFormatTable","tableKeys","Object","keys","tableRowsCount","length","rowFormatTable","index","tableItem","keyIndex","fieldName","push"],"sources":["../../src/tables/convert-arrow-to-table.ts"],"sourcesContent":["// loaders.gl, MIT license\n// Copyright (c) vis.gl contributors\n\nimport type {ColumnarTable, ObjectRowTable} from '@loaders.gl/schema';\nimport type * as arrow from 'apache-arrow';\nimport type {ArrowTable} from '../lib/arrow-table';\n\n/**\n * Wrap an apache arrow table in a loaders.gl table wrapper.\n * From this additional conversions are available.\n * @param arrowTable\n * @returns\n */\nexport function convertApacheArrowToArrowTable(arrowTable: arrow.Table): ArrowTable {\n  return {\n    shape: 'arrow-table',\n    data: arrowTable\n  };\n}\n\n/**\n * Convert an Apache Arrow table to a ColumnarTable\n * @note Currently does not convert schema\n */\nexport function convertArrowToColumnarTable(table: ArrowTable): ColumnarTable {\n  // TODO - avoid calling `getColumn` on columns we are not interested in?\n  // Add options object?\n\n  const arrowTable = table.data;\n  const columnarTable = {};\n\n  for (const field of arrowTable.schema.fields) {\n    // This (is intended to) coalesce all record batches into a single typed array\n    const arrowColumn = arrowTable.getChild(field.name);\n    const values = arrowColumn?.toArray();\n    columnarTable[field.name] = values;\n  }\n\n  return {\n    shape: 'columnar-table',\n    data: columnarTable\n  };\n}\n\n/**\n *\n * @note - should be part of schema module\n */\nexport function convertColumnarToRowFormatTable(columnarTable: ColumnarTable): ObjectRowTable {\n  const tableKeys = Object.keys(columnarTable);\n  const tableRowsCount = columnarTable[tableKeys[0]].length;\n\n  const rowFormatTable: {}[] = [];\n\n  for (let index = 0; index < tableRowsCount; index++) {\n    const tableItem = {};\n    for (let keyIndex = 0; keyIndex < tableKeys.length; keyIndex++) {\n      const fieldName = tableKeys[keyIndex];\n      tableItem[fieldName] = columnarTable[fieldName][index];\n    }\n    rowFormatTable.push(tableItem);\n  }\n\n  return {\n    shape: 'object-row-table',\n    data: rowFormatTable\n  };\n}\n"],"mappings":"AAaA,OAAO,SAASA,8BAA8BA,CAACC,UAAuB,EAAc;EAClF,OAAO;IACLC,KAAK,EAAE,aAAa;IACpBC,IAAI,EAAEF;EACR,CAAC;AACH;AAMA,OAAO,SAASG,2BAA2BA,CAACC,KAAiB,EAAiB;EAI5E,MAAMJ,UAAU,GAAGI,KAAK,CAACF,IAAI;EAC7B,MAAMG,aAAa,GAAG,CAAC,CAAC;EAExB,KAAK,MAAMC,KAAK,IAAIN,UAAU,CAACO,MAAM,CAACC,MAAM,EAAE;IAE5C,MAAMC,WAAW,GAAGT,UAAU,CAACU,QAAQ,CAACJ,KAAK,CAACK,IAAI,CAAC;IACnD,MAAMC,MAAM,GAAGH,WAAW,aAAXA,WAAW,uBAAXA,WAAW,CAAEI,OAAO,CAAC,CAAC;IACrCR,aAAa,CAACC,KAAK,CAACK,IAAI,CAAC,GAAGC,MAAM;EACpC;EAEA,OAAO;IACLX,KAAK,EAAE,gBAAgB;IACvBC,IAAI,EAAEG;EACR,CAAC;AACH;AAMA,OAAO,SAASS,+BAA+BA,CAACT,aAA4B,EAAkB;EAC5F,MAAMU,SAAS,GAAGC,MAAM,CAACC,IAAI,CAACZ,aAAa,CAAC;EAC5C,MAAMa,cAAc,GAAGb,aAAa,CAACU,SAAS,CAAC,CAAC,CAAC,CAAC,CAACI,MAAM;EAEzD,MAAMC,cAAoB,GAAG,EAAE;EAE/B,KAAK,IAAIC,KAAK,GAAG,CAAC,EAAEA,KAAK,GAAGH,cAAc,EAAEG,KAAK,EAAE,EAAE;IACnD,MAAMC,SAAS,GAAG,CAAC,CAAC;IACpB,KAAK,IAAIC,QAAQ,GAAG,CAAC,EAAEA,QAAQ,GAAGR,SAAS,CAACI,MAAM,EAAEI,QAAQ,EAAE,EAAE;MAC9D,MAAMC,SAAS,GAAGT,SAAS,CAACQ,QAAQ,CAAC;MACrCD,SAAS,CAACE,SAAS,CAAC,GAAGnB,aAAa,CAACmB,SAAS,CAAC,CAACH,KAAK,CAAC;IACxD;IACAD,cAAc,CAACK,IAAI,CAACH,SAAS,CAAC;EAChC;EAEA,OAAO;IACLrB,KAAK,EAAE,kBAAkB;IACzBC,IAAI,EAAEkB;EACR,CAAC;AACH"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@loaders.gl/arrow",
-  "version": "4.0.1",
+  "version": "4.0.3",
   "description": "Simple columnar table loader for the Apache Arrow format",
   "license": "MIT",
   "type": "module",
@@ -46,10 +46,10 @@
     "build-worker2": "esbuild src/workers/arrow-worker.ts --bundle --outfile=dist/arrow-worker.js --platform=browser --external:{stream}"
   },
   "dependencies": {
-    "@loaders.gl/gis": "4.0.1",
-    "@loaders.gl/loader-utils": "4.0.1",
-    "@loaders.gl/schema": "4.0.1",
+    "@loaders.gl/gis": "4.0.3",
+    "@loaders.gl/loader-utils": "4.0.3",
+    "@loaders.gl/schema": "4.0.3",
     "apache-arrow": "^13.0.0"
   },
-  "gitHead": "765e5a26a6bf3f2cc02cabffc4a1e3665ec92a53"
+  "gitHead": "03c871839b36c997249dabae1844df53a35d3760"
 }

package/src/arrow-writer.ts

@@ -1,6 +1,6 @@
 // import type {} from '@loaders.gl/loader-utils';
 
-import type {Writer, WriterOptions} 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';
 
@@ -13,7 +13,7 @@ type ArrowWriterOptions = WriterOptions & {
 };
 
 /** Apache Arrow writer */
-export const ArrowWriter: Writer<ColumnarTable, never, ArrowWriterOptions> = {
+export const ArrowWriter: WriterWithEncoder<ColumnarTable, never, ArrowWriterOptions> = {
   name: 'Apache Arrow',
   id: 'arrow',
   module: 'arrow',
@@ -24,9 +24,12 @@ export const ArrowWriter: Writer<ColumnarTable, never, ArrowWriterOptions> = {
     'application/vnd.apache.arrow.stream',
     'application/octet-stream'
   ],
-  encodeSync(data, options?) {
+  binary: true,
+  options: {},
+  encode: async function encodeArrow(data, options?): Promise<ArrayBuffer> {
     return encodeArrowSync(data);
   },
-  binary: true,
-  options: {}
+  encodeSync(data, options?) {
+    return encodeArrowSync(data);
+  }
 };