{"version":3,"sources":["builder.ts"],"names":[],"mappings":"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","file":"builder.js","sourcesContent":["// Licensed to the Apache Software Foundation (ASF) under one\n// or more contributor license agreements.  See the NOTICE file\n// distributed with this work for additional information\n// regarding copyright ownership.  The ASF licenses this file\n// to you under the Apache License, Version 2.0 (the\n// \"License\"); you may not use this file except in compliance\n// with the License.  You may obtain a copy of the License at\n//\n//   http://www.apache.org/licenses/LICENSE-2.0\n//\n// Unless required by applicable law or agreed to in writing,\n// software distributed under the License is distributed on an\n// \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY\n// KIND, either express or implied.  See the License for the\n// specific language governing permissions and limitations\n// under the License.\n\nimport { Vector } from './vector';\nimport { BufferType } from './enum';\nimport { Data, Buffers } from './data';\nimport { createIsValidFunction } from './builder/valid';\nimport { BuilderType as B, VectorType as V} from './interfaces';\nimport { BufferBuilder, BitmapBufferBuilder, DataBufferBuilder, OffsetsBufferBuilder } from './builder/buffer';\nimport {\n    DataType, strideForType,\n    Float, Int, Decimal, FixedSizeBinary,\n    Date_, Time, Timestamp, Interval,\n    Utf8, Binary, List, Map_\n} from './type';\n\n/**\n * A set of options required to create a `Builder` instance for a given `DataType`.\n * @see {@link Builder}\n */\nexport interface BuilderOptions<T extends DataType = any, TNull = any> {\n    type: T;\n    nullValues?: TNull[] | ReadonlyArray<TNull> | null;\n    children?: { [key: string]: BuilderOptions; } | BuilderOptions[];\n}\n\n/**\n * A set of options to create an Iterable or AsyncIterable `Builder` transform function.\n * @see {@link Builder.throughIterable}\n * @see {@link Builder.throughAsyncIterable}\n */\n\nexport interface IterableBuilderOptions<T extends DataType = any, TNull = any> extends BuilderOptions<T, TNull> {\n    highWaterMark?: number;\n    queueingStrategy?: 'bytes' | 'count';\n    dictionaryHashFunction?: (value: any) => string | number;\n    valueToChildTypeId?: (builder: Builder<T, TNull>, value: any, offset: number) => number;\n}\n\n/**\n * An abstract base class for types that construct Arrow Vectors from arbitrary JavaScript values.\n *\n * A `Builder` is responsible for writing arbitrary JavaScript values\n * to ArrayBuffers and/or child Builders according to the Arrow specification\n * for each DataType, creating or resizing the underlying ArrayBuffers as necessary.\n *\n * The `Builder` for each Arrow `DataType` handles converting and appending\n * values for a given `DataType`. The high-level {@link Builder.new `Builder.new()`} convenience\n * method creates the specific `Builder` subclass for the supplied `DataType`.\n *\n * Once created, `Builder` instances support both appending values to the end\n * of the `Builder`, and random-access writes to specific indices\n * (`Builder.prototype.append(value)` is a convenience method for\n * `builder.set(builder.length, value)`). Appending or setting values beyond the\n * Builder's current length may cause the builder to grow its underlying buffers\n * or child Builders (if applicable) to accommodate the new values.\n *\n * After enough values have been written to a `Builder`, `Builder.prototype.flush()`\n * will commit the values to the underlying ArrayBuffers (or child Builders). The\n * internal Builder state will be reset, and an instance of `Data<T>` is returned.\n * Alternatively, `Builder.prototype.toVector()` will flush the `Builder` and return\n * an instance of `Vector<T>` instead.\n *\n * When there are no more values to write, use `Builder.prototype.finish()` to\n * finalize the `Builder`. This does not reset the internal state, so it is\n * necessary to call `Builder.prototype.flush()` or `toVector()` one last time\n * if there are still values queued to be flushed.\n *\n * Note: calling `Builder.prototype.finish()` is required when using a `DictionaryBuilder`,\n * because this is when it flushes the values that have been enqueued in its internal\n * dictionary's `Builder`, and creates the `dictionaryVector` for the `Dictionary` `DataType`.\n *\n * ```ts\n * import { Builder, Utf8 } from 'apache-arrow';\n *\n * const utf8Builder = Builder.new({\n *     type: new Utf8(),\n *     nullValues: [null, 'n/a']\n * });\n *\n * utf8Builder\n *     .append('hello')\n *     .append('n/a')\n *     .append('world')\n *     .append(null);\n *\n * const utf8Vector = utf8Builder.finish().toVector();\n *\n * console.log(utf8Vector.toJSON());\n * // > [\"hello\", null, \"world\", null]\n * ```\n *\n * @typeparam T The `DataType` of this `Builder`.\n * @typeparam TNull The type(s) of values which will be considered null-value sentinels.\n */\nexport abstract class Builder<T extends DataType = any, TNull = any> {\n\n    /**\n     * Create a `Builder` instance based on the `type` property of the supplied `options` object.\n     * @param {BuilderOptions<T, TNull>} options An object with a required `DataType` instance\n     * and other optional parameters to be passed to the `Builder` subclass for the given `type`.\n     *\n     * @typeparam T The `DataType` of the `Builder` to create.\n     * @typeparam TNull The type(s) of values which will be considered null-value sentinels.\n     * @nocollapse\n     */\n    // @ts-ignore\n    public static new<T extends DataType = any, TNull = any>(options: BuilderOptions<T, TNull>): B<T, TNull> {}\n\n    /** @nocollapse */\n    // @ts-ignore\n    public static throughNode<T extends DataType = any, TNull = any>(options: import('./io/node/builder').BuilderDuplexOptions<T, TNull>): import('stream').Duplex {\n        throw new Error(`\"throughNode\" not available in this environment`);\n    }\n    /** @nocollapse */\n    // @ts-ignore\n    public static throughDOM<T extends DataType = any, TNull = any>(options: import('./io/whatwg/builder').BuilderTransformOptions<T, TNull>): import('./io/whatwg/builder').BuilderTransform<T, TNull> {\n        throw new Error(`\"throughDOM\" not available in this environment`);\n    }\n\n    /**\n     * Transform a synchronous `Iterable` of arbitrary JavaScript values into a\n     * sequence of Arrow Vector<T> following the chunking semantics defined in\n     * the supplied `options` argument.\n     *\n     * This function returns a function that accepts an `Iterable` of values to\n     * transform. When called, this function returns an Iterator of `Vector<T>`.\n     *\n     * The resulting `Iterator<Vector<T>>` yields Vectors based on the\n     * `queueingStrategy` and `highWaterMark` specified in the `options` argument.\n     *\n     * * If `queueingStrategy` is `\"count\"` (or omitted), The `Iterator<Vector<T>>`\n     *   will flush the underlying `Builder` (and yield a new `Vector<T>`) once the\n     *   Builder's `length` reaches or exceeds the supplied `highWaterMark`.\n     * * If `queueingStrategy` is `\"bytes\"`, the `Iterator<Vector<T>>` will flush\n     *   the underlying `Builder` (and yield a new `Vector<T>`) once its `byteLength`\n     *   reaches or exceeds the supplied `highWaterMark`.\n     *\n     * @param {IterableBuilderOptions<T, TNull>} options An object of properties which determine the `Builder` to create and the chunking semantics to use.\n     * @returns A function which accepts a JavaScript `Iterable` of values to\n     *          write, and returns an `Iterator` that yields Vectors according\n     *          to the chunking semantics defined in the `options` argument.\n     * @nocollapse\n     */\n    public static throughIterable<T extends DataType = any, TNull = any>(options: IterableBuilderOptions<T, TNull>) {\n        return throughIterable(options);\n    }\n\n    /**\n     * Transform an `AsyncIterable` of arbitrary JavaScript values into a\n     * sequence of Arrow Vector<T> following the chunking semantics defined in\n     * the supplied `options` argument.\n     *\n     * This function returns a function that accepts an `AsyncIterable` of values to\n     * transform. When called, this function returns an AsyncIterator of `Vector<T>`.\n     *\n     * The resulting `AsyncIterator<Vector<T>>` yields Vectors based on the\n     * `queueingStrategy` and `highWaterMark` specified in the `options` argument.\n     *\n     * * If `queueingStrategy` is `\"count\"` (or omitted), The `AsyncIterator<Vector<T>>`\n     *   will flush the underlying `Builder` (and yield a new `Vector<T>`) once the\n     *   Builder's `length` reaches or exceeds the supplied `highWaterMark`.\n     * * If `queueingStrategy` is `\"bytes\"`, the `AsyncIterator<Vector<T>>` will flush\n     *   the underlying `Builder` (and yield a new `Vector<T>`) once its `byteLength`\n     *   reaches or exceeds the supplied `highWaterMark`.\n     *\n     * @param {IterableBuilderOptions<T, TNull>} options An object of properties which determine the `Builder` to create and the chunking semantics to use.\n     * @returns A function which accepts a JavaScript `AsyncIterable` of values\n     *          to write, and returns an `AsyncIterator` that yields Vectors\n     *          according to the chunking semantics defined in the `options`\n     *          argument.\n     * @nocollapse\n     */\n    public static throughAsyncIterable<T extends DataType = any, TNull = any>(options: IterableBuilderOptions<T, TNull>) {\n        return throughAsyncIterable(options);\n    }\n\n    /**\n     * Construct a builder with the given Arrow DataType with optional null values,\n     * which will be interpreted as \"null\" when set or appended to the `Builder`.\n     * @param {{ type: T, nullValues?: any[] }} options A `BuilderOptions` object used to create this `Builder`.\n     */\n    constructor({ 'type': type, 'nullValues': nulls }: BuilderOptions<T, TNull>) {\n        this.type = type;\n        this.children = [];\n        this.nullValues = nulls;\n        this.stride = strideForType(type);\n        this._nulls = new BitmapBufferBuilder();\n        if (nulls && nulls.length > 0) {\n            this._isValid = createIsValidFunction(nulls);\n        }\n    }\n\n    /**\n     * The Builder's `DataType` instance.\n     * @readonly\n     */\n    public type: T;\n    /**\n     * The number of values written to the `Builder` that haven't been flushed yet.\n     * @readonly\n     */\n    public length = 0;\n    /**\n     * A boolean indicating whether `Builder.prototype.finish()` has been called on this `Builder`.\n     * @readonly\n     */\n    public finished = false;\n    /**\n     * The number of elements in the underlying values TypedArray that\n     * represent a single logical element, determined by this Builder's\n     * `DataType`. This is 1 for most types, but is larger when the `DataType`\n     * is `Int64`, `Uint64`, `Decimal`, `DateMillisecond`, certain variants of\n     * `Interval`, `Time`, or `Timestamp`, `FixedSizeBinary`, and `FixedSizeList`.\n     * @readonly\n     */\n    public readonly stride: number;\n    public readonly children: Builder[];\n    /**\n     * The list of null-value sentinels for this `Builder`. When one of these values\n     * is written to the `Builder` (either via `Builder.prototype.set()` or `Builder.prototype.append()`),\n     * a 1-bit is written to this Builder's underlying null BitmapBufferBuilder.\n     * @readonly\n     */\n    public readonly nullValues?: TNull[] | ReadonlyArray<TNull> | null;\n\n    /**\n     * Flush the `Builder` and return a `Vector<T>`.\n     * @returns {Vector<T>} A `Vector<T>` of the flushed values.\n     */\n    public toVector() { return Vector.new(this.flush()); }\n\n    public get ArrayType() { return this.type.ArrayType; }\n    public get nullCount() { return this._nulls.numInvalid; }\n    public get numChildren() { return this.children.length; }\n\n    /**\n     * @returns The aggregate length (in bytes) of the values that have been written.\n     */\n    public get byteLength(): number {\n        let size = 0;\n        this._offsets && (size += this._offsets.byteLength);\n        this._values && (size += this._values.byteLength);\n        this._nulls && (size += this._nulls.byteLength);\n        this._typeIds && (size += this._typeIds.byteLength);\n        return this.children.reduce((size, child) => size + child.byteLength, size);\n    }\n\n    /**\n     * @returns The aggregate number of rows that have been reserved to write new values.\n     */\n    public get reservedLength(): number {\n        return this._nulls.reservedLength;\n    }\n\n    /**\n     * @returns The aggregate length (in bytes) that has been reserved to write new values.\n     */\n    public get reservedByteLength(): number {\n        let size = 0;\n        this._offsets && (size += this._offsets.reservedByteLength);\n        this._values && (size += this._values.reservedByteLength);\n        this._nulls && (size += this._nulls.reservedByteLength);\n        this._typeIds && (size += this._typeIds.reservedByteLength);\n        return this.children.reduce((size, child) => size + child.reservedByteLength, size);\n    }\n\n    // @ts-ignore\n    protected _offsets: DataBufferBuilder<Int32Array>;\n    public get valueOffsets() { return this._offsets ? this._offsets.buffer : null; }\n\n    // @ts-ignore\n    protected _values: BufferBuilder<T['TArray'], any>;\n    public get values() { return this._values ? this._values.buffer : null; }\n\n    protected _nulls: BitmapBufferBuilder;\n    public get nullBitmap() { return this._nulls ? this._nulls.buffer : null; }\n\n    // @ts-ignore\n    protected _typeIds: DataBufferBuilder<Int8Array>;\n    public get typeIds() { return this._typeIds ? this._typeIds.buffer : null; }\n\n    // @ts-ignore\n    protected _isValid: (value: T['TValue'] | TNull) => boolean;\n    // @ts-ignore\n    protected _setValue: (inst: Builder<T>, index: number, value: T['TValue']) => void;\n\n    /**\n     * Appends a value (or null) to this `Builder`.\n     * This is equivalent to `builder.set(builder.length, value)`.\n     * @param {T['TValue'] | TNull } value The value to append.\n     */\n    public append(value: T['TValue'] | TNull) { return this.set(this.length, value); }\n\n    /**\n     * Validates whether a value is valid (true), or null (false)\n     * @param {T['TValue'] | TNull } value The value to compare against null the value representations\n     */\n    // @ts-ignore\n    public isValid(value: T['TValue'] | TNull): boolean { return this._isValid(value); }\n\n    /**\n     * Write a value (or null-value sentinel) at the supplied index.\n     * If the value matches one of the null-value representations, a 1-bit is\n     * written to the null `BitmapBufferBuilder`. Otherwise, a 0 is written to\n     * the null `BitmapBufferBuilder`, and the value is passed to\n     * `Builder.prototype.setValue()`.\n     * @param {number} index The index of the value to write.\n     * @param {T['TValue'] | TNull } value The value to write at the supplied index.\n     * @returns {this} The updated `Builder` instance.\n     */\n    public set(index: number, value: T['TValue'] | TNull) {\n        if (this.setValid(index, this.isValid(value))) {\n            this.setValue(index, value);\n        }\n        return this;\n    }\n\n    /**\n     * Write a value to the underlying buffers at the supplied index, bypassing\n     * the null-value check. This is a low-level method that\n     * @param {number} index\n     * @param {T['TValue'] | TNull } value\n     */\n    // @ts-ignore\n    public setValue(index: number, value: T['TValue']) { this._setValue(this, index, value); }\n    public setValid(index: number, valid: boolean) {\n        this.length = this._nulls.set(index, +valid).length;\n        return valid;\n    }\n\n    // @ts-ignore\n    public addChild(child: Builder, name = `${this.numChildren}`) {\n        throw new Error(`Cannot append children to non-nested type \"${this.type}\"`);\n    }\n\n    /**\n     * Retrieve the child `Builder` at the supplied `index`, or null if no child\n     * exists at that index.\n     * @param {number} index The index of the child `Builder` to retrieve.\n     * @returns {Builder | null} The child Builder at the supplied index or null.\n     */\n    public getChildAt<R extends DataType = any>(index: number): Builder<R> | null {\n        return this.children[index] || null;\n    }\n\n    /**\n     * Commit all the values that have been written to their underlying\n     * ArrayBuffers, including any child Builders if applicable, and reset\n     * the internal `Builder` state.\n     * @returns A `Data<T>` of the buffers and childData representing the values written.\n     */\n    public flush() {\n\n        const buffers: any = [];\n        const values =  this._values;\n        const offsets =  this._offsets;\n        const typeIds =  this._typeIds;\n        const { length, nullCount } = this;\n\n        if (typeIds) { /* Unions */\n            buffers[BufferType.TYPE] = typeIds.flush(length);\n            // DenseUnions\n            offsets && (buffers[BufferType.OFFSET] = offsets.flush(length));\n        } else if (offsets) { /* Variable-width primitives (Binary, Utf8) and Lists */\n            // Binary, Utf8\n            values && (buffers[BufferType.DATA] = values.flush(offsets.last()));\n            buffers[BufferType.OFFSET] = offsets.flush(length);\n        } else if (values) { /* Fixed-width primitives (Int, Float, Decimal, Time, Timestamp, and Interval) */\n            buffers[BufferType.DATA] = values.flush(length);\n        }\n\n        nullCount > 0 && (buffers[BufferType.VALIDITY] = this._nulls.flush(length));\n\n        const data = Data.new<T>(\n            this.type, 0, length, nullCount, buffers as Buffers<T>,\n            this.children.map((child) => child.flush())) as Data<T>;\n\n        this.clear();\n\n        return data;\n    }\n\n    /**\n     * Finalize this `Builder`, and child builders if applicable.\n     * @returns {this} The finalized `Builder` instance.\n     */\n    public finish() {\n        this.finished = true;\n        this.children.forEach((child) => child.finish());\n        return this;\n    }\n\n    /**\n     * Clear this Builder's internal state, including child Builders if applicable, and reset the length to 0.\n     * @returns {this} The cleared `Builder` instance.\n     */\n    public clear() {\n        this.length = 0;\n        this._offsets && (this._offsets.clear());\n        this._values && (this._values.clear());\n        this._nulls && (this._nulls.clear());\n        this._typeIds && (this._typeIds.clear());\n        this.children.forEach((child) => child.clear());\n        return this;\n    }\n}\n\n(Builder.prototype as any).length = 1;\n(Builder.prototype as any).stride = 1;\n(Builder.prototype as any).children = null;\n(Builder.prototype as any).finished = false;\n(Builder.prototype as any).nullValues = null;\n(Builder.prototype as any)._isValid = () => true;\n\n/** @ignore */\nexport abstract class FixedWidthBuilder<T extends Int | Float | FixedSizeBinary | Date_ | Timestamp | Time | Decimal | Interval = any, TNull = any> extends Builder<T, TNull> {\n    constructor(opts: BuilderOptions<T, TNull>) {\n        super(opts);\n        this._values = new DataBufferBuilder(new this.ArrayType(0), this.stride);\n    }\n    public setValue(index: number, value: T['TValue']) {\n        const values = this._values;\n        values.reserve(index - values.length + 1);\n        return super.setValue(index, value);\n    }\n}\n\n/** @ignore */\nexport abstract class VariableWidthBuilder<T extends Binary | Utf8 | List | Map_, TNull = any> extends Builder<T, TNull> {\n    protected _pendingLength: number = 0;\n    protected _offsets: OffsetsBufferBuilder;\n    protected _pending: Map<number, any> | undefined;\n    constructor(opts: BuilderOptions<T, TNull>) {\n        super(opts);\n        this._offsets = new OffsetsBufferBuilder();\n    }\n    public setValue(index: number, value: T['TValue']) {\n        const pending = this._pending || (this._pending = new Map());\n        const current = pending.get(index);\n        current && (this._pendingLength -= current.length);\n        this._pendingLength += value.length;\n        pending.set(index, value);\n    }\n    public setValid(index: number, isValid: boolean) {\n        if (!super.setValid(index, isValid)) {\n            (this._pending || (this._pending = new Map())).set(index, undefined);\n            return false;\n        }\n        return true;\n    }\n    public clear() {\n        this._pendingLength = 0;\n        this._pending = undefined;\n        return super.clear();\n    }\n    public flush() {\n        this._flush();\n        return super.flush();\n    }\n    public finish() {\n        this._flush();\n        return super.finish();\n    }\n    protected _flush() {\n        const pending = this._pending;\n        const pendingLength = this._pendingLength;\n        this._pendingLength = 0;\n        this._pending = undefined;\n        if (pending && pending.size > 0) {\n            this._flushPending(pending, pendingLength);\n        }\n        return this;\n    }\n    protected abstract _flushPending(pending: Map<number, any>, pendingLength: number): void;\n}\n\n/** @ignore */\ntype ThroughIterable<T extends DataType = any, TNull = any> = (source: Iterable<T['TValue'] | TNull>) => IterableIterator<V<T>>;\n\n/** @ignore */\nfunction throughIterable<T extends DataType = any, TNull = any>(options: IterableBuilderOptions<T, TNull>): ThroughIterable<T, TNull> {\n    const { ['queueingStrategy']: queueingStrategy = 'count' } = options;\n    const { ['highWaterMark']: highWaterMark = queueingStrategy !== 'bytes' ? 1000 : 2 ** 14 } = options;\n    const sizeProperty: 'length' | 'byteLength' = queueingStrategy !== 'bytes' ? 'length' : 'byteLength';\n    return function*(source: Iterable<T['TValue'] | TNull>) {\n        let numChunks = 0;\n        let builder = Builder.new(options);\n        for (const value of source) {\n            if (builder.append(value)[sizeProperty] >= highWaterMark) {\n                ++numChunks && (yield builder.toVector());\n            }\n        }\n        if (builder.finish().length > 0 || numChunks === 0) {\n            yield builder.toVector();\n        }\n    };\n}\n\n/** @ignore */\ntype ThroughAsyncIterable<T extends DataType = any, TNull = any> = (source: Iterable<T['TValue'] | TNull> | AsyncIterable<T['TValue'] | TNull>) => AsyncIterableIterator<V<T>>;\n\n/** @ignore */\nfunction throughAsyncIterable<T extends DataType = any, TNull = any>(options: IterableBuilderOptions<T, TNull>): ThroughAsyncIterable<T, TNull> {\n    const { ['queueingStrategy']: queueingStrategy = 'count' } = options;\n    const { ['highWaterMark']: highWaterMark = queueingStrategy !== 'bytes' ? 1000 : 2 ** 14 } = options;\n    const sizeProperty: 'length' | 'byteLength' = queueingStrategy !== 'bytes' ? 'length' : 'byteLength';\n    return async function* (source: Iterable<T['TValue'] | TNull> | AsyncIterable<T['TValue'] | TNull>) {\n        let numChunks = 0;\n        let builder = Builder.new(options);\n        for await (const value of source) {\n            if (builder.append(value)[sizeProperty] >= highWaterMark) {\n                ++numChunks && (yield builder.toVector());\n            }\n        }\n        if (builder.finish().length > 0 || numChunks === 0) {\n            yield builder.toVector();\n        }\n    };\n}\n"]}