@loaders.gl/schema 3.1.0-alpha.2 → 3.1.0-beta.1

package/dist/esm/lib/utils/async-queue.js

@@ -0,0 +1,119 @@
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+
+let _Symbol$asyncIterator;
+
+class ArrayQueue extends Array {
+  enqueue(value) {
+    return this.push(value);
+  }
+
+  dequeue() {
+    return this.shift();
+  }
+
+}
+
+_Symbol$asyncIterator = Symbol.asyncIterator;
+export default class AsyncQueue {
+  constructor() {
+    _defineProperty(this, "_values", void 0);
+
+    _defineProperty(this, "_settlers", void 0);
+
+    _defineProperty(this, "_closed", void 0);
+
+    this._values = new ArrayQueue();
+    this._settlers = new ArrayQueue();
+    this._closed = false;
+  }
+
+  close() {
+    while (this._settlers.length > 0) {
+      this._settlers.dequeue().resolve({
+        done: true
+      });
+    }
+
+    this._closed = true;
+  }
+
+  [_Symbol$asyncIterator]() {
+    return this;
+  }
+
+  enqueue(value) {
+    if (this._closed) {
+      throw new Error('Closed');
+    }
+
+    if (this._settlers.length > 0) {
+      if (this._values.length > 0) {
+        throw new Error('Illegal internal state');
+      }
+
+      const settler = this._settlers.dequeue();
+
+      if (value instanceof Error) {
+        settler.reject(value);
+      } else {
+        settler.resolve({
+          value
+        });
+      }
+    } else {
+      this._values.enqueue(value);
+    }
+  }
+
+  next() {
+    if (this._values.length > 0) {
+      const value = this._values.dequeue();
+
+      if (value instanceof Error) {
+        return Promise.reject(value);
+      }
+
+      return Promise.resolve({
+        value
+      });
+    }
+
+    if (this._closed) {
+      if (this._settlers.length > 0) {
+        throw new Error('Illegal internal state');
+      }
+
+      return Promise.resolve({
+        done: true
+      });
+    }
+
+    return new Promise((resolve, reject) => {
+      this._settlers.enqueue({
+        resolve,
+        reject
+      });
+    });
+  }
+
+}
+export async function takeAsync(asyncIterable, count = Infinity) {
+  const result = [];
+  const iterator = asyncIterable[Symbol.asyncIterator]();
+
+  while (result.length < count) {
+    const {
+      value,
+      done
+    } = await iterator.next();
+
+    if (done) {
+      break;
+    }
+
+    result.push(value);
+  }
+
+  return result;
+}
+//# sourceMappingURL=async-queue.js.map

package/dist/esm/lib/utils/async-queue.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/utils/async-queue.ts"],"names":["ArrayQueue","Array","enqueue","value","push","dequeue","shift","Symbol","asyncIterator","AsyncQueue","constructor","_values","_settlers","_closed","close","length","resolve","done","Error","settler","reject","next","Promise","takeAsync","asyncIterable","count","Infinity","result","iterator"],"mappings":"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","sourcesContent":["// From https://github.com/rauschma/async-iter-demo/tree/master/src under MIT license\n// http://2ality.com/2016/10/asynchronous-iteration.html\n\nclass ArrayQueue<T> extends Array<T> {\n  enqueue(value: T) {\n    // Add at the end\n    return this.push(value);\n  }\n  dequeue(): T {\n    // Remove first element\n    return this.shift() as T;\n  }\n}\n\nexport default class AsyncQueue<T> {\n  private _values: ArrayQueue<T | Error>;\n  private _settlers: ArrayQueue<{resolve: (value: any) => void; reject: (reason?: any) => void}>;\n  private _closed: boolean;\n\n  constructor() {\n    // enqueues > dequeues\n    this._values = new ArrayQueue<T>();\n    // dequeues > enqueues\n    this._settlers = new ArrayQueue<{\n      resolve: (value: any) => void;\n      reject: (reason?: any) => void;\n    }>();\n    this._closed = false;\n  }\n\n  close(): void {\n    while (this._settlers.length > 0) {\n      this._settlers.dequeue().resolve({done: true});\n    }\n    this._closed = true;\n  }\n\n  [Symbol.asyncIterator](): AsyncIterator<T> {\n    return this;\n  }\n\n  enqueue(value: T | Error): void {\n    if (this._closed) {\n      throw new Error('Closed');\n    }\n\n    if (this._settlers.length > 0) {\n      if (this._values.length > 0) {\n        throw new Error('Illegal internal state');\n      }\n      const settler = this._settlers.dequeue();\n      if (value instanceof Error) {\n        settler.reject(value);\n      } else {\n        settler.resolve({value});\n      }\n    } else {\n      this._values.enqueue(value);\n    }\n  }\n\n  /**\n   * @returns a Promise for an IteratorResult\n   */\n  next(): Promise<any> {\n    if (this._values.length > 0) {\n      const value = this._values.dequeue();\n      if (value instanceof Error) {\n        return Promise.reject(value);\n      }\n      return Promise.resolve({value});\n    }\n\n    if (this._closed) {\n      if (this._settlers.length > 0) {\n        throw new Error('Illegal internal state');\n      }\n      return Promise.resolve({done: true});\n    }\n    // Wait for new values to be enqueued\n    return new Promise((resolve, reject) => {\n      this._settlers.enqueue({resolve, reject});\n    });\n  }\n}\n\n/**\n * @returns a Promise for an Array with the elements in `asyncIterable`\n */\nexport async function takeAsync(\n  asyncIterable: AsyncIterable<any>,\n  count = Infinity\n): Promise<any[]> {\n  const result: Array<any> = [];\n  const iterator = asyncIterable[Symbol.asyncIterator]();\n  while (result.length < count) {\n    const {value, done} = await iterator.next();\n    if (done) {\n      break;\n    }\n    result.push(value);\n  }\n  return result;\n}\n"],"file":"async-queue.js"}

package/dist/esm/lib/utils/row-utils.js

@@ -0,0 +1,35 @@
+export 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;
+}
+export 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;
+}
+//# sourceMappingURL=row-utils.js.map

package/dist/esm/lib/utils/row-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/lib/utils/row-utils.ts"],"names":["convertToObjectRow","arrayRow","headers","Error","objectRow","i","length","convertToArrayRow","Array"],"mappings":"AACA,OAAO,SAASA,kBAAT,CACLC,QADK,EAELC,OAFK,EAGwB;AAC7B,MAAI,CAACD,QAAL,EAAe;AACb,UAAM,IAAIE,KAAJ,CAAU,UAAV,CAAN;AACD;;AACD,MAAI,CAACD,OAAL,EAAc;AACZ,UAAM,IAAIC,KAAJ,CAAU,YAAV,CAAN;AACD;;AACD,QAAMC,SAAS,GAAG,EAAlB;;AACA,OAAK,IAAIC,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGH,OAAO,CAACI,MAA5B,EAAoCD,CAAC,EAArC,EAAyC;AACvCD,IAAAA,SAAS,CAACF,OAAO,CAACG,CAAD,CAAR,CAAT,GAAwBJ,QAAQ,CAACI,CAAD,CAAhC;AACD;;AACD,SAAOD,SAAP;AACD;AAGD,OAAO,SAASG,iBAAT,CACLH,SADK,EAELF,OAFK,EAGE;AACP,MAAI,CAACE,SAAL,EAAgB;AACd,UAAM,IAAID,KAAJ,CAAU,UAAV,CAAN;AACD;;AACD,MAAI,CAACD,OAAL,EAAc;AACZ,UAAM,IAAIC,KAAJ,CAAU,YAAV,CAAN;AACD;;AACD,QAAMF,QAAQ,GAAG,IAAIO,KAAJ,CAAUN,OAAO,CAACI,MAAlB,CAAjB;;AACA,OAAK,IAAID,CAAC,GAAG,CAAb,EAAgBA,CAAC,GAAGH,OAAO,CAACI,MAA5B,EAAoCD,CAAC,EAArC,EAAyC;AACvCJ,IAAAA,QAAQ,CAACI,CAAD,CAAR,GAAcD,SAAS,CAACF,OAAO,CAACG,CAAD,CAAR,CAAvB;AACD;;AACD,SAAOJ,QAAP;AACD","sourcesContent":["/** Convert an object row to an array row */\nexport function convertToObjectRow(\n  arrayRow: any[],\n  headers: string[]\n): {[columnName: string]: any} {\n  if (!arrayRow) {\n    throw new Error('null row');\n  }\n  if (!headers) {\n    throw new Error('no headers');\n  }\n  const objectRow = {};\n  for (let i = 0; i < headers.length; i++) {\n    objectRow[headers[i]] = arrayRow[i];\n  }\n  return objectRow;\n}\n\n/** Convert an object row to an array row */\nexport function convertToArrayRow(\n  objectRow: {[columnName: string]: any},\n  headers: string[]\n): any[] {\n  if (!objectRow) {\n    throw new Error('null row');\n  }\n  if (!headers) {\n    throw new Error('no headers');\n  }\n  const arrayRow = new Array(headers.length);\n  for (let i = 0; i < headers.length; i++) {\n    arrayRow[i] = objectRow[headers[i]];\n  }\n  return arrayRow;\n}\n"],"file":"row-utils.js"}

package/dist/esm/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=types.js.map

package/dist/esm/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":[],"names":[],"mappings":"","sourcesContent":[],"file":"types.js"}

package/dist/index.d.ts

@@ -0,0 +1,23 @@
+export type { TypedArray, NumberArray, AnyArray } from './types';
+export type { Batch } from './category/common';
+export type { Table, ArrayRowTable, ObjectRowTable, ColumnarTable, ArrowTable } from './category/table/table-types';
+export type { TableBatch, RowArrayTableBatch, RowObjectTableBatch, ColumnarTableBatch, ArrowTableBatch } from './category/table/table-types';
+export { default as TableBatchBuilder } from './lib/batches/table-batch-builder';
+export type { TableBatchAggregator } from './lib/batches/table-batch-aggregator';
+export { default as RowTableBatchAggregator } from './lib/batches/row-table-batch-aggregator';
+export { default as ColumnarTableBatchAggregator } from './lib/batches/columnar-table-batch-aggregator';
+export { convertToObjectRow, convertToArrayRow } from './lib/utils/row-utils';
+export type { MeshTable, MeshArrowTable, Mesh, MeshGeometry, MeshAttribute, MeshAttributes } from './category/mesh/mesh-types';
+export { getMeshSize, getMeshBoundingBox } from './category/mesh/mesh-utils';
+export { convertMesh } from './category/mesh/convert-mesh';
+export { deduceMeshSchema, deduceMeshField, makeMeshAttributeMetadata } from './category/mesh/deduce-mesh-schema';
+export type { GeoJSON, Feature, Geometry, Position, GeoJsonProperties } from './category/gis';
+export type { Point, MultiPoint, LineString, MultiLineString, Polygon, MultiPolygon } from './category/gis';
+export type { BinaryGeometryType, BinaryGeometry, BinaryPointGeometry, BinaryLineGeometry, BinaryPolygonGeometry, BinaryAttribute } from './category/gis';
+export type { BinaryFeatures, BinaryPointFeatures, BinaryLineFeatures, BinaryPolygonFeatures } from './category/gis';
+export { Schema, Field, DataType, Null, Binary, Bool, Int, Int8, Int16, Int32, Int64, Uint8, Uint16, Uint32, Uint64, Float, Float16, Float32, Float64, Utf8, Date, DateDay, DateMillisecond, Time, TimeMillisecond, TimeSecond, Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond, Interval, IntervalDayTime, IntervalYearMonth, FixedSizeList, Struct } from './lib/schema/schema';
+export { deduceTypeFromColumn, deduceTypeFromValue } from './lib/schema-utils/deduce-column-type';
+export { getTypeInfo } from './lib/arrow/get-type-info';
+export { getArrowTypeFromTypedArray } from './lib/arrow/arrow-like-type-utils';
+export { default as AsyncQueue } from './lib/utils/async-queue';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AACA,YAAY,EAAC,UAAU,EAAE,WAAW,EAAE,QAAQ,EAAC,MAAM,SAAS,CAAC;AAE/D,YAAY,EAAC,KAAK,EAAC,MAAM,mBAAmB,CAAC;AAI7C,YAAY,EACV,KAAK,EACL,aAAa,EACb,cAAc,EACd,aAAa,EACb,UAAU,EACX,MAAM,8BAA8B,CAAC;AACtC,YAAY,EACV,UAAU,EACV,kBAAkB,EAClB,mBAAmB,EACnB,kBAAkB,EAClB,eAAe,EAChB,MAAM,8BAA8B,CAAC;AAGtC,OAAO,EAAC,OAAO,IAAI,iBAAiB,EAAC,MAAM,mCAAmC,CAAC;AAC/E,YAAY,EAAC,oBAAoB,EAAC,MAAM,sCAAsC,CAAC;AAC/E,OAAO,EAAC,OAAO,IAAI,uBAAuB,EAAC,MAAM,0CAA0C,CAAC;AAC5F,OAAO,EAAC,OAAO,IAAI,4BAA4B,EAAC,MAAM,+CAA+C,CAAC;AAEtG,OAAO,EAAC,kBAAkB,EAAE,iBAAiB,EAAC,MAAM,uBAAuB,CAAC;AAG5E,YAAY,EACV,SAAS,EACT,cAAc,EACd,IAAI,EACJ,YAAY,EACZ,aAAa,EACb,cAAc,EACf,MAAM,4BAA4B,CAAC;AAEpC,OAAO,EAAC,WAAW,EAAE,kBAAkB,EAAC,MAAM,4BAA4B,CAAC;AAC3E,OAAO,EAAC,WAAW,EAAC,MAAM,8BAA8B,CAAC;AACzD,OAAO,EACL,gBAAgB,EAChB,eAAe,EACf,yBAAyB,EAC1B,MAAM,oCAAoC,CAAC;AAI5C,YAAY,EAAC,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,QAAQ,EAAE,iBAAiB,EAAC,MAAM,gBAAgB,CAAC;AAC5F,YAAY,EACV,KAAK,EACL,UAAU,EACV,UAAU,EACV,eAAe,EACf,OAAO,EACP,YAAY,EACb,MAAM,gBAAgB,CAAC;AAGxB,YAAY,EACV,kBAAkB,EAClB,cAAc,EACd,mBAAmB,EACnB,kBAAkB,EAClB,qBAAqB,EACrB,eAAe,EAChB,MAAM,gBAAgB,CAAC;AACxB,YAAY,EACV,cAAc,EACd,mBAAmB,EACnB,kBAAkB,EAClB,qBAAqB,EACtB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,MAAM,EACN,KAAK,EACL,QAAQ,EACR,IAAI,EACJ,MAAM,EACN,IAAI,EACJ,GAAG,EACH,IAAI,EACJ,KAAK,EACL,KAAK,EACL,KAAK,EACL,KAAK,EACL,MAAM,EACN,MAAM,EACN,MAAM,EACN,KAAK,EACL,OAAO,EACP,OAAO,EACP,OAAO,EACP,IAAI,EACJ,IAAI,EACJ,OAAO,EACP,eAAe,EACf,IAAI,EACJ,eAAe,EACf,UAAU,EACV,SAAS,EACT,eAAe,EACf,oBAAoB,EACpB,oBAAoB,EACpB,mBAAmB,EACnB,QAAQ,EACR,eAAe,EACf,iBAAiB,EACjB,aAAa,EACb,MAAM,EACP,MAAM,qBAAqB,CAAC;AAK7B,OAAO,EAAC,oBAAoB,EAAE,mBAAmB,EAAC,MAAM,uCAAuC,CAAC;AAChG,OAAO,EAAC,WAAW,EAAC,MAAM,2BAA2B,CAAC;AACtD,OAAO,EAAC,0BAA0B,EAAC,MAAM,mCAAmC,CAAC;AAE7E,OAAO,EAAC,OAAO,IAAI,UAAU,EAAC,MAAM,yBAAyB,CAAC"}

package/dist/index.js

@@ -1,13 +1,75 @@
-export { default as TableBatchBuilder } from './lib/batches/table-batch-builder';
-export { default as RowTableBatchAggregator } from './lib/batches/row-table-batch-aggregator';
-export { default as ColumnarTableBatchAggregator } from './lib/batches/columnar-table-batch-aggregator';
-export { convertToObjectRow, convertToArrayRow } from './lib/utils/row-utils';
-export { getMeshSize, getMeshBoundingBox } from './category/mesh/mesh-utils';
-export { convertMesh } from './category/mesh/convert-mesh';
-export { deduceMeshSchema, deduceMeshField, makeMeshAttributeMetadata } from './category/mesh/deduce-mesh-schema';
-export { Schema, Field, DataType, Null, Binary, Bool, Int, Int8, Int16, Int32, Int64, Uint8, Uint16, Uint32, Uint64, Float, Float16, Float32, Float64, Utf8, Date, DateDay, DateMillisecond, Time, TimeMillisecond, TimeSecond, Timestamp, TimestampSecond, TimestampMillisecond, TimestampMicrosecond, TimestampNanosecond, Interval, IntervalDayTime, IntervalYearMonth, FixedSizeList, Struct } from './lib/schema';
-export { deduceTypeFromColumn, deduceTypeFromValue } from './lib/schema-utils/deduce-column-type';
-export { getTypeInfo } from './lib/arrow/get-type-info';
-export { getArrowTypeFromTypedArray } from './lib/arrow/arrow-like-type-utils';
-export { default as AsyncQueue } from './lib/utils/async-queue';
-//# sourceMappingURL=index.js.map
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypeInfo = exports.deduceTypeFromValue = exports.deduceTypeFromColumn = exports.Struct = exports.FixedSizeList = exports.IntervalYearMonth = exports.IntervalDayTime = exports.Interval = exports.TimestampNanosecond = exports.TimestampMicrosecond = exports.TimestampMillisecond = exports.TimestampSecond = exports.Timestamp = exports.TimeSecond = exports.TimeMillisecond = exports.Time = exports.DateMillisecond = exports.DateDay = exports.Date = exports.Utf8 = exports.Float64 = exports.Float32 = exports.Float16 = exports.Float = exports.Uint64 = exports.Uint32 = exports.Uint16 = exports.Uint8 = exports.Int64 = exports.Int32 = exports.Int16 = exports.Int8 = exports.Int = exports.Bool = exports.Binary = exports.Null = exports.DataType = exports.Field = exports.Schema = exports.makeMeshAttributeMetadata = exports.deduceMeshField = exports.deduceMeshSchema = exports.convertMesh = exports.getMeshBoundingBox = exports.getMeshSize = exports.convertToArrayRow = exports.convertToObjectRow = exports.ColumnarTableBatchAggregator = exports.RowTableBatchAggregator = exports.TableBatchBuilder = void 0;
+exports.AsyncQueue = exports.getArrowTypeFromTypedArray = void 0;
+// TABLE CATEGORY UTILS
+var table_batch_builder_1 = require("./lib/batches/table-batch-builder");
+Object.defineProperty(exports, "TableBatchBuilder", { enumerable: true, get: function () { return __importDefault(table_batch_builder_1).default; } });
+var row_table_batch_aggregator_1 = require("./lib/batches/row-table-batch-aggregator");
+Object.defineProperty(exports, "RowTableBatchAggregator", { enumerable: true, get: function () { return __importDefault(row_table_batch_aggregator_1).default; } });
+var columnar_table_batch_aggregator_1 = require("./lib/batches/columnar-table-batch-aggregator");
+Object.defineProperty(exports, "ColumnarTableBatchAggregator", { enumerable: true, get: function () { return __importDefault(columnar_table_batch_aggregator_1).default; } });
+var row_utils_1 = require("./lib/utils/row-utils");
+Object.defineProperty(exports, "convertToObjectRow", { enumerable: true, get: function () { return row_utils_1.convertToObjectRow; } });
+Object.defineProperty(exports, "convertToArrayRow", { enumerable: true, get: function () { return row_utils_1.convertToArrayRow; } });
+var mesh_utils_1 = require("./category/mesh/mesh-utils");
+Object.defineProperty(exports, "getMeshSize", { enumerable: true, get: function () { return mesh_utils_1.getMeshSize; } });
+Object.defineProperty(exports, "getMeshBoundingBox", { enumerable: true, get: function () { return mesh_utils_1.getMeshBoundingBox; } });
+var convert_mesh_1 = require("./category/mesh/convert-mesh");
+Object.defineProperty(exports, "convertMesh", { enumerable: true, get: function () { return convert_mesh_1.convertMesh; } });
+var deduce_mesh_schema_1 = require("./category/mesh/deduce-mesh-schema");
+Object.defineProperty(exports, "deduceMeshSchema", { enumerable: true, get: function () { return deduce_mesh_schema_1.deduceMeshSchema; } });
+Object.defineProperty(exports, "deduceMeshField", { enumerable: true, get: function () { return deduce_mesh_schema_1.deduceMeshField; } });
+Object.defineProperty(exports, "makeMeshAttributeMetadata", { enumerable: true, get: function () { return deduce_mesh_schema_1.makeMeshAttributeMetadata; } });
+// SCHEMA
+var schema_1 = require("./lib/schema/schema");
+Object.defineProperty(exports, "Schema", { enumerable: true, get: function () { return schema_1.Schema; } });
+Object.defineProperty(exports, "Field", { enumerable: true, get: function () { return schema_1.Field; } });
+Object.defineProperty(exports, "DataType", { enumerable: true, get: function () { return schema_1.DataType; } });
+Object.defineProperty(exports, "Null", { enumerable: true, get: function () { return schema_1.Null; } });
+Object.defineProperty(exports, "Binary", { enumerable: true, get: function () { return schema_1.Binary; } });
+Object.defineProperty(exports, "Bool", { enumerable: true, get: function () { return schema_1.Bool; } });
+Object.defineProperty(exports, "Int", { enumerable: true, get: function () { return schema_1.Int; } });
+Object.defineProperty(exports, "Int8", { enumerable: true, get: function () { return schema_1.Int8; } });
+Object.defineProperty(exports, "Int16", { enumerable: true, get: function () { return schema_1.Int16; } });
+Object.defineProperty(exports, "Int32", { enumerable: true, get: function () { return schema_1.Int32; } });
+Object.defineProperty(exports, "Int64", { enumerable: true, get: function () { return schema_1.Int64; } });
+Object.defineProperty(exports, "Uint8", { enumerable: true, get: function () { return schema_1.Uint8; } });
+Object.defineProperty(exports, "Uint16", { enumerable: true, get: function () { return schema_1.Uint16; } });
+Object.defineProperty(exports, "Uint32", { enumerable: true, get: function () { return schema_1.Uint32; } });
+Object.defineProperty(exports, "Uint64", { enumerable: true, get: function () { return schema_1.Uint64; } });
+Object.defineProperty(exports, "Float", { enumerable: true, get: function () { return schema_1.Float; } });
+Object.defineProperty(exports, "Float16", { enumerable: true, get: function () { return schema_1.Float16; } });
+Object.defineProperty(exports, "Float32", { enumerable: true, get: function () { return schema_1.Float32; } });
+Object.defineProperty(exports, "Float64", { enumerable: true, get: function () { return schema_1.Float64; } });
+Object.defineProperty(exports, "Utf8", { enumerable: true, get: function () { return schema_1.Utf8; } });
+Object.defineProperty(exports, "Date", { enumerable: true, get: function () { return schema_1.Date; } });
+Object.defineProperty(exports, "DateDay", { enumerable: true, get: function () { return schema_1.DateDay; } });
+Object.defineProperty(exports, "DateMillisecond", { enumerable: true, get: function () { return schema_1.DateMillisecond; } });
+Object.defineProperty(exports, "Time", { enumerable: true, get: function () { return schema_1.Time; } });
+Object.defineProperty(exports, "TimeMillisecond", { enumerable: true, get: function () { return schema_1.TimeMillisecond; } });
+Object.defineProperty(exports, "TimeSecond", { enumerable: true, get: function () { return schema_1.TimeSecond; } });
+Object.defineProperty(exports, "Timestamp", { enumerable: true, get: function () { return schema_1.Timestamp; } });
+Object.defineProperty(exports, "TimestampSecond", { enumerable: true, get: function () { return schema_1.TimestampSecond; } });
+Object.defineProperty(exports, "TimestampMillisecond", { enumerable: true, get: function () { return schema_1.TimestampMillisecond; } });
+Object.defineProperty(exports, "TimestampMicrosecond", { enumerable: true, get: function () { return schema_1.TimestampMicrosecond; } });
+Object.defineProperty(exports, "TimestampNanosecond", { enumerable: true, get: function () { return schema_1.TimestampNanosecond; } });
+Object.defineProperty(exports, "Interval", { enumerable: true, get: function () { return schema_1.Interval; } });
+Object.defineProperty(exports, "IntervalDayTime", { enumerable: true, get: function () { return schema_1.IntervalDayTime; } });
+Object.defineProperty(exports, "IntervalYearMonth", { enumerable: true, get: function () { return schema_1.IntervalYearMonth; } });
+Object.defineProperty(exports, "FixedSizeList", { enumerable: true, get: function () { return schema_1.FixedSizeList; } });
+Object.defineProperty(exports, "Struct", { enumerable: true, get: function () { return schema_1.Struct; } });
+// EXPERIMENTAL APIs
+// SCHEMA UTILS
+var deduce_column_type_1 = require("./lib/schema-utils/deduce-column-type");
+Object.defineProperty(exports, "deduceTypeFromColumn", { enumerable: true, get: function () { return deduce_column_type_1.deduceTypeFromColumn; } });
+Object.defineProperty(exports, "deduceTypeFromValue", { enumerable: true, get: function () { return deduce_column_type_1.deduceTypeFromValue; } });
+var get_type_info_1 = require("./lib/arrow/get-type-info");
+Object.defineProperty(exports, "getTypeInfo", { enumerable: true, get: function () { return get_type_info_1.getTypeInfo; } });
+var arrow_like_type_utils_1 = require("./lib/arrow/arrow-like-type-utils");
+Object.defineProperty(exports, "getArrowTypeFromTypedArray", { enumerable: true, get: function () { return arrow_like_type_utils_1.getArrowTypeFromTypedArray; } });
+var async_queue_1 = require("./lib/utils/async-queue");
+Object.defineProperty(exports, "AsyncQueue", { enumerable: true, get: function () { return __importDefault(async_queue_1).default; } });

package/dist/lib/arrow/arrow-like-type-utils.d.ts

@@ -0,0 +1,4 @@
+import type { TypedArray } from '../../types';
+import { DataType } from '../schema/schema';
+export declare function getArrowTypeFromTypedArray(array: TypedArray): DataType;
+//# sourceMappingURL=arrow-like-type-utils.d.ts.map

package/dist/lib/arrow/arrow-like-type-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrow-like-type-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/arrow/arrow-like-type-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,aAAa,CAAC;AAC5C,OAAO,EACL,QAAQ,EAST,MAAM,kBAAkB,CAAC;AAE1B,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,UAAU,GAAG,QAAQ,CAqBtE"}

package/dist/lib/arrow/arrow-like-type-utils.js

@@ -1,32 +1,27 @@
-import { Float32, Float64, Int16, Int32, Int8, Uint16, Uint32, Uint8 } from '../schema';
-export function getArrowTypeFromTypedArray(array) {
-  switch (array.constructor) {
-    case Int8Array:
-      return new Int8();
-
-    case Uint8Array:
-      return new Uint8();
-
-    case Int16Array:
-      return new Int16();
-
-    case Uint16Array:
-      return new Uint16();
-
-    case Int32Array:
-      return new Int32();
-
-    case Uint32Array:
-      return new Uint32();
-
-    case Float32Array:
-      return new Float32();
-
-    case Float64Array:
-      return new Float64();
-
-    default:
-      throw new Error('array type not supported');
-  }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArrowTypeFromTypedArray = void 0;
+const schema_1 = require("../schema/schema");
+function getArrowTypeFromTypedArray(array) {
+    switch (array.constructor) {
+        case Int8Array:
+            return new schema_1.Int8();
+        case Uint8Array:
+            return new schema_1.Uint8();
+        case Int16Array:
+            return new schema_1.Int16();
+        case Uint16Array:
+            return new schema_1.Uint16();
+        case Int32Array:
+            return new schema_1.Int32();
+        case Uint32Array:
+            return new schema_1.Uint32();
+        case Float32Array:
+            return new schema_1.Float32();
+        case Float64Array:
+            return new schema_1.Float64();
+        default:
+            throw new Error('array type not supported');
+    }
 }
-//# sourceMappingURL=arrow-like-type-utils.js.map
+exports.getArrowTypeFromTypedArray = getArrowTypeFromTypedArray;

package/dist/lib/arrow/arrow-type-utils.d.ts

@@ -0,0 +1,6 @@
+import type { TypedArray } from '../../types';
+import { DataType } from 'apache-arrow/Arrow.dom';
+import { AbstractVector } from 'apache-arrow/vector';
+export declare function getArrowType(array: TypedArray): DataType;
+export declare function getArrowVector(array: TypedArray): AbstractVector;
+//# sourceMappingURL=arrow-type-utils.d.ts.map

package/dist/lib/arrow/arrow-type-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrow-type-utils.d.ts","sourceRoot":"","sources":["../../../src/lib/arrow/arrow-type-utils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,aAAa,CAAC;AAC5C,OAAO,EACL,QAAQ,EAiBT,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAC,cAAc,EAAC,MAAM,qBAAqB,CAAC;AAEnD,wBAAgB,YAAY,CAAC,KAAK,EAAE,UAAU,GAAG,QAAQ,CAqBxD;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,UAAU,GAAG,cAAc,CAqBhE"}

package/dist/lib/arrow/arrow-type-utils.js

@@ -1,62 +1,50 @@
-import { Float32, Float64, Int16, Int32, Int8, Uint16, Uint32, Uint8, Int8Vector, Uint8Vector, Int16Vector, Uint16Vector, Int32Vector, Uint32Vector, Float32Vector, Float64Vector } from 'apache-arrow';
-export function getArrowType(array) {
-  switch (array.constructor) {
-    case Int8Array:
-      return new Int8();
-
-    case Uint8Array:
-      return new Uint8();
-
-    case Int16Array:
-      return new Int16();
-
-    case Uint16Array:
-      return new Uint16();
-
-    case Int32Array:
-      return new Int32();
-
-    case Uint32Array:
-      return new Uint32();
-
-    case Float32Array:
-      return new Float32();
-
-    case Float64Array:
-      return new Float64();
-
-    default:
-      throw new Error('array type not supported');
-  }
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArrowVector = exports.getArrowType = void 0;
+const Arrow_dom_1 = require("apache-arrow/Arrow.dom");
+function getArrowType(array) {
+    switch (array.constructor) {
+        case Int8Array:
+            return new Arrow_dom_1.Int8();
+        case Uint8Array:
+            return new Arrow_dom_1.Uint8();
+        case Int16Array:
+            return new Arrow_dom_1.Int16();
+        case Uint16Array:
+            return new Arrow_dom_1.Uint16();
+        case Int32Array:
+            return new Arrow_dom_1.Int32();
+        case Uint32Array:
+            return new Arrow_dom_1.Uint32();
+        case Float32Array:
+            return new Arrow_dom_1.Float32();
+        case Float64Array:
+            return new Arrow_dom_1.Float64();
+        default:
+            throw new Error('array type not supported');
+    }
 }
-export function getArrowVector(array) {
-  switch (array.constructor) {
-    case Int8Array:
-      return Int8Vector.from(array);
-
-    case Uint8Array:
-      return Uint8Vector.from(array);
-
-    case Int16Array:
-      return Int16Vector.from(array);
-
-    case Uint16Array:
-      return Uint16Vector.from(array);
-
-    case Int32Array:
-      return Int32Vector.from(array);
-
-    case Uint32Array:
-      return Uint32Vector.from(array);
-
-    case Float32Array:
-      return Float32Vector.from(array);
-
-    case Float64Array:
-      return Float64Vector.from(array);
-
-    default:
-      throw new Error('array type not supported');
-  }
+exports.getArrowType = getArrowType;
+function getArrowVector(array) {
+    switch (array.constructor) {
+        case Int8Array:
+            return Arrow_dom_1.Int8Vector.from(array);
+        case Uint8Array:
+            return Arrow_dom_1.Uint8Vector.from(array);
+        case Int16Array:
+            return Arrow_dom_1.Int16Vector.from(array);
+        case Uint16Array:
+            return Arrow_dom_1.Uint16Vector.from(array);
+        case Int32Array:
+            return Arrow_dom_1.Int32Vector.from(array);
+        case Uint32Array:
+            return Arrow_dom_1.Uint32Vector.from(array);
+        case Float32Array:
+            return Arrow_dom_1.Float32Vector.from(array);
+        case Float64Array:
+            return Arrow_dom_1.Float64Vector.from(array);
+        default:
+            throw new Error('array type not supported');
+    }
 }
-//# sourceMappingURL=arrow-type-utils.js.map
+exports.getArrowVector = getArrowVector;

package/dist/lib/arrow/get-type-info.d.ts

@@ -0,0 +1,14 @@
+import { Type } from '../schema/schema';
+import { AnyArray } from '../../types';
+/**
+ * Gets type information from an Arrow type object or "mock" Arrow type object
+ * @param arrowTypeLike Arrow Type or type object of similar shape
+ */
+export declare function getTypeInfo(arrowTypeLike: any): {
+    typeId: Type;
+    ArrayType: AnyArray;
+    typeName: string;
+    typeEnumName?: string;
+    precision?: number;
+};
+//# sourceMappingURL=get-type-info.d.ts.map

package/dist/lib/arrow/get-type-info.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"get-type-info.d.ts","sourceRoot":"","sources":["../../../src/lib/arrow/get-type-info.ts"],"names":[],"mappings":"AAAA,OAAO,EAAC,IAAI,EAAC,MAAM,kBAAkB,CAAC;AACtC,OAAO,EAAC,QAAQ,EAAC,MAAM,aAAa,CAAC;AAErC;;;GAGG;AACH,wBAAgB,WAAW,CAAC,aAAa,EAAE,GAAG,GAAG;IAC/C,MAAM,EAAE,IAAI,CAAC;IACb,SAAS,EAAE,QAAQ,CAAC;IACpB,QAAQ,EAAE,MAAM,CAAC;IACjB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB,CAQA"}

package/dist/lib/arrow/get-type-info.js

@@ -1,24 +1,28 @@
-import { Type } from '../schema';
-export function getTypeInfo(arrowTypeLike) {
-  return {
-    typeId: arrowTypeLike.typeId,
-    ArrayType: arrowTypeLike.ArrayType,
-    typeName: arrowTypeLike.toString(),
-    typeEnumName: getTypeKey(arrowTypeLike.typeId),
-    precision: arrowTypeLike.precision
-  };
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypeInfo = void 0;
+const schema_1 = require("../schema/schema");
+/**
+ * Gets type information from an Arrow type object or "mock" Arrow type object
+ * @param arrowTypeLike Arrow Type or type object of similar shape
+ */
+function getTypeInfo(arrowTypeLike) {
+    return {
+        typeId: arrowTypeLike.typeId,
+        ArrayType: arrowTypeLike.ArrayType,
+        typeName: arrowTypeLike.toString(),
+        typeEnumName: getTypeKey(arrowTypeLike.typeId),
+        precision: arrowTypeLike.precision
+    };
 }
+exports.getTypeInfo = getTypeInfo;
 let ReverseType = null;
-
 function getTypeKey(typeKey) {
-  if (!ReverseType) {
-    ReverseType = {};
-
-    for (const key in Type) {
-      ReverseType[Type[key]] = key;
+    if (!ReverseType) {
+        ReverseType = {};
+        for (const key in schema_1.Type) {
+            ReverseType[schema_1.Type[key]] = key;
+        }
     }
-  }
-
-  return ReverseType[typeKey];
+    return ReverseType[typeKey];
 }
-//# sourceMappingURL=get-type-info.js.map

package/dist/lib/batches/base-table-batch-aggregator.d.ts

@@ -0,0 +1,19 @@
+import type { Schema } from '../schema/schema';
+import type { TableBatch } from '../../category/table/table-types';
+import { TableBatchAggregator, TableBatchOptions } from './table-batch-aggregator';
+export default class RowTableBatchAggregator implements TableBatchAggregator {
+    schema: Schema;
+    options: TableBatchOptions;
+    length: number;
+    rows: any[] | null;
+    cursor: number;
+    private _headers;
+    constructor(schema: Schema, options: TableBatchOptions);
+    rowCount(): number;
+    addArrayRow(row: any[], cursor?: number): void;
+    addObjectRow(row: {
+        [columnName: string]: any;
+    }, cursor?: number): void;
+    getBatch(): TableBatch | null;
+}
+//# sourceMappingURL=base-table-batch-aggregator.d.ts.map

package/dist/lib/batches/base-table-batch-aggregator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-table-batch-aggregator.d.ts","sourceRoot":"","sources":["../../../src/lib/batches/base-table-batch-aggregator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,kBAAkB,CAAC;AAC7C,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,kCAAkC,CAAC;AACjE,OAAO,EAAC,oBAAoB,EAAE,iBAAiB,EAAC,MAAM,0BAA0B,CAAC;AAIjF,MAAM,CAAC,OAAO,OAAO,uBAAwB,YAAW,oBAAoB;IAC1E,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,iBAAiB,CAAC;IAE3B,MAAM,EAAE,MAAM,CAAK;IACnB,IAAI,EAAE,GAAG,EAAE,GAAG,IAAI,CAAQ;IAC1B,MAAM,EAAE,MAAM,CAAK;IACnB,OAAO,CAAC,QAAQ,CAAgB;gBAEpB,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB;IActD,QAAQ,IAAI,MAAM;IAIlB,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAU9C,YAAY,CAAC,GAAG,EAAE;QAAC,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAUrE,QAAQ,IAAI,UAAU,GAAG,IAAI;CAoB9B"}