armpit/dist/tsUtils.js

Another resource manager programming interface toolkit.

export class CallableClassBase {
    constructor() {
        const closure = function (...args) {
            // eslint-disable-next-line @typescript-eslint/no-explicit-any
            return closure.fnImpl(...args);
        };
        return Object.setPrototypeOf(closure, new.target.prototype);
    }
}
export function isStringValueOrValueArrayEqual(a, b, opt) {
    if (a == null) {
        return b == null;
    }
    if (b == null) {
        return false;
    }
    if (typeof a === "string") {
        if (typeof b === "string") {
            return a === b;
        }
        a = [a];
    }
    else {
        if (typeof b === "string") {
            b = [b];
        }
    }
    return isStringValueArrayEqual(a, b, opt);
}
export function isStringValueArrayEqual(a, b, opt) {
    if (a.length !== b.length) {
        return false;
    }
    if (opt?.sort) {
        a = [...a];
        b = [...b];
        if (opt.sort === true) {
            a.sort();
            b.sort();
        }
        else {
            a.sort(opt.sort);
            b.sort(opt.sort);
        }
    }
    for (let i = 0; i < a.length; i++) {
        const aValue = a[i];
        if (aValue == null) {
            if (b[i] != null) {
                return false;
            }
        }
        else if (aValue !== b[i]) {
            return false;
        }
    }
    return true;
}
export function isArrayEqual(a, b, equals) {
    if (a.length !== b.length) {
        return false;
    }
    if (a.length === 0) {
        return true;
    }
    equals ??= (a, b) => a == b;
    for (let i = 0; i < a.length; i++) {
        if (!equals(a[i], b[i])) {
            return false;
        }
    }
    return true;
}
export function isArrayEqualUnordered(a, b, equals) {
    if (a.length !== b.length) {
        return false;
    }
    if (a.length === 0) {
        return true;
    }
    equals ??= (a, b) => a == b;
    const aSearch = [...a];
    const bSearch = [...b];
    for (let aIndex = 0; aIndex < aSearch.length;) {
        const aItem = aSearch[aIndex];
        const bIndex = bSearch.findIndex(bItem => equals(aItem, bItem));
        if (bIndex >= 0) {
            aSearch.splice(aIndex, 1);
            bSearch.splice(bIndex, 1);
        }
        else {
            return false; // unmatched item
        }
    }
    return aSearch.length === 0 && bSearch.length === 0;
}
export function isObjectShallowEqual(a, b) {
    if (a == null) {
        return b == null;
    }
    else if (b == null) {
        return false;
    }
    const aKeys = Object.keys(a);
    const bKeys = Object.keys(b);
    if (aKeys.length !== bKeys.length) {
        return false;
    }
    for (const key of aKeys) {
        if (a[key] != b[key]) {
            return false;
        }
    }
    return true;
}
export function mergeAbortSignals(...args) {
    const signals = args.filter(s => s != null);
    if (signals.length === 1) {
        return signals[0];
    }
    else if (signals.length > 1) {
        return AbortSignal.any(signals);
    }
    else {
        return null;
    }
}
export function isTemplateStringArray(value) {
    return value != null && Array.isArray(value);
}
export function isPromiseLike(value) {
    return (value != null &&
        (typeof value === "object" || typeof value === "function") &&
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        typeof value.then === "function");
}
export function isStringy(value) {
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    return value != null && typeof value.toString === "function";
}
export function isAbortSignal(value) {
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    return value != null && typeof value.aborted === "boolean";
}
export function isThrowableAbortSignal(value) {
    // eslint-disable-next-line @typescript-eslint/no-explicit-any
    return isAbortSignal(value) && typeof value.throwIfAborted === "function";
}
export function isPrimitiveValue(value) {
    if (value == null) {
        return true;
    }
    switch (typeof value) {
        case "bigint":
        case "boolean":
        case "number":
        case "string":
        case "undefined":
            return true;
        default:
            return false;
    }
}
export function filterProperties(object, ...keys) {
    return Object.fromEntries(Object.entries(object).filter(pair => keys.includes(pair[0])));
}
export function pickValues(object, ...keys) {
    return keys.map(k => object[k]);
}
//# sourceMappingURL=tsUtils.js.map