@ohos-ports/nodejs-polars 0.22.2-beta.0

package/bin/datatypes/conversion.d.ts

@@ -0,0 +1,2 @@
+import type { DataType } from "./datatype";
+export type JsToDtype<T> = T extends bigint ? DataType.UInt64 : T extends number ? DataType.Float64 : T extends boolean ? DataType.Bool : T extends string ? DataType.String : T extends Date ? DataType.Datetime : never;

package/bin/datatypes/conversion.js

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

package/bin/datatypes/datatype.d.ts

@@ -0,0 +1,252 @@
+import { Field } from "./field";
+export declare abstract class DataType<Dtype extends DataTypeName = any> {
+    readonly __dtype: Dtype;
+    get variant(): DataTypeName;
+    protected identity: string;
+    protected get inner(): null | any[];
+    equals(other: DataType): boolean;
+    /** Null type */
+    static get Null(): Null;
+    /** `true` and `false`. */
+    static get Bool(): Bool;
+    /** An `i8` */
+    static get Int8(): Int8;
+    /** An `i16` */
+    static get Int16(): Int16;
+    /** An `i32` */
+    static get Int32(): Int32;
+    /** An `i64` */
+    static get Int64(): Int64;
+    /** An `u8` */
+    static get UInt8(): UInt8;
+    /** An `u16` */
+    static get UInt16(): UInt16;
+    /** An `u32` */
+    static get UInt32(): UInt32;
+    /** An `u64` */
+    static get UInt64(): UInt64;
+    /** A `f32` */
+    static get Float32(): Float32;
+    /** A `f64` */
+    static get Float64(): Float64;
+    static get Date(): Date;
+    /** Time of day type */
+    static get Time(): Time;
+    /** Type for wrapping arbitrary JS objects */
+    static get Object(): Object_;
+    /** A categorical encoding of a set of strings  */
+    static get Categorical(): Categorical;
+    /** Decimal type */
+    static Decimal(precision?: number, scale?: number): Decimal;
+    /**
+     * Calendar date and time type
+     * @param timeUnit any of 'ms' | 'ns' | 'us'
+     * @param timeZone timezone string as defined by Intl.DateTimeFormat `America/New_York` for example.
+     */
+    static Datetime(timeUnit?: TimeUnit | "ms" | "ns" | "us", timeZone?: string | null | undefined): Datetime;
+    /**
+     * Nested list/array type
+     *
+     * @param inner The `DataType` of values within the list
+     *
+     */
+    static List(inner: DataType): List;
+    /**
+     * List of fixed length
+     * This is called `Array` in other polars implementations, but `Array` is widely used in JS, so we use `FixedSizeList` instead.
+     *
+     */
+    static FixedSizeList(inner: DataType, listSize: number): FixedSizeList;
+    /**
+     * Struct type
+     */
+    static Struct(fields: Field[]): DataType;
+    static Struct(fields: {
+        [key: string]: DataType;
+    }): DataType;
+    /** A variable-length UTF-8 encoded string whose offsets are represented as `i64`. */
+    static get Utf8(): Utf8;
+    static get String(): String;
+    toString(): string;
+    toJSON(): {
+        [x: string]: {
+            [x: string]: any;
+        };
+    } | {
+        [x: string]: DataTypeName;
+    };
+    asFixedSizeList(): (this & FixedSizeList) | null;
+}
+export declare class Null extends DataType<"Null"> {
+    __dtype: "Null";
+}
+export declare class Bool extends DataType<"Bool"> {
+    __dtype: "Bool";
+}
+export declare class Int8 extends DataType<"Int8"> {
+    __dtype: "Int8";
+}
+export declare class Int16 extends DataType<"Int16"> {
+    __dtype: "Int16";
+}
+export declare class Int32 extends DataType<"Int32"> {
+    __dtype: "Int32";
+}
+export declare class Int64 extends DataType<"Int64"> {
+    __dtype: "Int64";
+}
+export declare class UInt8 extends DataType<"UInt8"> {
+    __dtype: "UInt8";
+}
+export declare class UInt16 extends DataType<"UInt16"> {
+    __dtype: "UInt16";
+}
+export declare class UInt32 extends DataType<"UInt32"> {
+    __dtype: "UInt32";
+}
+export declare class UInt64 extends DataType<"UInt64"> {
+    __dtype: "UInt64";
+}
+export declare class Float32 extends DataType<"Float32"> {
+    __dtype: "Float32";
+}
+export declare class Float64 extends DataType<"Float64"> {
+    __dtype: "Float64";
+}
+export declare class Date extends DataType<"Date"> {
+    __dtype: "Date";
+}
+export declare class Time extends DataType<"Time"> {
+    __dtype: "Time";
+}
+export declare class Object_ extends DataType<"Object"> {
+    __dtype: "Object";
+}
+export declare class Utf8 extends DataType<"Utf8"> {
+    __dtype: "Utf8";
+}
+export declare class String extends DataType<"String"> {
+    __dtype: "String";
+}
+export declare class Categorical extends DataType<"Categorical"> {
+    __dtype: "Categorical";
+}
+export declare class Decimal extends DataType<"Decimal"> {
+    __dtype: "Decimal";
+    private precision;
+    private scale;
+    constructor(precision?: number, scale?: number);
+    get inner(): (number | null)[];
+    equals(other: DataType): boolean;
+    toJSON(): {
+        [x: string]: {
+            [x: string]: {
+                precision: number | null;
+                scale: number | null;
+            };
+        };
+    };
+}
+/**
+ * Datetime type
+ */
+export declare class Datetime extends DataType<"Datetime"> {
+    private timeUnit;
+    private timeZone?;
+    __dtype: "Datetime";
+    constructor(timeUnit?: TimeUnit | "ms" | "ns" | "us", timeZone?: string | null | undefined);
+    get inner(): (string | null | undefined)[];
+    equals(other: DataType): boolean;
+}
+export declare class List extends DataType<"List"> {
+    protected __inner: DataType;
+    __dtype: "List";
+    constructor(__inner: DataType);
+    get inner(): DataType<any>[];
+    equals(other: DataType): boolean;
+}
+export declare class FixedSizeList extends DataType<"FixedSizeList"> {
+    protected __inner: DataType;
+    protected listSize: number;
+    __dtype: "FixedSizeList";
+    constructor(__inner: DataType, listSize: number);
+    get inner(): [DataType, number];
+    equals(other: DataType): boolean;
+    toJSON(): {
+        [x: string]: {
+            [x: string]: {
+                type: {
+                    [x: string]: {
+                        [x: string]: any;
+                    };
+                } | {
+                    [x: string]: DataTypeName;
+                };
+                size: number;
+            };
+        };
+    };
+}
+export declare class Struct extends DataType<"Struct"> {
+    __dtype: "Struct";
+    private fields;
+    constructor(inner: {
+        [name: string]: DataType;
+    } | Field[]);
+    get inner(): Field[];
+    equals(other: DataType): boolean;
+    toJSON(): any;
+}
+/**
+ * Datetime time unit
+ */
+export declare enum TimeUnit {
+    Nanoseconds = "ns",
+    Microseconds = "us",
+    Milliseconds = "ms"
+}
+/**
+ * @ignore
+ * Timeunit namespace
+ */
+export declare namespace TimeUnit {
+    function from(s: "ms" | "ns" | "us"): TimeUnit;
+}
+/**
+ * Datatype namespace
+ */
+export declare namespace DataType {
+    type Categorical = import(".").Categorical;
+    type Int8 = import(".").Int8;
+    type Int16 = import(".").Int16;
+    type Int32 = import(".").Int32;
+    type Int64 = import(".").Int64;
+    type UInt8 = import(".").UInt8;
+    type UInt16 = import(".").UInt16;
+    type UInt32 = import(".").UInt32;
+    type UInt64 = import(".").UInt64;
+    type Float32 = import(".").Float32;
+    type Float64 = import(".").Float64;
+    type Bool = import(".").Bool;
+    type Utf8 = import(".").Utf8;
+    type String = import(".").String;
+    type List = import(".").List;
+    type FixedSizeList = import(".").FixedSizeList;
+    type Date = import(".").Date;
+    type Datetime = import(".").Datetime;
+    type Time = import(".").Time;
+    type Object = import(".").Object_;
+    type Null = import(".").Null;
+    type Struct = import(".").Struct;
+    type Decimal = import(".").Decimal;
+    /**
+     * deserializes a datatype from the serde output of rust polars `DataType`
+     * @param dtype dtype object
+     */
+    function deserialize(dtype: any): DataType;
+}
+export type DataTypeName = "Null" | "Bool" | "Int8" | "Int16" | "Int32" | "Int64" | "UInt8" | "UInt16" | "UInt32" | "UInt64" | "Float32" | "Float64" | "Decimal" | "Date" | "Datetime" | "Time" | "Object" | "Utf8" | "String" | "Categorical" | "List" | "FixedSizeList" | "Struct";
+export type JsType = number | boolean | string;
+export type DTypeToJs<T> = T extends DataType.Decimal ? bigint : T extends DataType.Float64 ? number : T extends DataType.Float32 ? number : T extends DataType.Int64 ? bigint : T extends DataType.Int32 ? number : T extends DataType.Int16 ? number : T extends DataType.Int8 ? number : T extends DataType.Bool ? boolean : T extends DataType.Utf8 ? string : T extends DataType.String ? string : never;
+export type DTypeToJsLoose<T> = T extends DataType.Decimal ? number | bigint : T extends DataType.Float64 ? number | bigint : T extends DataType.Float32 ? number | bigint : T extends DataType.Int64 ? number | bigint : T extends DataType.Int32 ? number | bigint : T extends DataType.Int16 ? number | bigint : T extends DataType.Int8 ? number | bigint : T extends DataType.Bool ? boolean : T extends DataType.Utf8 ? string : T extends DataType.String ? string : never;
+export type DtypeToJsName<T> = T extends DataType.Decimal ? "Decimal" : T extends DataType.Float64 ? "Float64" : T extends DataType.Float32 ? "Float32" : T extends DataType.Int64 ? "Int64" : T extends DataType.Int32 ? "Int32" : T extends DataType.Int16 ? "Int16" : T extends DataType.Int8 ? "Int8" : T extends DataType.UInt64 ? "UInt64" : T extends DataType.UInt32 ? "UInt32" : T extends DataType.UInt16 ? "UInt16" : T extends DataType.UInt8 ? "UInt8" : T extends DataType.Bool ? "Bool" : T extends DataType.Utf8 ? "Utf8" : never;

package/bin/datatypes/datatype.js

@@ -0,0 +1,386 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeUnit = exports.Struct = exports.FixedSizeList = exports.List = exports.Datetime = exports.Decimal = exports.Categorical = exports.String = exports.Utf8 = exports.Object_ = exports.Time = exports.Date = exports.Float64 = exports.Float32 = exports.UInt64 = exports.UInt32 = exports.UInt16 = exports.UInt8 = exports.Int64 = exports.Int32 = exports.Int16 = exports.Int8 = exports.Bool = exports.Null = exports.DataType = void 0;
+const field_1 = require("./field");
+class DataType {
+    get variant() {
+        return this.constructor.name;
+    }
+    identity = "DataType";
+    get inner() {
+        return null;
+    }
+    equals(other) {
+        return (this.variant === other.variant &&
+            this.inner === null &&
+            other.inner === null);
+    }
+    /** Null type */
+    static get Null() {
+        return new Null();
+    }
+    /** `true` and `false`. */
+    static get Bool() {
+        return new Bool();
+    }
+    /** An `i8` */
+    static get Int8() {
+        return new Int8();
+    }
+    /** An `i16` */
+    static get Int16() {
+        return new Int16();
+    }
+    /** An `i32` */
+    static get Int32() {
+        return new Int32();
+    }
+    /** An `i64` */
+    static get Int64() {
+        return new Int64();
+    }
+    /** An `u8` */
+    static get UInt8() {
+        return new UInt8();
+    }
+    /** An `u16` */
+    static get UInt16() {
+        return new UInt16();
+    }
+    /** An `u32` */
+    static get UInt32() {
+        return new UInt32();
+    }
+    /** An `u64` */
+    static get UInt64() {
+        return new UInt64();
+    }
+    /** A `f32` */
+    static get Float32() {
+        return new Float32();
+    }
+    /** A `f64` */
+    static get Float64() {
+        return new Float64();
+    }
+    static get Date() {
+        return new Date();
+    }
+    /** Time of day type */
+    static get Time() {
+        return new Time();
+    }
+    /** Type for wrapping arbitrary JS objects */
+    static get Object() {
+        return new Object_();
+    }
+    /** A categorical encoding of a set of strings  */
+    static get Categorical() {
+        return new Categorical();
+    }
+    /** Decimal type */
+    static Decimal(precision, scale) {
+        return new Decimal(precision, scale);
+    }
+    /**
+     * Calendar date and time type
+     * @param timeUnit any of 'ms' | 'ns' | 'us'
+     * @param timeZone timezone string as defined by Intl.DateTimeFormat `America/New_York` for example.
+     */
+    static Datetime(timeUnit, timeZone = null) {
+        return new Datetime(timeUnit ?? "ms", timeZone);
+    }
+    /**
+     * Nested list/array type
+     *
+     * @param inner The `DataType` of values within the list
+     *
+     */
+    static List(inner) {
+        return new List(inner);
+    }
+    /**
+     * List of fixed length
+     * This is called `Array` in other polars implementations, but `Array` is widely used in JS, so we use `FixedSizeList` instead.
+     *
+     */
+    static FixedSizeList(inner, listSize) {
+        return new FixedSizeList(inner, listSize);
+    }
+    static Struct(fields) {
+        return new Struct(fields);
+    }
+    /** A variable-length UTF-8 encoded string whose offsets are represented as `i64`. */
+    static get Utf8() {
+        return new Utf8();
+    }
+    static get String() {
+        return new String();
+    }
+    toString() {
+        if (this.inner) {
+            return `${this.identity}(${this.variant}(${this.inner}))`;
+        }
+        return `${this.identity}(${this.variant})`;
+    }
+    toJSON() {
+        const inner = this.inner;
+        if (inner) {
+            return {
+                [this.identity]: {
+                    [this.variant]: inner[0],
+                },
+            };
+        }
+        return {
+            [this.identity]: this.variant,
+        };
+    }
+    [Symbol.for("nodejs.util.inspect.custom")]() {
+        return this.toString();
+    }
+    asFixedSizeList() {
+        if (this instanceof FixedSizeList) {
+            return this;
+        }
+        return null;
+    }
+}
+exports.DataType = DataType;
+class Null extends DataType {
+}
+exports.Null = Null;
+class Bool extends DataType {
+}
+exports.Bool = Bool;
+class Int8 extends DataType {
+}
+exports.Int8 = Int8;
+class Int16 extends DataType {
+}
+exports.Int16 = Int16;
+class Int32 extends DataType {
+}
+exports.Int32 = Int32;
+class Int64 extends DataType {
+}
+exports.Int64 = Int64;
+class UInt8 extends DataType {
+}
+exports.UInt8 = UInt8;
+class UInt16 extends DataType {
+}
+exports.UInt16 = UInt16;
+class UInt32 extends DataType {
+}
+exports.UInt32 = UInt32;
+class UInt64 extends DataType {
+}
+exports.UInt64 = UInt64;
+class Float32 extends DataType {
+}
+exports.Float32 = Float32;
+class Float64 extends DataType {
+}
+exports.Float64 = Float64;
+// biome-ignore lint/suspicious/noShadowRestrictedNames: Using Polars Date
+class Date extends DataType {
+}
+exports.Date = Date;
+class Time extends DataType {
+}
+exports.Time = Time;
+class Object_ extends DataType {
+}
+exports.Object_ = Object_;
+class Utf8 extends DataType {
+}
+exports.Utf8 = Utf8;
+// biome-ignore lint/suspicious/noShadowRestrictedNames: Using Polars String
+class String extends DataType {
+}
+exports.String = String;
+class Categorical extends DataType {
+}
+exports.Categorical = Categorical;
+class Decimal extends DataType {
+    precision;
+    scale;
+    constructor(precision, scale) {
+        super();
+        this.precision = precision ?? null;
+        this.scale = scale ?? null;
+    }
+    get inner() {
+        return [this.precision, this.scale];
+    }
+    equals(other) {
+        if (other.variant === this.variant) {
+            return (this.precision === other.precision &&
+                this.scale === other.scale);
+        }
+        return false;
+    }
+    toJSON() {
+        return {
+            [this.identity]: {
+                [this.variant]: {
+                    precision: this.precision,
+                    scale: this.scale,
+                },
+            },
+        };
+    }
+}
+exports.Decimal = Decimal;
+/**
+ * Datetime type
+ */
+class Datetime extends DataType {
+    timeUnit;
+    timeZone;
+    constructor(timeUnit = "ms", timeZone) {
+        super();
+        this.timeUnit = timeUnit;
+        this.timeZone = timeZone;
+    }
+    get inner() {
+        return [this.timeUnit, this.timeZone];
+    }
+    equals(other) {
+        if (other.variant === this.variant) {
+            return (this.timeUnit === other.timeUnit &&
+                this.timeZone === other.timeZone);
+        }
+        return false;
+    }
+}
+exports.Datetime = Datetime;
+class List extends DataType {
+    __inner;
+    constructor(__inner) {
+        super();
+        this.__inner = __inner;
+    }
+    get inner() {
+        return [this.__inner];
+    }
+    equals(other) {
+        if (other.variant === this.variant) {
+            return this.inner[0].equals(other.inner[0]);
+        }
+        return false;
+    }
+}
+exports.List = List;
+class FixedSizeList extends DataType {
+    __inner;
+    listSize;
+    constructor(__inner, listSize) {
+        super();
+        this.__inner = __inner;
+        this.listSize = listSize;
+    }
+    get inner() {
+        return [this.__inner, this.listSize];
+    }
+    equals(other) {
+        if (other.variant === this.variant) {
+            return (this.inner[0].equals(other.inner[0]) &&
+                this.inner[1] === other.inner[1]);
+        }
+        return false;
+    }
+    toJSON() {
+        return {
+            [this.identity]: {
+                [this.variant]: {
+                    type: this.inner[0].toJSON(),
+                    size: this.inner[1],
+                },
+            },
+        };
+    }
+}
+exports.FixedSizeList = FixedSizeList;
+class Struct extends DataType {
+    fields;
+    constructor(inner) {
+        super();
+        if (Array.isArray(inner)) {
+            this.fields = inner;
+        }
+        else {
+            this.fields = Object.entries(inner).map(field_1.Field.from);
+        }
+    }
+    get inner() {
+        return this.fields;
+    }
+    equals(other) {
+        if (other.variant === this.variant) {
+            return this.inner
+                .map((fld, idx) => {
+                const otherfld = other.fields[idx];
+                return otherfld.name === fld.name && otherfld.dtype.equals(fld.dtype);
+            })
+                .every((value) => value);
+        }
+        return false;
+    }
+    toJSON() {
+        return {
+            [this.identity]: {
+                [this.variant]: this.fields,
+            },
+        };
+    }
+}
+exports.Struct = Struct;
+/**
+ * Datetime time unit
+ */
+var TimeUnit;
+(function (TimeUnit) {
+    TimeUnit["Nanoseconds"] = "ns";
+    TimeUnit["Microseconds"] = "us";
+    TimeUnit["Milliseconds"] = "ms";
+})(TimeUnit || (exports.TimeUnit = TimeUnit = {}));
+/**
+ * @ignore
+ * Timeunit namespace
+ */
+(function (TimeUnit) {
+    function from(s) {
+        return TimeUnit[s];
+    }
+    TimeUnit.from = from;
+})(TimeUnit || (exports.TimeUnit = TimeUnit = {}));
+/**
+ * Datatype namespace
+ */
+(function (DataType) {
+    /**
+     * deserializes a datatype from the serde output of rust polars `DataType`
+     * @param dtype dtype object
+     */
+    function deserialize(dtype) {
+        if (typeof dtype === "string") {
+            return DataType[dtype];
+        }
+        let { variant, inner } = dtype;
+        if (variant === "Struct") {
+            inner = [
+                inner[0].map((fld) => field_1.Field.from(fld.name, deserialize(fld.dtype))),
+            ];
+        }
+        if (variant === "List") {
+            inner = [deserialize(inner[0])];
+        }
+        if (variant === "FixedSizeList") {
+            inner = [deserialize(inner[0]), inner[1]];
+        }
+        return DataType[variant](...inner);
+    }
+    DataType.deserialize = deserialize;
+})(DataType || (exports.DataType = DataType = {}));

package/bin/datatypes/field.d.ts

@@ -0,0 +1,26 @@
+import type { DataType } from "./datatype";
+/**
+ * A field is a name and a datatype.
+ */
+export interface iField {
+    name: string;
+    dtype: DataType;
+}
+export declare class Field implements iField {
+    name: string;
+    dtype: DataType;
+    constructor(name: string, dtype: DataType);
+    toString(): string;
+    toJSON(): {
+        name: string;
+        dtype: DataType<any>;
+    };
+}
+export declare namespace Field {
+    function from(name: string, dtype: DataType): Field;
+    function from([string, DataType]: [any, any]): Field;
+    function from(obj: {
+        name: string;
+        dtype: DataType;
+    }): Field;
+}

package/bin/datatypes/field.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Field = void 0;
+class Field {
+    name;
+    dtype;
+    constructor(name, dtype) {
+        this.name = name;
+        this.dtype = dtype;
+    }
+    toString() {
+        return `Field("${this.name}", ${this.dtype})`;
+    }
+    toJSON() {
+        return {
+            name: this.name,
+            dtype: this.dtype,
+        };
+    }
+    [Symbol.for("nodejs.util.inspect.custom")]() {
+        return this.toJSON();
+    }
+}
+exports.Field = Field;
+(function (Field) {
+    function from(nameOrObj, dtype) {
+        if (typeof nameOrObj === "string" && dtype) {
+            return new Field(nameOrObj, dtype);
+        }
+        if (Array.isArray(nameOrObj)) {
+            return new Field(nameOrObj[0], nameOrObj[1]);
+        }
+        return new Field(nameOrObj.name, nameOrObj.dtype);
+    }
+    Field.from = from;
+})(Field || (exports.Field = Field = {}));