@loaders.gl/schema 4.0.0-alpha.4 → 4.0.0-alpha.6

package/dist/lib/table/arrow-api/enum.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Main data type enumeration.
+ *
+ * Data types in this library are all *logical*. They can be expressed as
+ * either a primitive physical type (bytes or bits of some fixed size), a
+ * nested type consisting of other data types, or another data type (e.g. a
+ * timestamp encoded as an int64).
+ *
+ * **Note**: Only enum values 0-17 (NONE through Map) are written to an Arrow
+ * IPC payload.
+ *
+ * The rest of the values are specified here so TypeScript can narrow the type
+ * signatures further beyond the base Arrow Types. The Arrow DataTypes include
+ * metadata like `bitWidth` that impact the type signatures of the values we
+ * accept and return.
+ *
+ * For example, the `Int8Vector` reads 1-byte numbers from an `Int8Array`, an
+ * `Int32Vector` reads a 4-byte number from an `Int32Array`, and an `Int64Vector`
+ * reads a pair of 4-byte lo, hi 32-bit integers as a zero-copy slice from the
+ * underlying `Int32Array`.
+ *
+ * Library consumers benefit by knowing the narrowest type, since we can ensure
+ * the types across all public methods are propagated, and never bail to `any`.
+ * These values are _never_ used at runtime, and they will _never_ be written
+ * to the flatbuffers metadata of serialized Arrow IPC payloads.
+ */
+export declare enum Type {
+    /** The default placeholder type */
+    NONE = 0,
+    /** A NULL type having no physical storage */
+    Null = 1,
+    /** Signed or unsigned 8, 16, 32, or 64-bit little-endian integer */
+    Int = 2,
+    /** 2, 4, or 8-byte floating point value */
+    Float = 3,
+    /** Variable-length bytes (no guarantee of UTF8-ness) */
+    Binary = 4,
+    /** UTF8 variable-length string as List<Char> */
+    Utf8 = 5,
+    /** Boolean as 1 bit, LSB bit-packed ordering */
+    Bool = 6,
+    /** Precision-and-scale-based decimal type. Storage type depends on the parameters. */
+    Decimal = 7,
+    /** int32_t days or int64_t milliseconds since the UNIX epoch */
+    Date = 8,
+    /** Time as signed 32 or 64-bit integer, representing either seconds, milliseconds, microseconds, or nanoseconds since midnight since midnight */
+    Time = 9,
+    /** Exact timestamp encoded with int64 since UNIX epoch (Default unit millisecond) */
+    Timestamp = 10,
+    /** YEAR_MONTH or DAY_TIME interval in SQL style */
+    Interval = 11,
+    /** A list of some logical data type */
+    List = 12,
+    /** Struct of logical types */
+    Struct = 13,
+    /** Union of logical types */
+    Union = 14,
+    /** Fixed-size binary. Each value occupies the same number of bytes */
+    FixedSizeBinary = 15,
+    /** Fixed-size list. Each value occupies the same number of bytes */
+    FixedSizeList = 16,
+    /** Map of named logical types */
+    Map = 17,
+    /** Dictionary aka Category type */
+    Dictionary = -1,
+    Int8 = -2,
+    Int16 = -3,
+    Int32 = -4,
+    Int64 = -5,
+    Uint8 = -6,
+    Uint16 = -7,
+    Uint32 = -8,
+    Uint64 = -9,
+    Float16 = -10,
+    Float32 = -11,
+    Float64 = -12,
+    DateDay = -13,
+    DateMillisecond = -14,
+    TimestampSecond = -15,
+    TimestampMillisecond = -16,
+    TimestampMicrosecond = -17,
+    TimestampNanosecond = -18,
+    TimeSecond = -19,
+    TimeMillisecond = -20,
+    TimeMicrosecond = -21,
+    TimeNanosecond = -22,
+    DenseUnion = -23,
+    SparseUnion = -24,
+    IntervalDayTime = -25,
+    IntervalYearMonth = -26
+}
+//# sourceMappingURL=enum.d.ts.map

package/dist/lib/table/arrow-api/enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"enum.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/arrow-api/enum.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH,oBAAY,IAAI;IACd,mCAAmC;IACnC,IAAI,IAAI;IACR,6CAA6C;IAC7C,IAAI,IAAI;IACR,oEAAoE;IACpE,GAAG,IAAI;IACP,2CAA2C;IAC3C,KAAK,IAAI;IACT,wDAAwD;IACxD,MAAM,IAAI;IACV,gDAAgD;IAChD,IAAI,IAAI;IACR,gDAAgD;IAChD,IAAI,IAAI;IACR,sFAAsF;IACtF,OAAO,IAAI;IACX,gEAAgE;IAChE,IAAI,IAAI;IACR,iJAAiJ;IACjJ,IAAI,IAAI;IACR,qFAAqF;IACrF,SAAS,KAAK;IACd,mDAAmD;IACnD,QAAQ,KAAK;IACb,uCAAuC;IACvC,IAAI,KAAK;IACT,8BAA8B;IAC9B,MAAM,KAAK;IACX,6BAA6B;IAC7B,KAAK,KAAK;IACV,sEAAsE;IACtE,eAAe,KAAK;IACpB,oEAAoE;IACpE,aAAa,KAAK;IAClB,iCAAiC;IACjC,GAAG,KAAK;IAER,mCAAmC;IACnC,UAAU,KAAK;IACf,IAAI,KAAK;IACT,KAAK,KAAK;IACV,KAAK,KAAK;IACV,KAAK,KAAK;IACV,KAAK,KAAK;IACV,MAAM,KAAK;IACX,MAAM,KAAK;IACX,MAAM,KAAK;IACX,OAAO,MAAM;IACb,OAAO,MAAM;IACb,OAAO,MAAM;IACb,OAAO,MAAM;IACb,eAAe,MAAM;IACrB,eAAe,MAAM;IACrB,oBAAoB,MAAM;IAC1B,oBAAoB,MAAM;IAC1B,mBAAmB,MAAM;IACzB,UAAU,MAAM;IAChB,eAAe,MAAM;IACrB,eAAe,MAAM;IACrB,cAAc,MAAM;IACpB,UAAU,MAAM;IAChB,WAAW,MAAM;IACjB,eAAe,MAAM;IACrB,iBAAiB,MAAM;CACxB"}

package/dist/lib/table/arrow-api/enum.js

@@ -0,0 +1,97 @@
+"use strict";
+// This code is adapted from ArrowJS https://github.com/apache/arrow
+// under Apache license http://www.apache.org/licenses/LICENSE-2.0
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Type = void 0;
+/**
+ * Main data type enumeration.
+ *
+ * Data types in this library are all *logical*. They can be expressed as
+ * either a primitive physical type (bytes or bits of some fixed size), a
+ * nested type consisting of other data types, or another data type (e.g. a
+ * timestamp encoded as an int64).
+ *
+ * **Note**: Only enum values 0-17 (NONE through Map) are written to an Arrow
+ * IPC payload.
+ *
+ * The rest of the values are specified here so TypeScript can narrow the type
+ * signatures further beyond the base Arrow Types. The Arrow DataTypes include
+ * metadata like `bitWidth` that impact the type signatures of the values we
+ * accept and return.
+ *
+ * For example, the `Int8Vector` reads 1-byte numbers from an `Int8Array`, an
+ * `Int32Vector` reads a 4-byte number from an `Int32Array`, and an `Int64Vector`
+ * reads a pair of 4-byte lo, hi 32-bit integers as a zero-copy slice from the
+ * underlying `Int32Array`.
+ *
+ * Library consumers benefit by knowing the narrowest type, since we can ensure
+ * the types across all public methods are propagated, and never bail to `any`.
+ * These values are _never_ used at runtime, and they will _never_ be written
+ * to the flatbuffers metadata of serialized Arrow IPC payloads.
+ */
+var Type;
+(function (Type) {
+    /** The default placeholder type */
+    Type[Type["NONE"] = 0] = "NONE";
+    /** A NULL type having no physical storage */
+    Type[Type["Null"] = 1] = "Null";
+    /** Signed or unsigned 8, 16, 32, or 64-bit little-endian integer */
+    Type[Type["Int"] = 2] = "Int";
+    /** 2, 4, or 8-byte floating point value */
+    Type[Type["Float"] = 3] = "Float";
+    /** Variable-length bytes (no guarantee of UTF8-ness) */
+    Type[Type["Binary"] = 4] = "Binary";
+    /** UTF8 variable-length string as List<Char> */
+    Type[Type["Utf8"] = 5] = "Utf8";
+    /** Boolean as 1 bit, LSB bit-packed ordering */
+    Type[Type["Bool"] = 6] = "Bool";
+    /** Precision-and-scale-based decimal type. Storage type depends on the parameters. */
+    Type[Type["Decimal"] = 7] = "Decimal";
+    /** int32_t days or int64_t milliseconds since the UNIX epoch */
+    Type[Type["Date"] = 8] = "Date";
+    /** Time as signed 32 or 64-bit integer, representing either seconds, milliseconds, microseconds, or nanoseconds since midnight since midnight */
+    Type[Type["Time"] = 9] = "Time";
+    /** Exact timestamp encoded with int64 since UNIX epoch (Default unit millisecond) */
+    Type[Type["Timestamp"] = 10] = "Timestamp";
+    /** YEAR_MONTH or DAY_TIME interval in SQL style */
+    Type[Type["Interval"] = 11] = "Interval";
+    /** A list of some logical data type */
+    Type[Type["List"] = 12] = "List";
+    /** Struct of logical types */
+    Type[Type["Struct"] = 13] = "Struct";
+    /** Union of logical types */
+    Type[Type["Union"] = 14] = "Union";
+    /** Fixed-size binary. Each value occupies the same number of bytes */
+    Type[Type["FixedSizeBinary"] = 15] = "FixedSizeBinary";
+    /** Fixed-size list. Each value occupies the same number of bytes */
+    Type[Type["FixedSizeList"] = 16] = "FixedSizeList";
+    /** Map of named logical types */
+    Type[Type["Map"] = 17] = "Map";
+    /** Dictionary aka Category type */
+    Type[Type["Dictionary"] = -1] = "Dictionary";
+    Type[Type["Int8"] = -2] = "Int8";
+    Type[Type["Int16"] = -3] = "Int16";
+    Type[Type["Int32"] = -4] = "Int32";
+    Type[Type["Int64"] = -5] = "Int64";
+    Type[Type["Uint8"] = -6] = "Uint8";
+    Type[Type["Uint16"] = -7] = "Uint16";
+    Type[Type["Uint32"] = -8] = "Uint32";
+    Type[Type["Uint64"] = -9] = "Uint64";
+    Type[Type["Float16"] = -10] = "Float16";
+    Type[Type["Float32"] = -11] = "Float32";
+    Type[Type["Float64"] = -12] = "Float64";
+    Type[Type["DateDay"] = -13] = "DateDay";
+    Type[Type["DateMillisecond"] = -14] = "DateMillisecond";
+    Type[Type["TimestampSecond"] = -15] = "TimestampSecond";
+    Type[Type["TimestampMillisecond"] = -16] = "TimestampMillisecond";
+    Type[Type["TimestampMicrosecond"] = -17] = "TimestampMicrosecond";
+    Type[Type["TimestampNanosecond"] = -18] = "TimestampNanosecond";
+    Type[Type["TimeSecond"] = -19] = "TimeSecond";
+    Type[Type["TimeMillisecond"] = -20] = "TimeMillisecond";
+    Type[Type["TimeMicrosecond"] = -21] = "TimeMicrosecond";
+    Type[Type["TimeNanosecond"] = -22] = "TimeNanosecond";
+    Type[Type["DenseUnion"] = -23] = "DenseUnion";
+    Type[Type["SparseUnion"] = -24] = "SparseUnion";
+    Type[Type["IntervalDayTime"] = -25] = "IntervalDayTime";
+    Type[Type["IntervalYearMonth"] = -26] = "IntervalYearMonth";
+})(Type = exports.Type || (exports.Type = {}));

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

@@ -0,0 +1,13 @@
+import { Type } from './arrow-like-type';
+/**
+ * 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: ArrayLike<unknown>;
+    typeName: string;
+    typeEnumName?: string;
+    precision?: number;
+};
+//# sourceMappingURL=get-type-info.d.ts.map

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

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

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

@@ -0,0 +1,29 @@
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypeInfo = void 0;
+const arrow_like_type_1 = require("./arrow-like-type");
+/**
+ * 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 arrow_like_type_1.Type) {
+            ReverseType[arrow_like_type_1.Type[key]] = key;
+        }
+    }
+    return ReverseType[typeKey];
+}

package/dist/lib/table/arrow-api/index.d.ts

@@ -0,0 +1,5 @@
+export { ArrowLikeField as Field } from './arrow-like-field';
+export { ArrowLikeSchema as Schema } from './arrow-like-schema';
+export { ArrowLikeTable as Table } from './arrow-like-table';
+export * from './arrow-like-type';
+//# sourceMappingURL=index.d.ts.map

package/dist/lib/table/arrow-api/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/arrow-api/index.ts"],"names":[],"mappings":"AAEA,OAAO,EAAC,cAAc,IAAI,KAAK,EAAC,MAAM,oBAAoB,CAAC;AAC3D,OAAO,EAAC,eAAe,IAAI,MAAM,EAAC,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EAAC,cAAc,IAAI,KAAK,EAAC,MAAM,oBAAoB,CAAC;AAC3D,cAAc,mBAAmB,CAAC"}

package/dist/lib/table/arrow-api/index.js

@@ -0,0 +1,25 @@
+"use strict";
+// loaders.gl, MIT license
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Table = exports.Schema = exports.Field = void 0;
+var arrow_like_field_1 = require("./arrow-like-field");
+Object.defineProperty(exports, "Field", { enumerable: true, get: function () { return arrow_like_field_1.ArrowLikeField; } });
+var arrow_like_schema_1 = require("./arrow-like-schema");
+Object.defineProperty(exports, "Schema", { enumerable: true, get: function () { return arrow_like_schema_1.ArrowLikeSchema; } });
+var arrow_like_table_1 = require("./arrow-like-table");
+Object.defineProperty(exports, "Table", { enumerable: true, get: function () { return arrow_like_table_1.ArrowLikeTable; } });
+__exportStar(require("./arrow-like-type"), exports);

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

@@ -0,0 +1,19 @@
+import type { Schema } from '../../../types/schema';
+import type { TableBatch } from '../../../types/category-table';
+import { TableBatchAggregator, TableBatchOptions } from './table-batch-aggregator';
+export declare class BaseTableBatchAggregator 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/table/batches/base-table-batch-aggregator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base-table-batch-aggregator.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/batches/base-table-batch-aggregator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,uBAAuB,CAAC;AAClD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,+BAA+B,CAAC;AAC9D,OAAO,EAAC,oBAAoB,EAAE,iBAAiB,EAAC,MAAM,0BAA0B,CAAC;AAIjF,qBAAa,wBAAyB,YAAW,oBAAoB;IACnE,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"}

package/dist/lib/table/batches/base-table-batch-aggregator.js

@@ -0,0 +1,60 @@
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseTableBatchAggregator = void 0;
+const DEFAULT_ROW_COUNT = 100;
+class BaseTableBatchAggregator {
+    constructor(schema, options) {
+        this.length = 0;
+        this.rows = null;
+        this.cursor = 0;
+        this._headers = [];
+        this.options = options;
+        this.schema = schema;
+        // schema is an array if there're no headers
+        // object if there are headers
+        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;
+    }
+}
+exports.BaseTableBatchAggregator = BaseTableBatchAggregator;

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

@@ -0,0 +1,23 @@
+import type { Schema } from '../../../types/schema';
+import type { ColumnarTableBatch, ArrowTableBatch } from '../../../types/category-table';
+import { TableBatchAggregator } from './table-batch-aggregator';
+type ColumnarTableBatchOptions = {};
+export declare class ColumnarTableBatchAggregator implements TableBatchAggregator {
+    schema: Schema;
+    length: number;
+    allocated: number;
+    columns: {
+        [columnName: string]: any[];
+    };
+    constructor(schema: Schema, options: ColumnarTableBatchOptions);
+    rowCount(): number;
+    addArrayRow(row: any[]): void;
+    addObjectRow(row: {
+        [columnName: string]: any;
+    }): void;
+    getBatch(): ColumnarTableBatch | ArrowTableBatch | null;
+    _reallocateColumns(): void;
+    _pruneColumns(): void;
+}
+export {};
+//# sourceMappingURL=columnar-table-batch-aggregator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"columnar-table-batch-aggregator.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/batches/columnar-table-batch-aggregator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,uBAAuB,CAAC;AAClD,OAAO,KAAK,EAAC,kBAAkB,EAAE,eAAe,EAAC,MAAM,+BAA+B,CAAC;AACvF,OAAO,EAAC,oBAAoB,EAAC,MAAM,0BAA0B,CAAC;AAE9D,KAAK,yBAAyB,GAAG,EAAE,CAAC;AAIpC,qBAAa,4BAA6B,YAAW,oBAAoB;IACvE,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,MAAM,CAAK;IACnB,SAAS,EAAE,MAAM,CAAK;IACtB,OAAO,EAAE;QAAC,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,EAAE,CAAA;KAAC,CAAM;gBAEhC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,yBAAyB;IAK9D,QAAQ,IAAI,MAAM;IAIlB,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE;IAWtB,YAAY,CAAC,GAAG,EAAE;QAAC,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,GAAG,IAAI;IASpD,QAAQ,IAAI,kBAAkB,GAAG,eAAe,GAAG,IAAI;IA6BvD,kBAAkB;IA8BlB,aAAa;CAKd"}

package/dist/lib/table/batches/columnar-table-batch-aggregator.js

@@ -0,0 +1,92 @@
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ColumnarTableBatchAggregator = void 0;
+const DEFAULT_ROW_COUNT = 100;
+class ColumnarTableBatchAggregator {
+    constructor(schema, options) {
+        this.length = 0;
+        this.allocated = 0;
+        this.columns = {};
+        this.schema = schema;
+        this._reallocateColumns();
+    }
+    rowCount() {
+        return this.length;
+    }
+    addArrayRow(row) {
+        // If user keeps pushing rows beyond batch size, reallocate
+        this._reallocateColumns();
+        let i = 0;
+        // TODO what if no csv header, columns not populated?
+        for (const fieldName in this.columns) {
+            this.columns[fieldName][this.length] = row[i++];
+        }
+        this.length++;
+    }
+    addObjectRow(row) {
+        // If user keeps pushing rows beyond batch size, reallocate
+        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 : {};
+        // schema is an array if there're no headers
+        // object if there are headers
+        // columns should match schema format
+        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;
+        }
+        // @ts-ignore TODO
+        this.allocated = this.allocated > 0 ? (this.allocated *= 2) : DEFAULT_ROW_COUNT;
+        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)) {
+                // Copy the old data to the new array
+                const typedArray = new ArrayType(this.allocated);
+                typedArray.set(oldColumn);
+                this.columns[field.index] = typedArray;
+            }
+            else if (oldColumn) {
+                // Plain array
+                oldColumn.length = this.allocated;
+                this.columns[field.index] = oldColumn;
+            }
+            else {
+                // Create new
+                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);
+        }
+    }
+}
+exports.ColumnarTableBatchAggregator = ColumnarTableBatchAggregator;

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

@@ -0,0 +1,22 @@
+import type { Schema } from '../../../types/schema';
+import type { TableBatch } from '../../../types/category-table';
+import { TableBatchAggregator, TableBatchOptions } from './table-batch-aggregator';
+export declare class RowTableBatchAggregator implements TableBatchAggregator {
+    schema: Schema;
+    options: TableBatchOptions;
+    length: number;
+    objectRows: {
+        [columnName: string]: any;
+    } | null;
+    arrayRows: 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=row-table-batch-aggregator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"row-table-batch-aggregator.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/batches/row-table-batch-aggregator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,uBAAuB,CAAC;AAClD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,+BAA+B,CAAC;AAG9D,OAAO,EAAC,oBAAoB,EAAE,iBAAiB,EAAC,MAAM,0BAA0B,CAAC;AAIjF,qBAAa,uBAAwB,YAAW,oBAAoB;IAClE,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,iBAAiB,CAAC;IAE3B,MAAM,EAAE,MAAM,CAAK;IACnB,UAAU,EAAE;QAAC,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,GAAG,IAAI,CAAQ;IACtD,SAAS,EAAE,GAAG,EAAE,GAAG,IAAI,CAAQ;IAC/B,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;IAmB9C,YAAY,CAAC,GAAG,EAAE;QAAC,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,EAAE,MAAM,CAAC,EAAE,MAAM,GAAG,IAAI;IAmBrE,QAAQ,IAAI,UAAU,GAAG,IAAI;CAmB9B"}

package/dist/lib/table/batches/row-table-batch-aggregator.js

@@ -0,0 +1,81 @@
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RowTableBatchAggregator = void 0;
+// import type {ArrayRowTableBatch, ObjectRowTableBatch} from '../../category/table.js';
+const row_utils_1 = require("../simple-table/row-utils");
+const DEFAULT_ROW_COUNT = 100;
+class RowTableBatchAggregator {
+    constructor(schema, options) {
+        this.length = 0;
+        this.objectRows = null;
+        this.arrayRows = null;
+        this.cursor = 0;
+        this._headers = [];
+        this.options = options;
+        this.schema = schema;
+        // schema is an array if there're no headers
+        // object if there are headers
+        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;
+        }
+        // eslint-disable-next-line default-case
+        switch (this.options.shape) {
+            case 'object-row-table':
+                const rowObject = (0, row_utils_1.convertToObjectRow)(row, this._headers);
+                this.addObjectRow(rowObject, cursor);
+                break;
+            case 'array-row-table':
+                this.arrayRows = this.arrayRows || new Array(DEFAULT_ROW_COUNT);
+                this.arrayRows[this.length] = row;
+                this.length++;
+                break;
+        }
+    }
+    addObjectRow(row, cursor) {
+        if (Number.isFinite(cursor)) {
+            this.cursor = cursor;
+        }
+        // eslint-disable-next-line default-case
+        switch (this.options.shape) {
+            case 'array-row-table':
+                const rowArray = (0, row_utils_1.convertToArrayRow)(row, this._headers);
+                this.addArrayRow(rowArray, cursor);
+                break;
+            case 'object-row-table':
+                this.objectRows = this.objectRows || new Array(DEFAULT_ROW_COUNT);
+                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
+        };
+    }
+}
+exports.RowTableBatchAggregator = RowTableBatchAggregator;

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

@@ -0,0 +1,25 @@
+import type { Schema } from '../../../types/schema';
+import type { TableBatch } from '../../../types/category-table';
+export interface TableBatchOptions {
+    batchSize: number | string;
+    [key: string]: any;
+}
+export interface TableBatchConstructor {
+    new (schema: Schema, options: TableBatchOptions): TableBatchAggregator;
+}
+/**
+ * TableBatchBuilder delegates batch building to this interface
+ */
+export interface TableBatchAggregator {
+    /** Number of rows */
+    rowCount(): number;
+    /** Add one row */
+    addArrayRow(row: any[]): void;
+    /** Add one row */
+    addObjectRow(row: {
+        [columnName: string]: any;
+    }): void;
+    /** return a batch object */
+    getBatch(): TableBatch | null;
+}
+//# sourceMappingURL=table-batch-aggregator.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"table-batch-aggregator.d.ts","sourceRoot":"","sources":["../../../../src/lib/table/batches/table-batch-aggregator.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAC,MAAM,EAAC,MAAM,uBAAuB,CAAC;AAClD,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,+BAA+B,CAAC;AAE9D,MAAM,WAAW,iBAAiB;IAChC,SAAS,EAAE,MAAM,GAAG,MAAM,CAAC;IAC3B,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,qBAAqB;IACpC,KAAK,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,iBAAiB,GAAG,oBAAoB,CAAC;CACxE;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,qBAAqB;IACrB,QAAQ,IAAI,MAAM,CAAC;IACnB,kBAAkB;IAClB,WAAW,CAAC,GAAG,EAAE,GAAG,EAAE,GAAG,IAAI,CAAC;IAC9B,kBAAkB;IAClB,YAAY,CAAC,GAAG,EAAE;QAAC,CAAC,UAAU,EAAE,MAAM,GAAG,GAAG,CAAA;KAAC,GAAG,IAAI,CAAC;IACrD,4BAA4B;IAC5B,QAAQ,IAAI,UAAU,GAAG,IAAI,CAAC;CAC/B"}

package/dist/lib/table/batches/table-batch-aggregator.js

@@ -0,0 +1,3 @@
+"use strict";
+// loaders.gl, MIT license
+Object.defineProperty(exports, "__esModule", { value: true });