alar/dist/util.js

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const os = require("os");
const path = require("path");
const startsWith = require("lodash/startsWith");
const structured_clone_1 = require("@hyurl/structured-clone");
const isOwnKey_1 = require("@hyurl/utils/isOwnKey");
const hash = require("string-hash");
const WinPipe = "\\\\?\\pipe\\";
exports.local = Symbol("local");
exports.proxyRoot = Symbol("proxyRoot");
exports.readyState = Symbol("readyState");
function absPath(filename, withPipe) {
    if (!path.isAbsolute(filename)) {
        filename = path.resolve(process.cwd(), filename);
    }
    if (withPipe && os.platform() == "win32" && !startsWith(filename, WinPipe)) {
        filename = WinPipe + filename;
    }
    return filename;
}
exports.absPath = absPath;
function set(target, prop, value, writable = false, enumerable = false) {
    Object.defineProperty(target, prop, {
        configurable: true,
        enumerable,
        writable,
        value
    });
}
exports.set = set;
function getInstance(mod, forRemote = false) {
    let ins;
    let { ctor } = mod;
    if (ctor) {
        if (!forRemote) {
            if (typeof ctor.getInstance === "function") {
                ins = ctor.getInstance();
            }
            else {
                ins = mod.create();
            }
        }
        else {
            ins = Object.create(ctor.prototype);
        }
    }
    else {
        ins = mod.proto;
    }
    return ins;
}
exports.getInstance = getInstance;
function mergeFnProperties(fn, origin) {
    set(fn, "proxified", true);
    set(fn, "name", origin.name);
    set(fn, "length", origin.length);
    set(fn, "toString", function toString() {
        return "[ModuleProxy] " + Function.prototype.toString.call(origin);
    }, true);
    return fn;
}
exports.mergeFnProperties = mergeFnProperties;
function createRemoteInstance(mod, fnCreator) {
    return new Proxy(getInstance(mod, true), {
        get: (ins, prop) => {
            if (typeof prop === "symbol") {
                return ins[prop];
            }
            let type = typeof ins[prop];
            let isFn = type === "function";
            if (isFn && !ins[prop]["proxified"] && !isOwnKey_1.default(ins, prop)) {
                set(ins, prop, mergeFnProperties(fnCreator(prop), ins[prop]));
            }
            return isFn ? ins[prop] : (type === "undefined" ? undefined : null);
        },
        has: (ins, prop) => {
            return typeof prop === "symbol"
                ? (prop in ins)
                : typeof ins[prop] === "function";
        }
    });
}
exports.createRemoteInstance = createRemoteInstance;
function humanizeDuration(duration) {
    let num;
    let unit;
    if (duration < 1000) {
        num = duration;
        unit = "millisecond";
    }
    else if (duration < 60000) {
        num = Math.round(duration / 1000);
        unit = "second";
    }
    else {
        num = Math.round(duration / 60000);
        unit = "minute";
    }
    if (num !== 1)
        unit += "s";
    return num + " " + unit;
}
exports.humanizeDuration = humanizeDuration;
async function tryLifeCycleFunction(mod, fn, errorHandle = void 0) {
    let ins = mod();
    if (fn === "init") {
        if (typeof ins.init === "function") {
            ins[exports.readyState] = 1;
            if (errorHandle) {
                try {
                    await ins.init();
                }
                catch (err) {
                    errorHandle(err);
                }
            }
            else {
                await ins.init();
            }
        }
        ins[exports.readyState] = 2;
    }
    else if (fn === "destroy") {
        if (typeof ins.destroy === "function") {
            ins[exports.readyState] = 3;
            if (errorHandle) {
                try {
                    await ins.destroy();
                }
                catch (err) {
                    errorHandle(err);
                }
            }
            else {
                await ins.destroy();
            }
        }
        ins[exports.readyState] = 0;
    }
}
exports.tryLifeCycleFunction = tryLifeCycleFunction;
function throwUnavailableError(name) {
    throw new ReferenceError(`Service ${name} is not available`);
}
exports.throwUnavailableError = throwUnavailableError;
function getCodecOptions(codec) {
    switch (codec) {
        case "JSON":
            return {
                objectSerializer: JSON.stringify,
                objectDeserializer: JSON.parse
            };
        case "CLONE":
            return {
                objectSerializer: structured_clone_1.serialize,
                objectDeserializer: structured_clone_1.deserialize
            };
        case "FRON": {
            let FRON = require("fron");
            return {
                objectSerializer: FRON.stringify,
                objectDeserializer: FRON.parse
            };
        }
        case "BSON": {
            let BSON;
            try {
                let BSONExt = require("bson-ext");
                BSON = new BSONExt([
                    BSONExt.Binary,
                    BSONExt.Code,
                    BSONExt.DBRef,
                    BSONExt.Decimal128,
                    BSONExt.Double,
                    BSONExt.Int32,
                    BSONExt.Long,
                    BSONExt.Map,
                    BSONExt.MaxKey,
                    BSONExt.MinKey,
                    BSONExt.ObjectId,
                    BSONExt.BSONRegExp,
                    BSONExt.Symbol,
                    BSONExt.Timestamp
                ]);
            }
            catch (e) {
                try {
                    BSON = require("bson");
                }
                catch (e) {
                    throw new Error("Cannot find module 'bson' or 'bson-ext'");
                }
            }
            return {
                objectSerializer: BSON.serialize.bind(BSON),
                objectDeserializer: BSON.deserialize.bind(BSON),
                serializationStyle: "buffer"
            };
        }
    }
}
exports.getCodecOptions = getCodecOptions;
function patchProperties(target, filename, loader, singletons) {
    set(target, "path", path.normalize(filename), false, true);
    set(target, "loader", loader);
    set(target, "singletons", singletons);
    set(target, "remoteSingletons", dict());
    set(target, "children", dict());
}
exports.patchProperties = patchProperties;
function dict() {
    return Object.create(null);
}
exports.dict = dict;
function evalRouteId(value) {
    let type = typeof value;
    switch (type) {
        case "number":
        case "boolean":
            return Number(value);
        case "string":
        case "symbol":
        case "bigint":
            return hash(String(value));
        case "function":
            return hash(String(value.name || value));
        case "object":
        case "undefined":
            if (value === null || value === undefined) {
                return 0;
            }
            else {
                return hash(formatObjectStructure(value));
            }
    }
}
exports.evalRouteId = evalRouteId;
function formatObjectStructure(obj, memory = void 0) {
    memory || (memory = [obj]);
    let token = "{";
    Object.keys(obj).sort().forEach((key, i) => {
        if (i !== 0) {
            token += "," + key;
        }
        else {
            token += key;
        }
        try {
            if (obj[key] !== null && typeof obj[key] === "object") {
                if (!memory.includes(obj[key])) {
                    memory.push(obj[key]);
                    token += ":" + formatObjectStructure(obj[key], memory);
                }
            }
        }
        catch (e) { }
    });
    return token + "}";
}
//# sourceMappingURL=util.js.map