clean-architecture/tools/createObjectThatThrowsIfAccessed.js

Utilities for implementing clean architecture using Redux

"use strict";
var __extends = (this && this.__extends) || (function () {
    var extendStatics = function (d, b) {
        extendStatics = Object.setPrototypeOf ||
            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
        return extendStatics(d, b);
    };
    return function (d, b) {
        if (typeof b !== "function" && b !== null)
            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
        extendStatics(d, b);
        function __() { this.constructor = d; }
        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
    };
})();
var __read = (this && this.__read) || function (o, n) {
    var m = typeof Symbol === "function" && o[Symbol.iterator];
    if (!m) return o;
    var i = m.call(o), r, ar = [], e;
    try {
        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
    }
    catch (error) { e = { error: error }; }
    finally {
        try {
            if (r && !r.done && (m = i["return"])) m.call(i);
        }
        finally { if (e) throw e.error; }
    }
    return ar;
};
var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
        if (ar || !(i in from)) {
            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
            ar[i] = from[i];
        }
    }
    return to.concat(ar || Array.prototype.slice.call(from));
};
Object.defineProperty(exports, "__esModule", { value: true });
exports.createObjectWithSomePropertiesThatThrowIfAccessed = exports.THROW_IF_ACCESSED = exports.isObjectThatThrowIfAccessed = exports.createObjectThatThrowsIfAccessedFactory = exports.createObjectThatThrowsIfAccessed = exports.AccessError = void 0;
var keyIsTrapped = "isTrapped_zSskDe9d";
var AccessError = /** @class */ (function (_super) {
    __extends(AccessError, _super);
    function AccessError(message) {
        var _newTarget = this.constructor;
        var _this = _super.call(this, message) || this;
        Object.setPrototypeOf(_this, _newTarget.prototype);
        return _this;
    }
    return AccessError;
}(Error));
exports.AccessError = AccessError;
function createObjectThatThrowsIfAccessed(params) {
    var _a;
    var _b = params !== null && params !== void 0 ? params : {}, _c = _b.debugMessage, debugMessage = _c === void 0 ? "" : _c, _d = _b.isPropertyWhitelisted, isPropertyWhitelisted = _d === void 0 ? function () { return false; } : _d;
    var get = function () {
        var args = [];
        for (var _i = 0; _i < arguments.length; _i++) {
            args[_i] = arguments[_i];
        }
        var _a = __read(args, 2), prop = _a[1];
        if (isPropertyWhitelisted(prop) || prop === keyIsTrapped) {
            return Reflect.get.apply(Reflect, __spreadArray([], __read(args), false));
        }
        throw new AccessError("Cannot access ".concat(String(prop), " yet ").concat(debugMessage));
    };
    var trappedObject = new Proxy((_a = {}, _a[keyIsTrapped] = true, _a), {
        get: get,
        "set": get
    });
    return trappedObject;
}
exports.createObjectThatThrowsIfAccessed = createObjectThatThrowsIfAccessed;
function createObjectThatThrowsIfAccessedFactory(params) {
    var isPropertyWhitelisted = params.isPropertyWhitelisted;
    return {
        "createObjectThatThrowsIfAccessed": function (params) {
            var debugMessage = (params !== null && params !== void 0 ? params : {}).debugMessage;
            return createObjectThatThrowsIfAccessed({
                debugMessage: debugMessage,
                isPropertyWhitelisted: isPropertyWhitelisted
            });
        }
    };
}
exports.createObjectThatThrowsIfAccessedFactory = createObjectThatThrowsIfAccessedFactory;
function isObjectThatThrowIfAccessed(obj) {
    return obj[keyIsTrapped] === true;
}
exports.isObjectThatThrowIfAccessed = isObjectThatThrowIfAccessed;
exports.THROW_IF_ACCESSED = {
    __brand: "THROW_IF_ACCESSED"
};
function createObjectWithSomePropertiesThatThrowIfAccessed(obj, debugMessage) {
    return Object.defineProperties(obj, Object.fromEntries(Object.entries(obj)
        .filter(function (_a) {
        var _b = __read(_a, 2), value = _b[1];
        return value === exports.THROW_IF_ACCESSED;
    })
        .map(function (_a) {
        var _b = __read(_a, 1), key = _b[0];
        var getAndSet = function () {
            throw new AccessError("Cannot access ".concat(key, " yet ").concat(debugMessage !== null && debugMessage !== void 0 ? debugMessage : ""));
        };
        var pd = {
            "get": getAndSet,
            "set": getAndSet,
            "enumerable": true
        };
        return [key, pd];
    })));
}
exports.createObjectWithSomePropertiesThatThrowIfAccessed = createObjectWithSomePropertiesThatThrowIfAccessed;
//# sourceMappingURL=createObjectThatThrowsIfAccessed.js.map