@the-w1zard/dx 1.0.11 → 1.0.13

package/dist/index.js

@@ -861,7 +861,7 @@ function date_wrap_native_super(Class) {
     return date_wrap_native_super(Class);
 }
 var DATE_TAG = 0x4432; // "D2"
-var D2_CODEC = {
+var D2_CODEC = (/* unused pure expression or super */ null && ({
     tag: DATE_TAG,
     test: function test(v) {
         return date_instanceof1(v, Date);
@@ -872,7 +872,7 @@ var D2_CODEC = {
     dec: function dec(ms) {
         return new date_D2I(ms);
     }
-};
+}));
 var FORMAT = {
     full: {
         weekday: "short",
@@ -14166,4 +14166,5 @@ globalThis.WS2 = weak_set_WS2I;
 
 
 
-export { D2_CODEC, DATE_TAG, RECC2, array_A2I as A2I, boolean_byte_B2BI as B2BI, date_D2I as D2I, date_R2I as R2I, date_R2II as R2II, error_ER2I as ER2I, iterator_I2I as I2I, map_M2I as M2I, map_byte_M2BI as M2BI, map_rv as rv, map_sameValue as sameValue, number_N2I as N2I, object_O2I as O2I, promise_P2I as P2I, reg_ex_REC2 as REC2, set_SET2I as SET2I, set_byte_SET2BI as SET2BI, soa_codec_SOA_CODEC as SOA_CODEC, string_S2I as S2I, unit8array_U82I as U82I, url_search_params_USP2I as USP2I, weak_map_WM2I as WM2I, weak_set_WS2I as WS2I };
+
+export { RECC2 as RECC, array_A2I as A2, boolean_byte_B2BI as B2B, date_D2I as D2, date_R2I as R2, date_R2II as R2I, error_ER2I as ER2, iterator_I2I as I2, map_M2I as M2, map_byte_M2BI as M2B, number_N2I as N2, object_O2I as O2, promise_P2I as P2, reg_ex_REC2 as REC, set_SET2I as SET2, set_byte_SET2BI as SET2B, soa_codec_SOA_CODEC as SOA_CODEC, string_S2I as S2, unit8array_U82I as U82, url_search_params_USP2I as USP2, weak_map_WM2I as WM2, weak_set_WS2I as WS2 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@the-w1zard/dx",
-	"version": "1.0.11",
+	"version": "1.0.13",
 	"sideEffects": false,
 	"type": "module",
 	"main": "./dist/index.js",
@@ -12,7 +12,7 @@
 	},
 	"files": [
 		"dist",
-		"./src/dx.d.ts"
+		"src"
 	],
 	"scripts": {
 		"1": "git add .",

package/src/array.ts

@@ -0,0 +1,301 @@
+
+
+export class A2I<T = A> extends Array<T> implements A2<T> {
+    constructor(...items: T[]) {
+        super(...items);
+        Object.setPrototypeOf(this, new.target.prototype);
+    }
+
+    static get [Symbol.species](): ArrayConstructor {
+        return Array;
+    }
+
+    static from<T>(arrayLike: ArrayLike<T> | Iterable<T>): A2<T> {
+        return new A2I<T>(...Array.from(arrayLike));
+    }
+
+    static of<T>(...items: T[]): A2<T> {
+        return new A2I<T>(...items);
+    }
+
+    first(): T | UD {
+        return this[0];
+    }
+
+    last(): T | UD {
+        return this[this.length - 1];
+    }
+
+    isEmpty(): B {
+        return this.length === 0;
+    }
+
+    isNotEmpty(): B {
+        return this.length !== 0;
+    }
+
+    clear(): this {
+        this.length = 0;
+        return this;
+    }
+
+    clone(): A2<T> {
+        return new A2I<T>(...this);
+    }
+
+    unique(): A2<T> {
+        return new A2I<T>(...new Set(this));
+    }
+
+    compact(): A2<NonNullable<T>> {
+        return new A2<NonNullable<T>>(
+            ...this.filter((value): value is NonNullable<T> => value != null)
+        );
+    }
+
+    take(count: N): A2<T> {
+        return new A2I<T>(...this.slice(0, Math.max(0, count)));
+    }
+
+    takeLast(count: N): A2<T> {
+        return new A2I<T>(...this.slice(Math.max(0, this.length - Math.max(0, count))));
+    }
+
+    drop(count: N): A2<T> {
+        return new A2I<T>(...this.slice(Math.max(0, count)));
+    }
+
+    dropLast(count: N): A2<T> {
+        return new A2I<T>(...this.slice(0, Math.max(0, this.length - Math.max(0, count))));
+    }
+
+    chunk(size: N): A2<A2<T>> {
+        if (!Number.isInteger(size) || size < 1) {
+            throw new RangeError("Chunk size must be a positive integer.");
+        }
+
+        const result = new A2<A2<T>>();
+
+        for (let i = 0; i < this.length; i += size) {
+            result.push(new A2I<T>(...this.slice(i, i + size)));
+        }
+
+        return result;
+    }
+
+    flatten<X>(depth: N = Infinity): A2<X> {
+        return new A2<X>(...this.flat(depth) as X[]);
+    }
+
+    flatMap<U>(callback: (value: T, index: N, array: this) => U | readonly U[]): A2<U> {
+        return new A2<U>(
+            ...this.flatMap((value, index) => callback(value, index as N, this))
+        );
+    }
+
+    distinctBy<K>(callback: (value: T, index: N) => K): A2<T> {
+        const seen = new Set<K>();
+        const result = new A2I<T>();
+
+        this.forEach((value, index) => {
+            const key = callback(value, index as N);
+
+            if (!seen.has(key)) {
+                seen.add(key);
+                result.push(value);
+            }
+        });
+
+        return result;
+    }
+
+    groupBy<K extends PropertyKey>(callback: (value: T, index: N) => K): Map<K, A2<T>> {
+        const result = new Map<K, A2<T>>();
+
+        this.forEach((value, index) => {
+            const key = callback(value, index as N);
+            let group = result.get(key);
+
+            if (!group) {
+                group = new A2I<T>();
+                result.set(key, group);
+            }
+
+            group.push(value);
+        });
+
+        return result;
+    }
+
+    partition(callback: (value: T, index: N) => B): [A2<T>, A2<T>] {
+        const yes = new A2I<T>();
+        const no = new A2I<T>();
+
+        this.forEach((value, index) => {
+            (callback(value, index as N) ? yes : no).push(value);
+        });
+
+        return [yes, no];
+    }
+
+    insert(index: N, ...items: T[]): this {
+        this.splice(index, 0, ...items);
+        return this;
+    }
+
+    removeAt(index: N): T | UD {
+        const normalized = index < 0 ? this.length + index : index;
+
+        if (normalized < 0 || normalized >= this.length) {
+            return undefined;
+        }
+
+        return this.splice(normalized, 1)[0];
+    }
+
+    remove(value: T): B {
+        const index = this.indexOf(value);
+
+        if (index === -1) {
+            return false;
+        }
+
+        this.splice(index, 1);
+        return true;
+    }
+
+    removeAll(value: T): N {
+        let removed = 0;
+
+        for (let i = this.length - 1; i >= 0; i--) {
+            if (Object.is(this[i], value)) {
+                this.splice(i, 1);
+                removed++;
+            }
+        }
+
+        return removed as N;
+    }
+
+    replaceAt(index: N, value: T): T | UD {
+        const normalized = index < 0 ? this.length + index : index;
+
+        if (normalized < 0 || normalized >= this.length) {
+            return undefined;
+        }
+
+        const previous = this[normalized];
+        this[normalized] = value;
+        return previous;
+    }
+
+    move(from: N, to: N): this {
+        const source = from < 0 ? this.length + from : from;
+        const target = to < 0 ? this.length + to : to;
+
+        if (
+            source < 0 || source >= this.length ||
+            target < 0 || target >= this.length ||
+            source === target
+        ) {
+            return this;
+        }
+
+        const [item] = this.splice(source, 1);
+        this.splice(target, 0, item);
+        return this;
+    }
+
+    swap(first: N, second: N): this {
+        const a = first < 0 ? this.length + first : first;
+        const b = second < 0 ? this.length + second : second;
+
+        if (
+            a < 0 || a >= this.length ||
+            b < 0 || b >= this.length
+        ) {
+            return this;
+        }
+
+        [this[a], this[b]] = [this[b], this[a]];
+        return this;
+    }
+
+    sample(): T | UD {
+        if (this.length === 0) {
+            return undefined;
+        }
+
+        return this[Math.floor(Math.random() * this.length)];
+    }
+
+    shuffle(): this {
+        for (let i = this.length - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [this[i], this[j]] = [this[j], this[i]];
+        }
+
+        return this;
+    }
+
+    countBy(callback: (value: T, index: N) => B): N {
+        let count = 0;
+
+        this.forEach((value, index) => {
+            if (callback(value, index as N)) count++;
+        });
+
+        return count as N;
+    }
+
+    sum(callback?: (value: T, index: N) => N): N {
+        let total = 0;
+
+        this.forEach((value, index) => {
+            total += callback ? callback(value, index as N) : Number(value);
+        });
+
+        return total as N;
+    }
+
+    average(callback?: (value: T, index: N) => N): N {
+        return (this.length === 0 ? NaN : this.sum(callback) / this.length) as N;
+    }
+
+    min(callback?: (value: T, index: N) => N): T | UD {
+        if (this.length === 0) return undefined;
+
+        return this.reduce((best, value, index) => {
+            const current = callback ? callback(value, index as N) : Number(value);
+            const bestValue = callback ? callback(best, this.indexOf(best) as N) : Number(best);
+
+            return current < bestValue ? value : best;
+        });
+    }
+
+    max(callback?: (value: T, index: N) => N): T | UD {
+        if (this.length === 0) return undefined;
+
+        return this.reduce((best, value, index) => {
+            const current = callback ? callback(value, index as N) : Number(value);
+            const bestValue = callback ? callback(best, this.indexOf(best) as N) : Number(best);
+
+            return current > bestValue ? value : best;
+        });
+    }
+
+    equals(array: readonly T[]): B {
+        return this.length === array.length &&
+            this.every((value, index) => Object.is(value, array[index]));
+    }
+
+    includesAll(values: readonly T[]): B {
+        return values.every(value => this.includes(value));
+    }
+
+    intersects(values: readonly T[]): B {
+        return values.some(value => this.includes(value));
+    }
+}
+
+globalThis.A2 = A2I;

package/src/boolean_byte.ts

@@ -0,0 +1,23 @@
+/*  ==========================================================================================================================
+    SITH - PURE BINARY BYTE_BOOL
+    Replaces boolean properties and boolean maps with a zero-allocation, PID-indexed Uint8Array lane.
+    ================================================================================================================    ⇦✦──⇦✦──✦──✦──← 'pew pew' 🧙 [BYTE_BOOL] */
+
+export class B2BI {
+    public readonly flags: Uint8Array;
+    constructor(maxParticles: number = 8192) {
+        this.flags = new Uint8Array(maxParticles);
+    }/** Set a boolean flag for a PID. O(1) time complexity. */
+    public set(pid: number, value: boolean): void { this.flags[pid] = value ? 1 : 0; }
+    public true(pid: number, value: boolean) { this.flags[pid] = 1 }
+    public false(pid: number, value: boolean) { this.flags[pid] = 0 }
+    /** Get the boolean state for a PID. O(1) time complexity. */
+    public get(pid: number): boolean { return this.flags[pid] === 1; }
+    /** Toggle the boolean state for a PID. O(1) time complexity. */
+    public toggle(pid: number): boolean {
+        this.flags[pid] = this.flags[pid] === 1 ? 0 : 1;
+        return this.flags[pid] === 1;
+    }/** Clear all flags instantly without reallocating memory. */
+    public clear(): void { this.flags.fill(0);    }
+}
+globalThis.B2B = B2BI;