alar/dist/index.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const path_1 = require("path");
const chokidar_1 = require("chokidar");
exports.FSWatcher = chokidar_1.FSWatcher;
const startsWith = require("lodash/startsWith");
const once = require("lodash/once");
const channel_1 = require("./rpc/channel");
exports.RpcChannel = channel_1.RpcChannel;
const client_1 = require("./rpc/client");
exports.RpcClient = client_1.RpcClient;
const server_1 = require("./rpc/server");
exports.RpcServer = server_1.RpcServer;
const proxy_1 = require("./proxy");
exports.createModuleProxy = proxy_1.createModuleProxy;
const util_1 = require("./util");
exports.local = util_1.local;
class ModuleProxy extends proxy_1.ModuleProxy {
    constructor(name, path, loader) {
        super();
        this.name = name;
        this.server = null;
        util_1.patchProperties(this, path, loader || proxy_1.defaultLoader, util_1.dict());
        this.local = util_1.local;
    }
    async serve(config, immediate = true) {
        this.server = new server_1.RpcServer(config);
        this.server["proxyRoot"] = this;
        immediate && (await this.server.open(false));
        return this.server;
    }
    async connect(config, immediate = true) {
        let client = new client_1.RpcClient(config);
        immediate && (await client.open());
        return client;
    }
    resolve(path) {
        let dir = this.path + path_1.sep;
        if (startsWith(path, dir)) {
            let modPath = path.slice(dir.length), ext = path_1.extname(modPath);
            if (Array.isArray(this.loader.extension)) {
                if (this.loader.extension.includes(ext)) {
                    modPath = modPath.slice(0, -ext.length);
                }
                else {
                    return;
                }
            }
            else if (ext === this.loader.extension) {
                modPath = modPath.slice(0, -ext.length);
            }
            else if (ext) {
                return;
            }
            return this.name + "." + modPath.replace(/\\|\//g, ".");
        }
        else {
            return;
        }
    }
    watch(listener) {
        let { path } = this;
        let clearCache = async (event, filename, cb) => {
            let name = this.resolve(filename);
            if (name && this.singletons[name]) {
                let tryUnload = once(() => {
                    delete this.singletons[name];
                    this.loader.unload(filename);
                });
                try {
                    if (this.server &&
                        this.server["enableLifeCycle"] &&
                        this.server["registry"][name]) {
                        let mod = this.server["registry"][name];
                        let handleError = this.server["errorHandler"];
                        await util_1.tryLifeCycleFunction(mod, "destroy", handleError);
                        tryUnload();
                        await util_1.tryLifeCycleFunction(mod, "init", handleError);
                    }
                    else {
                        tryUnload();
                    }
                }
                catch (err) {
                    console.error(err);
                    tryUnload();
                }
            }
            else {
                this.loader.unload(filename);
            }
            cb && cb(event, filename);
        };
        return chokidar_1.watch(path, {
            awaitWriteFinish: true,
            followSymlinks: false,
            ignored: (file) => {
                let ext = path_1.extname(file);
                if (!ext) {
                    return false;
                }
                else if (typeof this.loader.extension === "string") {
                    return this.loader.extension !== ext;
                }
                else {
                    return !this.loader.extension.includes(ext);
                }
            }
        }).on("change", (filename) => {
            clearCache("change", filename, listener);
        }).on("unlink", (filename) => {
            clearCache("unlink", filename, listener);
        }).on("unlinkDir", dirname => {
            dirname = dirname + path_1.sep;
            if (this.loader.cache) {
                for (let filename in this.loader.cache) {
                    if (startsWith(filename, dirname)) {
                        clearCache("unlink", filename, listener);
                    }
                }
            }
        });
    }
    setLoader(loader) {
        util_1.set(this, "loader", loader);
    }
}
exports.ModuleProxy = ModuleProxy;
exports.default = ModuleProxy;
//# sourceMappingURL=index.js.map