@apache-arrow/es2015-umd - npm Package Compare versions

Comparing version 16.0.0 to 16.1.0

Arrow.d.ts

@@ -57,27 +57,20 @@ export { MessageHeader } from './fb/message-header.js';
     valueToString(x: any): string;
-    clampIndex<T extends {
+    clampRange<T extends {
         length: number;
         stride?: number | undefined;
-    }>(source: T, index: number): number;
-    clampIndex<T_1 extends {
+    }>(source: T, begin: number | undefined, end: number | undefined): [number, number];
+    clampRange<T_1 extends {
         length: number;
         stride?: number | undefined;
-    }, N extends (source: T_1, index: number) => any = (source: T_1, index: number) => any>(source: T_1, index: number, then: N): ReturnType<N>;
-    clampRange<T_2 extends {
-        length: number;
-        stride?: number | undefined;
-    }>(source: T_2, begin: number | undefined, end: number | undefined): [number, number];
-    clampRange<T_3 extends {
-        length: number;
-        stride?: number | undefined;
-    }, N_1 extends (source: T_3, offset: number, length: number) => any = (source: T_3, offset: number, length: number) => any>(source: T_3, begin: number | undefined, end: number | undefined, then: N_1): ReturnType<N_1>;
+    }, N extends (source: T_1, offset: number, length: number) => any = (source: T_1, offset: number, length: number) => any>(source: T_1, begin: number | undefined, end: number | undefined, then: N): ReturnType<N>;
     createElementComparator(search: any): (value: any) => boolean;
+    wrapIndex: (index: number, len: number) => number;
     memcpy<TTarget extends ArrayBufferView, TSource extends ArrayBufferView>(target: TTarget, source: TSource, targetByteOffset?: number, sourceByteLength?: number): TTarget;
     joinUint8Arrays(chunks: Uint8Array[], size?: number | null | undefined): [Uint8Array, Uint8Array[], number];
-    toArrayBufferView<T_4 extends import("./interfaces.js").TypedArrayConstructor<any> | import("./interfaces.js").BigIntArrayConstructor<any>>(ArrayBufferViewCtor: any, input: util_buffer_.ArrayBufferViewInput): InstanceType<T_4>;
-    toArrayBufferViewIterator<T_5 extends import("./interfaces.js").TypedArray>(ArrayCtor: import("./interfaces.js").TypedArrayConstructor<T_5>, source: util_buffer_.ArrayBufferViewInput | Iterable<util_buffer_.ArrayBufferViewInput>): Generator<T_5, T_5, number | undefined>;
-    toArrayBufferViewAsyncIterator<T_6 extends import("./interfaces.js").TypedArray>(ArrayCtor: import("./interfaces.js").TypedArrayConstructor<T_6>, source: util_buffer_.ArrayBufferViewInput | AsyncIterable<util_buffer_.ArrayBufferViewInput> | Iterable<util_buffer_.ArrayBufferViewInput> | PromiseLike<util_buffer_.ArrayBufferViewInput>): AsyncGenerator<T_6, T_6, number | undefined>;
+    toArrayBufferView<T_2 extends import("./interfaces.js").TypedArrayConstructor<any> | import("./interfaces.js").BigIntArrayConstructor<any>>(ArrayBufferViewCtor: any, input: util_buffer_.ArrayBufferViewInput): InstanceType<T_2>;
+    toArrayBufferViewIterator<T_3 extends import("./interfaces.js").TypedArray>(ArrayCtor: import("./interfaces.js").TypedArrayConstructor<T_3>, source: util_buffer_.ArrayBufferViewInput | Iterable<util_buffer_.ArrayBufferViewInput>): Generator<T_3, T_3, number | undefined>;
+    toArrayBufferViewAsyncIterator<T_4 extends import("./interfaces.js").TypedArray>(ArrayCtor: import("./interfaces.js").TypedArrayConstructor<T_4>, source: util_buffer_.ArrayBufferViewInput | AsyncIterable<util_buffer_.ArrayBufferViewInput> | Iterable<util_buffer_.ArrayBufferViewInput> | PromiseLike<util_buffer_.ArrayBufferViewInput>): AsyncGenerator<T_4, T_4, number | undefined>;
     rebaseValueOffsets(offset: number, length: number, valueOffsets: Int32Array): Int32Array;
     rebaseValueOffsets(offset: number, length: number, valueOffsets: BigInt64Array): BigInt64Array;
-    compareArrayLike<T_7 extends ArrayLike<any>>(a: T_7, b: T_7): boolean;
+    compareArrayLike<T_5 extends ArrayLike<any>>(a: T_5, b: T_5): boolean;
     toInt8Array: (input: util_buffer_.ArrayBufferViewInput) => any;
@@ -127,7 +120,7 @@ toInt16Array: (input: util_buffer_.ArrayBufferViewInput) => any;
     Int128: typeof util_int_.Int128;
-    bigNumToNumber<T_8 extends util_bn_.BN<(Int8Array | Int16Array | Int32Array) | (Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array)>>(bn: T_8, scale?: number | undefined): number;
-    bigNumToString<T_9 extends util_bn_.BN<(Int8Array | Int16Array | Int32Array) | (Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array)>>(a: T_9): string;
-    bigNumToBigInt<T_10 extends util_bn_.BN<(Int8Array | Int16Array | Int32Array) | (Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array)>>(a: T_10): bigint;
+    bigNumToNumber<T_6 extends util_bn_.BN<(Int8Array | Int16Array | Int32Array) | (Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array)>>(bn: T_6, scale?: number | undefined): number;
+    bigNumToString<T_7 extends util_bn_.BN<(Int8Array | Int16Array | Int32Array) | (Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array)>>(a: T_7): string;
+    bigNumToBigInt<T_8 extends util_bn_.BN<(Int8Array | Int16Array | Int32Array) | (Uint8Array | Uint8ClampedArray | Uint16Array | Uint32Array)>>(a: T_8): bigint;
     isArrowBigNumSymbol: typeof util_bn_.isArrowBigNumSymbol;
     BN: typeof util_bn_.BN;
 };

Arrow.externs.js

@@ -519,5 +519,5 @@ // Licensed to the Apache Software Foundation (ASF) under one
 /** @type {?} */
+Date_.prototype.ArrayType;
+/** @type {?} */
 Date_.prototype.unit;
-/** @type {?} */
-Date_.prototype.ArrayType;
 var DateDay = function() {};
@@ -658,2 +658,4 @@ var DateMillisecond = function() {};
 /** @type {?} */
+Table.prototype.at;
+/** @type {?} */
 Table.prototype.set;
@@ -853,2 +855,4 @@ /** @type {?} */
 /** @type {?} */
+Vector.prototype.at;
+/** @type {?} */
 Vector.prototype.set;
@@ -1104,2 +1108,4 @@ /** @type {?} */
 /** @type {?} */
+RecordBatch.prototype.at;
+/** @type {?} */
 RecordBatch.prototype.set;
@@ -1240,4 +1246,2 @@ /** @type {?} */
 /** @type {?} */
-util.clampIndex = function() {};
-/** @type {?} */
 util.clampRange = function() {};
@@ -1247,2 +1251,4 @@ /** @type {?} */
 /** @type {?} */
+util.wrapIndex = function() {};
+/** @type {?} */
 util.valueToString = function() {};
@@ -1249,0 +1255,0 @@ /** @type {?} */

bin/arrow2csv.js

@@ -22,4 +22,4 @@ #! /usr/bin/env node
 /* eslint-disable unicorn/no-array-for-each */
-const fs = require("fs");
-const stream = require("stream");
+const fs = require("node:fs");
+const stream = require("node:stream");
 const Arrow_js_1 = require("../Arrow.js");
@@ -26,0 +26,0 @@ const commandLineUsage = require("command-line-usage");

builder.d.ts

@@ -0,1 +1,2 @@
+/// <reference types="node" />
 import { Vector } from './vector.js';
@@ -5,2 +6,5 @@ import { Data } from './data.js';
 import { BufferBuilder, BitmapBufferBuilder, DataBufferBuilder, OffsetsBufferBuilder } from './builder/buffer.js';
+import type { BuilderDuplexOptions } from './io/node/builder.js';
+import type { BuilderTransform, BuilderTransformOptions } from './io/whatwg/builder.js';
+import type { Duplex } from 'node:stream';
 /**
@@ -76,5 +80,5 @@ * A set of options required to create a `Builder` instance for a given `DataType`.
     /** @nocollapse */
-    static throughNode<T extends DataType = any, TNull = any>(options: import('./io/node/builder').BuilderDuplexOptions<T, TNull>): import('stream').Duplex;
+    static throughNode<T extends DataType = any, TNull = any>(options: BuilderDuplexOptions<T, TNull>): Duplex;
     /** @nocollapse */
-    static throughDOM<T extends DataType = any, TNull = any>(options: import('./io/whatwg/builder').BuilderTransformOptions<T, TNull>): import('./io/whatwg/builder').BuilderTransform<T, TNull>;
+    static throughDOM<T extends DataType = any, TNull = any>(options: BuilderTransformOptions<T, TNull>): BuilderTransform<T, TNull>;
     /**
@@ -81,0 +85,0 @@ * Construct a builder with the given Arrow DataType with optional null values,

enum.d.ts

@@ -34,24 +34,24 @@ export { MetadataVersion } from './fb/metadata-version.js';
 export declare enum Type {
-    NONE = 0,
-    Null = 1,
-    Int = 2,
-    Float = 3,
-    Binary = 4,
-    Utf8 = 5,
-    Bool = 6,
-    Decimal = 7,
-    Date = 8,
-    Time = 9,
-    Timestamp = 10,
-    Interval = 11,
-    List = 12,
-    Struct = 13,
-    Union = 14,
-    FixedSizeBinary = 15,
-    FixedSizeList = 16,
-    Map = 17,
-    Duration = 18,
-    LargeBinary = 19,
-    LargeUtf8 = 20,
-    Dictionary = -1,
+    NONE = 0,/** The default placeholder type */
+    Null = 1,/** A NULL type having no physical storage */
+    Int = 2,/** Signed or unsigned 8, 16, 32, or 64-bit little-endian integer */
+    Float = 3,/** 2, 4, or 8-byte floating point value */
+    Binary = 4,/** Variable-length bytes (no guarantee of UTF8-ness) */
+    Utf8 = 5,/** UTF8 variable-length string as List<Char> */
+    Bool = 6,/** Boolean as 1 bit, LSB bit-packed ordering */
+    Decimal = 7,/** Precision-and-scale-based decimal type. Storage type depends on the parameters. */
+    Date = 8,/** int32_t days or int64_t milliseconds since the UNIX epoch */
+    Time = 9,/** Time as signed 32 or 64-bit integer, representing either seconds, milliseconds, microseconds, or nanoseconds since midnight since midnight */
+    Timestamp = 10,/** Exact timestamp encoded with int64 since UNIX epoch (Default unit millisecond) */
+    Interval = 11,/** YEAR_MONTH or DAY_TIME interval in SQL style */
+    List = 12,/** A list of some logical data type */
+    Struct = 13,/** Struct of logical types */
+    Union = 14,/** Union of logical types */
+    FixedSizeBinary = 15,/** Fixed-size binary. Each value occupies the same number of bytes */
+    FixedSizeList = 16,/** Fixed-size list. Each value occupies the same number of bytes */
+    Map = 17,/** Map of named logical types */
+    Duration = 18,/** Measure of elapsed time in either seconds, milliseconds, microseconds or nanoseconds */
+    LargeBinary = 19,/** Large variable-length bytes (no guarantee of UTF8-ness) */
+    LargeUtf8 = 20,/** Large variable-length string as List<Char> */
+    Dictionary = -1,/** Dictionary aka Category type */
     Int8 = -2,
@@ -58,0 +58,0 @@ Int16 = -3,

io/adapters.d.ts

@@ -6,4 +6,6 @@ /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
 import { ArrayBufferViewInput } from '../util/buffer.js';
 import { ReadableDOMStreamOptions } from './interfaces.js';
+import type { ReadableOptions, Readable } from 'node:stream';
 type Uint8ArrayGenerator = Generator<Uint8Array, null, {
@@ -19,3 +21,3 @@ cmd: 'peek' | 'read';
 declare const _default: {
-    fromIterable<T extends ArrayBufferViewInput>(source: T | Iterable<T>): Uint8ArrayGenerator;
+    fromIterable<T extends ArrayBufferViewInput>(source: Iterable<T> | T): Uint8ArrayGenerator;
     fromAsyncIterable<T_1 extends ArrayBufferViewInput>(source: AsyncIterable<T_1> | PromiseLike<T_1>): AsyncUint8ArrayGenerator;
@@ -25,4 +27,4 @@ fromDOMStream<T_2 extends ArrayBufferViewInput>(source: ReadableStream<T_2>): AsyncUint8ArrayGenerator;
     toDOMStream<T_3>(source: Iterable<T_3> | AsyncIterable<T_3>, options?: ReadableDOMStreamOptions): ReadableStream<T_3>;
-    toNodeStream<T_4>(source: Iterable<T_4> | AsyncIterable<T_4>, options?: import('stream').ReadableOptions): import('stream').Readable;
+    toNodeStream<T_4>(source: Iterable<T_4> | AsyncIterable<T_4>, options?: ReadableOptions): Readable;
 };
 export default _default;

io/file.d.ts

@@ -0,1 +1,2 @@
+/// <reference types="node" />
 import { FileHandle } from './interfaces.js';
@@ -2,0 +3,0 @@ import { ByteStream, AsyncByteStream } from './stream.js';

io/interfaces.d.ts

 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
+export type { FileHandle } from 'node:fs/promises';
+import type { ReadableOptions, Readable as StreamReadable } from 'node:stream';
 /** @ignore */
 export declare const ITERATOR_DONE: any;
 /** @ignore */
-export type FileHandle = import('fs').promises.FileHandle;
-/** @ignore */
 export type ArrowJSONLike = {
@@ -48,3 +49,3 @@ schema: any;
     toDOMStream(options?: ReadableDOMStreamOptions): ReadableStream<TReadable>;
-    toNodeStream(options?: import('stream').ReadableOptions): import('stream').Readable;
+    toNodeStream(options?: ReadableOptions): StreamReadable;
 }
@@ -54,3 +55,3 @@ /** @ignore */
     abstract toDOMStream(options?: ReadableDOMStreamOptions): ReadableStream<T>;
-    abstract toNodeStream(options?: import('stream').ReadableOptions): import('stream').Readable;
+    abstract toNodeStream(options?: ReadableOptions): StreamReadable;
     tee(): [ReadableStream<T>, ReadableStream<T>];
@@ -67,3 +68,3 @@ pipe<R extends NodeJS.WritableStream>(writable: R, options?: {
     private _getDOMStream;
-    protected _nodeStream?: import('stream').Readable;
+    protected _nodeStream?: StreamReadable;
     private _getNodeStream;
@@ -93,3 +94,3 @@ }
     toDOMStream(options?: ReadableDOMStreamOptions): ReadableStream<TReadable>;
-    toNodeStream(options?: import('stream').ReadableOptions): import("stream").Readable;
+    toNodeStream(options?: ReadableOptions): StreamReadable;
     throw(_?: any): Promise<any>;
@@ -102,2 +103,1 @@ return(_?: any): Promise<any>;
 }
-export {};

io/node/builder.d.ts

 /// <reference types="node" />
-import { Duplex } from 'stream';
+import { Duplex } from 'node:stream';
 import { DataType } from '../../type.js';
@@ -4,0 +4,0 @@ import { Builder, BuilderOptions } from '../../builder.js';

io/node/iterable.d.ts

 /// <reference types="node" />
-import { Readable } from 'stream';
+import { Readable, ReadableOptions as ReadableOptions_ } from 'node:stream';
 /** @ignore */
-type ReadableOptions = import('stream').ReadableOptions;
+type ReadableOptions = ReadableOptions_;
 /** @ignore */
 export declare function toNodeStream<T>(source: Iterable<T> | AsyncIterable<T>, options?: ReadableOptions): Readable;
 export {};

io/node/reader.d.ts

 /// <reference types="node" />
-import { Duplex, DuplexOptions } from 'stream';
+import { Duplex, DuplexOptions } from 'node:stream';
 import { AsyncByteQueue } from '../../io/stream.js';
@@ -4,0 +4,0 @@ import { RecordBatchReader } from '../../ipc/reader.js';

io/node/writer.d.ts

 /// <reference types="node" />
-import { Duplex, DuplexOptions } from 'stream';
+import { Duplex } from 'node:stream';
+import type { DuplexOptions } from 'node:stream';
 import { AsyncByteStream } from '../../io/stream.js';
@@ -4,0 +5,0 @@ import { RecordBatchWriter } from '../../ipc/writer.js';

ipc/message.d.ts

@@ -0,1 +1,2 @@
+/// <reference types="node" />
 import { MessageHeader } from '../enum.js';
@@ -2,0 +3,0 @@ import { Message } from './metadata/message.js';

ipc/reader.d.ts

 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
 import { Vector } from '../vector.js';
@@ -16,2 +17,3 @@ import { DataType, TypeMap } from '../type.js';
 import { MessageReader, AsyncMessageReader } from './message.js';
+import type { DuplexOptions, Duplex } from 'node:stream';
 /** @ignore */ export type FromArg0 = ArrowJSONLike;
@@ -45,3 +47,3 @@ /** @ignore */ export type FromArg1 = PromiseLike<ArrowJSONLike>;
     isStream(): this is RecordBatchStreamReaders<T>;
-    next(): IteratorResult<RecordBatch<T>, any> | Promise<IteratorResult<RecordBatch<T>, any>>;
+    next(): Promise<any> | IteratorResult<RecordBatch<T>, any>;
     throw(value?: any): IteratorResult<any, any> | Promise<IteratorResult<any, any>>;
@@ -56,7 +58,7 @@ return(value?: any): IteratorResult<any, any> | Promise<IteratorResult<any, any>>;
     toDOMStream(): ReadableStream<RecordBatch<T>>;
-    toNodeStream(): import("stream").Readable;
+    toNodeStream(): import('stream').Readable;
     /** @nocollapse */
-    static throughNode(options?: import('stream').DuplexOptions & {
+    static throughNode(options?: DuplexOptions & {
         autoDestroy: boolean;
-    }): import('stream').Duplex;
+    }): Duplex;
     /** @nocollapse */
@@ -63,0 +65,0 @@ static throughDOM<T extends TypeMap>(writableStrategy?: ByteLengthQueuingStrategy, readableStrategy?: {

ipc/writer.d.ts

@@ -13,2 +13,3 @@ /// <reference types="node" />
 import { Writable, ReadableInterop, ReadableDOMStreamOptions } from '../io/interfaces.js';
+import type { DuplexOptions, Duplex, ReadableOptions } from 'node:stream';
 export interface RecordBatchStreamWriterOptions {
@@ -29,5 +30,5 @@ /**
     /** @nocollapse */
-    static throughNode(options?: import('stream').DuplexOptions & {
+    static throughNode(options?: DuplexOptions & {
         autoDestroy: boolean;
-    }): import('stream').Duplex;
+    }): Duplex;
     /** @nocollapse */
@@ -64,3 +65,3 @@ static throughDOM<T extends TypeMap>(writableStrategy?: QueuingStrategy<RecordBatch<T>> & {
     toDOMStream(options?: ReadableDOMStreamOptions): ReadableStream<Uint8Array>;
-    toNodeStream(options?: import('stream').ReadableOptions): import("stream").Readable;
+    toNodeStream(options?: ReadableOptions): import("stream").Readable;
     close(): void;
@@ -67,0 +68,0 @@ abort(reason?: any): void;

package.json

 {
-  "version": "16.0.0",
+  "version": "16.1.0",
   "name": "@apache-arrow/es2015-umd",
@@ -25,9 +25,9 @@ "unpkg": "Arrow.js",
   "dependencies": {
-    "@swc/helpers": "^0.5.2",
-    "@types/command-line-args": "^5.2.1",
-    "@types/command-line-usage": "^5.0.2",
-    "@types/node": "^20.6.0",
+    "@swc/helpers": "^0.5.10",
+    "@types/command-line-args": "^5.2.3",
+    "@types/command-line-usage": "^5.0.4",
+    "@types/node": "^20.12.7",
     "command-line-args": "^5.2.1",
     "command-line-usage": "^7.0.1",
-    "flatbuffers": "^23.5.26",
+    "flatbuffers": "^24.3.25",
     "json-bignum": "^0.0.3",
@@ -34,0 +34,0 @@ "tslib": "^2.6.2"

recordbatch.d.ts

@@ -39,3 +39,3 @@ import { Data } from './data.js';
     /**
-     * Check whether an element is null.
+     * Check whether an row is null.
      * @param index The index at which to read the validity bitmap.
@@ -46,8 +46,13 @@ */
      * Get a row by position.
-     * @param index The index of the element to read.
+     * @param index The index of the row to read.
      */
     get(index: number): import("./Arrow.js").StructRowProxy<T> | null;
     /**
+      * Get a row value by position.
+      * @param index The index of the row to read. A negative index will count back from the last row.
+      */
+    at(index: number): import("./Arrow.js").StructRowProxy<T> | null;
+    /**
      * Set a row by position.
-     * @param index The index of the element to write.
+     * @param index The index of the row to write.
      * @param value The value to set.
@@ -79,3 +84,3 @@ */
      * @param start The beginning of the specified portion of the RecordBatch.
-     * @param end The end of the specified portion of the RecordBatch. This is exclusive of the element at the index 'end'.
+     * @param end The end of the specified portion of the RecordBatch. This is exclusive of the row at the index 'end'.
      */
@@ -82,0 +87,0 @@ slice(begin?: number, end?: number): RecordBatch<T>;

row/map.d.ts

@@ -6,2 +6,4 @@ import { Data } from '../data.js';
 /** @ignore */ export declare const kVals: unique symbol;
+/** @ignore */ export declare const kKeysAsStrings: unique symbol;
+/** @ignore */ export declare const _kKeysAsStrings: unique symbol;
 export declare class MapRow<K extends DataType = any, V extends DataType = any> {
@@ -11,2 +13,3 @@ [key: string]: V['TValue'];
     private [kVals];
+    private [_kKeysAsStrings];
     constructor(slice: Data<Struct<{
@@ -16,2 +19,4 @@ key: K;
     }>>);
+    /** @ignore */
+    get [kKeysAsStrings](): string[];
     [Symbol.iterator](): MapRowIterator<K, V>;
@@ -18,0 +23,0 @@ get size(): number;

src/bin/arrow2csv.ts

@@ -22,4 +22,4 @@ #! /usr/bin/env node
 
-import * as fs from 'fs';
-import * as stream from 'stream';
+import * as fs from 'node:fs';
+import * as stream from 'node:stream';
 import { Schema, RecordBatch, RecordBatchReader, AsyncByteQueue, util } from '../Arrow.js';
@@ -26,0 +26,0 @@

table.d.ts

@@ -77,2 +77,7 @@ import { Data } from './data.js';
     /**
+      * Get an element value by position.
+      * @param index The index of the element to read. A negative index will count back from the last element.
+      */
+    at(index: number): Struct<T>['TValue'] | null;
+    /**
      * Set an element value by position.
@@ -79,0 +84,0 @@ *

type.d.ts

@@ -320,6 +320,17 @@ import { Field } from './schema.js';
 /** @ignore */
+type DateType = {
+    [Type.Date]: {
+        TArray: Int32Array | BigInt64Array;
+    };
+    [Type.DateDay]: {
+        TArray: Int32Array;
+    };
+    [Type.DateMillisecond]: {
+        TArray: BigInt64Array;
+    };
+};
+/** @ignore */
 export interface Date_<T extends Dates = Dates> extends DataType<T> {
-    TArray: Int32Array;
-    TValue: Date;
-    ArrayType: TypedArrayConstructor<Int32Array>;
+    TArray: DateType[T]['TArray'];
+    TValue: number;
 }
@@ -331,2 +342,3 @@ /** @ignore */
     toString(): string;
+    get ArrayType(): Int32ArrayConstructor | BigInt64ArrayConstructor;
     protected static [Symbol.toStringTag]: string;
@@ -419,5 +431,5 @@ }
 interface Timestamp_<T extends Timestamps = Timestamps> extends DataType<T> {
-    TArray: Int32Array;
+    TArray: BigInt64Array;
     TValue: number;
-    ArrayType: TypedArrayConstructor<Int32Array>;
+    ArrayType: BigIntArrayConstructor<BigInt64Array>;
 }
@@ -479,3 +491,3 @@ /** @ignore */
     TValue: bigint;
-    ArrayType: BigInt64Array;
+    ArrayType: BigIntArrayConstructor<BigInt64Array>;
 }
@@ -482,0 +494,0 @@ /** @ignore */

util/bigint.d.ts

@@ -5,1 +5,11 @@ /**
 export declare function bigIntToNumber(number: bigint | number): number;
+/**
+ * Duivides the bigint number by the divisor and returns the result as a number.
+ * Dividing bigints always results in bigints so we don't get the remainder.
+ * This function gives us the remainder but assumes that the result fits into a number.
+ *
+ * @param number The number to divide.
+ * @param divisor The divisor.
+ * @returns The result of the division as a number.
+ */
+export declare function divideBigInts(number: bigint, divisor: bigint): number;

util/compat.d.ts

 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
 import { ArrowJSONLike } from '../io/interfaces.js';
+import type { ByteBuffer } from 'flatbuffers';
+import type { ReadStream } from 'node:fs';
+import type { FileHandle as FileHandle_ } from 'node:fs/promises';
 /** @ignore */
@@ -38,5 +42,5 @@ export interface Subscription {
 /** @ignore */
-export declare const isFileHandle: (x: any) => x is import("fs/promises").FileHandle;
+export declare const isFileHandle: (x: any) => x is FileHandle_;
 /** @ignore */
-export declare const isFSReadStream: (x: any) => x is import("fs").ReadStream;
+export declare const isFSReadStream: (x: any) => x is ReadStream;
 /** @ignore */
@@ -53,2 +57,2 @@ export declare const isFetchResponse: (x: any) => x is Response;
 /** @ignore */
-export declare const isFlatbuffersByteBuffer: (x: any) => x is import("flatbuffers").ByteBuffer;
+export declare const isFlatbuffersByteBuffer: (x: any) => x is ByteBuffer;

util/vector.d.ts

@@ -7,11 +7,9 @@ /** @ignore */
 /** @ignore */
-type ClampThen<T extends RangeLike> = (source: T, index: number) => any;
-/** @ignore */
 type ClampRangeThen<T extends RangeLike> = (source: T, offset: number, length: number) => any;
-export declare function clampIndex<T extends RangeLike>(source: T, index: number): number;
-export declare function clampIndex<T extends RangeLike, N extends ClampThen<T> = ClampThen<T>>(source: T, index: number, then: N): ReturnType<N>;
 export declare function clampRange<T extends RangeLike>(source: T, begin: number | undefined, end: number | undefined): [number, number];
 export declare function clampRange<T extends RangeLike, N extends ClampRangeThen<T> = ClampRangeThen<T>>(source: T, begin: number | undefined, end: number | undefined, then: N): ReturnType<N>;
 /** @ignore */
+export declare const wrapIndex: (index: number, len: number) => number;
+/** @ignore */
 export declare function createElementComparator(search: any): (value: any) => boolean;
 export {};

vector.d.ts

@@ -75,2 +75,7 @@ import { DataType } from './type.js';
     /**
+     * Get an element value by position.
+     * @param index The index of the element to read. A negative index will count back from the last element.
+     */
+    at(index: number): T['TValue'] | null;
+    /**
      * Set an element value by position.
@@ -77,0 +82,0 @@ * @param index The index of the element to write.

visitor/set.d.ts

@@ -69,63 +69,57 @@ import { Data } from '../data.js';
 /** @ignore */
-export declare const setEpochMsToMillisecondsLong: (data: Int32Array, index: number, epochMs: number) => void;
-/** @ignore */
-export declare const setEpochMsToMicrosecondsLong: (data: Int32Array, index: number, epochMs: number) => void;
-/** @ignore */
-export declare const setEpochMsToNanosecondsLong: (data: Int32Array, index: number, epochMs: number) => void;
-/** @ignore */
 export declare const setVariableWidthBytes: <T extends Int32Array | BigInt64Array>(values: Uint8Array, valueOffsets: T, index: number, value: Uint8Array) => void;
 /** @ignore */
-export declare const setInt: <T extends Int<Type.Int | Type.Int8 | Type.Int16 | Type.Int32 | Type.Int64 | Type.Uint8 | Type.Uint16 | Type.Uint32 | Type.Uint64>>({ values }: Data<T>, index: number, value: T["TValue"]) => void;
+export declare const setInt: <T extends Int<Type.Int | Type.Int8 | Type.Int16 | Type.Int32 | Type.Int64 | Type.Uint8 | Type.Uint16 | Type.Uint32 | Type.Uint64>>({ values }: Data<T>, index: number, value: T['TValue']) => void;
 /** @ignore */
-export declare const setFloat: <T extends Float32 | Float64>({ values }: Data<T>, index: number, value: T["TValue"]) => void;
+export declare const setFloat: <T extends Float32 | Float64>({ values }: Data<T>, index: number, value: T['TValue']) => void;
 /** @ignore */
-export declare const setFloat16: <T extends Float16>({ values }: Data<T>, index: number, value: T["TValue"]) => void;
+export declare const setFloat16: <T extends Float16>({ values }: Data<T>, index: number, value: T['TValue']) => void;
 /** @ignore */
-export declare const setAnyFloat: <T extends Float<Type.Float | Type.Float16 | Type.Float32 | Type.Float64>>(data: Data<T>, index: number, value: T["TValue"]) => void;
+export declare const setAnyFloat: <T extends Float<Type.Float | Type.Float16 | Type.Float32 | Type.Float64>>(data: Data<T>, index: number, value: T['TValue']) => void;
 /** @ignore */
-export declare const setDateDay: <T extends DateDay>({ values }: Data<T>, index: number, value: T["TValue"]) => void;
+export declare const setDateDay: <T extends DateDay>({ values }: Data<T>, index: number, value: T['TValue']) => void;
 /** @ignore */
-export declare const setDateMillisecond: <T extends DateMillisecond>({ values }: Data<T>, index: number, value: T["TValue"]) => void;
+export declare const setDateMillisecond: <T extends DateMillisecond>({ values }: Data<T>, index: number, value: T['TValue']) => void;
 /** @ignore */
-export declare const setFixedSizeBinary: <T extends FixedSizeBinary>({ stride, values }: Data<T>, index: number, value: T["TValue"]) => void;
-export declare const setDate: <T extends Date_<import("../type.js").Dates>>(data: Data<T>, index: number, value: T["TValue"]) => void;
+export declare const setFixedSizeBinary: <T extends FixedSizeBinary>({ stride, values }: Data<T>, index: number, value: T['TValue']) => void;
+export declare const setDate: <T extends Date_<import("../type.js").Dates>>(data: Data<T>, index: number, value: T['TValue']) => void;
 /** @ignore */
-export declare const setTimestampSecond: <T extends TimestampSecond>({ values }: Data<T>, index: number, value: T["TValue"]) => void;
+export declare const setTimestampSecond: <T extends TimestampSecond>({ values }: Data<T>, index: number, value: T['TValue']) => void;
 /** @ignore */
-export declare const setTimestampMillisecond: <T extends TimestampMillisecond>({ values }: Data<T>, index: number, value: T["TValue"]) => void;
+export declare const setTimestampMillisecond: <T extends TimestampMillisecond>({ values }: Data<T>, index: number, value: T['TValue']) => void;
 /** @ignore */
-export declare const setTimestampMicrosecond: <T extends TimestampMicrosecond>({ values }: Data<T>, index: number, value: T["TValue"]) => void;
+export declare const setTimestampMicrosecond: <T extends TimestampMicrosecond>({ values }: Data<T>, index: number, value: T['TValue']) => void;
 /** @ignore */
-export declare const setTimestampNanosecond: <T extends TimestampNanosecond>({ values }: Data<T>, index: number, value: T["TValue"]) => void;
+export declare const setTimestampNanosecond: <T extends TimestampNanosecond>({ values }: Data<T>, index: number, value: T['TValue']) => void;
 /** @ignore */
-export declare const setTimestamp: <T extends Timestamp<Type.Timestamp | Type.TimestampSecond | Type.TimestampMillisecond | Type.TimestampMicrosecond | Type.TimestampNanosecond>>(data: Data<T>, index: number, value: T["TValue"]) => void;
+export declare const setTimestamp: <T extends Timestamp<Type.Timestamp | Type.TimestampSecond | Type.TimestampMillisecond | Type.TimestampMicrosecond | Type.TimestampNanosecond>>(data: Data<T>, index: number, value: T['TValue']) => void;
 /** @ignore */
-export declare const setTimeSecond: <T extends TimeSecond>({ values }: Data<T>, index: number, value: T["TValue"]) => void;
+export declare const setTimeSecond: <T extends TimeSecond>({ values }: Data<T>, index: number, value: T['TValue']) => void;
 /** @ignore */
-export declare const setTimeMillisecond: <T extends TimeMillisecond>({ values }: Data<T>, index: number, value: T["TValue"]) => void;
+export declare const setTimeMillisecond: <T extends TimeMillisecond>({ values }: Data<T>, index: number, value: T['TValue']) => void;
 /** @ignore */
-export declare const setTimeMicrosecond: <T extends TimeMicrosecond>({ values }: Data<T>, index: number, value: T["TValue"]) => void;
+export declare const setTimeMicrosecond: <T extends TimeMicrosecond>({ values }: Data<T>, index: number, value: T['TValue']) => void;
 /** @ignore */
-export declare const setTimeNanosecond: <T extends TimeNanosecond>({ values }: Data<T>, index: number, value: T["TValue"]) => void;
+export declare const setTimeNanosecond: <T extends TimeNanosecond>({ values }: Data<T>, index: number, value: T['TValue']) => void;
 /** @ignore */
-export declare const setTime: <T extends Time<Type.Time | Type.TimeSecond | Type.TimeMillisecond | Type.TimeMicrosecond | Type.TimeNanosecond>>(data: Data<T>, index: number, value: T["TValue"]) => void;
+export declare const setTime: <T extends Time<Type.Time | Type.TimeSecond | Type.TimeMillisecond | Type.TimeMicrosecond | Type.TimeNanosecond>>(data: Data<T>, index: number, value: T['TValue']) => void;
 /** @ignore */
-export declare const setDecimal: <T extends Decimal>({ values, stride }: Data<T>, index: number, value: T["TValue"]) => void;
+export declare const setDecimal: <T extends Decimal>({ values, stride }: Data<T>, index: number, value: T['TValue']) => void;
 /** @ignore */
-export declare const setIntervalValue: <T extends Interval<Type.Interval | Type.IntervalDayTime | Type.IntervalYearMonth>>(data: Data<T>, index: number, value: T["TValue"]) => void;
+export declare const setIntervalValue: <T extends Interval<Type.Interval | Type.IntervalDayTime | Type.IntervalYearMonth>>(data: Data<T>, index: number, value: T['TValue']) => void;
 /** @ignore */
-export declare const setIntervalDayTime: <T extends IntervalDayTime>({ values }: Data<T>, index: number, value: T["TValue"]) => void;
+export declare const setIntervalDayTime: <T extends IntervalDayTime>({ values }: Data<T>, index: number, value: T['TValue']) => void;
 /** @ignore */
-export declare const setIntervalYearMonth: <T extends IntervalYearMonth>({ values }: Data<T>, index: number, value: T["TValue"]) => void;
+export declare const setIntervalYearMonth: <T extends IntervalYearMonth>({ values }: Data<T>, index: number, value: T['TValue']) => void;
 /** @ignore */
-export declare const setDurationSecond: <T extends DurationSecond>({ values }: Data<T>, index: number, value: T["TValue"]) => void;
+export declare const setDurationSecond: <T extends DurationSecond>({ values }: Data<T>, index: number, value: T['TValue']) => void;
 /** @ignore */
-export declare const setDurationMillisecond: <T extends DurationMillisecond>({ values }: Data<T>, index: number, value: T["TValue"]) => void;
+export declare const setDurationMillisecond: <T extends DurationMillisecond>({ values }: Data<T>, index: number, value: T['TValue']) => void;
 /** @ignore */
-export declare const setDurationMicrosecond: <T extends DurationMicrosecond>({ values }: Data<T>, index: number, value: T["TValue"]) => void;
+export declare const setDurationMicrosecond: <T extends DurationMicrosecond>({ values }: Data<T>, index: number, value: T['TValue']) => void;
 /** @ignore */
-export declare const setDurationNanosecond: <T extends DurationNanosecond>({ values }: Data<T>, index: number, value: T["TValue"]) => void;
+export declare const setDurationNanosecond: <T extends DurationNanosecond>({ values }: Data<T>, index: number, value: T['TValue']) => void;
 /** @ignore */
-export declare const setDuration: <T extends Duration<Type.Duration | Type.DurationSecond | Type.DurationMillisecond | Type.DurationMicrosecond | Type.DurationNanosecond>>(data: Data<T>, index: number, value: T["TValue"]) => void;
+export declare const setDuration: <T extends Duration<Type.Duration | Type.DurationSecond | Type.DurationMillisecond | Type.DurationMicrosecond | Type.DurationNanosecond>>(data: Data<T>, index: number, value: T['TValue']) => void;
 /** @ignore */
 export declare const instance: SetVisitor;

New alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Fixed alerts

License Policy Violation

License

This package is not allowed per your license policy. Review the package's license to ensure compliance.

Found 1 instance in 1 package

Filesystem access

Supply chain risk

Accesses the file system, and could potentially read sensitive data.

Found 1 instance in 1 package

Improved metrics

Total package byte prevSize

1177506

increased by0.24%

Lines of code

9610

increased by0.47%

Number of low supply chain risk alerts

0

decreased by-100%

Dependency changes

• + Addedflatbuffers@24.3.25(transitive)

• - Removedflatbuffers@23.5.26(transitive)

• Updated@swc/helpers@^0.5.10

• Updated@types/command-line-args@^5.2.3

• Updated@types/command-line-usage@^5.0.4

• Updated@types/node@^20.12.7

• Updatedflatbuffers@^24.3.25