rvx/dist/es/store/barrier.js

A signal based rendering library

import { createReactiveArrayProxy } from "./reactive-array-proxy.js";
import { ReactiveMap } from "./reactive-map.js";
import { createReactiveProxy } from "./reactive-proxy.js";
import { ReactiveSet } from "./reactive-set.js";
const WRAP_INSTANCE = Symbol.for("rvx:store:wrap_instance");
const WRAPPERS = new WeakMap();
const TARGETS = new WeakMap();
export const BARRIER = { wrap, unwrap };
export function wrap(value) {
    if (value !== null && typeof value === "object") {
        if (TARGETS.has(value)) {
            return value;
        }
        let wrapper = WRAPPERS.get(value);
        if (wrapper !== undefined) {
            return wrapper;
        }
        const ctor = value.constructor;
        const wrapInstance = ctor[WRAP_INSTANCE];
        if (wrapInstance) {
            wrapper = wrapInstance(value);
        }
        else {
            const proto = Object.getPrototypeOf(value);
            switch (proto) {
                case Object.prototype:
                    wrapper = createReactiveProxy(value, BARRIER);
                    break;
                case Array.prototype:
                    wrapper = createReactiveArrayProxy(value, BARRIER);
                    break;
                case Map.prototype:
                    wrapper = new ReactiveMap(value, BARRIER);
                    break;
                case Set.prototype:
                    wrapper = new ReactiveSet(value, BARRIER);
                    break;
                default:
                    return value;
            }
        }
        WRAPPERS.set(value, wrapper);
        TARGETS.set(wrapper, value);
        return wrapper;
    }
    return value;
}
export function unwrap(value) {
    if (value !== null && typeof value === "object") {
        const target = TARGETS.get(value);
        if (target !== undefined) {
            return target;
        }
    }
    return value;
}
function defaultWrapInstance(value) {
    return createReactiveProxy(value, BARRIER);
}
export function wrapInstancesOf(targetClass, wrap) {
    Object.defineProperty(targetClass, WRAP_INSTANCE, {
        configurable: true,
        enumerable: false,
        writable: false,
        value: wrap ?? defaultWrapInstance,
    });
}
//# sourceMappingURL=barrier.js.map