df-script 1.4.0

package/dist/dataframe/grouped/grouped.d.ts

@@ -0,0 +1,15 @@
+import { DataFrame } from "../dataframe";
+import type { GroupMap } from "../types";
+import { DataType } from "../../datatypes";
+import type { IExpr, ColumnDict, RowRecord } from "../../types";
+export declare class GroupedData<T, K extends keyof T> {
+    private groups;
+    private keys;
+    private allKeys;
+    private parentColumns;
+    private parentHeight;
+    private parentSchema;
+    constructor(groups: GroupMap, keys: K[], allKeys: (keyof T)[], parentColumns: ColumnDict, parentHeight: number, parentSchema: Record<string, DataType>);
+    to_dataframe<U extends RowRecord = any>(): DataFrame<U>;
+    agg<U extends RowRecord = any>(...exprs: (IExpr | any)[]): DataFrame<U>;
+}

package/dist/dataframe/grouped/grouped.js

@@ -0,0 +1,113 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GroupedData = void 0;
+const dataframe_1 = require("../dataframe");
+const utils_1 = require("../utils");
+const columnExpressions_1 = require("../../columnExpressions");
+class GroupedData {
+    groups;
+    keys;
+    allKeys;
+    parentColumns;
+    parentHeight;
+    parentSchema;
+    constructor(groups, keys, allKeys, parentColumns, parentHeight, parentSchema) {
+        this.groups = groups;
+        this.keys = keys;
+        this.allKeys = allKeys;
+        this.parentColumns = parentColumns;
+        this.parentHeight = parentHeight;
+        this.parentSchema = parentSchema;
+    }
+    to_dataframe() {
+        const keysLen = this.keys.length;
+        const keysStr = new Array(keysLen);
+        for (let i = 0; i < keysLen; i++) {
+            keysStr[i] = String(this.keys[i]);
+        }
+        const numGroups = this.groups.size;
+        const newColumns = {};
+        for (let i = 0; i < keysStr.length; i++) {
+            newColumns[keysStr[i]] = new Array(numGroups);
+        }
+        let groupIdx = 0;
+        for (const indices of this.groups.values()) {
+            if (indices.length === 0)
+                continue;
+            const firstIdx = indices[0];
+            for (let i = 0; i < keysStr.length; i++) {
+                const k = keysStr[i];
+                const val = this.parentColumns[k][firstIdx];
+                newColumns[k][groupIdx] = val === undefined ? null : val;
+            }
+            groupIdx++;
+        }
+        const outSchema = {};
+        for (const k of keysStr) {
+            outSchema[k] = this.parentSchema[k];
+        }
+        return new dataframe_1.DataFrame(newColumns, outSchema, groupIdx);
+    }
+    agg(...exprs) {
+        const allKeysLen = this.allKeys.length;
+        const allKeysStr = new Array(allKeysLen);
+        for (let i = 0; i < allKeysLen; i++) {
+            allKeysStr[i] = String(this.allKeys[i]);
+        }
+        const keysLen = this.keys.length;
+        const keysStr = new Array(keysLen);
+        for (let i = 0; i < keysLen; i++) {
+            keysStr[i] = String(this.keys[i]);
+        }
+        const expandedExprs = (0, columnExpressions_1.resolveColumnSelectors)(exprs.flat(), allKeysStr, keysStr);
+        const numGroups = this.groups.size;
+        const newColumns = {};
+        for (let i = 0; i < keysStr.length; i++) {
+            newColumns[keysStr[i]] = new Array(numGroups);
+        }
+        let groupIdx = 0;
+        for (const indices of this.groups.values()) {
+            if (indices.length === 0)
+                continue;
+            const firstIdx = indices[0];
+            for (let i = 0; i < keysStr.length; i++) {
+                const k = keysStr[i];
+                const val = this.parentColumns[k][firstIdx];
+                newColumns[k][groupIdx] = val === undefined ? null : val;
+            }
+            groupIdx++;
+        }
+        for (let i = 0; i < expandedExprs.length; i++) {
+            const e = expandedExprs[i];
+            const targetKey = e.outputName || e.colName || columnExpressions_1.ALL_COLUMNS_MARKER;
+            if (!e.aggFn) {
+                newColumns[targetKey] = e.evaluate(newColumns, numGroups);
+                continue;
+            }
+            const preGroupedCol = e.evaluatePreGrouping(this.parentColumns, this.parentHeight);
+            const aggregatedGroupValues = new Array(numGroups);
+            let gIdx = 0;
+            for (const indices of this.groups.values()) {
+                if (indices.length === 0)
+                    continue;
+                const groupValues = new Array(indices.length);
+                for (let k = 0; k < indices.length; k++) {
+                    groupValues[k] = preGroupedCol[indices[k]];
+                }
+                aggregatedGroupValues[gIdx] = e.aggFn(groupValues);
+                gIdx++;
+            }
+            newColumns[targetKey] = e.evaluatePostGrouping(aggregatedGroupValues, newColumns);
+        }
+        const outSchema = {};
+        for (const k of keysStr) {
+            outSchema[k] = this.parentSchema[k];
+        }
+        for (const e of expandedExprs) {
+            const targetKey = e.outputName || e.colName || columnExpressions_1.ALL_COLUMNS_MARKER;
+            outSchema[targetKey] = (0, utils_1.inferColumnType)(newColumns[targetKey]);
+        }
+        return new dataframe_1.DataFrame(newColumns, outSchema, groupIdx);
+    }
+}
+exports.GroupedData = GroupedData;

package/dist/dataframe/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./dataframe";
+export * from "./utils";
+export * from "./types";
+export * from "./grouped/grouped";

package/dist/dataframe/index.js

@@ -0,0 +1,20 @@
+"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 });
+__exportStar(require("./dataframe"), exports);
+__exportStar(require("./utils"), exports);
+__exportStar(require("./types"), exports);
+__exportStar(require("./grouped/grouped"), exports);

package/dist/dataframe/types.d.ts

@@ -0,0 +1,33 @@
+import type { IExpr, AggFn, RowRecord } from "../types";
+import type { DataFrame } from "./dataframe";
+export type JoinType = "inner" | "left" | "outer" | "right";
+export type LimitPosition = "start" | "end";
+export type GroupMap = Map<string, number[]>;
+export interface LimitOptions {
+    offset?: number;
+    from?: LimitPosition;
+}
+export interface SortOptions<T> {
+    by: keyof T | (keyof T)[] | IExpr | IExpr[];
+    descending?: boolean | boolean[];
+    nullsLast?: boolean;
+    custom?: Partial<Record<keyof T, (a: any, b: any) => number>>;
+}
+export interface PivotOptions<T> {
+    index: (keyof T) | (keyof T)[];
+    columns: keyof T;
+    values: keyof T;
+    agg?: AggFn<any> | string;
+}
+export interface JoinOptions<T, U extends RowRecord = any> {
+    other: DataFrame<U>;
+    on: (keyof T & keyof U) | (keyof T & keyof U)[];
+    how?: JoinType;
+    suffixes?: [string, string];
+}
+export interface UnpivotOptions<T> {
+    idVars: (keyof T) | (keyof T)[];
+    valueVars: (keyof T) | (keyof T)[];
+    varName?: string;
+    valueName?: string;
+}

package/dist/dataframe/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/dataframe/utils.d.ts

@@ -0,0 +1,11 @@
+import type { IExpr, ColumnData, ColumnDict } from "../types";
+import { DataType } from "../datatypes";
+export declare function resolveWindowExpr(expr: IExpr, columns: ColumnDict, height: number): ColumnData;
+export declare function rowsToColumns(rows: any[]): {
+    columns: ColumnDict;
+    height: number;
+};
+export declare function columnsToRows(columns: ColumnDict, height: number): any[];
+export declare function getRowFromColumns(columns: ColumnDict, idx: number, keys: string[]): any;
+export declare function inferColumnType(col: ColumnData): DataType;
+export declare function gatherColumnsByIndices(columns: ColumnDict, indices: number[]): ColumnDict;

package/dist/dataframe/utils.js

@@ -0,0 +1,215 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveWindowExpr = resolveWindowExpr;
+exports.rowsToColumns = rowsToColumns;
+exports.columnsToRows = columnsToRows;
+exports.getRowFromColumns = getRowFromColumns;
+exports.inferColumnType = inferColumnType;
+exports.gatherColumnsByIndices = gatherColumnsByIndices;
+const datatypes_1 = require("../datatypes");
+const constants_1 = require("./constants");
+const utils_1 = require("../utils");
+const exceptions_1 = require("../exceptions");
+function partition_by_columns(columns, height, partitionKeys) {
+    const partitionMap = new Map();
+    const pKeysLen = partitionKeys.length;
+    const keyColumns = new Array(pKeysLen);
+    for (let i = 0; i < pKeysLen; i++) {
+        const pKey = partitionKeys[i];
+        if (typeof pKey === "string") {
+            (0, exceptions_1.assertColumnExists)(pKey, columns, "Partition key", " in the DataFrame.");
+            keyColumns[i] = columns[pKey];
+        }
+        else {
+            keyColumns[i] = pKey.evaluate(columns, height);
+        }
+    }
+    for (let i = 0; i < height; i++) {
+        const keyValues = new Array(keyColumns.length);
+        for (let j = 0; j < keyColumns.length; j++) {
+            const val = keyColumns[j][i];
+            keyValues[j] = val == null ? "" : String(val);
+        }
+        const hash = keyValues.join(constants_1.KEY_SEPARATOR);
+        let group = partitionMap.get(hash);
+        if (group === undefined) {
+            group = [];
+            partitionMap.set(hash, group);
+        }
+        group.push(i);
+    }
+    return partitionMap;
+}
+function resolveWindowExpr(expr, columns, height) {
+    const results = new Array(height);
+    if (height === 0)
+        return results;
+    const partitionKeys = expr.partitionBy || [];
+    const partitionGroups = partition_by_columns(columns, height, partitionKeys);
+    const prePartitionArray = expr.evaluatePrePartition(columns, height);
+    for (const indices of partitionGroups.values()) {
+        const groupLen = indices.length;
+        const groupPreValues = new Array(groupLen);
+        for (let k = 0; k < groupLen; k++) {
+            groupPreValues[k] = prePartitionArray[indices[k]];
+        }
+        if (expr.evaluateWindow) {
+            for (let k = 0; k < groupLen; k++) {
+                results[indices[k]] = expr.evaluateWindow(groupPreValues, indices, k);
+            }
+            continue;
+        }
+        if (expr.aggFn) {
+            const aggregatedVal = expr.aggFn(groupPreValues);
+            for (let k = 0; k < groupLen; k++) {
+                results[indices[k]] = aggregatedVal;
+            }
+            continue;
+        }
+        for (let k = 0; k < groupLen; k++) {
+            results[indices[k]] = prePartitionArray[indices[k]];
+        }
+    }
+    return expr.evaluatePostPartition(results, columns);
+}
+function rowsToColumns(rows) {
+    if (!Array.isArray(rows) || rows.length === 0) {
+        return { columns: {}, height: 0 };
+    }
+    const height = rows.length;
+    const keysSet = new Set();
+    for (let r = 0; r < height; r++) {
+        const row = rows[r];
+        if ((0, utils_1.isObj)(row)) {
+            const rowKeys = Object.keys(row);
+            for (let i = 0; i < rowKeys.length; i++) {
+                keysSet.add(rowKeys[i]);
+            }
+        }
+    }
+    const keys = Array.from(keysSet);
+    const columns = {};
+    for (let i = 0; i < keys.length; i++) {
+        columns[keys[i]] = new Array(height);
+    }
+    for (let r = 0; r < height; r++) {
+        const row = rows[r] || {};
+        for (let i = 0; i < keys.length; i++) {
+            const k = keys[i];
+            const val = row[k];
+            columns[k][r] = val === undefined ? null : val;
+        }
+    }
+    return { columns, height };
+}
+function columnsToRows(columns, height) {
+    const keys = Object.keys(columns);
+    const rows = new Array(height);
+    for (let r = 0; r < height; r++) {
+        const row = {};
+        for (let i = 0; i < keys.length; i++) {
+            const k = keys[i];
+            const val = columns[k][r];
+            row[k] = val === undefined ? null : val;
+        }
+        rows[r] = row;
+    }
+    return rows;
+}
+function getRowFromColumns(columns, idx, keys) {
+    const row = {};
+    for (let i = 0; i < keys.length; i++) {
+        const k = keys[i];
+        const val = columns[k][idx];
+        row[k] = val === undefined ? null : val;
+    }
+    return row;
+}
+function inferColumnType(col) {
+    if (col.length === 0)
+        return datatypes_1.DataTypeRegistry.Utf8;
+    let isBoolean = true;
+    let isInteger = true;
+    let isNumeric = true;
+    let isBigInt = true;
+    let isDate = true;
+    let isList = true;
+    let hasDateObj = false;
+    let hasNonNull = false;
+    const allListElements = [];
+    for (let i = 0; i < col.length; i++) {
+        const val = col[i];
+        if (val == null)
+            continue;
+        hasNonNull = true;
+        if (!Array.isArray(val)) {
+            isList = false;
+        }
+        else {
+            for (let j = 0; j < val.length; j++) {
+                allListElements.push(val[j]);
+            }
+        }
+        if (val instanceof Date)
+            hasDateObj = true;
+        if (typeof val !== "boolean")
+            isBoolean = false;
+        if (typeof val !== "bigint")
+            isBigInt = false;
+        if (typeof val !== "number") {
+            isNumeric = false;
+            isInteger = false;
+        }
+        else {
+            if (!Number.isInteger(val))
+                isInteger = false;
+        }
+        if (!(val instanceof Date) && (typeof val !== "string" || isNaN(Date.parse(val)))) {
+            isDate = false;
+        }
+    }
+    if (!hasNonNull)
+        return datatypes_1.DataTypeRegistry.Utf8;
+    if (isList) {
+        const innerType = inferColumnType(allListElements);
+        return datatypes_1.DataTypeRegistry.List(innerType);
+    }
+    if (isBoolean)
+        return datatypes_1.DataTypeRegistry.Boolean;
+    if (isBigInt)
+        return datatypes_1.DataTypeRegistry.Int64;
+    if (isNumeric && !isInteger)
+        return datatypes_1.DataTypeRegistry.Float64;
+    if (isNumeric && isInteger) {
+        let fitsInInt32 = true;
+        for (let i = 0; i < col.length; i++) {
+            const val = col[i];
+            if (val == null)
+                continue;
+            if (val < -2147483648 || val > 2147483647) {
+                fitsInInt32 = false;
+                break;
+            }
+        }
+        return fitsInInt32 ? datatypes_1.DataTypeRegistry.Int32 : datatypes_1.DataTypeRegistry.Float64;
+    }
+    if (isDate && hasDateObj)
+        return datatypes_1.DataTypeRegistry.Datetime;
+    return datatypes_1.DataTypeRegistry.Utf8;
+}
+function gatherColumnsByIndices(columns, indices) {
+    const keys = Object.keys(columns);
+    const numKeys = keys.length;
+    const newHeight = indices.length;
+    const res = {};
+    for (let j = 0; j < numKeys; j++) {
+        const k = keys[j];
+        const oldCol = columns[k];
+        const newCol = new Array(newHeight);
+        for (let idx = 0; idx < newHeight; idx++) {
+            newCol[idx] = oldCol[indices[idx]];
+        }
+        res[k] = newCol;
+    }
+    return res;
+}

package/dist/datatypes/DataType.d.ts

@@ -0,0 +1,40 @@
+export declare abstract class DataType<T = any> {
+    abstract readonly name: string;
+    abstract coerce(val: any): T;
+    abstract equals(other: DataType): boolean;
+    abstract allocate(size: number): ArrayLike<T>;
+    get isNumeric(): boolean;
+    get isInteger(): boolean;
+    get isFloat(): boolean;
+    get isSigned(): boolean;
+    get isUnsigned(): boolean;
+    get isTemporal(): boolean;
+    get isNested(): boolean;
+    get isBoolean(): boolean;
+    get isString(): boolean;
+    get isUtf8(): boolean;
+    get isObject(): boolean;
+    get isNull(): boolean;
+    get isBinary(): boolean;
+}
+export declare abstract class NumericDataType<T = number | null> extends DataType<T> {
+    get isNumeric(): boolean;
+}
+export declare abstract class IntegerDataType<T = number | null> extends NumericDataType<T> {
+    get isInteger(): boolean;
+}
+export declare abstract class SignedIntegerType<T = number | null> extends IntegerDataType<T> {
+    get isSigned(): boolean;
+}
+export declare abstract class UnsignedIntegerType<T = number | null> extends IntegerDataType<T> {
+    get isUnsigned(): boolean;
+}
+export declare abstract class FloatDataType<T = number | null> extends NumericDataType<T> {
+    get isFloat(): boolean;
+}
+export declare abstract class TemporalDataType<T = any> extends DataType<T> {
+    get isTemporal(): boolean;
+}
+export declare abstract class NestedDataType<T = any> extends DataType<T> {
+    get isNested(): boolean;
+}

package/dist/datatypes/DataType.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NestedDataType = exports.TemporalDataType = exports.FloatDataType = exports.UnsignedIntegerType = exports.SignedIntegerType = exports.IntegerDataType = exports.NumericDataType = exports.DataType = void 0;
+class DataType {
+    get isNumeric() { return false; }
+    get isInteger() { return false; }
+    get isFloat() { return false; }
+    get isSigned() { return false; }
+    get isUnsigned() { return false; }
+    get isTemporal() { return false; }
+    get isNested() { return false; }
+    get isBoolean() { return false; }
+    get isString() { return false; }
+    get isUtf8() { return false; }
+    get isObject() { return false; }
+    get isNull() { return false; }
+    get isBinary() { return false; }
+}
+exports.DataType = DataType;
+class NumericDataType extends DataType {
+    get isNumeric() { return true; }
+}
+exports.NumericDataType = NumericDataType;
+class IntegerDataType extends NumericDataType {
+    get isInteger() { return true; }
+}
+exports.IntegerDataType = IntegerDataType;
+class SignedIntegerType extends IntegerDataType {
+    get isSigned() { return true; }
+}
+exports.SignedIntegerType = SignedIntegerType;
+class UnsignedIntegerType extends IntegerDataType {
+    get isUnsigned() { return true; }
+}
+exports.UnsignedIntegerType = UnsignedIntegerType;
+class FloatDataType extends NumericDataType {
+    get isFloat() { return true; }
+}
+exports.FloatDataType = FloatDataType;
+class TemporalDataType extends DataType {
+    get isTemporal() { return true; }
+}
+exports.TemporalDataType = TemporalDataType;
+class NestedDataType extends DataType {
+    get isNested() { return true; }
+}
+exports.NestedDataType = NestedDataType;

package/dist/datatypes/index.d.ts

@@ -0,0 +1,29 @@
+import { DataType as BaseDataType } from "./DataType";
+import { DecimalType } from "./types";
+export { BaseDataType as DataType };
+export declare const DataTypeRegistry: {
+    Int8: import("./types").Int8Type;
+    Int16: import("./types").Int16Type;
+    Int32: import("./types").Int32Type;
+    Int64: import("./types").Int64Type;
+    UInt8: import("./types").UInt8Type;
+    UInt16: import("./types").UInt16Type;
+    UInt32: import("./types").UInt32Type;
+    UInt64: import("./types").UInt64Type;
+    Float32: import("./types").Float32Type;
+    Float64: import("./types").Float64Type;
+    Decimal: (precision?: number, scale?: number) => DecimalType;
+    Boolean: import("./types").BooleanType;
+    Utf8: import("./types").Utf8Type;
+    Binary: import("./types").BinaryType;
+    Date: import("./types").DateType;
+    Datetime: import("./types").DatetimeType;
+    Time: import("./types").TimeType;
+    Duration: import("./types").DurationType;
+    Object: import("./types").ObjectType;
+    Null: import("./types").NullType;
+    List: <TInner>(inner: BaseDataType<TInner>) => import("./types").ListType<TInner>;
+    Struct: <TFields extends import("..").RowRecord>(fields: { [K in keyof TFields]: BaseDataType<TFields[K]>; }) => import("./types").StructType<TFields>;
+};
+export * from "./types";
+export * from "./DataType";

package/dist/datatypes/index.js

@@ -0,0 +1,46 @@
+"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.DataTypeRegistry = exports.DataType = void 0;
+const DataType_1 = require("./DataType");
+Object.defineProperty(exports, "DataType", { enumerable: true, get: function () { return DataType_1.DataType; } });
+const types_1 = require("./types");
+exports.DataTypeRegistry = {
+    Int8: types_1.Int8,
+    Int16: types_1.Int16,
+    Int32: types_1.Int32,
+    Int64: types_1.Int64,
+    UInt8: types_1.UInt8,
+    UInt16: types_1.UInt16,
+    UInt32: types_1.UInt32,
+    UInt64: types_1.UInt64,
+    Float32: types_1.Float32,
+    Float64: types_1.Float64,
+    Decimal: (precision, scale) => new types_1.DecimalType(precision, scale),
+    Boolean: types_1.Boolean,
+    Utf8: types_1.Utf8,
+    Binary: types_1.Binary,
+    Date: types_1.Date,
+    Datetime: types_1.Datetime,
+    Time: types_1.Time,
+    Duration: types_1.Duration,
+    Object: types_1.Object,
+    Null: types_1.Null,
+    List: types_1.List,
+    Struct: types_1.Struct
+};
+__exportStar(require("./types"), exports);
+__exportStar(require("./DataType"), exports);

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

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

package/dist/datatypes/types/Binary.js

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

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

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

package/dist/datatypes/types/Boolean.js

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

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

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

package/dist/datatypes/types/Date.js

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