df-script 1.4.0

package/dist/datatypes/types/Datetime.d.ts

@@ -0,0 +1,8 @@
+import { TemporalDataType, DataType } from "../DataType";
+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;

package/dist/datatypes/types/Datetime.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Datetime = exports.DatetimeType = void 0;
+const DataType_1 = require("../DataType");
+const utils_1 = require("../../utils");
+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();

package/dist/datatypes/types/Decimal.d.ts

@@ -0,0 +1,10 @@
+import { NumericDataType, DataType } from "../DataType";
+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)[];
+}

package/dist/datatypes/types/Decimal.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecimalType = void 0;
+const DataType_1 = require("../DataType");
+const utils_1 = require("../../utils");
+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;

package/dist/datatypes/types/Duration.d.ts

@@ -0,0 +1,8 @@
+import { TemporalDataType, DataType } from "../DataType";
+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;

package/dist/datatypes/types/Duration.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Duration = exports.DurationType = void 0;
+const DataType_1 = require("../DataType");
+const utils_1 = require("../../utils");
+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();

package/dist/datatypes/types/Float32.d.ts

@@ -0,0 +1,8 @@
+import { FloatDataType, DataType } from "../DataType";
+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;

package/dist/datatypes/types/Float32.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Float32 = exports.Float32Type = void 0;
+const DataType_1 = require("../DataType");
+const utils_1 = require("../../utils");
+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();

package/dist/datatypes/types/Float64.d.ts

@@ -0,0 +1,8 @@
+import { FloatDataType, DataType } from "../DataType";
+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;

package/dist/datatypes/types/Float64.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Float64 = exports.Float64Type = void 0;
+const DataType_1 = require("../DataType");
+const utils_1 = require("../../utils");
+class Float64Type extends DataType_1.FloatDataType {
+    name = "Float64";
+    coerce(val) {
+        return (0, utils_1.toValidFloat)(val);
+    }
+    equals(other) {
+        return other.name === "Float64";
+    }
+    allocate(size) { return new Float64Array(size); }
+}
+exports.Float64Type = Float64Type;
+exports.Float64 = new Float64Type();

package/dist/datatypes/types/Int16.d.ts

@@ -0,0 +1,8 @@
+import { SignedIntegerType, DataType } from "../DataType";
+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;

package/dist/datatypes/types/Int16.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Int16 = exports.Int16Type = void 0;
+const DataType_1 = require("../DataType");
+const utils_1 = require("../../utils");
+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();

package/dist/datatypes/types/Int32.d.ts

@@ -0,0 +1,8 @@
+import { SignedIntegerType, DataType } from "../DataType";
+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;

package/dist/datatypes/types/Int32.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Int32 = exports.Int32Type = void 0;
+const DataType_1 = require("../DataType");
+const utils_1 = require("../../utils");
+class Int32Type extends DataType_1.SignedIntegerType {
+    name = "Int32";
+    coerce(val) {
+        return (0, utils_1.toValidInt)(val);
+    }
+    equals(other) {
+        return other.name === "Int32";
+    }
+    allocate(size) { return new Int32Array(size); }
+}
+exports.Int32Type = Int32Type;
+exports.Int32 = new Int32Type();

package/dist/datatypes/types/Int64.d.ts

@@ -0,0 +1,8 @@
+import { SignedIntegerType, DataType } from "../DataType";
+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;

package/dist/datatypes/types/Int64.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Int64 = exports.Int64Type = void 0;
+const DataType_1 = require("../DataType");
+const utils_1 = require("../../utils");
+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();

package/dist/datatypes/types/Int8.d.ts

@@ -0,0 +1,8 @@
+import { SignedIntegerType, DataType } from "../DataType";
+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;

package/dist/datatypes/types/Int8.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Int8 = exports.Int8Type = void 0;
+const DataType_1 = require("../DataType");
+const utils_1 = require("../../utils");
+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();

package/dist/datatypes/types/List.d.ts

@@ -0,0 +1,10 @@
+import { NestedDataType, DataType } from "../DataType";
+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>;

package/dist/datatypes/types/List.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.List = exports.ListType = void 0;
+const DataType_1 = require("../DataType");
+const utils_1 = require("../../utils");
+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;

package/dist/datatypes/types/Null.d.ts

@@ -0,0 +1,9 @@
+import { DataType } from "../DataType";
+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;

package/dist/datatypes/types/Null.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Null = exports.NullType = void 0;
+const DataType_1 = require("../DataType");
+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();

package/dist/datatypes/types/Object.d.ts

@@ -0,0 +1,9 @@
+import { DataType } from "../DataType";
+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;

package/dist/datatypes/types/Object.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Object = exports.ObjectType = void 0;
+const DataType_1 = require("../DataType");
+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();

package/dist/datatypes/types/Struct.d.ts

@@ -0,0 +1,14 @@
+import { NestedDataType, DataType } from "../DataType";
+export declare class StructType<TFields extends Record<string, any> = 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 Record<string, any>>(fields: { [K in keyof TFields]: DataType<TFields[K]>; }) => StructType<TFields>;

package/dist/datatypes/types/Struct.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Struct = exports.StructType = void 0;
+const DataType_1 = require("../DataType");
+const utils_1 = require("../../utils");
+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 Object.entries(this.fields)) {
+            res[k] = type.coerce(val[k]);
+        }
+        return res;
+    }
+    equals(other) {
+        if (!(other instanceof StructType))
+            return false;
+        const keysThis = Object.keys(this.fields);
+        const keysOther = 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/datatypes/types/Time.d.ts

@@ -0,0 +1,8 @@
+import { TemporalDataType, DataType } from "../DataType";
+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;

package/dist/datatypes/types/Time.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Time = exports.TimeType = void 0;
+const DataType_1 = require("../DataType");
+const utils_1 = require("../../utils");
+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 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();

package/dist/datatypes/types/UInt16.d.ts

@@ -0,0 +1,8 @@
+import { UnsignedIntegerType, DataType } from "../DataType";
+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;

package/dist/datatypes/types/UInt16.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UInt16 = exports.UInt16Type = void 0;
+const DataType_1 = require("../DataType");
+const utils_1 = require("../../utils");
+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();

package/dist/datatypes/types/UInt32.d.ts

@@ -0,0 +1,8 @@
+import { UnsignedIntegerType, DataType } from "../DataType";
+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;

package/dist/datatypes/types/UInt32.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UInt32 = exports.UInt32Type = void 0;
+const DataType_1 = require("../DataType");
+const utils_1 = require("../../utils");
+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();

package/dist/datatypes/types/UInt64.d.ts

@@ -0,0 +1,8 @@
+import { UnsignedIntegerType, DataType } from "../DataType";
+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;

package/dist/datatypes/types/UInt64.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UInt64 = exports.UInt64Type = void 0;
+const DataType_1 = require("../DataType");
+const utils_1 = require("../../utils");
+class UInt64Type extends DataType_1.UnsignedIntegerType {
+    name = "UInt64";
+    coerce(val) {
+        return (0, utils_1.toValidBigInt)(val);
+    }
+    equals(other) {
+        return other.name === "UInt64";
+    }
+    allocate(size) { return new BigUint64Array(size); }
+}
+exports.UInt64Type = UInt64Type;
+exports.UInt64 = new UInt64Type();

package/dist/datatypes/types/UInt8.d.ts

@@ -0,0 +1,8 @@
+import { UnsignedIntegerType, DataType } from "../DataType";
+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;

package/dist/datatypes/types/UInt8.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UInt8 = exports.UInt8Type = void 0;
+const DataType_1 = require("../DataType");
+const utils_1 = require("../../utils");
+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();

package/dist/datatypes/types/Utf8.d.ts

@@ -0,0 +1,10 @@
+import { DataType } from "../DataType";
+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;

package/dist/datatypes/types/Utf8.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Utf8 = exports.Utf8Type = void 0;
+const DataType_1 = require("../DataType");
+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();