doddle/dist/cjs/utils.js

Tiny yet feature-packed (async) iteration toolkit.

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.isPosInt = exports.isPair = exports.isBool = exports.isInt = exports.orderedStages = void 0;
exports._iter = _iter;
exports._aiter = _aiter;
exports._xiter = _xiter;
exports.isObject = isObject;
exports.isFunction = isFunction;
exports.isArrayLike = isArrayLike;
exports.isIterable = isIterable;
exports.isAsyncIterable = isAsyncIterable;
exports.isReadableStream = isReadableStream;
exports.isNextable = isNextable;
exports.getClassName = getClassName;
exports.getValueDesc = getValueDesc;
exports.isThenable = isThenable;
exports.isDoddle = isDoddle;
exports.returnKvp = returnKvp;
exports.shuffleArray = shuffleArray;
exports.createCompare = createCompare;
exports.createCompareKey = createCompareKey;
const index_js_1 = require("./doddle/index.js");
function _iter(input) {
    return input[Symbol.iterator]();
}
function _aiter(input) {
    return input[Symbol.asyncIterator]();
}
function _xiter(input) {
    return isAsyncIterable(input) ? _aiter(input) : _iter(input);
}
function isObject(value) {
    return typeof value === "object" && value != null;
}
function isFunction(value) {
    return typeof value === "function";
}
function isArrayLike(value) {
    return isObject(value) && (0, exports.isInt)(value.length);
}
function isIterable(value) {
    return isObject(value) && isFunction(value[Symbol.iterator]);
}
exports.orderedStages = [undefined, "before", "after", "both"];
exports.isInt = Number.isSafeInteger;
const isBool = (value) => !!value === value;
exports.isBool = isBool;
const isPair = (value) => Array.isArray(value) && value.length === 2;
exports.isPair = isPair;
const isPosInt = (value) => (0, exports.isInt)(value) && value > 0;
exports.isPosInt = isPosInt;
function isAsyncIterable(value) {
    return isObject(value) && isFunction(value[Symbol.asyncIterator]);
}
function isReadableStream(value) {
    return isObject(value) && isFunction(value.getReader);
}
function isNextable(value) {
    // Checks if value is an iterator
    return isObject(value) && isFunction(value.next);
}
function getClassName(something) {
    if (something === null) {
        return "null";
    }
    if (!isObject(something)) {
        return typeof something;
    }
    const ctorName = something.constructor?.name ?? something?.[Symbol.toStringTag] ?? "Object";
    return ctorName;
}
function getValueDesc(object) {
    if (object == null) {
        return `${object}`;
    }
    if (isFunction(object)) {
        return `function ${object.name || "<anonymous>"}`;
    }
    if (typeof object === "bigint") {
        return `${object}n`;
    }
    if (typeof object === "symbol") {
        return object.description;
    }
    if (typeof object === "string") {
        if (object.length > 30) {
            object = object.slice(0, 30) + "⋯";
        }
        return `"${object}"`;
    }
    if (isObject(object)) {
        if (isDoddle(object)) {
            return object.toString();
        }
        if (isNextable(object)) {
            return `iterator ${getClassName(object)}`;
        }
        else if (isIterable(object)) {
            return `iterable ${getClassName(object)}`;
        }
        else if (isAsyncIterable(object)) {
            return `async iterable ${getClassName(object)}`;
        }
        else if (isDoddle(object)) {
            return object.toString();
        }
        else if (isThenable(object)) {
            return `a Promise`;
        }
        else {
            return `object ${getClassName(object)}`;
        }
    }
    return `${object}`;
}
/**
 * Checks if the given value is a thenable.
 *
 * @param what The value to check.
 */
function isThenable(what) {
    return isObject(what) && isFunction(what.then);
}
function isDoddle(value) {
    return isObject(value) && isFunction(value.pull);
}
function returnKvp(input, key, value) {
    key = (0, index_js_1.pull)(key);
    if (isAsyncIterable(input) && isThenable(key)) {
        return key.then(key => [(0, index_js_1.pull)(key), value]);
    }
    return [key, value];
}
function shuffleArray(array) {
    for (let i = array.length - 1; i > 0; i--) {
        const j = Math.floor(Math.random() * (i + 1));
        const temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
    return array;
}
function createCompare(desc) {
    const baseCompare = (a, b) => (desc ? -1 : 1) * (a < b ? -1 : a > b ? 1 : 0);
    return (a, b) => {
        if (Array.isArray(a) && Array.isArray(b)) {
            for (let i = 0; i < a.length; i++) {
                const result = baseCompare(a[i], b[i]);
                if (result !== 0) {
                    return result;
                }
            }
            return 0;
        }
        return baseCompare(a, b);
    };
}
function createCompareKey(desc) {
    const compare = createCompare(desc);
    return (a, b) => {
        return compare(a[0], b[0]);
    };
}
//# sourceMappingURL=utils.js.map