vasille-jsx/lib/objects.js

The first Developer eXperience Orientated front-end framework (JSX components)

import { IValue, Reference } from "vasille";
import { ensureIValue } from "./library.js";
export class ProxyReference extends Reference {
    forceUpdate() {
        this.updateDeps(this.state);
    }
}
export function proxyObject(obj, proxyRef) {
    return new Proxy(obj, {
        get(target, p, receiver) {
            const value = Reflect.get(target, p, receiver);
            return value instanceof Object ? proxyObject(value, proxyRef) : value;
        },
        set(target, p, newValue, receiver) {
            const response = Reflect.set(target, p, newValue, receiver);
            /* istanbul ignore else */
            if (response) {
                proxyRef.forceUpdate();
            }
            return response;
        },
        defineProperty(target, property, attributes) {
            const response = Reflect.defineProperty(target, property, attributes);
            /* istanbul ignore else */
            if (response) {
                proxyRef.forceUpdate();
            }
            return response;
        },
        deleteProperty(target, p) {
            const response = Reflect.deleteProperty(target, p);
            /* istanbul ignore else */
            if (response) {
                proxyRef.forceUpdate();
            }
            return response;
        },
    });
}
export function proxy(o) {
    if (typeof o === "object" && o && o.constructor === Object) {
        const proxyRef = new ProxyReference(undefined);
        proxyRef.$ = proxyObject(o, proxyRef);
        return proxyRef;
    }
    return o;
}
export function reactiveObject(node, o, name) {
    for (const key of Object.keys(o)) {
        if (!(o[key] instanceof IValue)) {
            o[key] = ensureIValue(node, proxy(o[key]));
        }
    }
    if (name) {
        node.addState("reactiveObject", name, o);
    }
    return new Proxy(o, {
        get(_, p) {
            if (p in o) {
                return o[p];
            }
            else {
                return (o[p] = node.register(new Reference(undefined)));
            }
        },
        deleteProperty(_, p) {
            /* istanbul ignore else */
            if (p in o && o[p] instanceof IValue) {
                node.release(p[0]);
            }
            return Reflect.deleteProperty(o, p);
        },
    });
}
export function reactiveObjectProxy(o) {
    return new Proxy(o, {
        get(_, p) {
            return o[p].$;
        },
        set(_, p, newValue) {
            o[p].$ = newValue;
            return true;
        },
    });
}
export function storeReactiveObject(o) {
    for (const key of Object.keys(o)) {
        /* istanbul ignore else */
        if (!(o[key] instanceof IValue)) {
            o[key] = new Reference(proxy(o[key]));
        }
    }
    return new Proxy(o, {
        get(_, p) {
            if (p in o) {
                return o[p];
            }
            else {
                return (o[p] = new Reference(undefined));
            }
        },
    });
}