@carlosv2/glue/dist/esm/utils.js

Dependency injection library that stays out of the way

var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
    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) : adopt(result.value).then(fulfilled, rejected); }
        step((generator = generator.apply(thisArg, _arguments || [])).next());
    });
};
export const library = '@carlosv2/glue';
export function isNull(value) {
    return value === null;
}
export function isSymbol(value) {
    return typeof value === 'symbol';
}
export function isString(value) {
    return typeof value === 'string';
}
export function isNumber(value) {
    return typeof value === 'number';
}
export function isObject(value) {
    return !isNull(value) && typeof value === 'object';
}
export function isBoolean(value) {
    return typeof value === 'boolean';
}
export function isUndefined(value) {
    return typeof value === 'undefined';
}
export function isFunction(value) {
    return typeof value === 'function';
}
export function isArray(value) {
    return Array.isArray(value);
}
export function isDictionary(value) {
    return isObject(value) && value.constructor.name === 'Object';
}
export function zip([ts, ys]) {
    const length = Math.min(ts.length, ys.length);
    const result = [];
    for (let i = 0; i < length; i++) {
        result.push([ts[i], ys[i]]);
    }
    return result;
}
export function zipObject(keys, values) {
    return Object.fromEntries(zip([keys, values]));
}
export function unzip(data) {
    const ts = [];
    const ys = [];
    data.forEach(([t, y]) => {
        ts.push(t);
        ys.push(y);
    });
    return [ts, ys];
}
export function has(key, obj) {
    return key in obj;
}
export function gibberish(length) {
    const generate = () => Math.random().toString(36).substring(2);
    let result = '';
    while (result.length < length)
        result += generate();
    return result.substring(0, length);
}
export function uniq(items) {
    return Array.from(new Set(items));
}
export function isFirstChar(value, char) {
    return (value.length > 1 && value.charAt(0) === char && value.charAt(1) !== char);
}
export function getCallerFile() {
    const oldPrepareStackTrace = Error.prepareStackTrace;
    Error.prepareStackTrace = (_, stack) => stack;
    const stack = new Error().stack;
    Error.prepareStackTrace = oldPrepareStackTrace;
    if (stack !== null && typeof stack === 'object') {
        return stack[3] ? stack[3].getFileName() : undefined;
    }
    return undefined;
}
export function resolvePromises(obj) {
    return __awaiter(this, void 0, void 0, function* () {
        const [keys, promises] = unzip(Object.entries(obj));
        const values = yield Promise.all(promises);
        return zipObject(keys, values);
    });
}