@loaders.gl/arrow 4.0.3 → 4.1.0-alpha.1

package/dist/arrow-worker.js

@@ -6,6 +6,9 @@
       __defProp(target, name, { get: all[name], enumerable: true });
   };
 
+  // ../worker-utils/src/lib/node/worker_threads-browser.ts
+  var parentPort = null;
+
   // ../worker-utils/src/lib/worker-utils/get-transfer-list.ts
   function getTransferList(object, recursive = true, transfers) {
     const transfersSet = transfers || /* @__PURE__ */ new Set();
@@ -43,19 +46,6 @@
 
   // ../worker-utils/src/lib/worker-farm/worker-body.ts
   async function getParentPort() {
-    let parentPort;
-    try {
-      eval("globalThis.parentPort = require('worker_threads').parentPort");
-      parentPort = globalThis.parentPort;
-    } catch {
-      try {
-        eval("globalThis.workerThreadsPromise = import('worker_threads')");
-        const workerThreads = await globalThis.workerThreadsPromise;
-        parentPort = workerThreads.parentPort;
-      } catch (error) {
-        console.error(error.message);
-      }
-    }
     return parentPort;
   }
   var onMessageWrapperMap = /* @__PURE__ */ new Map();
@@ -213,375 +203,6 @@
     return await parser(data, { ...options }, context, loader);
   }
 
-  // ../schema/src/lib/table/batches/base-table-batch-aggregator.ts
-  var DEFAULT_ROW_COUNT = 100;
-  var BaseTableBatchAggregator = class {
-    constructor(schema, options) {
-      this.length = 0;
-      this.rows = null;
-      this.cursor = 0;
-      this._headers = [];
-      this.options = options;
-      this.schema = schema;
-      if (!Array.isArray(schema)) {
-        this._headers = [];
-        for (const key in schema) {
-          this._headers[schema[key].index] = schema[key].name;
-        }
-      }
-    }
-    rowCount() {
-      return this.length;
-    }
-    addArrayRow(row, cursor) {
-      if (Number.isFinite(cursor)) {
-        this.cursor = cursor;
-      }
-      this.rows = this.rows || new Array(DEFAULT_ROW_COUNT);
-      this.rows[this.length] = row;
-      this.length++;
-    }
-    addObjectRow(row, cursor) {
-      if (Number.isFinite(cursor)) {
-        this.cursor = cursor;
-      }
-      this.rows = this.rows || new Array(DEFAULT_ROW_COUNT);
-      this.rows[this.length] = row;
-      this.length++;
-    }
-    getBatch() {
-      let rows = this.rows;
-      if (!rows) {
-        return null;
-      }
-      rows = rows.slice(0, this.length);
-      this.rows = null;
-      const batch = {
-        shape: this.options.shape,
-        batchType: "data",
-        data: rows,
-        length: this.length,
-        schema: this.schema,
-        cursor: this.cursor
-      };
-      return batch;
-    }
-  };
-
-  // ../schema/src/lib/table/simple-table/row-utils.ts
-  function convertToObjectRow(arrayRow, headers) {
-    if (!arrayRow) {
-      throw new Error("null row");
-    }
-    if (!headers) {
-      throw new Error("no headers");
-    }
-    const objectRow = {};
-    for (let i = 0; i < headers.length; i++) {
-      objectRow[headers[i]] = arrayRow[i];
-    }
-    return objectRow;
-  }
-  function convertToArrayRow(objectRow, headers) {
-    if (!objectRow) {
-      throw new Error("null row");
-    }
-    if (!headers) {
-      throw new Error("no headers");
-    }
-    const arrayRow = new Array(headers.length);
-    for (let i = 0; i < headers.length; i++) {
-      arrayRow[i] = objectRow[headers[i]];
-    }
-    return arrayRow;
-  }
-
-  // ../schema/src/lib/table/batches/row-table-batch-aggregator.ts
-  var DEFAULT_ROW_COUNT2 = 100;
-  var RowTableBatchAggregator = class {
-    constructor(schema, options) {
-      this.length = 0;
-      this.objectRows = null;
-      this.arrayRows = null;
-      this.cursor = 0;
-      this._headers = [];
-      this.options = options;
-      this.schema = schema;
-      if (!Array.isArray(schema)) {
-        this._headers = [];
-        for (const key in schema) {
-          this._headers[schema[key].index] = schema[key].name;
-        }
-      }
-    }
-    rowCount() {
-      return this.length;
-    }
-    addArrayRow(row, cursor) {
-      if (Number.isFinite(cursor)) {
-        this.cursor = cursor;
-      }
-      switch (this.options.shape) {
-        case "object-row-table":
-          const rowObject = convertToObjectRow(row, this._headers);
-          this.addObjectRow(rowObject, cursor);
-          break;
-        case "array-row-table":
-          this.arrayRows = this.arrayRows || new Array(DEFAULT_ROW_COUNT2);
-          this.arrayRows[this.length] = row;
-          this.length++;
-          break;
-      }
-    }
-    addObjectRow(row, cursor) {
-      if (Number.isFinite(cursor)) {
-        this.cursor = cursor;
-      }
-      switch (this.options.shape) {
-        case "array-row-table":
-          const rowArray = convertToArrayRow(row, this._headers);
-          this.addArrayRow(rowArray, cursor);
-          break;
-        case "object-row-table":
-          this.objectRows = this.objectRows || new Array(DEFAULT_ROW_COUNT2);
-          this.objectRows[this.length] = row;
-          this.length++;
-          break;
-      }
-    }
-    getBatch() {
-      let rows = this.arrayRows || this.objectRows;
-      if (!rows) {
-        return null;
-      }
-      rows = rows.slice(0, this.length);
-      this.arrayRows = null;
-      this.objectRows = null;
-      return {
-        shape: this.options.shape,
-        batchType: "data",
-        data: rows,
-        length: this.length,
-        schema: this.schema,
-        cursor: this.cursor
-      };
-    }
-  };
-
-  // ../schema/src/lib/table/batches/columnar-table-batch-aggregator.ts
-  var DEFAULT_ROW_COUNT3 = 100;
-  var ColumnarTableBatchAggregator = class {
-    constructor(schema, options) {
-      this.length = 0;
-      this.allocated = 0;
-      this.columns = {};
-      this.schema = schema;
-      this._reallocateColumns();
-    }
-    rowCount() {
-      return this.length;
-    }
-    addArrayRow(row) {
-      this._reallocateColumns();
-      let i = 0;
-      for (const fieldName in this.columns) {
-        this.columns[fieldName][this.length] = row[i++];
-      }
-      this.length++;
-    }
-    addObjectRow(row) {
-      this._reallocateColumns();
-      for (const fieldName in row) {
-        this.columns[fieldName][this.length] = row[fieldName];
-      }
-      this.length++;
-    }
-    getBatch() {
-      this._pruneColumns();
-      const columns = Array.isArray(this.schema) ? this.columns : {};
-      if (!Array.isArray(this.schema)) {
-        for (const fieldName in this.schema) {
-          const field = this.schema[fieldName];
-          columns[field.name] = this.columns[field.index];
-        }
-      }
-      this.columns = {};
-      const batch = {
-        shape: "columnar-table",
-        batchType: "data",
-        data: columns,
-        schema: this.schema,
-        length: this.length
-      };
-      return batch;
-    }
-    // HELPERS
-    _reallocateColumns() {
-      if (this.length < this.allocated) {
-        return;
-      }
-      this.allocated = this.allocated > 0 ? this.allocated *= 2 : DEFAULT_ROW_COUNT3;
-      this.columns = {};
-      for (const fieldName in this.schema) {
-        const field = this.schema[fieldName];
-        const ArrayType = field.type || Float32Array;
-        const oldColumn = this.columns[field.index];
-        if (oldColumn && ArrayBuffer.isView(oldColumn)) {
-          const typedArray = new ArrayType(this.allocated);
-          typedArray.set(oldColumn);
-          this.columns[field.index] = typedArray;
-        } else if (oldColumn) {
-          oldColumn.length = this.allocated;
-          this.columns[field.index] = oldColumn;
-        } else {
-          this.columns[field.index] = new ArrayType(this.allocated);
-        }
-      }
-    }
-    _pruneColumns() {
-      for (const [columnName, column] of Object.entries(this.columns)) {
-        this.columns[columnName] = column.slice(0, this.length);
-      }
-    }
-  };
-
-  // ../schema/src/lib/table/batches/table-batch-builder.ts
-  var DEFAULT_OPTIONS = {
-    shape: "array-row-table",
-    batchSize: "auto",
-    batchDebounceMs: 0,
-    limit: 0,
-    _limitMB: 0
-  };
-  var ERR_MESSAGE = "TableBatchBuilder";
-  var TableBatchBuilder = class {
-    constructor(schema, options) {
-      this.aggregator = null;
-      this.batchCount = 0;
-      this.bytesUsed = 0;
-      this.isChunkComplete = false;
-      this.lastBatchEmittedMs = Date.now();
-      this.totalLength = 0;
-      this.totalBytes = 0;
-      this.rowBytes = 0;
-      this.schema = schema;
-      this.options = { ...DEFAULT_OPTIONS, ...options };
-    }
-    limitReached() {
-      if (Boolean(this.options?.limit) && this.totalLength >= this.options.limit) {
-        return true;
-      }
-      if (Boolean(this.options?._limitMB) && this.totalBytes / 1e6 >= this.options._limitMB) {
-        return true;
-      }
-      return false;
-    }
-    /** @deprecated Use addArrayRow or addObjectRow */
-    addRow(row) {
-      if (this.limitReached()) {
-        return;
-      }
-      this.totalLength++;
-      this.rowBytes = this.rowBytes || this._estimateRowMB(row);
-      this.totalBytes += this.rowBytes;
-      if (Array.isArray(row)) {
-        this.addArrayRow(row);
-      } else {
-        this.addObjectRow(row);
-      }
-    }
-    /** Add one row to the batch */
-    addArrayRow(row) {
-      if (!this.aggregator) {
-        const TableBatchType = this._getTableBatchType();
-        this.aggregator = new TableBatchType(this.schema, this.options);
-      }
-      this.aggregator.addArrayRow(row);
-    }
-    /** Add one row to the batch */
-    addObjectRow(row) {
-      if (!this.aggregator) {
-        const TableBatchType = this._getTableBatchType();
-        this.aggregator = new TableBatchType(this.schema, this.options);
-      }
-      this.aggregator.addObjectRow(row);
-    }
-    /** Mark an incoming raw memory chunk has completed */
-    chunkComplete(chunk) {
-      if (chunk instanceof ArrayBuffer) {
-        this.bytesUsed += chunk.byteLength;
-      }
-      if (typeof chunk === "string") {
-        this.bytesUsed += chunk.length;
-      }
-      this.isChunkComplete = true;
-    }
-    getFullBatch(options) {
-      return this._isFull() ? this._getBatch(options) : null;
-    }
-    getFinalBatch(options) {
-      return this._getBatch(options);
-    }
-    // INTERNAL
-    _estimateRowMB(row) {
-      return Array.isArray(row) ? row.length * 8 : Object.keys(row).length * 8;
-    }
-    _isFull() {
-      if (!this.aggregator || this.aggregator.rowCount() === 0) {
-        return false;
-      }
-      if (this.options.batchSize === "auto") {
-        if (!this.isChunkComplete) {
-          return false;
-        }
-      } else if (this.options.batchSize > this.aggregator.rowCount()) {
-        return false;
-      }
-      if (this.options.batchDebounceMs > Date.now() - this.lastBatchEmittedMs) {
-        return false;
-      }
-      this.isChunkComplete = false;
-      this.lastBatchEmittedMs = Date.now();
-      return true;
-    }
-    /**
-     * bytesUsed can be set via chunkComplete or via getBatch*
-     */
-    _getBatch(options) {
-      if (!this.aggregator) {
-        return null;
-      }
-      if (options?.bytesUsed) {
-        this.bytesUsed = options.bytesUsed;
-      }
-      const normalizedBatch = this.aggregator.getBatch();
-      normalizedBatch.count = this.batchCount;
-      normalizedBatch.bytesUsed = this.bytesUsed;
-      Object.assign(normalizedBatch, options);
-      this.batchCount++;
-      this.aggregator = null;
-      return normalizedBatch;
-    }
-    _getTableBatchType() {
-      switch (this.options.shape) {
-        case "row-table":
-          return BaseTableBatchAggregator;
-        case "array-row-table":
-        case "object-row-table":
-          return RowTableBatchAggregator;
-        case "columnar-table":
-          return ColumnarTableBatchAggregator;
-        case "arrow-table":
-          if (!TableBatchBuilder.ArrowBatch) {
-            throw new Error(ERR_MESSAGE);
-          }
-          return TableBatchBuilder.ArrowBatch;
-        default:
-          throw new Error(ERR_MESSAGE);
-      }
-    }
-  };
-
   // ../schema/src/lib/table/simple-table/table-accessors.ts
   function getTableLength(table) {
     switch (table.shape) {
@@ -952,30 +573,6 @@
     };
   }
 
-  // src/arrow-loader.ts
-  var VERSION = true ? "4.0.3" : "latest";
-  var ArrowLoader = {
-    name: "Apache Arrow",
-    id: "arrow",
-    module: "arrow",
-    version: VERSION,
-    // worker: true,
-    category: "table",
-    extensions: ["arrow", "feather"],
-    mimeTypes: [
-      "application/vnd.apache.arrow.file",
-      "application/vnd.apache.arrow.stream",
-      "application/octet-stream"
-    ],
-    binary: true,
-    tests: ["ARROW"],
-    options: {
-      arrow: {
-        shape: "columnar-table"
-      }
-    }
-  };
-
   // ../../node_modules/tslib/tslib.es6.mjs
   function __rest(s, e) {
     var t = {};
@@ -2282,6 +1879,16 @@
     proto.ArrayType = Int32Array;
     return proto[Symbol.toStringTag] = "Date";
   })(Date_.prototype);
+  var DateDay = class extends Date_ {
+    constructor() {
+      super(DateUnit.DAY);
+    }
+  };
+  var DateMillisecond = class extends Date_ {
+    constructor() {
+      super(DateUnit.MILLISECOND);
+    }
+  };
   var Time_ = class extends DataType {
     constructor(unit, bitWidth) {
       super();
@@ -2310,6 +1917,26 @@
     proto.bitWidth = null;
     return proto[Symbol.toStringTag] = "Time";
   })(Time_.prototype);
+  var TimeSecond = class extends Time_ {
+    constructor() {
+      super(TimeUnit.SECOND, 32);
+    }
+  };
+  var TimeMillisecond = class extends Time_ {
+    constructor() {
+      super(TimeUnit.MILLISECOND, 32);
+    }
+  };
+  var TimeMicrosecond = class extends Time_ {
+    constructor() {
+      super(TimeUnit.MICROSECOND, 64);
+    }
+  };
+  var TimeNanosecond = class extends Time_ {
+    constructor() {
+      super(TimeUnit.NANOSECOND, 64);
+    }
+  };
   var Timestamp_ = class extends DataType {
     constructor(unit, timezone) {
       super();
@@ -2330,6 +1957,26 @@
     proto.ArrayType = Int32Array;
     return proto[Symbol.toStringTag] = "Timestamp";
   })(Timestamp_.prototype);
+  var TimestampSecond = class extends Timestamp_ {
+    constructor(timezone) {
+      super(TimeUnit.SECOND, timezone);
+    }
+  };
+  var TimestampMillisecond = class extends Timestamp_ {
+    constructor(timezone) {
+      super(TimeUnit.MILLISECOND, timezone);
+    }
+  };
+  var TimestampMicrosecond = class extends Timestamp_ {
+    constructor(timezone) {
+      super(TimeUnit.MICROSECOND, timezone);
+    }
+  };
+  var TimestampNanosecond = class extends Timestamp_ {
+    constructor(timezone) {
+      super(TimeUnit.NANOSECOND, timezone);
+    }
+  };
   var Interval_ = class extends DataType {
     constructor(unit) {
       super();
@@ -2348,6 +1995,16 @@
     proto.ArrayType = Int32Array;
     return proto[Symbol.toStringTag] = "Interval";
   })(Interval_.prototype);
+  var IntervalDayTime = class extends Interval_ {
+    constructor() {
+      super(IntervalUnit.DAY_TIME);
+    }
+  };
+  var IntervalYearMonth = class extends Interval_ {
+    constructor() {
+      super(IntervalUnit.YEAR_MONTH);
+    }
+  };
   var List = class extends DataType {
     constructor(child) {
       super();
@@ -4771,63 +4428,6 @@
       });
     }
   };
-  function makeVector(init) {
-    if (init) {
-      if (init instanceof Data) {
-        return new Vector([init]);
-      }
-      if (init instanceof Vector) {
-        return new Vector(init.data);
-      }
-      if (init.type instanceof DataType) {
-        return new Vector([makeData(init)]);
-      }
-      if (Array.isArray(init)) {
-        return new Vector(init.flatMap((v) => unwrapInputs(v)));
-      }
-      if (ArrayBuffer.isView(init)) {
-        if (init instanceof DataView) {
-          init = new Uint8Array(init.buffer);
-        }
-        const props = { offset: 0, length: init.length, nullCount: 0, data: init };
-        if (init instanceof Int8Array) {
-          return new Vector([makeData(Object.assign(Object.assign({}, props), { type: new Int8() }))]);
-        }
-        if (init instanceof Int16Array) {
-          return new Vector([makeData(Object.assign(Object.assign({}, props), { type: new Int16() }))]);
-        }
-        if (init instanceof Int32Array) {
-          return new Vector([makeData(Object.assign(Object.assign({}, props), { type: new Int32() }))]);
-        }
-        if (init instanceof BigInt64Array) {
-          return new Vector([makeData(Object.assign(Object.assign({}, props), { type: new Int64() }))]);
-        }
-        if (init instanceof Uint8Array || init instanceof Uint8ClampedArray) {
-          return new Vector([makeData(Object.assign(Object.assign({}, props), { type: new Uint8() }))]);
-        }
-        if (init instanceof Uint16Array) {
-          return new Vector([makeData(Object.assign(Object.assign({}, props), { type: new Uint16() }))]);
-        }
-        if (init instanceof Uint32Array) {
-          return new Vector([makeData(Object.assign(Object.assign({}, props), { type: new Uint32() }))]);
-        }
-        if (init instanceof BigUint64Array) {
-          return new Vector([makeData(Object.assign(Object.assign({}, props), { type: new Uint64() }))]);
-        }
-        if (init instanceof Float32Array) {
-          return new Vector([makeData(Object.assign(Object.assign({}, props), { type: new Float32() }))]);
-        }
-        if (init instanceof Float64Array) {
-          return new Vector([makeData(Object.assign(Object.assign({}, props), { type: new Float64() }))]);
-        }
-        throw new Error("Unrecognized input");
-      }
-    }
-    throw new Error("Unrecognized input");
-  }
-  function unwrapInputs(x) {
-    return x instanceof Data ? [x] : x instanceof Vector ? x.data : makeVector(x).data;
-  }
 
   // ../../node_modules/apache-arrow/builder/valid.mjs
   function createIsValidFunction(nullValues) {
@@ -12342,13 +11942,7 @@ return true;`);
   RecordBatchFileWriter["throughDOM"] = recordBatchWriterThroughDOMStream;
   RecordBatchStreamWriter["throughDOM"] = recordBatchWriterThroughDOMStream;
 
-  // src/tables/convert-arrow-to-table.ts
-  function convertApacheArrowToArrowTable(arrowTable) {
-    return {
-      shape: "arrow-table",
-      data: arrowTable
-    };
-  }
+  // src/tables/convert-arrow-to-columnar-table.ts
   function convertArrowToColumnarTable(table) {
     const arrowTable = table.data;
     const columnarTable = {};
@@ -12359,29 +11953,207 @@ return true;`);
     }
     return {
       shape: "columnar-table",
+      schema: table.schema,
       data: columnarTable
     };
   }
 
-  // src/lib/parse-arrow-sync.ts
+  // src/schema/convert-arrow-schema.ts
+  function serializeArrowSchema(arrowSchema) {
+    return {
+      fields: arrowSchema.fields.map((arrowField) => serializeArrowField(arrowField)),
+      metadata: serializeArrowMetadata(arrowSchema.metadata)
+    };
+  }
+  function serializeArrowMetadata(arrowMetadata) {
+    return Object.fromEntries(arrowMetadata);
+  }
+  function serializeArrowField(field) {
+    return {
+      name: field.name,
+      type: serializeArrowType(field.type),
+      nullable: field.nullable,
+      metadata: serializeArrowMetadata(field.metadata)
+    };
+  }
+  function serializeArrowType(arrowType) {
+    switch (arrowType.constructor) {
+      case Null:
+        return "null";
+      case Binary:
+        return "binary";
+      case Bool:
+        return "bool";
+      case Int_:
+        const intType = arrowType;
+        return `${intType.isSigned ? "u" : ""}int${intType.bitWidth}`;
+      case Int8:
+        return "int8";
+      case Int16:
+        return "int16";
+      case Int32:
+        return "int32";
+      case Int64:
+        return "int64";
+      case Uint8:
+        return "uint8";
+      case Uint16:
+        return "uint16";
+      case Uint32:
+        return "uint32";
+      case Uint64:
+        return "uint64";
+      case Float:
+        const precision = arrowType.precision;
+        switch (precision) {
+          case Precision.HALF:
+            return "float16";
+          case Precision.SINGLE:
+            return "float32";
+          case Precision.DOUBLE:
+            return "float64";
+          default:
+            return "float16";
+        }
+      case Float16:
+        return "float16";
+      case Float32:
+        return "float32";
+      case Float64:
+        return "float64";
+      case Utf8:
+        return "utf8";
+      case Decimal:
+        const decimal = arrowType;
+        return {
+          type: "decimal",
+          bitWidth: decimal.bitWidth,
+          precision: decimal.precision,
+          scale: decimal.scale
+        };
+      case Date_:
+        const dateUnit = arrowType.unit;
+        return dateUnit === DateUnit.DAY ? "date-day" : "date-millisecond";
+      case DateDay:
+        return "date-day";
+      case DateMillisecond:
+        return "date-millisecond";
+      case Time_:
+        const timeUnit = arrowType.unit;
+        switch (timeUnit) {
+          case TimeUnit.SECOND:
+            return "time-second";
+          case TimeUnit.MILLISECOND:
+            return "time-millisecond";
+          case TimeUnit.MICROSECOND:
+            return "time-microsecond";
+          case TimeUnit.NANOSECOND:
+            return "time-nanosecond";
+          default:
+            return "time-second";
+        }
+      case TimeMillisecond:
+        return "time-millisecond";
+      case TimeSecond:
+        return "time-second";
+      case TimeMicrosecond:
+        return "time-microsecond";
+      case TimeNanosecond:
+        return "time-nanosecond";
+      case Timestamp_:
+        const timeStampUnit = arrowType.unit;
+        switch (timeStampUnit) {
+          case TimeUnit.SECOND:
+            return "timestamp-second";
+          case TimeUnit.MILLISECOND:
+            return "timestamp-millisecond";
+          case TimeUnit.MICROSECOND:
+            return "timestamp-microsecond";
+          case TimeUnit.NANOSECOND:
+            return "timestamp-nanosecond";
+          default:
+            return "timestamp-second";
+        }
+      case TimestampSecond:
+        return "timestamp-second";
+      case TimestampMillisecond:
+        return "timestamp-millisecond";
+      case TimestampMicrosecond:
+        return "timestamp-microsecond";
+      case TimestampNanosecond:
+        return "timestamp-nanosecond";
+      case Interval_:
+        const intervalUnit = arrowType.unit;
+        switch (intervalUnit) {
+          case IntervalUnit.DAY_TIME:
+            return "interval-daytime";
+          case IntervalUnit.YEAR_MONTH:
+            return "interval-yearmonth";
+          default:
+            return "interval-daytime";
+        }
+      case IntervalDayTime:
+        return "interval-daytime";
+      case IntervalYearMonth:
+        return "interval-yearmonth";
+      case Map_:
+        const mapType = arrowType;
+        return {
+          type: "map",
+          keysSorted: mapType.keysSorted,
+          children: mapType.children.map((arrowField) => serializeArrowField(arrowField))
+        };
+      case List:
+        const listType = arrowType;
+        const listField = listType.valueField;
+        return {
+          type: "list",
+          children: [serializeArrowField(listField)]
+        };
+      case FixedSizeList:
+        const fixedSizeList = arrowType;
+        return {
+          type: "fixed-size-list",
+          listSize: fixedSizeList.listSize,
+          children: [serializeArrowField(fixedSizeList.children[0])]
+        };
+      case Struct:
+        const structType = arrowType;
+        return {
+          type: "struct",
+          children: structType.children.map((arrowField) => serializeArrowField(arrowField))
+        };
+      default:
+        throw new Error(`arrow type not supported: ${arrowType.constructor.name}`);
+    }
+  }
+
+  // src/parsers/parse-arrow-sync.ts
   function parseArrowSync(arrayBuffer, options) {
     const apacheArrowTable = tableFromIPC([new Uint8Array(arrayBuffer)]);
-    const arrowTable = convertApacheArrowToArrowTable(apacheArrowTable);
-    const shape = options?.arrow?.shape || "arrow-table";
+    const arrowTable = {
+      shape: "arrow-table",
+      schema: serializeArrowSchema(apacheArrowTable.schema),
+      data: apacheArrowTable
+    };
+    const shape = options?.shape || "arrow-table";
     switch (shape) {
       case "arrow-table":
         return arrowTable;
       case "columnar-table":
         return convertArrowToColumnarTable(arrowTable);
       case "object-row-table":
-        const columnarTable = convertArrowToColumnarTable(arrowTable);
+        let columnarTable = convertArrowToColumnarTable(arrowTable);
         return convertTable(columnarTable, "object-row-table");
+      case "array-row-table":
+        columnarTable = convertArrowToColumnarTable(arrowTable);
+        return convertTable(columnarTable, "array-row-table");
       default:
         throw new Error(shape);
     }
   }
 
-  // src/lib/parse-arrow-in-batches.ts
+  // src/parsers/parse-arrow-in-batches.ts
   function parseArrowInBatches(asyncIterator) {
     async function* makeArrowAsyncIterator() {
       const readers = RecordBatchReader.readAll(asyncIterator);
@@ -12401,73 +12173,36 @@ return true;`);
     return makeArrowAsyncIterator();
   }
 
-  // src/lib/arrow-table-batch.ts
-  var ArrowTableBatchAggregator = class extends ColumnarTableBatchAggregator {
-    constructor(schema, options) {
-      super(schema, options);
-      this.arrowSchema = null;
-    }
-    getBatch() {
-      const batch = super.getBatch();
-      if (batch) {
-        this.arrowSchema = this.arrowSchema || getArrowSchema(batch.schema);
-        const arrowVectors = getArrowVectors(this.arrowSchema, batch.data);
-        const recordBatch = new RecordBatch(
-          this.arrowSchema,
-          makeData({
-            type: new Struct(this.arrowSchema.fields),
-            children: arrowVectors.map(({ data }) => data[0])
-          })
-        );
-        return {
-          shape: "arrow-table",
-          batchType: "data",
-          data: new Table([recordBatch]),
-          length: batch.length
-        };
+  // src/arrow-loader.ts
+  var VERSION = true ? "4.1.0-alpha.1" : "latest";
+  var ArrowWorkerLoader = {
+    name: "Apache Arrow",
+    id: "arrow",
+    module: "arrow",
+    version: VERSION,
+    // worker: true,
+    category: "table",
+    extensions: ["arrow", "feather"],
+    mimeTypes: [
+      "application/vnd.apache.arrow.file",
+      "application/vnd.apache.arrow.stream",
+      "application/octet-stream"
+    ],
+    binary: true,
+    tests: ["ARROW"],
+    options: {
+      arrow: {
+        shape: "columnar-table"
       }
-      return null;
     }
   };
-  function getArrowSchema(schema) {
-    const arrowFields = [];
-    for (const key in schema) {
-      const field = schema[key];
-      if (field.type === Float32Array) {
-        const metadata = /* @__PURE__ */ new Map();
-        const arrowField = new Field2(field.name, new Float32(), field.nullable, metadata);
-        arrowFields.push(arrowField);
-      }
-    }
-    if (arrowFields.length === 0) {
-      throw new Error("No arrow convertible fields");
-    }
-    return new Schema2(arrowFields);
-  }
-  function getArrowVectors(arrowSchema, data) {
-    const arrowVectors = [];
-    for (const field of arrowSchema.fields) {
-      const vector = data[field.name];
-      if (vector instanceof Float32Array) {
-        const arrowVector = makeVector(vector);
-        arrowVectors.push(arrowVector);
-      }
-    }
-    if (arrowSchema.fields.length !== arrowVectors.length) {
-      throw new Error("Some columns not arrow convertible");
-    }
-    return arrowVectors;
-  }
-
-  // src/index.ts
-  TableBatchBuilder.ArrowBatch = ArrowTableBatchAggregator;
-  var ArrowLoader2 = {
-    ...ArrowLoader,
-    parse: async (arraybuffer, options) => parseArrowSync(arraybuffer, options),
-    parseSync: parseArrowSync,
+  var ArrowLoader = {
+    ...ArrowWorkerLoader,
+    parse: async (arraybuffer, options) => parseArrowSync(arraybuffer, options?.arrow),
+    parseSync: (arraybuffer, options) => parseArrowSync(arraybuffer, options?.arrow),
     parseInBatches: parseArrowInBatches
   };
 
   // src/workers/arrow-worker.ts
-  createLoaderWorker(ArrowLoader2);
+  createLoaderWorker(ArrowLoader);
 })();