alar/dist/proxy.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const path_1 = require("path");
const js_magic_1 = require("js-magic");
const di_1 = require("./di");
const fs_1 = require("fs");
const cloneDeep = require("lodash/cloneDeep");
const merge = require("lodash/merge");
const values = require("lodash/values");
const could_be_class_1 = require("could-be-class");
const util_1 = require("./util");
const fallbackToLocal = Symbol("fallbackToLocal");
const cmd = process.execArgv.concat(process.argv).join(" ");
const isTsNode = cmd.includes("ts-node");
exports.defaultLoader = {
    extension: isTsNode ? ".ts" : ".js",
    cache: require.cache,
    load: require,
    unload(filename) {
        delete this.cache[filename];
    }
};
function createModuleProxy(name, path, loader = exports.defaultLoader, singletons = util_1.dict(), root = void 0) {
    let proxy = function (...args) {
        if (!new.target) {
            return proxy.instance(args[0]);
        }
        else {
            return proxy.create(...args);
        }
    };
    (!loader && root) && (loader = root["loader"]);
    (!singletons && root) && (singletons = root["singletons"]);
    Object.setPrototypeOf(proxy, ModuleProxy.prototype);
    util_1.set(proxy, "name", name);
    util_1.patchProperties(proxy, path, loader, singletons);
    proxy[fallbackToLocal] = true;
    proxy[util_1.proxyRoot] = root;
    proxy[Symbol.toStringTag] = "ModuleProxy";
    proxy[Symbol.hasInstance] = function ModuleProxy(ins) {
        return ins instanceof proxy.ctor;
    };
    return js_magic_1.applyMagic(proxy, true);
}
exports.createModuleProxy = createModuleProxy;
let ModuleProxy = class ModuleProxy extends di_1.Injectable {
    get exports() {
        if (typeof this.loader.extension === "string") {
            return this.loader.load(this.path + this.loader.extension);
        }
        else {
            let dir = path_1.dirname(this.path);
            let name = path_1.basename(this.path);
            let files = fs_1.readdirSync(dir);
            for (let file of files) {
                let ext = path_1.extname(file);
                let _name = path_1.basename(file, ext);
                if (_name === name && this.loader.extension.includes(ext)) {
                    return this.loader.load(this.path + ext);
                }
            }
            throw new Error(`Cannot find module '${this.path}'`);
        }
    }
    get proto() {
        let { exports } = this;
        if (typeof exports === "object") {
            if (typeof exports.default === "object") {
                return exports.default;
            }
            else if (typeof exports.default === "function" &&
                could_be_class_1.default(exports.default, true)) {
                return exports.default.prototype;
            }
            return exports;
        }
        else if (typeof exports === "function" && could_be_class_1.default(exports, true)) {
            return exports.prototype;
        }
        else {
            return null;
        }
    }
    get ctor() {
        let { exports } = this;
        if (typeof exports === "object" &&
            could_be_class_1.default(exports.default, true)) {
            return exports.default;
        }
        else if (typeof exports === "function" && could_be_class_1.default(exports, true)) {
            return exports;
        }
        else {
            return null;
        }
    }
    create(...args) {
        if (this.ctor) {
            return new this.ctor(...args);
        }
        else if (this.proto) {
            return merge(cloneDeep(this.proto), args[0]);
        }
        else {
            throw new TypeError(`${this.name} is not a valid module`);
        }
    }
    instance(route = util_1.local) {
        if (route === util_1.local) {
            return this.singletons[this.name] || (this.singletons[this.name] = util_1.getInstance(this));
        }
        if (typeof route === "string" && this.remoteSingletons[route]) {
            return this.remoteSingletons[route];
        }
        let singletons = values(this.remoteSingletons);
        if (singletons.length > 0) {
            let id = util_1.evalRouteId(route);
            let availableSingletons = singletons.filter(item => {
                return item[util_1.readyState] === 2;
            });
            if (availableSingletons.length > 0) {
                return availableSingletons[id % availableSingletons.length];
            }
            else {
                return singletons[id % singletons.length];
            }
        }
        else {
            util_1.throwUnavailableError(this.name);
        }
    }
    fallbackToLocal(enable = void 0) {
        if (enable === void 0) {
            return this[fallbackToLocal];
        }
        else {
            this[fallbackToLocal] = Boolean(enable);
            return this;
        }
    }
    noLocal() {
        return this.fallbackToLocal(false);
    }
    __get(prop) {
        if (prop in this) {
            return this[prop];
        }
        else if (prop in this.children) {
            return this.children[prop];
        }
        else if (typeof prop != "symbol") {
            return this.children[prop] = createModuleProxy(this.name + "." + String(prop), this.path + path_1.sep + String(prop), this.loader, this.singletons, this[util_1.proxyRoot] || this);
        }
    }
    __has(prop) {
        return (prop in this) || (prop in this.children);
    }
    toString() {
        return this.name;
    }
    toJSON() {
        return this.name;
    }
};
ModuleProxy = tslib_1.__decorate([
    js_magic_1.applyMagic
], ModuleProxy);
exports.ModuleProxy = ModuleProxy;
//# sourceMappingURL=proxy.js.map