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

package/bin/datatypes/datatype.js

@@ -0,0 +1,430 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TimeUnit = exports.Struct = exports.FixedSizeList = exports.List = exports.Duration = 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 {
+    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);
+    }
+    static Duration(timeUnit) {
+        return new Duration(timeUnit);
+    }
+    /**
+     * 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 {
+    variant = "Null";
+}
+exports.Null = Null;
+class Bool extends DataType {
+    variant = "Bool";
+}
+exports.Bool = Bool;
+class Int8 extends DataType {
+    variant = "Int8";
+}
+exports.Int8 = Int8;
+class Int16 extends DataType {
+    variant = "Int16";
+}
+exports.Int16 = Int16;
+class Int32 extends DataType {
+    variant = "Int32";
+}
+exports.Int32 = Int32;
+class Int64 extends DataType {
+    variant = "Int64";
+}
+exports.Int64 = Int64;
+class UInt8 extends DataType {
+    variant = "UInt8";
+}
+exports.UInt8 = UInt8;
+class UInt16 extends DataType {
+    variant = "UInt16";
+}
+exports.UInt16 = UInt16;
+class UInt32 extends DataType {
+    variant = "UInt32";
+}
+exports.UInt32 = UInt32;
+class UInt64 extends DataType {
+    variant = "UInt64";
+}
+exports.UInt64 = UInt64;
+class Float32 extends DataType {
+    variant = "Float32";
+}
+exports.Float32 = Float32;
+class Float64 extends DataType {
+    variant = "Float64";
+}
+exports.Float64 = Float64;
+// biome-ignore lint/suspicious/noShadowRestrictedNames: Using Polars Date
+class Date extends DataType {
+    variant = "Date";
+}
+exports.Date = Date;
+class Time extends DataType {
+    variant = "Time";
+}
+exports.Time = Time;
+class Object_ extends DataType {
+    variant = "Object";
+}
+exports.Object_ = Object_;
+class Utf8 extends DataType {
+    variant = "Utf8";
+}
+exports.Utf8 = Utf8;
+// biome-ignore lint/suspicious/noShadowRestrictedNames: Using Polars String
+class String extends DataType {
+    variant = "String";
+}
+exports.String = String;
+class Categorical extends DataType {
+    variant = "Categorical";
+}
+exports.Categorical = Categorical;
+class Decimal extends DataType {
+    variant = "Decimal";
+    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;
+    variant = "Datetime";
+    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 Duration extends DataType {
+    timeUnit;
+    variant = "Duration";
+    constructor(timeUnit = "ms") {
+        super();
+        this.timeUnit = timeUnit;
+    }
+    get inner() {
+        return [this.timeUnit];
+    }
+    equals(other) {
+        if (other.variant === this.variant) {
+            return this.timeUnit === other.timeUnit;
+        }
+        return false;
+    }
+}
+exports.Duration = Duration;
+class List extends DataType {
+    __inner;
+    variant = "List";
+    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;
+    variant = "FixedSizeList";
+    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 {
+    variant = "Struct";
+    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") {
+            const member = DataType[dtype];
+            // if it's a factory function, call it with no args (use defaults),
+            // otherwise return the already-instantiated value
+            return typeof member === "function" ? member() : member;
+        }
+        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 = {}));

package/bin/datatypes/index.d.ts

@@ -0,0 +1,43 @@
+export * from "./conversion";
+export * from "./datatype";
+export { Field } from "./field";
+import { type DataType } from "./datatype";
+/** @ignore */
+export type TypedArray = Int8Array | Int16Array | Int32Array | BigInt64Array | Uint8Array | Uint16Array | Uint32Array | BigInt64Array | Float32Array | Float64Array;
+/**
+ *  @ignore
+ */
+export type Optional<T> = T | undefined | null;
+/**
+ * @ignore
+ */
+export type JsDataFrame = any;
+export type NullValues = string | Array<string> | Record<string, string>;
+/**
+ * @ignore
+ */
+export declare const DTYPE_TO_FFINAME: {
+    Int8: string;
+    Int16: string;
+    Int32: string;
+    Int64: string;
+    UInt8: string;
+    UInt16: string;
+    UInt32: string;
+    UInt64: string;
+    Float32: string;
+    Float64: string;
+    Bool: string;
+    Utf8: string;
+    String: string;
+    List: string;
+    Date: string;
+    Datetime: string;
+    Duration: string;
+    Time: string;
+    Object: string;
+    Categorical: string;
+    Struct: string;
+};
+/** @ignore */
+export declare const polarsTypeToConstructor: (dtype: DataType) => CallableFunction;

package/bin/datatypes/index.js

@@ -0,0 +1,120 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.polarsTypeToConstructor = exports.DTYPE_TO_FFINAME = exports.Field = void 0;
+__exportStar(require("./conversion"), exports);
+__exportStar(require("./datatype"), exports);
+var field_1 = require("./field");
+Object.defineProperty(exports, "Field", { enumerable: true, get: function () { return field_1.Field; } });
+const polars_internal_1 = __importDefault(require("../internals/polars_internal"));
+const datatype_1 = require("./datatype");
+/**
+ * @ignore
+ */
+exports.DTYPE_TO_FFINAME = {
+    Int8: "I8",
+    Int16: "I16",
+    Int32: "I32",
+    Int64: "I64",
+    UInt8: "U8",
+    UInt16: "U16",
+    UInt32: "U32",
+    UInt64: "U64",
+    Float32: "F32",
+    Float64: "F64",
+    Bool: "Bool",
+    Utf8: "Str",
+    String: "Str",
+    List: "List",
+    Date: "Date",
+    Datetime: "Datetime",
+    Duration: "Duration",
+    Time: "Time",
+    Object: "Object",
+    Categorical: "Categorical",
+    Struct: "Struct",
+};
+const POLARS_TYPE_TO_CONSTRUCTOR = {
+    Float32(name, values) {
+        return polars_internal_1.default.JsSeries.newOptF64(name, values);
+    },
+    Float64(name, values) {
+        return polars_internal_1.default.JsSeries.newOptF64(name, values);
+    },
+    Int8(name, values) {
+        return polars_internal_1.default.JsSeries.newOptI32(name, values);
+    },
+    Int16(name, values) {
+        return polars_internal_1.default.JsSeries.newOptI32(name, values);
+    },
+    Int32(name, values) {
+        return polars_internal_1.default.JsSeries.newOptI32(name, values);
+    },
+    Int64(name, values) {
+        return polars_internal_1.default.JsSeries.newOptI64(name, values);
+    },
+    UInt8(name, values) {
+        return polars_internal_1.default.JsSeries.newOptU32(name, values);
+    },
+    UInt16(name, values) {
+        return polars_internal_1.default.JsSeries.newOptU32(name, values);
+    },
+    UInt32(name, values) {
+        return polars_internal_1.default.JsSeries.newOptU32(name, values);
+    },
+    UInt64(name, values) {
+        return polars_internal_1.default.JsSeries.newOptU64(name, values);
+    },
+    Date(name, values) {
+        return polars_internal_1.default.JsSeries.newOptI64(name, values);
+    },
+    Datetime(name, values) {
+        return polars_internal_1.default.JsSeries.newOptI64(name, values);
+    },
+    Time(name, values) {
+        return polars_internal_1.default.JsSeries.newAnyValue(name, values, datatype_1.Time);
+    },
+    Bool(name, values) {
+        return polars_internal_1.default.JsSeries.newOptBool(name, values);
+    },
+    Utf8(name, values) {
+        return polars_internal_1.default.JsSeries.newOptStr(name, values);
+    },
+    String(name, values) {
+        return polars_internal_1.default.JsSeries.newOptStr(name, values);
+    },
+    Categorical(name, values) {
+        return polars_internal_1.default.JsSeries.newOptStr(name, values);
+    },
+    List(name, values, dtype) {
+        return polars_internal_1.default.JsSeries.newList(name, values, dtype);
+    },
+    FixedSizeList(name, values, dtype) {
+        return polars_internal_1.default.JsSeries.newList(name, values, dtype);
+    },
+};
+/** @ignore */
+const polarsTypeToConstructor = (dtype) => {
+    const ctor = POLARS_TYPE_TO_CONSTRUCTOR[dtype.variant];
+    if (!ctor) {
+        throw new Error(`Cannot construct Series for type ${dtype.variant}.`);
+    }
+    return ctor;
+};
+exports.polarsTypeToConstructor = polarsTypeToConstructor;

package/bin/error.d.ts

@@ -0,0 +1,7 @@
+export declare class InvalidOperationError extends RangeError {
+    constructor(method: any, dtype: any);
+}
+export declare class NotImplemented extends Error {
+    constructor(method: any, dtype: any);
+}
+export declare const todo: () => Error;

package/bin/error.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.todo = exports.NotImplemented = exports.InvalidOperationError = void 0;
+class InvalidOperationError extends RangeError {
+    constructor(method, dtype) {
+        super(`Invalid operation: ${method} is not supported for ${dtype}`);
+    }
+}
+exports.InvalidOperationError = InvalidOperationError;
+class NotImplemented extends Error {
+    constructor(method, dtype) {
+        super(`Invalid operation: ${method} is not supported for ${dtype}`);
+    }
+}
+exports.NotImplemented = NotImplemented;
+const todo = () => new Error("not yet implemented");
+exports.todo = todo;

package/bin/functions.d.ts

@@ -0,0 +1,26 @@
+import { type DataFrame } from "./dataframe";
+import { type LazyDataFrame } from "./lazy/dataframe";
+import { type Series } from "./series";
+import type { ConcatOptions } from "./types";
+/**
+ * _Repeat a single value n times and collect into a Series._
+ * @param value - Value to repeat.
+ * @param n - Number of repeats
+ * @param name - Optional name of the Series
+ * @example
+ *
+ * ```
+ *
+ * >  const s = pl.repeat("a", 5)
+ * >  s.toArray()
+ * ["a", "a", "a", "a", "a"]
+ *
+ * ```
+ */
+export declare function repeat<V>(value: V, n: number, name?: string): Series;
+export declare function concat(items: Array<DataFrame>, options?: ConcatOptions): DataFrame;
+export declare function concat(items: Array<Series>, options?: {
+    rechunk: boolean;
+    parallel: boolean;
+}): Series;
+export declare function concat(items: Array<LazyDataFrame>, options?: ConcatOptions): LazyDataFrame;