df-script 1.4.0

package/dist/datatypes/types.d.ts

@@ -0,0 +1,172 @@
+import { DataType, SignedIntegerType, UnsignedIntegerType, FloatDataType, TemporalDataType, NestedDataType, NumericDataType } from "./DataType";
+import type { RowRecord } from "../types";
+export declare class Int8Type extends SignedIntegerType {
+    readonly name = "Int8";
+    coerce(val: any): number | null;
+    equals(other: DataType): boolean;
+    allocate(size: number): Int8Array;
+}
+export declare const Int8: Int8Type;
+export declare class Int16Type extends SignedIntegerType {
+    readonly name = "Int16";
+    coerce(val: any): number | null;
+    equals(other: DataType): boolean;
+    allocate(size: number): Int16Array;
+}
+export declare const Int16: Int16Type;
+export declare class Int32Type extends SignedIntegerType {
+    readonly name = "Int32";
+    coerce(val: any): number | null;
+    equals(other: DataType): boolean;
+    allocate(size: number): Int32Array;
+}
+export declare const Int32: Int32Type;
+export declare class Int64Type extends SignedIntegerType<bigint | null> {
+    readonly name = "Int64";
+    coerce(val: any): bigint | null;
+    equals(other: DataType): boolean;
+    allocate(size: number): BigInt64Array;
+}
+export declare const Int64: Int64Type;
+export declare class UInt8Type extends UnsignedIntegerType {
+    readonly name = "UInt8";
+    coerce(val: any): number | null;
+    equals(other: DataType): boolean;
+    allocate(size: number): Uint8Array;
+}
+export declare const UInt8: UInt8Type;
+export declare class UInt16Type extends UnsignedIntegerType {
+    readonly name = "UInt16";
+    coerce(val: any): number | null;
+    equals(other: DataType): boolean;
+    allocate(size: number): Uint16Array;
+}
+export declare const UInt16: UInt16Type;
+export declare class UInt32Type extends UnsignedIntegerType {
+    readonly name = "UInt32";
+    coerce(val: any): number | null;
+    equals(other: DataType): boolean;
+    allocate(size: number): Uint32Array;
+}
+export declare const UInt32: UInt32Type;
+export declare class UInt64Type extends UnsignedIntegerType<bigint | null> {
+    readonly name = "UInt64";
+    coerce(val: any): bigint | null;
+    equals(other: DataType): boolean;
+    allocate(size: number): BigUint64Array;
+}
+export declare const UInt64: UInt64Type;
+export declare class Float32Type extends FloatDataType {
+    readonly name = "Float32";
+    coerce(val: any): number | null;
+    equals(other: DataType): boolean;
+    allocate(size: number): Float32Array;
+}
+export declare const Float32: Float32Type;
+export declare class Float64Type extends FloatDataType {
+    readonly name = "Float64";
+    coerce(val: any): number | null;
+    equals(other: DataType): boolean;
+    allocate(size: number): Float64Array;
+}
+export declare const Float64: Float64Type;
+export declare class DecimalType extends NumericDataType {
+    readonly precision?: number | undefined;
+    readonly scale?: number | undefined;
+    readonly name: string;
+    constructor(precision?: number | undefined, scale?: number | undefined);
+    coerce(val: any): number | null;
+    equals(other: DataType): boolean;
+    allocate(size: number): (number | null)[];
+}
+export declare class BooleanType extends DataType {
+    readonly name = "Boolean";
+    get isBoolean(): boolean;
+    coerce(val: any): boolean | null;
+    equals(other: DataType): boolean;
+    allocate(size: number): (boolean | null)[];
+}
+export declare const Boolean: BooleanType;
+export declare class Utf8Type extends DataType {
+    readonly name = "Utf8";
+    get isString(): boolean;
+    get isUtf8(): boolean;
+    coerce(val: any): string | null;
+    equals(other: DataType): boolean;
+    allocate(size: number): (string | null)[];
+}
+export declare const Utf8: Utf8Type;
+export declare class BinaryType extends DataType {
+    readonly name = "Binary";
+    get isBinary(): boolean;
+    coerce(val: any): Uint8Array | null;
+    equals(other: DataType): boolean;
+    allocate(size: number): (Uint8Array | null)[];
+}
+export declare const Binary: BinaryType;
+export declare class NullType extends DataType {
+    readonly name = "Null";
+    get isNull(): boolean;
+    coerce(_val: any): null;
+    equals(other: DataType): boolean;
+    allocate(size: number): null[];
+}
+export declare const Null: NullType;
+export declare class ObjectType extends DataType {
+    readonly name = "Object";
+    get isObject(): boolean;
+    coerce(val: any): any;
+    equals(other: DataType): boolean;
+    allocate(size: number): any[];
+}
+export declare const Object: ObjectType;
+export declare class DateType extends TemporalDataType {
+    readonly name = "Date";
+    coerce(val: any): Date | null;
+    equals(other: DataType): boolean;
+    allocate(size: number): (Date | null)[];
+}
+export declare const Date: DateType;
+export declare class DatetimeType extends TemporalDataType {
+    readonly name = "Datetime";
+    coerce(val: any): Date | null;
+    equals(other: DataType): boolean;
+    allocate(size: number): (Date | null)[];
+}
+export declare const Datetime: DatetimeType;
+export declare class TimeType extends TemporalDataType {
+    readonly name = "Time";
+    coerce(val: any): string | null;
+    equals(other: DataType): boolean;
+    allocate(size: number): (string | null)[];
+}
+export declare const Time: TimeType;
+export declare class DurationType extends TemporalDataType {
+    readonly name = "Duration";
+    coerce(val: any): number | null;
+    equals(other: DataType): boolean;
+    allocate(size: number): (number | null)[];
+}
+export declare const Duration: DurationType;
+export declare class ListType<TInner = any> extends NestedDataType<TInner[] | null> {
+    readonly innerType: DataType<TInner>;
+    readonly name = "List";
+    constructor(innerType: DataType<TInner>);
+    coerce(val: any): TInner[] | null;
+    equals(other: DataType): boolean;
+    allocate(size: number): (TInner[] | null)[];
+}
+export declare const List: <TInner>(inner: DataType<TInner>) => ListType<TInner>;
+export declare class StructType<TFields extends RowRecord = any> extends NestedDataType<TFields | null> {
+    readonly fields: {
+        [K in keyof TFields]: DataType<TFields[K]>;
+    };
+    readonly name = "Struct";
+    constructor(fields: {
+        [K in keyof TFields]: DataType<TFields[K]>;
+    });
+    coerce(val: any): TFields | null;
+    equals(other: DataType): boolean;
+    allocate(size: number): (TFields | null)[];
+}
+export declare const Struct: <TFields extends RowRecord>(fields: { [K in keyof TFields]: DataType<TFields[K]>; }) => StructType<TFields>;

package/dist/datatypes/types.js

@@ -0,0 +1,286 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Struct = exports.StructType = exports.List = exports.ListType = exports.Duration = exports.DurationType = exports.Time = exports.TimeType = exports.Datetime = exports.DatetimeType = exports.Date = exports.DateType = exports.Object = exports.ObjectType = exports.Null = exports.NullType = exports.Binary = exports.BinaryType = exports.Utf8 = exports.Utf8Type = exports.Boolean = exports.BooleanType = exports.DecimalType = exports.Float64 = exports.Float64Type = exports.Float32 = exports.Float32Type = exports.UInt64 = exports.UInt64Type = exports.UInt32 = exports.UInt32Type = exports.UInt16 = exports.UInt16Type = exports.UInt8 = exports.UInt8Type = exports.Int64 = exports.Int64Type = exports.Int32 = exports.Int32Type = exports.Int16 = exports.Int16Type = exports.Int8 = exports.Int8Type = void 0;
+const DataType_1 = require("./DataType");
+const utils_1 = require("../utils");
+// ============================================================================
+// Numeric Types
+// ============================================================================
+class Int8Type extends DataType_1.SignedIntegerType {
+    name = "Int8";
+    coerce(val) { return (0, utils_1.toValidInt)(val, "Int8"); }
+    equals(other) { return other.name === "Int8"; }
+    allocate(size) { return new Int8Array(size); }
+}
+exports.Int8Type = Int8Type;
+exports.Int8 = new Int8Type();
+class Int16Type extends DataType_1.SignedIntegerType {
+    name = "Int16";
+    coerce(val) { return (0, utils_1.toValidInt)(val, "Int16"); }
+    equals(other) { return other.name === "Int16"; }
+    allocate(size) { return new Int16Array(size); }
+}
+exports.Int16Type = Int16Type;
+exports.Int16 = new Int16Type();
+class Int32Type extends DataType_1.SignedIntegerType {
+    name = "Int32";
+    coerce(val) { return (0, utils_1.toValidInt)(val, "Int32"); }
+    equals(other) { return other.name === "Int32"; }
+    allocate(size) { return new Int32Array(size); }
+}
+exports.Int32Type = Int32Type;
+exports.Int32 = new Int32Type();
+class Int64Type extends DataType_1.SignedIntegerType {
+    name = "Int64";
+    coerce(val) { return (0, utils_1.toValidBigInt)(val); }
+    equals(other) { return other.name === "Int64"; }
+    allocate(size) { return new BigInt64Array(size); }
+}
+exports.Int64Type = Int64Type;
+exports.Int64 = new Int64Type();
+class UInt8Type extends DataType_1.UnsignedIntegerType {
+    name = "UInt8";
+    coerce(val) { return (0, utils_1.toValidInt)(val, "UInt8"); }
+    equals(other) { return other.name === "UInt8"; }
+    allocate(size) { return new Uint8Array(size); }
+}
+exports.UInt8Type = UInt8Type;
+exports.UInt8 = new UInt8Type();
+class UInt16Type extends DataType_1.UnsignedIntegerType {
+    name = "UInt16";
+    coerce(val) { return (0, utils_1.toValidInt)(val, "UInt16"); }
+    equals(other) { return other.name === "UInt16"; }
+    allocate(size) { return new Uint16Array(size); }
+}
+exports.UInt16Type = UInt16Type;
+exports.UInt16 = new UInt16Type();
+class UInt32Type extends DataType_1.UnsignedIntegerType {
+    name = "UInt32";
+    coerce(val) { return (0, utils_1.toValidInt)(val, "UInt32"); }
+    equals(other) { return other.name === "UInt32"; }
+    allocate(size) { return new Uint32Array(size); }
+}
+exports.UInt32Type = UInt32Type;
+exports.UInt32 = new UInt32Type();
+class UInt64Type extends DataType_1.UnsignedIntegerType {
+    name = "UInt64";
+    coerce(val) { return (0, utils_1.toValidBigInt)(val, "UInt64"); }
+    equals(other) { return other.name === "UInt64"; }
+    allocate(size) { return new BigUint64Array(size); }
+}
+exports.UInt64Type = UInt64Type;
+exports.UInt64 = new UInt64Type();
+class Float32Type extends DataType_1.FloatDataType {
+    name = "Float32";
+    coerce(val) { return (0, utils_1.toValidFloat)(val, "Float32"); }
+    equals(other) { return other.name === "Float32"; }
+    allocate(size) { return new Float32Array(size); }
+}
+exports.Float32Type = Float32Type;
+exports.Float32 = new Float32Type();
+class Float64Type extends DataType_1.FloatDataType {
+    name = "Float64";
+    coerce(val) { return (0, utils_1.toValidFloat)(val, "Float64"); }
+    equals(other) { return other.name === "Float64"; }
+    allocate(size) { return new Float64Array(size); }
+}
+exports.Float64Type = Float64Type;
+exports.Float64 = new Float64Type();
+class DecimalType extends DataType_1.NumericDataType {
+    precision;
+    scale;
+    name;
+    constructor(precision, scale) {
+        super();
+        this.precision = precision;
+        this.scale = scale;
+        this.name = precision !== undefined && scale !== undefined
+            ? `Decimal(${precision}, ${scale})`
+            : "Decimal";
+    }
+    coerce(val) {
+        return (0, utils_1.toValidDecimal)(val, { precision: this.precision, scale: this.scale });
+    }
+    equals(other) {
+        return other instanceof DecimalType &&
+            this.precision === other.precision &&
+            this.scale === other.scale;
+    }
+    allocate(size) { return new Array(size).fill(null); }
+}
+exports.DecimalType = DecimalType;
+// ============================================================================
+// Standard Types
+// ============================================================================
+class BooleanType extends DataType_1.DataType {
+    name = "Boolean";
+    get isBoolean() { return true; }
+    coerce(val) {
+        if (val == null)
+            return null;
+        return !!val;
+    }
+    equals(other) { return other.name === "Boolean"; }
+    allocate(size) { return new Array(size).fill(null); }
+}
+exports.BooleanType = BooleanType;
+exports.Boolean = new BooleanType();
+class Utf8Type extends DataType_1.DataType {
+    name = "Utf8";
+    get isString() { return true; }
+    get isUtf8() { return true; }
+    coerce(val) {
+        if (val == null)
+            return null;
+        return String(val);
+    }
+    equals(other) { return other.name === "Utf8"; }
+    allocate(size) { return new Array(size).fill(null); }
+}
+exports.Utf8Type = Utf8Type;
+exports.Utf8 = new Utf8Type();
+class BinaryType extends DataType_1.DataType {
+    name = "Binary";
+    get isBinary() { return true; }
+    coerce(val) { return (0, utils_1.toValidBinary)(val); }
+    equals(other) { return other.name === "Binary"; }
+    allocate(size) { return new Array(size).fill(null); }
+}
+exports.BinaryType = BinaryType;
+exports.Binary = new BinaryType();
+class NullType extends DataType_1.DataType {
+    name = "Null";
+    get isNull() { return true; }
+    coerce(_val) { return null; }
+    equals(other) { return other.name === "Null"; }
+    allocate(size) { return new Array(size).fill(null); }
+}
+exports.NullType = NullType;
+exports.Null = new NullType();
+class ObjectType extends DataType_1.DataType {
+    name = "Object";
+    get isObject() { return true; }
+    coerce(val) { return val === undefined ? null : val; }
+    equals(other) { return other.name === "Object"; }
+    allocate(size) { return new Array(size).fill(null); }
+}
+exports.ObjectType = ObjectType;
+exports.Object = new ObjectType();
+// ============================================================================
+// Temporal Types
+// ============================================================================
+class DateType extends DataType_1.TemporalDataType {
+    name = "Date";
+    coerce(val) {
+        const d = (0, utils_1.toValidDate)(val);
+        if (!d)
+            return null;
+        d.setUTCHours(0, 0, 0, 0);
+        return d;
+    }
+    equals(other) { return other.name === "Date"; }
+    allocate(size) { return new Array(size).fill(null); }
+}
+exports.DateType = DateType;
+exports.Date = new DateType();
+class DatetimeType extends DataType_1.TemporalDataType {
+    name = "Datetime";
+    coerce(val) { return (0, utils_1.toValidDate)(val); }
+    equals(other) { return other.name === "Datetime"; }
+    allocate(size) { return new Array(size).fill(null); }
+}
+exports.DatetimeType = DatetimeType;
+exports.Datetime = new DatetimeType();
+class TimeType extends DataType_1.TemporalDataType {
+    name = "Time";
+    coerce(val) {
+        if (val == null)
+            return null;
+        if (typeof val === "string") {
+            const trimmed = val.trim();
+            if (utils_1.TIME_PREFIX_REGEX.test(trimmed)) {
+                const d = new globalThis.Date(`1970-01-01T${trimmed}${utils_1.ZONE_OFFSET_REGEX.test(trimmed) ? "" : "Z"}`);
+                if ((0, utils_1.isValidDateObj)(d)) {
+                    return d.toISOString().split("T")[1].slice(0, 12);
+                }
+            }
+        }
+        const d = (0, utils_1.toValidDate)(val);
+        return d ? d.toISOString().split("T")[1].slice(0, 12) : null;
+    }
+    equals(other) { return other.name === "Time"; }
+    allocate(size) { return new Array(size).fill(null); }
+}
+exports.TimeType = TimeType;
+exports.Time = new TimeType();
+class DurationType extends DataType_1.TemporalDataType {
+    name = "Duration";
+    coerce(val) { return (0, utils_1.toValidNumber)(val); }
+    equals(other) { return other.name === "Duration"; }
+    allocate(size) { return new Array(size).fill(null); }
+}
+exports.DurationType = DurationType;
+exports.Duration = new DurationType();
+// ============================================================================
+// Nested Types
+// ============================================================================
+class ListType extends DataType_1.NestedDataType {
+    innerType;
+    name = "List";
+    constructor(innerType) {
+        super();
+        this.innerType = innerType;
+    }
+    coerce(val) {
+        if (val == null)
+            return null;
+        const arr = (0, utils_1.isArrayOrTypedArray)(val) ? Array.from(val) : [val];
+        const len = arr.length;
+        const res = new Array(len);
+        for (let i = 0; i < len; i++) {
+            res[i] = this.innerType.coerce(arr[i]);
+        }
+        return res;
+    }
+    equals(other) {
+        return other instanceof ListType && this.innerType.equals(other.innerType);
+    }
+    allocate(size) { return new Array(size).fill(null); }
+}
+exports.ListType = ListType;
+const List = (inner) => new ListType(inner);
+exports.List = List;
+class StructType extends DataType_1.NestedDataType {
+    fields;
+    name = "Struct";
+    constructor(fields) {
+        super();
+        this.fields = fields;
+    }
+    coerce(val) {
+        if (!(0, utils_1.isObj)(val))
+            return null;
+        const res = {};
+        for (const [k, type] of globalThis.Object.entries(this.fields)) {
+            res[k] = type.coerce(val[k]);
+        }
+        return res;
+    }
+    equals(other) {
+        if (!(other instanceof StructType))
+            return false;
+        const keysThis = globalThis.Object.keys(this.fields);
+        const keysOther = globalThis.Object.keys(other.fields);
+        if (keysThis.length !== keysOther.length)
+            return false;
+        for (const k of keysThis) {
+            if (!other.fields[k] || !this.fields[k].equals(other.fields[k]))
+                return false;
+        }
+        return true;
+    }
+    allocate(size) { return new Array(size).fill(null); }
+}
+exports.StructType = StructType;
+const Struct = (fields) => new StructType(fields);
+exports.Struct = Struct;

package/dist/exceptions/index.d.ts

@@ -0,0 +1,13 @@
+export declare class DFScriptError extends Error {
+    constructor(message: string);
+}
+export declare class DataFrameError extends DFScriptError {
+}
+export declare class ColumnNotFoundError extends DataFrameError {
+    constructor(columnName: string, message?: string);
+}
+export declare class SchemaError extends DFScriptError {
+}
+export declare class ComputeError extends DFScriptError {
+}
+export * from "./utils";

package/dist/exceptions/index.js

@@ -0,0 +1,43 @@
+"use strict";
+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.ComputeError = exports.SchemaError = exports.ColumnNotFoundError = exports.DataFrameError = exports.DFScriptError = void 0;
+class DFScriptError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = this.constructor.name;
+        if (Error.captureStackTrace) {
+            Error.captureStackTrace(this, this.constructor);
+        }
+    }
+}
+exports.DFScriptError = DFScriptError;
+class DataFrameError extends DFScriptError {
+}
+exports.DataFrameError = DataFrameError;
+class ColumnNotFoundError extends DataFrameError {
+    constructor(columnName, message) {
+        super(message || `Column "${columnName}" does not exist in the DataFrame.`);
+    }
+}
+exports.ColumnNotFoundError = ColumnNotFoundError;
+class SchemaError extends DFScriptError {
+}
+exports.SchemaError = SchemaError;
+class ComputeError extends DFScriptError {
+}
+exports.ComputeError = ComputeError;
+__exportStar(require("./utils"), exports);

package/dist/exceptions/utils.d.ts

@@ -0,0 +1,2 @@
+import type { ColumnDict } from "../types";
+export declare function assertColumnExists(columnName: string, columns: ColumnDict, context: string, suffix?: string): void;

package/dist/exceptions/utils.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertColumnExists = assertColumnExists;
+const index_1 = require("./index");
+function assertColumnExists(columnName, columns, context, suffix = "") {
+    if (!(columnName in columns)) {
+        throw new index_1.ColumnNotFoundError(columnName, `${context} "${columnName}" does not exist${suffix}`);
+    }
+}

package/dist/functions/concat.d.ts

@@ -0,0 +1,4 @@
+import { DataFrame } from "../dataframe/dataframe";
+import type { ConcatOptions, ConcatItem, RowRecord } from "../types";
+export declare function normalizeToDataFrames(item: any, context: string, index: number): DataFrame<any>[];
+export declare function concat<U extends RowRecord = any>(rawItems: ConcatItem | ConcatItem[], options?: ConcatOptions): DataFrame<U>;