@the-w1zard/dx 1.0.13 → 1.0.14

package/dist/string.d.ts

@@ -0,0 +1,39 @@
+export declare class S2I extends String implements S2 {
+    constructor(value?: A);
+    empty(): boolean;
+    notEmpty(): boolean;
+    blank(): boolean;
+    notBlank(): boolean;
+    equals(value: string): boolean;
+    equalsIgnoreCase(value: string): boolean;
+    contains(value: string): boolean;
+    starts(value: string): boolean;
+    ends(value: string): boolean;
+    first(): string;
+    last(): string;
+    reverse(): string;
+    capitalize(): string;
+    uncapitalize(): string;
+    titleCase(): string;
+    camelCase(): string;
+    kebabCase(): string;
+    snakeCase(): string;
+    pascalCase(): string;
+    words(): string[];
+    lines(): string[];
+    chars(): string[];
+    unique(): string;
+    escapeRegExp(): string;
+    stripHtml(): string;
+    stripWhitespace(): string;
+    truncate(length: N, suffix?: string): string;
+    limit(length: N, suffix?: string): string;
+    toNumber(): number;
+    toInt(radix?: N): number;
+    toFloat(): number;
+    toBoolean(): boolean;
+    toArray(): string[];
+    toJSON(): string;
+    isWellFormed(): boolean;
+    toWellFormed(): string;
+}

package/dist/unit8array.d.ts

@@ -0,0 +1,64 @@
+export declare class U82I<T = A> extends Array<T> implements U82<T> {
+    constructor(...items: T[]);
+    static get [Symbol.species](): ArrayConstructor;
+    static from<T>(arrayLike: ArrayLike<T>): U82I<T>;
+    static from<T, U>(arrayLike: ArrayLike<T>, mapFn: (value: T, index: number) => U, thisArg?: A): U82I<U>;
+    static from<T>(iterable: Iterable<T> | ArrayLike<T>): U82I<T>;
+    static of<T>(...items: T[]): U82I<T>;
+    first(): T | undefined;
+    last(): T | undefined;
+    second(): T | undefined;
+    third(): T | undefined;
+    random(): T | undefined;
+    isEmpty(): boolean;
+    isNotEmpty(): boolean;
+    isNotEmptyAndDefined(): boolean;
+    clear(): this;
+    clone(): U82I<T>;
+    unique(): U82I<T>;
+    compact(): U82I<NonNullable<T>>;
+    chunk(size: N): U82I<U82I<T>>;
+    flatten<D extends N = 1>(depth?: D): U82I<A>;
+    shuffle(): this;
+    sample(count?: N): U82I<T>;
+    count(predicate?: (value: T, index: N, array: T[]) => unknown): N;
+    sum(this: U82I<number>): number;
+    average(this: U82I<number>): number;
+    min(this: U82I<number>): number | undefined;
+    max(this: U82I<number>): number | undefined;
+    groupBy<K extends PropertyKey>(keyFn: (value: T, index: N) => K): Map<K, U82I<T>>;
+    keyBy<K extends PropertyKey>(keyFn: (value: T, index: N) => K): Map<K, T>;
+    partition(predicate: (value: T, index: N, array: T[]) => unknown): [U82I<T>, U82I<T>];
+    difference(other: Iterable<T>): U82I<T>;
+    intersection(other: Iterable<T>): U82I<T>;
+    union(other: Iterable<T>): U82I<T>;
+    symmetricDifference(other: Iterable<T>): U82I<T>;
+    take(count: N): U82I<T>;
+    takeLast(count: N): U82I<T>;
+    drop(count: N): U82I<T>;
+    dropLast(count: N): U82I<T>;
+    pluck<K extends keyof T>(key: K): U82I<T[K]>;
+    flattenDeep(): U82I<A>;
+    insert(index: N, ...items: T[]): this;
+    removeAt(index: N): T | undefined;
+    remove(value: T): boolean;
+    removeWhere(predicate: (value: T, index: N, array: T[]) => unknown): this;
+    replace(oldValue: T, newValue: T): boolean;
+    move(from: N, to: N): this;
+    swap(i: N, j: N): this;
+    shuffleInPlace(): this;
+    pick(count?: N): U82I<T>;
+    toSet(): Set<T>;
+    toMap<K extends PropertyKey>(keyFn: (value: T, index: N) => K): Map<K, T>;
+    equals(other: readonly T[]): boolean;
+    startsWith(other: readonly T[]): boolean;
+    endsWith(other: readonly T[]): boolean;
+    isSorted(compareFn?: (a: T, b: T) => N): boolean;
+    frequencies(): Map<T, N>;
+    findLast<S extends T>(predicate: (value: T, index: N, obj: T[]) => value is S, thisArg?: A): S | undefined;
+    findLastIndex(predicate: (value: T, index: N, obj: T[]) => unknown, thisArg?: A): N;
+    toReversed(): T[];
+    toSorted(compareFn?: (a: T, b: T) => N): T[];
+    toSpliced(start: N, deleteCount: N, ...items: T[]): T[];
+    with(index: N, value: T): T[];
+}

package/dist/url_search_params.d.ts

@@ -0,0 +1,30 @@
+export declare class USP2I extends URLSearchParams implements USP2 {
+    constructor(init?: S | URLSearchParams | R<S, S> | S[][]);
+    get size(): N;
+    getOr(name: S, fallback: S): S;
+    getOrNull(name: S): S | NU;
+    getOrThrow(name: S, error?: A): string;
+    getNumber(name: S, fallback?: N): N | UD;
+    getInt(name: S, radix?: N): N | UD;
+    getFloat(name: S): N | UD;
+    getBoolean(name: S, fallback?: boolean): B;
+    getJSON<T = A>(name: S): T | UD;
+    getArray(name: S, separator?: string): S[];
+    getObject<T extends R<S, A> = R<S, A>>(): T;
+    setNumber(name: S, value: N): this;
+    setBoolean(name: S, value: B): this;
+    setJSON(name: S, value: A): this;
+    setArray(name: S, values: Iterable<A>, separator?: string): this;
+    setIfAbsent(name: S, value: S): this;
+    setIfPresent(name: S, value: S): this;
+    appendAll(params: URLSearchParams | R<S, A>): this;
+    merge(params: URLSearchParams | R<S, A>, overwrite?: boolean): this;
+    clone(): USP2I;
+    clear(): V;
+    isEmpty(): B;
+    isNotEmpty(): B;
+    toObject(): R<S, S | S[]>;
+    toJSON(): R<S, S | S[]>;
+    toURLSearchParams(): URLSearchParams;
+    toURL(url: S | URL): URL;
+}

package/dist/weak_map.d.ts

@@ -0,0 +1,32 @@
+export declare class WM2I<H extends WeakKey = A, T = A> extends WeakMap<H, T> implements WM2<H, T> {
+    g: (key: H) => T | undefined;
+    h: (key: H) => boolean;
+    d: (key: H) => boolean;
+    private _tracked?;
+    s(k: H, v: T | (() => T)): this;
+    swap(key: H, value: T): T | UD;
+    take(key: H): T | UD;
+    getAndDelete(key: H): T | UD;
+    peek(key: H): T | false;
+    getOrI(key: H, value: T): T;
+    getOrM(key: H, make: () => T): T;
+    getOr<G>(key: H, fallback: G): T | G;
+    getOrThrow(key: H, error?: Error): T;
+    getOrCreate(key: H, make: () => T): T;
+    ensure(key: H, make: () => T): T;
+    update(key: H, fn: (old: T, has: B) => T, initial: T): T;
+    setIfAbsent(key: H, value: T): B;
+    setIfPresent(key: H, value: T): B;
+    hasOrSet(key: H, value: T): B;
+    replace(key: H, value: T): B;
+    touch(key: H): B;
+    get tracked(): B;
+    get trackedSize(): N;
+    track(key: H): this;
+    untrack(key: H): B;
+    trackedKeys(): AR<H>;
+    trackedValues(): AR<T>;
+    trackedEntries(): AR<[H, T]>;
+    forEachTracked(fn: (value: T, key: H, map: this) => void): void;
+    clearTracked(): void;
+}

package/dist/weak_set.d.ts

@@ -0,0 +1,20 @@
+export declare class WS2I<T extends WeakKey = A> extends WeakSet<T> implements WS2<T> {
+    private readonly _tracked;
+    constructor(values?: readonly T[] | Iterable<T> | null);
+    add(value: T): this;
+    delete(value: T): boolean;
+    has(value: T): boolean;
+    addIfAbsent(value: T): boolean;
+    toggle(value: T): boolean;
+    deleteIfPresent(value: T): boolean;
+    hasAll(values: Iterable<T>): boolean;
+    hasAny(values: Iterable<T>): boolean;
+    addAll(values: Iterable<T>): this;
+    deleteAll(values: Iterable<T>): N;
+    replace(oldValue: T, newValue: T): boolean;
+    track(value: T): this;
+    untrack(value: T): boolean;
+    trackedKeys(): T[];
+    forEachTracked(callback: (value: T, set: this) => void, thisArg?: A): void;
+    clearTracked(): void;
+}

package/package.json

@@ -1,13 +1,15 @@
 {
 	"name": "@the-w1zard/dx",
-	"version": "1.0.13",
+	"version": "1.0.14",
 	"sideEffects": false,
 	"type": "module",
 	"main": "./dist/index.js",
+	"types": "./dist/index.d.ts",
 	"exports": {
 		".": {
+			"types": "./dist/index.d.ts",
 			"default": "./dist/index.js",
-			"types": "./src/dx.d.ts"
+			"import": "./dist/index.js"
 		}
 	},
 	"files": [
@@ -21,7 +23,7 @@
 		"4": "npm version patch",
 		"5": "git push --tags",
 		"6": "npm publish --access public",
-		"build": "rspack build",
+		"build": "tsc --emitDeclarationOnly && rspack build",
 		"dev": "rspack serve",
 		"check": "tsc --noEmit",
 		"*": "npm run 1 && npm run 2 && npm run 3 && npm run 4 && npm run 5 && npm run 6 && npm run *"
@@ -30,15 +32,15 @@
 		"@rspack/cli": "^2.3.1",
 		"@rspack/core": "^2.3.1",
 		"@rspack/dev-server": "^2.2.2",
+		"@the-w1zard/alias_types": "^1.0.3",
 		"@tsconfig/node-lts": "^24.0.0",
 		"@types/node": "^24.0.0",
-		"typescript": "^6.0.0",
-		"jsrepo": "^3.8.3"
+		"jsrepo": "^3.8.3",
+		"typescript": "^6.0.0"
 	},
 	"dependencies": {
 		"@babel/parser": "^8.1.0",
 		"@babel/traverse": "^8.1.0",
-		"@babel/types": "^8.1.0",
-		"@the-w1zard/alias_types": "^1.0.2"
+		"@babel/types": "^8.1.0"
 	}
 }

package/src/dx.d.ts

@@ -4,21 +4,25 @@ import { M2BINI } from "./map_bin";
 import { B2BI } from "./boolean_byte";
 import { M2I } from "./map";
 import { M2BI } from "./map_byte";
-import { SET2I } from "./set";
-import { SET2BI } from "./set_byte";
-import { D2I, R2I, R2II } from "./date";
+
 import { A2I } from "./array";
-import { O2I } from "./object";
-import { WM2I } from "./weak_map";
+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 { WS2I } from "./weak_set";
 import { USP2I } from "./url_search_params";
-import { ER2I } from "./error";
-import {MaybePromise} from '../bag_of_tricks/maybe_promise'
+
+import { WM2I } from "./weak_map";
+import { WS2I } from "./weak_set";
+import { MaybePromisei, type MaybePromise } from './index'
 export {};
 
 
@@ -31,7 +35,7 @@ declare global {
      it.
 	================================================================================== ⇦✦──⇦✦──✦──✦──← 'pew pew' 🧙 [UX/DX] */
 	type MaybePromise<R = any> = R;
-	var MaybePromise: MaybePromise;
+	var MaybePromise: MaybePromisei;
 	var B2B: typeof B2BI; // BOOLEAN BINARY
 
 	var M2: typeof M2I; // map
@@ -43,6 +47,9 @@ declare global {
 	var SET2: typeof SET2I; // set
 	var SET2B: typeof SET2BI; // set
 
+	var RES2: typeof RECC2; // reg ex static
+	var RE2: typeof REC2; // reg ex
+	var ER2: typeof ER2I; // error
 	var D2: typeof D2I; // Date
 	var A2: typeof A2I; // Array
 	var O2: typeof O2I; // Object
@@ -52,17 +59,30 @@ declare global {
 	var S2: typeof S2I; // String
 	var N2: typeof N2I; // Number
 	var USP2: typeof USP2I; // URLSearchParams
-	var ER2: typeof ER2I; // Error
 	var U82: typeof U82I; // Uint8Array
 	var I2: typeof I2I; // Iterator
 	var R2: typeof R2I;
     var R2FN: typeof R2II;
+    var soa_codec: typeof soa_codeci;
+	interface soa_codec {
+		readonly maxPids: number;
+		readonly channelMap: Int32Array;
+		readonly subChannelMap: Int32Array;
+		readonly tripChannelMap: Int32Array;
+		readonly keyMap: Int32Array;
+		readonly listeners: Array<((pid: number, val?: number) => void) | undefined>;
+		nextPid: number;
+	  
+		allocatePid(rId: number, mId: number, sId: number, kId: number): number;
+	  }
+	interface soa_codeci extends soa_codec {}
+
 	//                                                                                                 [MAP]
 	// #region ══════════════════════════════════════════════════════════════════════════════════════════════════════ 
 	type M2Op = "set" | "del" | "upd" | "dirty";
 	interface M2Event<H = A, T = A> {
 		op: M2Op;
-		pid: H;
+		pid?: H;
 		k: H;
 		v?: T;
 		prev?: T;

package/src/index.ts

@@ -1,25 +1,36 @@
+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 { B2BI } from './boolean_byte'
 import { D2I,  R2I, R2II } from './date'
 import { ER2I } from './error'
 import { I2I } from './iterator'
-import { M2BI } from './map_byte'
-import { M2I } from './map'
 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 } from './soa_codec'
+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 function MaybePromisei<R = any>(v: R): MaybePromise {
+    return v !== undefined ? v as R : Promise.resolve(v) as Promise<R> 
+}
 
+globalThis.MaybePromise = MaybePromisei;
 
 export {
+    M2RI as M2R,
+    M2DI as M2D, 
+    M2BINI as M2BIN, 
     A2I as A2,
     B2BI as B2B,
     D2I as D2,
@@ -30,16 +41,17 @@ export {
     N2I as N2,
     O2I as O2,
     P2I as P2,
-    REC2 as REC,
+    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,
-    RECC2 as RECC,
     R2I as R2,
     R2II as R2I 
 }

package/src/map_bin.ts

@@ -95,7 +95,7 @@ export class M2BINI<K = N, V = N> {
         return this.entries();
     }
 
-    forEach(fn: (v: V, k: K, m: Map<K, V>) => void, thisArg?: unknown): void {
+    forEach(fn: (v: V, k: K, m: M2BINI<K, V>) => V, thisArg?: unknown): void {
         for (let i = 0; i < this.#size; i++) fn.call(thisArg, this.#vals[i] as V, this.#slotToPid[i] as K, this);
         this.#odd?.forEach((v, k) => fn.call(thisArg, v, k as K, this));
     }

package/src/map_dense.ts

@@ -48,7 +48,7 @@ export class M2DI<Key=A, V = number> {
             this.#vals[k] = v;
             return this;
         }
-        (this.#odd ??= new Map()).set(k as Key, v);
+        (this.#odd ??= new M2<Key, V>()).set(k as Key, v);
         return this;
     }
     delete(k: number): B {
@@ -61,7 +61,7 @@ export class M2DI<Key=A, V = number> {
         }
         return this.#odd !== null && this.#odd.delete(k as Key);
     }
-    clear(): V {
+    clear() {
         this.#live.fill(0);
         this.#size = 0;
         this.#odd?.clear();
@@ -101,7 +101,7 @@ export class M2DI<Key=A, V = number> {
     [Symbol.iterator](): MapIterator<[N, V]> {
         return this.entries();
     }
-    forEach(fn: (v: V, k: N, m: M<N, V>) => V, thisArg?: U): V {
+    forEach(fn: (v: V, k: N, m: M<N, V>) => V, thisArg?: U) {
         const l = this.#live;
         for (let k = 0; k < l.length; k++) if (l[k] === 1) fn.call(thisArg, this.#vals[k] as V, k, this as U as Map<N, V>);
         this.#odd?.forEach((v, k) => fn.call(thisArg, v, k as N, this as U as Map<N, V>));
@@ -138,7 +138,7 @@ export class M2DI<Key=A, V = number> {
         return this.#live[pid] === 1;
     }
     /** walk live pids without allocating an iterator */
-    forEachRaw(fn: (pid: N, value: N) => V): V {
+    forEachRaw(fn: (pid: N, value: N) => V) {
         const l = this.#live;
         for (let k = 0; k < l.length; k++) if (l[k] === 1) fn(k, this.#vals[k]);
     }
@@ -150,7 +150,7 @@ export class M2DI<Key=A, V = number> {
         }
         return out;
     }
-    #grow(need: N): V {
+    #grow(need: N) {
         let cap = this.#live.length;
         while (cap <= need) cap *= 2;
         const v = new Float64Array(cap);

package/src/map_rows.ts

@@ -100,7 +100,7 @@ export class M2RI<K = N> {
     [Symbol.iterator](): MapIterator<[K, F64]> {
         return this.entries();
     }
-    forEach(fn: (v: F64, k: K, m: Map<K, F64>) => V, thisArg?: U): V {
+    forEach(fn: (v: F64, k: K, m: M2RI<K>) => V, thisArg?: U): V {
         for (const [k, v] of this.entries()) fn.call(thisArg, v, k, this);
     }
     forEachRaw(fn: (pid: N, slot: N) => V): V {

package/src/reg_ex.ts

@@ -415,8 +415,8 @@ export const RECC2: RE2Static = Object.assign(
 	},
 );
 
-(globalThis as A).REC2 = REC2;
-(globalThis as A).RE2 = RECC2;
+(globalThis as A).RE2 = REC2;
+(globalThis as A).RES2 = RECC2;
 
 /*  ====================================================================================================
     

package/src/soa_codec.ts

@@ -7,7 +7,7 @@ export class SOA_CODEC {// HIGH_PERFORMANCE_SOA_CODEC
 	public readonly keyMap: Int32Array;
 	public readonly listeners: Array<((pid: number, val?: number) => void) | undefined>;
 	public nextPid = 1;
-	constructor( maxPids = 8192) {
+	constructor( maxPids = 8192 * 2) {
 		this.maxPids = maxPids;
 		this.channelMap = new Int32Array(maxPids);
 		this.subChannelMap = new Int32Array(maxPids);
@@ -25,3 +25,6 @@ export class SOA_CODEC {// HIGH_PERFORMANCE_SOA_CODEC
 		return pid;
 	}
 }
+
+export const soa_codeci = new SOA_CODEC()
+globalThis.soa_codec = soa_codeci