@the-w1zard/dx 1.0.8 → 1.0.9

package/src/map_byte.js

@@ -1,483 +0,0 @@
-var _a;
-const sameValue128 = (a, b) => {
-    if (a === b)
-        return true;
-    if (a instanceof Float64Array && b instanceof Float64Array) {
-        if (a.length !== b.length)
-            return false;
-        for (let i = 0; i < a.length; i++)
-            if (!Object.is(a[i], b[i]))
-                return false;
-        return true;
-    }
-    return Object.is(a, b);
-};
-export class M2BI {
-    cap;
-    stride;
-    pidToSlot;
-    slotToPid;
-    vals;
-    #size = 0;
-    #subs;
-    #hist;
-    #histLimit = 0;
-    #strict = false;
-    #iterating = 0;
-    #batching = 0;
-    #pending;
-    #derived;
-    #dependents;
-    constructor(maxParticles, stride = 1, seed) {
-        this.cap = maxParticles;
-        this.stride = stride;
-        this.pidToSlot = new Int32Array(maxParticles).fill(-1);
-        this.slotToPid = new Int32Array(maxParticles).fill(-1);
-        this.vals = new Float64Array(maxParticles * stride);
-        if (seed)
-            for (const [pid, v] of seed)
-                this.s(v, pid);
-    }
-    get size() { return this.#size; }
-    // ---------------------------------------------------------------- internals
-    #emit(e) {
-        if (this.#batching > 0) {
-            this.#pending ??= new Map();
-            const pending = this.#pending.get(e.pid);
-            this.#pending.set(e.pid, pending ? { ...e, prev: pending.prev, batch: true } : { ...e, batch: true });
-            return;
-        }
-        this.#record(e);
-        this.#subs?.forEach((sub) => { try {
-            sub(e);
-        }
-        catch (err) {
-            process.emitWarning(err);
-        } });
-    }
-    #record(e) {
-        if (!this.#hist)
-            return;
-        this.#hist.push(e);
-        if (this.#hist.length > this.#histLimit)
-            this.#hist.splice(0, this.#hist.length - this.#histLimit);
-    }
-    #invalidate(pid) {
-        const deps = this.#dependents?.get(pid);
-        if (!deps)
-            return;
-        for (const dk of deps) {
-            const d = this.#derived?.get(dk);
-            if (!d || d.dirty)
-                continue;
-            d.dirty = true;
-            this.#emit({ op: "dirty", pid: dk, has: d.has });
-        }
-    }
-    #computeDerived(pid, d) {
-        const vals = d.deps.map((dep) => this.g(dep));
-        const next = d.fn(...vals);
-        const had = d.has;
-        const prev = d.value;
-        d.value = next;
-        d.has = true;
-        d.dirty = false;
-        if (!had || !sameValue128(prev, next)) {
-            this.#emit({ op: had ? "upd" : "set", pid, v: next, prev, has: true });
-        }
-        return next;
-    }
-    #assertNotIterating(op) {
-        if (this.#strict && this.#iterating > 0) {
-            throw new Error(`M2BI.${op}() during iteration. Snapshot keys first, or disable $strict().`);
-        }
-    }
-    #readSlot(slot) {
-        return this.stride === 1 ? this.vals[slot] : this.vals.subarray(slot * this.stride, slot * this.stride + this.stride);
-    }
-    #writeSlot(slot, v) {
-        if (this.stride === 1)
-            this.vals[slot] = v;
-        else
-            this.vals.set(v, slot * this.stride);
-    }
-    #fresh() { return new _a(this.cap, this.stride); } //                     [sibling-store factory]
-    // ---------------------------------------------------------------- subs / batch
-    on(fn) { (this.#subs ??= new Set()).add(fn); return () => this.off(fn); } //      [ON]
-    off(fn) { this.#subs?.delete(fn); } //                                                  [OFF]
-    batch(fn) {
-        this.#batching++;
-        this.#pending ??= new Map();
-        try {
-            fn();
-        }
-        finally {
-            this.#batching--;
-            if (this.#batching === 0) {
-                const events = [...this.#pending.values()];
-                this.#pending = undefined;
-                for (const e of events) {
-                    this.#record(e);
-                    this.#subs?.forEach(sub => sub(e));
-                }
-            }
-        }
-        return this;
-    }
-    // ---------------------------------------------------------------- core CRUD
-    s(v, pid) {
-        this.#assertNotIterating("s");
-        let slot = this.pidToSlot[pid];
-        const has = slot !== -1;
-        const prev = has ? this.#readSlot(slot) : undefined;
-        if (!has) {
-            slot = this.#size;
-            this.pidToSlot[pid] = slot;
-            this.slotToPid[slot] = pid;
-            this.#size++;
-        }
-        this.#writeSlot(slot, v);
-        this.#invalidate(pid);
-        this.#emit({ op: has ? "upd" : "set", pid, v, prev, has });
-        return this;
-    }
-    mutate(pid, fn) {
-        this.#assertNotIterating("mutate");
-        if (!this.h(pid))
-            return undefined;
-        const next = fn(this.g(pid), true);
-        this.s(next, pid);
-        return next;
-    }
-    d(pid) {
-        this.#assertNotIterating("delete");
-        const slot = this.pidToSlot[pid];
-        if (slot === -1)
-            return false;
-        const prev = this.#readSlot(slot);
-        const lastSlot = this.#size - 1;
-        const lastPid = this.slotToPid[lastSlot];
-        if (slot !== lastSlot) {
-            this.#writeSlot(slot, this.#readSlot(lastSlot));
-            this.slotToPid[slot] = lastPid;
-            this.pidToSlot[lastPid] = slot;
-        }
-        this.pidToSlot[pid] = -1;
-        this.slotToPid[lastSlot] = -1;
-        this.#size--;
-        this.#invalidate(pid);
-        this.#emit({ op: "del", pid, prev, has: false });
-        return true;
-    }
-    c() {
-        this.#assertNotIterating("clear");
-        for (let i = this.#size - 1; i >= 0; i--) {
-            const pid = this.slotToPid[i];
-            const prev = this.#readSlot(i);
-            this.pidToSlot[pid] = -1;
-            this.slotToPid[i] = -1;
-            this.#invalidate(pid);
-            this.#emit({ op: "del", pid, prev, has: false });
-        }
-        this.#size = 0;
-    }
-    dv(pid, deps, fn) {
-        (this.#derived ??= new Map()).set(pid, { deps, fn, dirty: true, has: false });
-        for (const dep of deps) {
-            const set = (this.#dependents ??= new Map());
-            if (!set.has(dep))
-                set.set(dep, new Set());
-            set.get(dep).add(pid);
-        }
-        return this;
-    }
-    dirty(...pids) {
-        for (const pid of pids) {
-            const d = this.#derived?.get(pid);
-            if (d && !d.dirty) {
-                d.dirty = true;
-                this.#emit({ op: "dirty", pid, has: d.has });
-            }
-        }
-        return this;
-    }
-    g(pid) {
-        const d = this.#derived?.get(pid);
-        if (d)
-            return d.dirty || !d.has ? this.#computeDerived(pid, d) : d.value;
-        const slot = this.pidToSlot[pid];
-        return slot === -1 ? undefined : this.#readSlot(slot);
-    }
-    h(pid) {
-        const d = this.#derived?.get(pid);
-        if (d) {
-            if (d.dirty || !d.has)
-                this.#computeDerived(pid, d);
-            return true;
-        }
-        return this.pidToSlot[pid] !== -1;
-    }
-    // ---------------------------------------------------------------- debug
-    $debug(limit = 256) { this.#hist ??= []; this.#histLimit = limit; return this; } //  [$DEBUG]
-    $strict() { this.#strict = true; return this; } //                                     [$STRICT]
-    $history() { return this.#hist ? [...this.#hist] : []; } //                    [$HISTORY]
-    $why(pid) {
-        if (!this.#hist)
-            return undefined;
-        for (let i = this.#hist.length - 1; i >= 0; i--)
-            if (this.#hist[i].pid === pid)
-                return this.#hist[i];
-        return undefined;
-    }
-    $diff(other) {
-        const add = [];
-        const del = [];
-        const chg = [];
-        for (const [pid, v] of this) {
-            if (!other.has(pid))
-                add.push([pid, v]);
-            else if (!sameValue128(other.get(pid), v))
-                chg.push([pid, v, other.get(pid)]);
-        }
-        for (const pid of other.keys())
-            if (!this.has(pid))
-                del.push(pid);
-        return { add, del, chg };
-    }
-    // ---------------------------------------------------------------- iteration (dense slots, no hashing)
-    *entries() {
-        this.#iterating++;
-        try {
-            for (let i = 0; i < this.#size; i++)
-                yield [this.slotToPid[i], this.#readSlot(i)];
-        }
-        finally {
-            this.#iterating--;
-        }
-    }
-    *keys() {
-        this.#iterating++;
-        try {
-            for (let i = 0; i < this.#size; i++)
-                yield this.slotToPid[i];
-        }
-        finally {
-            this.#iterating--;
-        }
-    }
-    *values() {
-        this.#iterating++;
-        try {
-            for (let i = 0; i < this.#size; i++)
-                yield this.#readSlot(i);
-        }
-        finally {
-            this.#iterating--;
-        }
-    }
-    [Symbol.iterator]() { return this.entries(); }
-    // ---------------------------------------------------------------- alias / has/has-not helpers
-    has = this.h; //                                                                             [has alias]
-    get = this.g; //                                                                             [get alias]
-    delete = this.d; //                                                                        [delete alias]
-    clear = this.c; //                                                                           [clear alias]
-    f = this.forEach.bind(this); //                                                            [FOR EACH]
-    forEach(fn) { for (const [pid, v] of this)
-        fn(v, pid, this); }
-    // ---------------------------------------------------------------- sugar
-    swap(value, pid) {
-        const previous = this.has(pid) ? this.get(pid) : value;
-        this.s(value, pid);
-        return previous;
-    }
-    take(pid) { const value = this.g(pid); this.d(pid); return value; } //             [TAKE]
-    peek(pid) { return this.h(pid) ? this.g(pid) : false; } //            [PEEK]
-    getOrI(value, pid) {
-        if (this.h(pid))
-            return this.g(pid);
-        this.s(value, pid);
-        return value;
-    }
-    getOrM(make, pid) {
-        if (this.h(pid))
-            return this.g(pid);
-        const value = make();
-        this.s(value, pid);
-        return value;
-    }
-    update(pid, fn, initial) {
-        const has = this.h(pid);
-        const old = has ? this.g(pid) : (initial === undefined ? 0 : initial);
-        const next = fn(old, has);
-        this.s(next, pid);
-        return next;
-    }
-    setIfAbsent(value, pid) {
-        if (this.h(pid))
-            return false;
-        this.s(value, pid);
-        return true;
-    }
-    setIfPresent(value, pid) {
-        if (!this.h(pid))
-            return false;
-        this.s(value, pid);
-        return true;
-    }
-    replace(value, pid) { return this.setIfPresent(value, pid); } //                 [REPLACE]
-    inc(pid, by = 1) {
-        return this.update(pid, (old) => ((old ?? 0) + by), 0);
-    }
-    touch(pid) { return this.setIfAbsent(0, pid); } //                            [SWTOUCHAP]
-    // ---------------------------------------------------------------- transforms (produce new M2BI, same cap/stride)
-    mapValues(fn) {
-        const out = this.#fresh();
-        for (const [pid, v] of this)
-            out.s(fn(v, pid), pid);
-        return out;
-    }
-    mapKeys(fn) {
-        const out = this.#fresh(); // target pids must still fit within cap
-        for (const [pid, v] of this)
-            out.s(v, fn(v, pid));
-        return out;
-    }
-    filterKV(pred) {
-        for (const pid of [...this.keys()])
-            if (!pred(this.g(pid), pid))
-                this.d(pid);
-        return this;
-    }
-    filterKeys(pred) { return this.filterKV(pred); } //          [FILTERKEYS]
-    partition(pred) {
-        const yes = this.#fresh(), no = this.#fresh();
-        for (const [pid, v] of this)
-            (pred(v, pid) ? yes : no).s(v, pid);
-        return [yes, no];
-    }
-    find(pred) {
-        for (const [pid, v] of this)
-            if (pred(v, pid))
-                return [pid, v];
-        return undefined;
-    }
-    findKey(pred) {
-        for (const [pid, v] of this)
-            if (pred(v, pid))
-                return pid;
-        return undefined;
-    }
-    findValue(pred) {
-        for (const [pid, v] of this)
-            if (pred(v, pid))
-                return v;
-        return undefined;
-    }
-    some(pred) {
-        for (const [pid, v] of this)
-            if (pred(v, pid))
-                return true;
-        return false;
-    }
-    every(pred) {
-        for (const [pid, v] of this)
-            if (!pred(v, pid))
-                return false;
-        return true;
-    }
-    reduce(fn, initial) {
-        let acc = initial;
-        for (const [pid, v] of this)
-            acc = fn(acc, v, pid);
-        return acc;
-    }
-    forEachKV(fn) { for (const [pid, v] of this)
-        fn(v, pid, this); } // [FOREACH]
-    invert() {
-        const out = new Map(); // values aren't valid pids/Int32 slots in general -> plain Map, not M2BI
-        for (const [pid, v] of this)
-            out.set(this.stride === 1 ? String(v) : Array.from(v).join(","), pid);
-        return out;
-    }
-    unique(fn) {
-        const out = this.#fresh();
-        const seen = new Set();
-        for (const [pid, v] of this) {
-            const keyFor = fn ? fn(v, pid) : pid;
-            const dedupeKey = this.stride === 1 ? String(v) : Array.from(v).join(",");
-            if (!seen.has(dedupeKey)) {
-                seen.add(dedupeKey);
-                out.s(v, keyFor);
-            }
-        }
-        return out;
-    }
-    pick(pids) {
-        const out = this.#fresh();
-        for (const pid of pids)
-            if (this.h(pid))
-                out.s(this.g(pid), pid);
-        return out;
-    }
-    omit(pids) {
-        const omitted = new Set(pids);
-        const out = this.#fresh();
-        for (const [pid, v] of this)
-            if (!omitted.has(pid))
-                out.s(v, pid);
-        return out;
-    }
-    merge(other) {
-        for (const [pid, v] of other)
-            this.s(v, pid);
-        return this;
-    }
-    clearAndSet(entries) {
-        return this.batch(() => { this.clear(); for (const [pid, v] of entries)
-            this.s(v, pid); });
-    }
-    toObject() {
-        const out = {};
-        for (const [pid, v] of this)
-            out[pid] = v;
-        return out;
-    }
-    toValues() { return [...this.values()]; } //                                       [TOVALUES]
-    toKeys() { return [...this.keys()]; } //                                                [TOKEYS]
-    toArray() { return [...this.entries()]; } //                                   [TOARRAY]
-    group(fn) {
-        const out = new Map();
-        for (const [pid, v] of this) {
-            const k = fn(v, pid);
-            if (!out.has(k))
-                out.set(k, []);
-            out.get(k).push(v);
-        }
-        return out;
-    }
-    clone() {
-        return new _a(this.cap, this.stride, this.entries());
-    }
-    equals(other) {
-        if (other === this)
-            return true;
-        if (this.size !== other.size)
-            return false;
-        for (const [pid, v] of this)
-            if (!other.has(pid) || !sameValue128(other.get(pid), v))
-                return false;
-        return true;
-    }
-    // ---------------------------------------------------------------- statics
-    static fromObject(obj, maxParticles, stride = 1) {
-        return new _a(maxParticles, stride, Object.entries(obj).map(([k, v]) => [Number(k), v]));
-    }
-    static fromEntries(entries, maxParticles, stride = 1) {
-        return new _a(maxParticles, stride, entries);
-    }
-    static from(map, maxParticles, stride = 1) {
-        return new _a(maxParticles, stride, map);
-    }
-}
-_a = M2BI;
-globalThis.M2B = M2BI;