@the-w1zard/dx 1.0.12 → 1.0.14

package/dist/array.d.ts

@@ -0,0 +1,41 @@
+export declare class A2I<T = A> extends Array<T> implements A2<T> {
+    constructor(...items: T[]);
+    static get [Symbol.species](): ArrayConstructor;
+    static from<T>(arrayLike: ArrayLike<T> | Iterable<T>): A2<T>;
+    static of<T>(...items: T[]): A2<T>;
+    first(): T | UD;
+    last(): T | UD;
+    isEmpty(): B;
+    isNotEmpty(): B;
+    clear(): this;
+    clone(): A2<T>;
+    unique(): A2<T>;
+    compact(): A2<NonNullable<T>>;
+    take(count: N): A2<T>;
+    takeLast(count: N): A2<T>;
+    drop(count: N): A2<T>;
+    dropLast(count: N): A2<T>;
+    chunk(size: N): A2<A2<T>>;
+    flatten<X>(depth?: N): A2<X>;
+    flatMap<U>(callback: (value: T, index: N, array: this) => U | readonly U[]): A2<U>;
+    distinctBy<K>(callback: (value: T, index: N) => K): A2<T>;
+    groupBy<K extends PropertyKey>(callback: (value: T, index: N) => K): Map<K, A2<T>>;
+    partition(callback: (value: T, index: N) => B): [A2<T>, A2<T>];
+    insert(index: N, ...items: T[]): this;
+    removeAt(index: N): T | UD;
+    remove(value: T): B;
+    removeAll(value: T): N;
+    replaceAt(index: N, value: T): T | UD;
+    move(from: N, to: N): this;
+    swap(first: N, second: N): this;
+    sample(): T | UD;
+    shuffle(): this;
+    countBy(callback: (value: T, index: N) => B): N;
+    sum(callback?: (value: T, index: N) => N): N;
+    average(callback?: (value: T, index: N) => N): N;
+    min(callback?: (value: T, index: N) => N): T | UD;
+    max(callback?: (value: T, index: N) => N): T | UD;
+    equals(array: readonly T[]): B;
+    includesAll(values: readonly T[]): B;
+    intersects(values: readonly T[]): B;
+}

package/dist/boolean_byte.d.ts

@@ -0,0 +1,12 @@
+export declare class B2BI {
+    readonly flags: Uint8Array;
+    constructor(maxParticles?: number); /** Set a boolean flag for a PID. O(1) time complexity. */
+    set(pid: number, value: boolean): void;
+    true(pid: number, value: boolean): void;
+    false(pid: number, value: boolean): void;
+    /** Get the boolean state for a PID. O(1) time complexity. */
+    get(pid: number): boolean;
+    /** Toggle the boolean state for a PID. O(1) time complexity. */
+    toggle(pid: number): boolean; /** Clear all flags instantly without reallocating memory. */
+    clear(): void;
+}

package/dist/date.d.ts

@@ -0,0 +1,146 @@
+export declare const DATE_TAG = 17458;
+export declare const D2_CODEC: {
+    tag: number;
+    test(v: A): v is D2;
+    enc(d: D): N;
+    dec(ms: N): D2;
+};
+export declare class D2I extends Date implements D2 {
+    constructor(value?: S | N | D);
+    toLocalString(format?: A): S;
+    static now(): N;
+    static fromUnix(seconds: N): D2;
+    static fromUnixMs(ms: N): D2;
+    static fromParts(year: N, month: N, day: N, hour?: number, minute?: number, second?: number, ms?: number): D2;
+    static today(): D2;
+    static min(...dates: D[]): D2;
+    static max(...dates: D[]): D2;
+    clone(): D2;
+    isValid(): B;
+    month(): N;
+    dateOfWeek(): N;
+    dayOfYear(): N;
+    quarter(): N;
+    unix(): N;
+    addMs(amount: N): D2;
+    addSeconds(amount: N): D2;
+    addMinutes(amount: N): D2;
+    addHours(amount: N): D2;
+    addDays(amount: N): D2;
+    addWeeks(amount: N): D2;
+    addMonths(amount: N): D2;
+    addYears(amount: N): D2;
+    subDays(amount: N): D2;
+    subMonths(amount: N): D2;
+    subYears(amount: N): D2;
+    startOfDay(): D2;
+    endOfDay(): D2;
+    startOfWeek(weekStartsOn?: number): D2;
+    endOfWeek(weekStartsOn?: number): D2;
+    startOfMonth(): D2;
+    endOfMonth(): D2;
+    startOfQuarter(): D2;
+    endOfQuarter(): D2;
+    startOfYear(): D2;
+    endOfYear(): D2;
+    daysInMonth(): N;
+    daysInYear(): N;
+    isLeapYear(): B;
+    isWeekend(): B;
+    isWeekday(): B;
+    isBefore(other: D): B;
+    isAfter(other: D): B;
+    isEqual(other: D): B;
+    isBetween(start: D, end: D): B;
+    diffMs(other: D): N;
+    diffSeconds(other: D): N;
+    diffMinutes(other: D): N;
+    diffHours(other: D): N;
+    diffDays(other: D): N;
+    sameDay(other: D): B;
+    sameMonth(other: D): B;
+    sameYear(other: D): B;
+    toUnixMs(): N;
+    toUnix(): N;
+    toD2(): D2;
+    ago(): S;
+    fromNow(): S;
+    from(other: D): S;
+    static from(v: A): D2;
+    toInputDate(): S;
+    toInputTime(): S;
+    toInputDateTime(): S;
+    toInputTimeWithSeconds(): S;
+    next(unit: DAYSD2): D2;
+    prev(unit: Parameters<D2["next"]>[0]): D2;
+    nextWeek(): D2;
+    prevWeek(): D2;
+    nextMonth(): D2;
+    prevMonth(): D2;
+    nextQuarter(): D2;
+    prevQuarter(): D2;
+    nextYear(): D2;
+    prevYear(): D2;
+    subWeeks(n: N): D2;
+    at(hour: N, minute?: number, second?: number, ms?: number): D2;
+    atNoon(): D2;
+    midnight(): D2;
+    addBusinessDays(n: N): D2;
+    nextBusinessDay(): D2;
+    prevBusinessDay(): D2;
+    isBusinessDay(): B;
+    calendarDays(other: D): N;
+    businessDays(other: D): N;
+    diffHuman(other?: D): S;
+    fmt(format: S): S;
+    static parseDate(v: S): D2;
+    static parseDateTime(v: S): D2;
+    set(f: Partial<{
+        year: N;
+        month: N;
+        day: N;
+        hour: N;
+        minute: N;
+        second: N;
+        ms: N;
+    }>): D2;
+    withDate(year: N, month: N, day: N): D2;
+    sameTimeOn(other: D): D2;
+    to(other: D): R2;
+    isSameOrBefore(other: D): B;
+    isSameOrAfter(other: D): B;
+    clamp(min: D, max: D): D2;
+    isSame(unit: "day" | "week" | "month" | "quarter" | "year", other: D): B;
+    isToday(): B;
+    isTomorrow(): B;
+    isYesterday(): B;
+    age(unit?: "years" | "months" | "days"): N;
+}
+export declare class R2I implements R2 {
+    start: D2;
+    end: D2;
+    constructor(start: D2, end: D2);
+    contains(d: D): B;
+    overlaps(other: R2): B;
+    durationMs(): N;
+    days(): N;
+    eachDay(fn: (d: D2, i: N) => void): void;
+    toArray(): A2I<D2>;
+}
+export declare const R2II: (start: D, end: D) => R2;
+/**
+ *     enc(value:A) {
+if (D2_CODEC.test(value)) {
+    writeTag(DATE_TAG);
+    writeI64(value.getTime());
+    return;
+}
+
+// existing object / array / string / map handling
+}
+dec(value:A) {
+if (tag === DATE_TAG) { return new D2(readI64()); }
+
+// existing revival paths
+}
+ */

package/dist/error.d.ts

@@ -0,0 +1,16 @@
+export declare class ER2I extends Error implements ER2 {
+    constructor(message?: string, options?: ErrorOptions);
+    clone(): ER2I;
+    toJSON(): {
+        name: string;
+        message: string;
+        stack?: string;
+        cause?: unknown;
+    };
+    toString(): string;
+    static is(value: unknown): value is Error;
+    static isER2(value: unknown): value is ER2I;
+    static from(value: unknown, fallback?: string): ER2I;
+    static wrap(value: unknown, message?: string): ER2I;
+    static aggregate(errors: Iterable<unknown>, message?: string): AggregateError;
+}

package/dist/index.d.ts

@@ -0,0 +1,25 @@
+import { M2RI } from "./map_rows";
+import { M2DI } from "./map_dense";
+import { M2BINI } from "./map_bin";
+import { B2BI } from "./boolean_byte";
+import { M2I } from "./map";
+import { M2BI } from "./map_byte";
+import { A2I } from './array';
+import { D2I, R2I, R2II } from './date';
+import { ER2I } from './error';
+import { I2I } from './iterator';
+import { N2I } from './number';
+import { O2I } from './object';
+import { P2I } from './promise';
+import { REC2, RECC2 } from './reg_ex';
+import { SET2I } from './set';
+import { SET2BI } from './set_byte';
+import { SOA_CODEC, soa_codeci } from './soa_codec';
+import { S2I } from './string';
+import { U82I } from './unit8array';
+import { USP2I } from './url_search_params';
+import { WM2I } from './weak_map';
+import { WS2I } from './weak_set';
+export type MaybePromise<R = any> = R;
+export declare function MaybePromisei<R = any>(v: R): MaybePromise;
+export { M2RI as M2R, M2DI as M2D, M2BINI as M2BIN, A2I as A2, B2BI as B2B, D2I as D2, ER2I as ER2, I2I as I2, M2BI as M2B, M2I as M2, N2I as N2, O2I as O2, P2I as P2, REC2 as RE2, RECC2 as RES2, SET2I as SET2, SET2BI as SET2B, SOA_CODEC, soa_codeci as soa_codec, S2I as S2, U82I as U82, USP2I as USP2, WM2I as WM2, WS2I as WS2, R2I as R2, R2II as R2I };