@loaders.gl/arrow 4.0.1 → 4.0.2

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","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","List","listType","listField","valueField","children","FixedSizeList","listSize","Error","dataType","child","Struct"],"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 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.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      return {\n        type: 'fixed-size-list',\n        listSize: (arrowType as arrow.FixedSizeList).listSize,\n        children: [serializeArrowField((arrowType as arrow.FixedSizeList).children[0])]\n      };\n    // case arrow.Struct:\n    //   return {type: 'struct', children: (arrowType as arrow.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): arrow.DataType {\n  if (typeof dataType === 'object') {\n    switch (dataType.type) {\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        const 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.2",
   "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.2",
+    "@loaders.gl/loader-utils": "4.0.2",
+    "@loaders.gl/schema": "4.0.2",
     "apache-arrow": "^13.0.0"
   },
-  "gitHead": "765e5a26a6bf3f2cc02cabffc4a1e3665ec92a53"
+  "gitHead": "471058d109d5652f28c32c1f296fd632f9a5c806"
 }

package/src/arrow-writer.ts

@@ -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);
+  }
 };

package/src/geoarrow/convert-geoarrow-to-binary-geometry.ts

@@ -1,7 +1,7 @@
 // loaders.gl, MIT license
 // Copyright (c) vis.gl contributors
 
-import {Data, Vector} from 'apache-arrow';
+import * as arrow from 'apache-arrow';
 import {BinaryFeatureCollection as BinaryFeatures} from '@loaders.gl/schema';
 import {GeoArrowEncoding} from '@loaders.gl/gis';
 import {updateBoundsFromGeoArrowSamples} from './get-arrow-bounds';
@@ -24,7 +24,7 @@ type BinaryGeometryContent = {
 };
 
 // binary geometry template, see deck.gl BinaryGeometry
-const BINARY_GEOMETRY_TEMPLATE = {
+export const BINARY_GEOMETRY_TEMPLATE = {
   globalFeatureIds: {value: new Uint32Array(0), size: 1},
   positions: {value: new Float32Array(0), size: 2},
   properties: [],
@@ -40,7 +40,7 @@ const BINARY_GEOMETRY_TEMPLATE = {
  * @returns BinaryDataFromGeoArrow
  */
 export function getBinaryGeometriesFromArrow(
-  geoColumn: Vector,
+  geoColumn: arrow.Vector,
   geoEncoding: GeoArrowEncoding
 ): BinaryDataFromGeoArrow {
   const featureTypes = {
@@ -50,14 +50,13 @@ export function getBinaryGeometriesFromArrow(
   };
 
   const chunks = geoColumn.data;
-  const bounds: [number, number, number, number] = [Infinity, Infinity, -Infinity, -Infinity];
+  let bounds: [number, number, number, number] = [Infinity, Infinity, -Infinity, -Infinity];
   let globalFeatureIdOffset = 0;
   const binaryGeometries: BinaryFeatures[] = [];
 
-  for (let c = 0; c < chunks.length; c++) {
-    const geometries = chunks[c];
+  chunks.forEach((chunk) => {
     const {featureIds, flatCoordinateArray, nDim, geomOffset} = getBinaryGeometriesFromChunk(
-      geometries,
+      chunk,
       geoEncoding
     );
 
@@ -74,14 +73,13 @@ export function getBinaryGeometriesFromArrow(
         size: nDim
       },
       featureIds: {value: featureIds, size: 1},
-      // eslint-disable-next-line no-loop-func
-      properties: [...Array(geometries.length).keys()].map((i) => ({
+      properties: [...Array(chunk.length).keys()].map((i) => ({
         index: i + globalFeatureIdOffset
       }))
     };
 
     // TODO: check if chunks are sequentially accessed
-    globalFeatureIdOffset += geometries.length;
+    globalFeatureIdOffset += chunk.length;
 
     // NOTE: deck.gl defines the BinaryFeatures structure must have points, lines, polygons even if they are empty
     binaryGeometries.push({
@@ -114,8 +112,8 @@ export function getBinaryGeometriesFromArrow(
       }
     });
 
-    updateBoundsFromGeoArrowSamples(flatCoordinateArray, nDim, bounds);
-  }
+    bounds = updateBoundsFromGeoArrowSamples(flatCoordinateArray, nDim, bounds);
+  });
 
   return {binaryGeometries, bounds, featureTypes};
 }
@@ -127,7 +125,7 @@ export function getBinaryGeometriesFromArrow(
  * @returns BinaryGeometryContent
  */
 function getBinaryGeometriesFromChunk(
-  chunk: Data,
+  chunk: arrow.Data,
   geoEncoding: GeoArrowEncoding
 ): BinaryGeometryContent {
   switch (geoEncoding) {
@@ -151,7 +149,7 @@ function getBinaryGeometriesFromChunk(
  * @param geoEncoding the geo encoding of the geoarrow polygon column
  * @returns BinaryGeometryContent
  */
-function getBinaryPolygonsFromChunk(chunk: Data, geoEncoding: string): BinaryGeometryContent {
+function getBinaryPolygonsFromChunk(chunk: arrow.Data, geoEncoding: string): BinaryGeometryContent {
   const isMultiPolygon = geoEncoding === 'geoarrow.multipolygon';
 
   const polygonData = isMultiPolygon ? chunk.children[0] : chunk;
@@ -193,7 +191,7 @@ function getBinaryPolygonsFromChunk(chunk: Data, geoEncoding: string): BinaryGeo
  * @param geoEncoding the geo encoding of the geoarrow column
  * @returns BinaryGeometryContent
  */
-function getBinaryLinesFromChunk(chunk: Data, geoEncoding: string): BinaryGeometryContent {
+function getBinaryLinesFromChunk(chunk: arrow.Data, geoEncoding: string): BinaryGeometryContent {
   const isMultiLineString = geoEncoding === 'geoarrow.multilinestring';
 
   const lineData = isMultiLineString ? chunk.children[0] : chunk;
@@ -232,7 +230,7 @@ function getBinaryLinesFromChunk(chunk: Data, geoEncoding: string): BinaryGeomet
  * @param geoEncoding  geo encoding of the geoarrow column
  * @returns BinaryGeometryContent
  */
-function getBinaryPointsFromChunk(chunk: Data, geoEncoding: string): BinaryGeometryContent {
+function getBinaryPointsFromChunk(chunk: arrow.Data, geoEncoding: string): BinaryGeometryContent {
   const isMultiPoint = geoEncoding === 'geoarrow.multipoint';
 
   const pointData = isMultiPoint ? chunk.children[0] : chunk;

package/src/geoarrow/convert-geoarrow-to-geojson.ts

@@ -1,7 +1,7 @@
 // loaders.gl, MIT license
 // Copyright (c) vis.gl contributors
 
-import {Vector} from 'apache-arrow';
+import * as arrow from 'apache-arrow';
 import {
   Feature,
   MultiPolygon,
@@ -71,7 +71,7 @@ export function parseGeometryFromArrow(rawData: RawArrowFeature): Feature | null
 /**
  * convert Arrow MultiPolygon to geojson Feature
  */
-function arrowMultiPolygonToFeature(arrowMultiPolygon: Vector): MultiPolygon {
+function arrowMultiPolygonToFeature(arrowMultiPolygon: arrow.Vector): MultiPolygon {
   const multiPolygon: Position[][][] = [];
   for (let m = 0; m < arrowMultiPolygon.length; m++) {
     const arrowPolygon = arrowMultiPolygon.get(m);
@@ -98,7 +98,7 @@ function arrowMultiPolygonToFeature(arrowMultiPolygon: Vector): MultiPolygon {
 /**
  * convert Arrow Polygon to geojson Feature
  */
-function arrowPolygonToFeature(arrowPolygon: Vector): Polygon {
+function arrowPolygonToFeature(arrowPolygon: arrow.Vector): Polygon {
   const polygon: Position[][] = [];
   for (let i = 0; arrowPolygon && i < arrowPolygon.length; i++) {
     const arrowRing = arrowPolygon.get(i);
@@ -120,7 +120,7 @@ function arrowPolygonToFeature(arrowPolygon: Vector): Polygon {
 /**
  * convert Arrow MultiPoint to geojson MultiPoint
  */
-function arrowMultiPointToFeature(arrowMultiPoint: Vector): MultiPoint {
+function arrowMultiPointToFeature(arrowMultiPoint: arrow.Vector): MultiPoint {
   const multiPoint: Position[] = [];
   for (let i = 0; arrowMultiPoint && i < arrowMultiPoint.length; i++) {
     const arrowPoint = arrowMultiPoint.get(i);
@@ -139,7 +139,7 @@ function arrowMultiPointToFeature(arrowMultiPoint: Vector): MultiPoint {
 /**
  * convert Arrow Point to geojson Point
  */
-function arrowPointToFeature(arrowPoint: Vector): Point {
+function arrowPointToFeature(arrowPoint: arrow.Vector): Point {
   const point: Position = Array.from(arrowPoint);
   const geometry: Point = {
     type: 'Point',
@@ -151,7 +151,7 @@ function arrowPointToFeature(arrowPoint: Vector): Point {
 /**
  * convert Arrow MultiLineString to geojson MultiLineString
  */
-function arrowMultiLineStringToFeature(arrowMultiLineString: Vector): MultiLineString {
+function arrowMultiLineStringToFeature(arrowMultiLineString: arrow.Vector): MultiLineString {
   const multiLineString: Position[][] = [];
   for (let i = 0; arrowMultiLineString && i < arrowMultiLineString.length; i++) {
     const arrowLineString = arrowMultiLineString.get(i);
@@ -175,7 +175,7 @@ function arrowMultiLineStringToFeature(arrowMultiLineString: Vector): MultiLineS
 /**
  * convert Arrow LineString to geojson LineString
  */
-function arrowLineStringToFeature(arrowLineString: Vector): LineString {
+function arrowLineStringToFeature(arrowLineString: arrow.Vector): LineString {
   const lineString: Position[] = [];
   for (let i = 0; arrowLineString && i < arrowLineString.length; i++) {
     const arrowCoord = arrowLineString.get(i);

package/src/geoarrow/get-arrow-bounds.ts

@@ -23,7 +23,7 @@ export function updateBoundsFromGeoArrowSamples(
   for (let i = 0; i < numberOfFeatures; i += sampleStep) {
     const lng = flatCoords[i * nDim];
     const lat = flatCoords[i * nDim + 1];
-    if (lng < bounds[0]) {
+    if (lng < newBounds[0]) {
       newBounds[0] = lng;
     }
     if (lat < newBounds[1]) {
@@ -36,6 +36,5 @@ export function updateBoundsFromGeoArrowSamples(
       newBounds[3] = lat;
     }
   }
-
   return newBounds;
 }

package/src/index.ts

@@ -65,6 +65,11 @@ export type {GeoArrowEncoding} from '@loaders.gl/gis';
 // getGeoArrowEncoding
 
 export type {BinaryDataFromGeoArrow} from './geoarrow/convert-geoarrow-to-binary-geometry';
-export {getBinaryGeometriesFromArrow} from './geoarrow/convert-geoarrow-to-binary-geometry';
+export {
+  BINARY_GEOMETRY_TEMPLATE,
+  getBinaryGeometriesFromArrow
+} from './geoarrow/convert-geoarrow-to-binary-geometry';
 
 export {parseGeometryFromArrow} from './geoarrow/convert-geoarrow-to-geojson';
+
+export {updateBoundsFromGeoArrowSamples} from './geoarrow/get-arrow-bounds';

package/src/lib/arrow-table-batch.ts

@@ -1,19 +1,9 @@
 import {ColumnarTableBatchAggregator} from '@loaders.gl/schema';
 import type {ArrowTableBatch} from './arrow-table';
-import {
-  Table as ApacheArrowTable,
-  Schema,
-  Field,
-  RecordBatch,
-  Struct,
-  makeVector,
-  makeData,
-  Vector,
-  Float32
-} from 'apache-arrow';
+import * as arrow from 'apache-arrow';
 
 export class ArrowTableBatchAggregator extends ColumnarTableBatchAggregator {
-  arrowSchema: Schema | null;
+  arrowSchema: arrow.Schema | null;
 
   constructor(schema, options) {
     super(schema, options);
@@ -30,10 +20,10 @@ export class ArrowTableBatchAggregator extends ColumnarTableBatchAggregator {
       const arrowVectors = getArrowVectors(this.arrowSchema, batch.data);
 
       // Create the record batch
-      const recordBatch = new RecordBatch(
+      const recordBatch = new arrow.RecordBatch(
         this.arrowSchema,
-        makeData({
-          type: new Struct(this.arrowSchema.fields),
+        arrow.makeData({
+          type: new arrow.Struct(this.arrowSchema.fields),
           children: arrowVectors.map(({data}) => data[0])
         })
       );
@@ -41,7 +31,7 @@ export class ArrowTableBatchAggregator extends ColumnarTableBatchAggregator {
       return {
         shape: 'arrow-table',
         batchType: 'data',
-        data: new ApacheArrowTable([recordBatch]),
+        data: new arrow.Table([recordBatch]),
         length: batch.length
       };
     }
@@ -51,15 +41,15 @@ export class ArrowTableBatchAggregator extends ColumnarTableBatchAggregator {
 }
 
 // Convert from a simple loaders.gl schema to an Arrow schema
-function getArrowSchema(schema): Schema {
-  const arrowFields: Field[] = [];
+function getArrowSchema(schema): arrow.Schema {
+  const arrowFields: arrow.Field[] = [];
   for (const key in schema) {
     const field = schema[key];
     if (field.type === Float32Array) {
       // TODO - just store the original field as metadata?
       const metadata = new Map(); // field;
-      // arrow: new Field(name, nullable, metadata)
-      const arrowField = new Field(field.name, new Float32(), field.nullable, metadata);
+      // arrow: new arrow.Field(name, nullable, metadata)
+      const arrowField = new arrow.Field(field.name, new arrow.Float32(), field.nullable, metadata);
       arrowFields.push(arrowField);
     }
   }
@@ -67,16 +57,16 @@ function getArrowSchema(schema): Schema {
     throw new Error('No arrow convertible fields');
   }
 
-  return new Schema(arrowFields);
+  return new arrow.Schema(arrowFields);
 }
 
 // Convert from simple loaders.gl arrays to arrow vectors
-function getArrowVectors(arrowSchema, data): Vector[] {
+function getArrowVectors(arrowSchema, data): arrow.Vector[] {
   const arrowVectors: any[] = [];
   for (const field of arrowSchema.fields) {
     const vector = data[field.name];
     if (vector instanceof Float32Array) {
-      const arrowVector = makeVector(vector);
+      const arrowVector = arrow.makeVector(vector);
       arrowVectors.push(arrowVector);
     }
   }

package/src/lib/arrow-table.ts

@@ -2,7 +2,7 @@
 // Copyright (c) vis.gl contributors
 
 import type {Batch, Schema} from '@loaders.gl/schema';
-import type {Table as ApacheArrowTable} from 'apache-arrow';
+import type * as arrow from 'apache-arrow';
 
 /**
  * A table organized as an Apache Arrow table
@@ -11,7 +11,7 @@ import type {Table as ApacheArrowTable} from 'apache-arrow';
 export type ArrowTable = {
   shape: 'arrow-table';
   schema?: Schema;
-  data: ApacheArrowTable;
+  data: arrow.Table;
 };
 
 /**
@@ -22,6 +22,6 @@ export type ArrowTableBatch = Batch & {
   shape: 'arrow-table';
   schemaType?: 'explicit' | 'deduced';
   schema?: Schema;
-  data: ApacheArrowTable; // ApacheRecordBatch;
+  data: arrow.Table; // ApacheRecordBatch;
   length: number;
 };

package/src/lib/encode-arrow.ts

@@ -1,4 +1,4 @@
-import {Table, Vector, tableToIPC, vectorFromArray} from 'apache-arrow';
+import * as arrow from 'apache-arrow';
 import {AnyArrayType, VECTOR_TYPES} from '../types';
 
 export type ColumnarTable = {
@@ -15,28 +15,28 @@ export type ColumnarTable = {
  * @returns - encoded ArrayBuffer
  */
 export function encodeArrowSync(data: ColumnarTable): ArrayBuffer {
-  const vectors: Record<string, Vector> = {};
+  const vectors: Record<string, arrow.Vector> = {};
   for (const arrayData of data) {
     const arrayVector = createVector(arrayData.array, arrayData.type);
     vectors[arrayData.name] = arrayVector;
   }
-  const table = new Table(vectors);
-  const arrowBuffer = tableToIPC(table);
+  const table = new arrow.Table(vectors);
+  const arrowBuffer = arrow.tableToIPC(table);
   return arrowBuffer;
 }
 
 /**
- * Create Arrow Vector from given data and vector type
+ * Create Arrow arrow.Vector from given data and vector type
  * @param array {import('../types').AnyArrayType} - columns data
  * @param type {number} - the writer options
  * @return a vector of one of vector's types defined in the Apache Arrow library
  */
-function createVector(array, type): Vector {
+function createVector(array, type): arrow.Vector {
   switch (type) {
     case VECTOR_TYPES.DATE:
-      return vectorFromArray(array);
+      return arrow.vectorFromArray(array);
     case VECTOR_TYPES.FLOAT:
     default:
-      return vectorFromArray(array);
+      return arrow.vectorFromArray(array);
   }
 }

package/src/lib/parse-arrow-in-batches.ts

@@ -1,6 +1,6 @@
 // TODO - this import defeats the sophisticated typescript checking in ArrowJS
 import type {ArrowTableBatch} from './arrow-table';
-import {RecordBatchReader, Table as ApacheArrowTable} from 'apache-arrow';
+import * as arrow from 'apache-arrow';
 // import {isIterable} from '@loaders.gl/core';
 
 /**
@@ -8,7 +8,7 @@ import {RecordBatchReader, Table as ApacheArrowTable} from 'apache-arrow';
 export function parseArrowInBatches(
   asyncIterator: AsyncIterable<ArrayBuffer> | Iterable<ArrayBuffer>
 ): AsyncIterable<ArrowTableBatch> {
-  // Creates the appropriate RecordBatchReader subclasses from the input
+  // Creates the appropriate arrow.RecordBatchReader subclasses from the input
   // This will also close the underlying source in case of early termination or errors
 
   // As an optimization, return a non-async iterator
@@ -28,13 +28,13 @@ export function parseArrowInBatches(
 
   async function* makeArrowAsyncIterator(): AsyncIterator<ArrowTableBatch> {
     // @ts-ignore
-    const readers = RecordBatchReader.readAll(asyncIterator);
+    const readers = arrow.RecordBatchReader.readAll(asyncIterator);
     for await (const reader of readers) {
       for await (const recordBatch of reader) {
         const arrowTabledBatch: ArrowTableBatch = {
           shape: 'arrow-table',
           batchType: 'data',
-          data: new ApacheArrowTable([recordBatch]),
+          data: new arrow.Table([recordBatch]),
           length: recordBatch.data.length
         };
         // processBatch(recordBatch);

package/src/lib/parse-arrow-sync.ts

@@ -1,7 +1,7 @@
 import type {ColumnarTable, ObjectRowTable} from '@loaders.gl/schema';
 import type {ArrowTable} from './arrow-table';
 import {convertTable} from '@loaders.gl/schema';
-import {tableFromIPC} from 'apache-arrow';
+import * as arrow from 'apache-arrow';
 import type {ArrowLoaderOptions} from '../arrow-loader';
 import {
   convertApacheArrowToArrowTable,
@@ -13,7 +13,7 @@ export default function parseArrowSync(
   arrayBuffer,
   options?: ArrowLoaderOptions
 ): ArrowTable | ColumnarTable | ObjectRowTable {
-  const apacheArrowTable = tableFromIPC([new Uint8Array(arrayBuffer)]);
+  const apacheArrowTable = arrow.tableFromIPC([new Uint8Array(arrayBuffer)]);
   const arrowTable = convertApacheArrowToArrowTable(apacheArrowTable);
 
   const shape = options?.arrow?.shape || 'arrow-table';

package/src/schema/arrow-type-utils.ts

@@ -2,46 +2,27 @@
 // Copyright (c) vis.gl contributors
 
 import type {TypedArray} from '@loaders.gl/schema';
-import {
-  DataType,
-  Float32,
-  Float64,
-  Int16,
-  Int32,
-  Int8,
-  Uint16,
-  Uint32,
-  Uint8
-  // Int8Vector,
-  // Uint8Vector,
-  // Int16Vector,
-  // Uint16Vector,
-  // Int32Vector,
-  // Uint32Vector,
-  // Float32Vector,
-  // Float64Vector
-} from 'apache-arrow';
-// import {AbstractVector} from 'apache-arrow/vector';
+import * as arrow from 'apache-arrow';
 
 /** Return an Apache Arrow Type instance that corresponds to the type of the elements in the supplied Typed Array */
-export function getArrowType(array: TypedArray): DataType {
+export function getArrowType(array: TypedArray): arrow.DataType {
   switch (array.constructor) {
     case Int8Array:
-      return new Int8();
+      return new arrow.Int8();
     case Uint8Array:
-      return new Uint8();
+      return new arrow.Uint8();
     case Int16Array:
-      return new Int16();
+      return new arrow.Int16();
     case Uint16Array:
-      return new Uint16();
+      return new arrow.Uint16();
     case Int32Array:
-      return new Int32();
+      return new arrow.Int32();
     case Uint32Array:
-      return new Uint32();
+      return new arrow.Uint32();
     case Float32Array:
-      return new Float32();
+      return new arrow.Float32();
     case Float64Array:
-      return new Float64();
+      return new arrow.Float64();
     default:
       throw new Error('array type not supported');
   }