rvx/dist/es/store/reactive-map.js

A signal based rendering library

import { $, batch } from "../core/signals.js";
import { ProbeMap } from "./probes.js";
export class ReactiveMap extends Map {
    #target;
    #barrier;
    #size;
    #iterators;
    #getProbes;
    #hasProbes;
    constructor(target, barrier) {
        super();
        this.#target = target;
        this.#barrier = barrier;
        this.#size = $(target.size);
        this.#iterators = $();
        this.#getProbes = new ProbeMap(key => target.get(key));
        this.#hasProbes = new ProbeMap(key => target.has(key));
    }
    get size() {
        this.#size.access();
        return this.#target.size;
    }
    get(key) {
        this.#getProbes.access(key);
        return this.#barrier.wrap(this.#target.get(key));
    }
    has(key) {
        this.#hasProbes.access(key);
        return this.#target.has(key);
    }
    set(key, value) {
        batch(() => {
            value = this.#barrier.unwrap(value);
            this.#target.set(key, value);
            this.#size.value = this.#target.size;
            this.#iterators.notify();
            this.#getProbes.update(key, value);
            this.#hasProbes.update(key, true);
        });
        return this;
    }
    delete(key) {
        return batch(() => {
            const deleted = this.#target.delete(key);
            if (deleted) {
                this.#size.value = this.#target.size;
                this.#iterators.notify();
                this.#getProbes.update(key, undefined);
                this.#hasProbes.update(key, false);
            }
            return deleted;
        });
    }
    clear() {
        batch(() => {
            this.#target.clear();
            this.#size.value = 0;
            this.#iterators.notify();
            this.#getProbes.fill(undefined);
            this.#hasProbes.fill(false);
        });
    }
    *entries() {
        this.#iterators.access();
        for (const entry of this.#target.entries()) {
            yield [entry[0], this.#barrier.wrap(entry[1])];
        }
    }
    keys() {
        this.#iterators.access();
        return this.#target.keys();
    }
    *values() {
        this.#iterators.access();
        for (const entry of this.#target.values()) {
            yield this.#barrier.wrap(entry);
        }
    }
    forEach(callback, thisArg) {
        this.#iterators.access();
        return this.#target.forEach((value, key) => callback.call(thisArg, this.#barrier.wrap(value), key, this));
    }
    *[Symbol.iterator]() {
        this.#iterators.access();
        for (const entry of this.#target.entries()) {
            yield [entry[0], this.#barrier.wrap(entry[1])];
        }
    }
    get [Symbol.toStringTag]() {
        return this.#target[Symbol.toStringTag];
    }
}
//# sourceMappingURL=reactive-map.js.map