@sebastianspeitel/proxystore/dist/index.js

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var fs = require('fs');

const hookKeys = Object.getOwnPropertyNames(Reflect);
class DeepProxy {
    constructor(root = {}) {
        this._paths = new WeakMap();
        if (typeof root !== "object") {
            throw TypeError("Root value has to be of type object");
        }
        this._root = root;
        const handler = {};
        for (const hook of hookKeys) {
            handler[hook] = (t, ...args) => {
                const path = this._paths.get(t);
                if (!path)
                    throw Error("Path not found");
                //console.log(hook, ["root", ...path].join("."));
                return this[hook](path, 
                //@ts-ignore
                ...args);
            };
        }
        this._handler = handler;
        this.proxy = this.addPath([], Object.getPrototypeOf(this._root));
    }
    addPath(path, proto) {
        const t = Array.isArray(proto) ? [] : Object.create(proto);
        this._paths.set(t, path);
        return new Proxy(t, this._handler);
    }
    getByPath(path) {
        try {
            const obj = path.reduce((o, k) => o[k], this._root);
            if (!obj)
                throw Error();
            return obj;
        }
        catch (e) {
            /* istanbul ignore next */
            throw Error(`Trying to access property ${path.join(".")} failed. Probably because it was removed.`);
        }
    }
    /** Always configurable to comply with:
     * > A property cannot be reported as non-configurable, if it does not exists as an own property of the target object or if it exists as a configurable own property of the target object.
     * > https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Proxy/handler/getOwnPropertyDescriptor (Invariants)
     * */
    getOwnPropertyDescriptor(path, prop) {
        const target = this.getByPath(path);
        const descriptor = Reflect.getOwnPropertyDescriptor(target, prop);
        if (!descriptor)
            return undefined;
        return Object.assign(descriptor, { configurable: true });
    }
    get(path, prop) {
        const target = this.getByPath(path);
        const val = Reflect.get(target, prop);
        if (typeof val === "object" && val) {
            return this.addPath([...path, prop], Object.getPrototypeOf(val));
        }
        return val;
    }
}
for (const key of Object.getOwnPropertyNames(Reflect)) {
    // Ignore already defined hooks
    if (DeepProxy.prototype[key])
        continue;
    // Create hook for all other traps
    DeepProxy.prototype[key] = function (path, ...args) {
        const target = this.getByPath(path);
        return Reflect[key](target, 
        //@ts-ignore typescript miscalculates the length of args
        ...args);
    };
}

class BaseProxyStore extends DeepProxy {
    constructor(root = {}) {
        super(root);
    }
    get store() {
        return this.proxy;
    }
    set store(store) {
        // not 100% sure, this is safe
        this._root = store;
        this.set([], BaseProxyStore.ROOT);
    }
}
BaseProxyStore.ROOT = Symbol("ProxyStore root");

/*! *****************************************************************************
Copyright (c) Microsoft Corporation. All rights reserved.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use
this file except in compliance with the License. You may obtain a copy of the
License at http://www.apache.org/licenses/LICENSE-2.0

THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
MERCHANTABLITY OR NON-INFRINGEMENT.

See the Apache Version 2.0 License for specific language governing permissions
and limitations under the License.
***************************************************************************** */

function __awaiter(thisArg, _arguments, P, generator) {
    return new (P || (P = Promise))(function (resolve, reject) {
        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
}

function readJSON(path, fallback) {
    try {
        const json = fs.readFileSync(path).toString();
        return JSON.parse(json);
    }
    catch (e) {
        if (typeof fallback === "undefined")
            throw e;
        return fallback;
    }
}
function writeJSON(path, obj, { pretty } = {}) {
    if (pretty === true)
        pretty = 2;
    else if (pretty === false)
        pretty = undefined;
    fs.writeFileSync(path, JSON.stringify(obj, null, pretty));
}
class ProxyStore extends BaseProxyStore {
    constructor(root = {}, { init = false, path, pretty = false, watch = false } = {
        path: ""
    }) {
        if (typeof path !== "string" || !path) {
            throw TypeError(`Invalid option path="${path}"`);
        }
        let r = root;
        if (init) {
            r = readJSON(path, r);
        }
        super(r);
        this.path = path;
        this.pretty = pretty;
        if (watch) {
            this.watcher = fs.watch(this.path, () => this.load());
        }
    }
    load() {
        this._root = readJSON(this.path, this._root);
    }
    save() {
        return __awaiter(this, void 0, void 0, function* () {
            writeJSON(this.path, this._root, { pretty: this.pretty });
        });
    }
    //@ts-ignore
    set(path, prop, val) {
        const ret = prop === ProxyStore.ROOT ? true : super.set(path, prop, val);
        this.save();
        return ret;
    }
    //@ts-ignore
    deleteProperty(path, prop) {
        const ret = super.deleteProperty(path, prop);
        this.save();
        return ret;
    }
}

function isProxyStoreConstructor(obj) {
    return (BaseProxyStore === obj || Object.prototype.isPrototypeOf.call(BaseProxyStore, obj));
}
function proxy(param1, param2, param3) {
    // First argument is a ProxyStore
    if (isProxyStoreConstructor(param1)) {
        const PS = param1;
        return new PS({}, param2).store;
    }
    // Second argument is a ProxyStore
    if (isProxyStoreConstructor(param2)) {
        const PS = param2;
        return new PS(param1, param3).store;
    }
    // No ProxyStore provided
    throw TypeError("No ProxyStore or derivative of it provided");
}

exports.DeepProxy = DeepProxy;
exports.ProxyStore = BaseProxyStore;
exports.ProxyStoreFS = ProxyStore;
exports.default = proxy;
exports.proxy = proxy;