@vinicunca/perkakas 0.2.1 → 0.3.1

package/dist/commonjs/utils/purry-order-rules.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.purryOrderRulesWithArgument = exports.purryOrderRules = void 0;
+const COMPARATORS = {
+    asc: (x, y) => x > y,
+    desc: (x, y) => x < y,
+};
+function purryOrderRules(func, inputArgs) {
+    const [dataOrRule, ...rules] = (Array.isArray(inputArgs) ? inputArgs : Array.from(inputArgs));
+    if (!isOrderRule(dataOrRule)) {
+        const compareFn = orderRuleComparer(...rules);
+        return func(dataOrRule, compareFn);
+    }
+    const compareFn = orderRuleComparer(dataOrRule, ...rules);
+    return (data) => func(data, compareFn);
+}
+exports.purryOrderRules = purryOrderRules;
+function purryOrderRulesWithArgument(func, inputArgs) {
+    const [first, second, ...rest] = Array.from(inputArgs);
+    let arg;
+    let argRemoved;
+    if (isOrderRule(second)) {
+        arg = first;
+        argRemoved = [second, ...rest];
+    }
+    else {
+        arg = second;
+        argRemoved = [first, ...rest];
+    }
+    return purryOrderRules((...args) => func(...args, arg), argRemoved);
+}
+exports.purryOrderRulesWithArgument = purryOrderRulesWithArgument;
+function orderRuleComparer(primaryRule, secondaryRule, ...otherRules) {
+    const projector = typeof primaryRule === 'function' ? primaryRule : primaryRule[0];
+    const direction = typeof primaryRule === 'function' ? 'asc' : primaryRule[1];
+    const comparator = COMPARATORS[direction];
+    const nextComparer = secondaryRule === undefined
+        ? undefined
+        : orderRuleComparer(secondaryRule, ...otherRules);
+    return (a, b) => {
+        const projectedA = projector(a);
+        const projectedB = projector(b);
+        if (comparator(projectedA, projectedB)) {
+            return 1;
+        }
+        if (comparator(projectedB, projectedA)) {
+            return -1;
+        }
+        return nextComparer?.(a, b) ?? 0;
+    };
+}
+function isOrderRule(x) {
+    if (isProjection(x)) {
+        return true;
+    }
+    if (typeof x !== 'object' || !Array.isArray(x)) {
+        return false;
+    }
+    const [maybeProjection, maybeDirection, ...rest] = x;
+    return (isProjection(maybeProjection)
+        && maybeDirection in COMPARATORS
+        && rest.length === 0);
+}
+function isProjection(x) {
+    return typeof x === 'function' && x.length === 1;
+}

package/dist/commonjs/utils/quick-select.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quickSelect = void 0;
+const swap_in_place_1 = require("./swap-in-place");
+function quickSelect(data, index, compareFn) {
+    return index < 0 || index >= data.length
+        ? undefined
+        : quickSelectImplementation([...data], 0, data.length - 1, index, compareFn);
+}
+exports.quickSelect = quickSelect;
+function quickSelectImplementation(data, left, right, index, compareFn) {
+    if (left === right) {
+        return data[left];
+    }
+    const pivotIndex = partition(data, left, right, compareFn);
+    return index === pivotIndex
+        ? data[index]
+        : quickSelectImplementation(data, index < pivotIndex ? left : pivotIndex + 1, index < pivotIndex ? pivotIndex - 1 : right, index, compareFn);
+}
+function partition(data, left, right, compareFn) {
+    const pivot = data[right];
+    let i = left;
+    for (let j = left; j < right; j++) {
+        if (compareFn(data[j], pivot) < 0) {
+            (0, swap_in_place_1.swapInPlace)(data, i, j);
+            i++;
+        }
+    }
+    (0, swap_in_place_1.swapInPlace)(data, i, right);
+    return i;
+}

package/dist/commonjs/utils/reduce-lazy.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reduceLazy = void 0;
+function reduceLazy(array, lazy, indexed) {
+    const newArray = [];
+    for (let index = 0; index < array.length; index++) {
+        const item = array[index];
+        const result = indexed ? lazy(item, index, array) : lazy(item);
+        if (result.hasMany === true) {
+            newArray.push(...result.next);
+        }
+        else if (result.hasNext) {
+            newArray.push(result.next);
+        }
+    }
+    return newArray;
+}
+exports.reduceLazy = reduceLazy;

package/dist/commonjs/utils/swap-in-place.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swapInPlace = void 0;
+function swapInPlace(data, i, j) {
+    [data[i], data[j]] = [data[j], data[i]];
+}
+exports.swapInPlace = swapInPlace;

package/dist/commonjs/utils/to-lazy-indexed.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toLazyIndexed = void 0;
+function toLazyIndexed(fn) {
+    return Object.assign(fn, { indexed: true });
+}
+exports.toLazyIndexed = toLazyIndexed;

package/dist/commonjs/utils/to-single.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toSingle = void 0;
+function toSingle(fn) {
+    fn.single = true;
+    return fn;
+}
+exports.toSingle = toSingle;

package/dist/commonjs/utils/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/commonjs/utils/with-precision.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withPrecision = void 0;
+const MAX_PRECISION = 15;
+function withPrecision(roundingFn) {
+    return (value, precision) => {
+        if (precision === 0) {
+            return roundingFn(value);
+        }
+        if (!Number.isInteger(precision)) {
+            throw new TypeError(`precision must be an integer: ${precision}`);
+        }
+        if (precision > MAX_PRECISION || precision < -MAX_PRECISION) {
+            throw new RangeError(`precision must be between ${-MAX_PRECISION} and ${MAX_PRECISION}`);
+        }
+        if (Number.isNaN(value) || !Number.isFinite(value)) {
+            return roundingFn(value);
+        }
+        const multiplier = 10 ** precision;
+        return roundingFn(value * multiplier) / multiplier;
+    };
+}
+exports.withPrecision = withPrecision;

package/dist/es/aria/index.js

@@ -0,0 +1 @@
+export * from './key-codes';

package/dist/es/aria/key-codes.js

@@ -0,0 +1,22 @@
+export const KEY_CODES = {
+    ALT: 'Alt',
+    ARROW_DOWN: 'ArrowDown',
+    ARROW_LEFT: 'ArrowLeft',
+    ARROW_RIGHT: 'ArrowRight',
+    ARROW_UP: 'ArrowUp',
+    AT: '@',
+    BACKSPACE: 'Backspace',
+    CTRL: 'Control',
+    DELETE: 'Delete',
+    END: 'End',
+    ENTER: 'Enter',
+    ESC: 'Escape',
+    HOME: 'Home',
+    KEY_F: 'KEY_F',
+    META: 'Meta',
+    PAGE_DOWN: 'PageDown',
+    PAGE_UP: 'PageUp',
+    SHIFT: 'Shift',
+    SPACE: 'Space',
+    TAB: 'Tab',
+};

package/dist/es/array/all-pass.js

@@ -0,0 +1,7 @@
+import { purry } from '../function/purry';
+export function allPass(...args) {
+    return purry(_allPass, args);
+}
+function _allPass(data, fns) {
+    return fns.every((fn) => fn(data));
+}

package/dist/es/array/any-pass.js

@@ -0,0 +1,7 @@
+import { purry } from '../function/purry';
+export function anyPass(...args) {
+    return purry(_anyPass, args);
+}
+function _anyPass(data, fns) {
+    return fns.some((fn) => fn(data));
+}

package/dist/es/array/chunk.js

@@ -0,0 +1,13 @@
+import { purry } from '../function/purry';
+export function chunk(...args) {
+    return purry(_chunk, args);
+}
+function _chunk(array, size) {
+    const ret = Array.from({
+        length: Math.ceil(array.length / size),
+    });
+    for (let index = 0; index < ret.length; index += 1) {
+        ret[index] = array.slice(index * size, (index + 1) * size);
+    }
+    return ret;
+}

package/dist/es/array/compact.js

@@ -0,0 +1,4 @@
+import { isTruthy } from '../guard/is-truthy';
+export function compact(items) {
+    return items.filter(isTruthy);
+}

package/dist/es/array/concat.js

@@ -0,0 +1,7 @@
+import { purry } from '../function/purry';
+export function concat(...args) {
+    return purry(_concat, args);
+}
+function _concat(arr1, arr2) {
+    return arr1.concat(arr2);
+}

package/dist/es/array/count-by.js

@@ -0,0 +1,18 @@
+import { purry } from '../function/purry';
+function _countBy(indexed) {
+    return (array, fn) => {
+        return array.reduce((ret, item, index) => {
+            const value = indexed ? fn(item, index, array) : fn(item);
+            return ret + (value ? 1 : 0);
+        }, 0);
+    };
+}
+export function countBy(...args) {
+    return purry(_countBy(false), args);
+}
+(function (countBy) {
+    function indexed(...args) {
+        return purry(_countBy(true), args);
+    }
+    countBy.indexed = indexed;
+})(countBy || (countBy = {}));

package/dist/es/array/difference-with.js

@@ -0,0 +1,27 @@
+import { purry } from '../function/purry';
+import { reduceLazy } from '../utils/reduce-lazy';
+export function differenceWith(...args) {
+    return purry(_differenceWith, args, differenceWith.lazy);
+}
+function _differenceWith(array, other, isEquals) {
+    const lazy = differenceWith.lazy(other, isEquals);
+    return reduceLazy(array, lazy);
+}
+(function (differenceWith) {
+    function lazy(other, isEquals) {
+        return (value) => {
+            if (other.every((otherValue) => !isEquals(value, otherValue))) {
+                return {
+                    done: false,
+                    hasNext: true,
+                    next: value,
+                };
+            }
+            return {
+                done: false,
+                hasNext: false,
+            };
+        };
+    }
+    differenceWith.lazy = lazy;
+})(differenceWith || (differenceWith = {}));

package/dist/es/array/difference.js

@@ -0,0 +1,28 @@
+import { purry } from '../function/purry';
+import { reduceLazy } from '../utils/reduce-lazy';
+export function difference(...args) {
+    return purry(_difference, args, difference.lazy);
+}
+function _difference(array, other) {
+    const lazy = difference.lazy(other);
+    return reduceLazy(array, lazy);
+}
+(function (difference) {
+    function lazy(other) {
+        const set = new Set(other);
+        return (value) => {
+            if (!set.has(value)) {
+                return {
+                    done: false,
+                    hasNext: true,
+                    next: value,
+                };
+            }
+            return {
+                done: false,
+                hasNext: false,
+            };
+        };
+    }
+    difference.lazy = lazy;
+})(difference || (difference = {}));

package/dist/es/array/drop-first-by.js

@@ -0,0 +1,22 @@
+import { heapMaybeInsert, heapify } from '../utils/heap';
+import { purryOrderRulesWithArgument } from '../utils/purry-order-rules';
+export function dropFirstBy(...args) {
+    return purryOrderRulesWithArgument(dropFirstByImplementation, args);
+}
+function dropFirstByImplementation(data, compareFn, n) {
+    if (n >= data.length) {
+        return [];
+    }
+    if (n <= 0) {
+        return [...data];
+    }
+    const heap = data.slice(0, n);
+    heapify(heap, compareFn);
+    const out = [];
+    const rest = data.slice(n);
+    for (const item of rest) {
+        const previousHead = heapMaybeInsert(heap, compareFn, item);
+        out.push(previousHead ?? item);
+    }
+    return out;
+}

package/dist/es/array/drop-last-while.js

@@ -0,0 +1,12 @@
+import { purry } from '../function/purry';
+export function dropLastWhile(...args) {
+    return purry(_dropLastWhile, args);
+}
+function _dropLastWhile(data, predicate) {
+    for (let i = data.length - 1; i >= 0; i--) {
+        if (!predicate(data[i])) {
+            return data.slice(0, i + 1);
+        }
+    }
+    return [];
+}

package/dist/es/array/drop-last.js

@@ -0,0 +1,11 @@
+import { purry } from '../function/purry';
+export function dropLast(...args) {
+    return purry(_dropLast, args);
+}
+function _dropLast(array, n) {
+    const copy = [...array];
+    if (n > 0) {
+        copy.splice(-n);
+    }
+    return copy;
+}

package/dist/es/array/drop-while.js

@@ -0,0 +1,12 @@
+import { purry } from '../function/purry';
+export function dropWhile(...args) {
+    return purry(_dropWhile, args);
+}
+function _dropWhile(data, predicate) {
+    for (let i = 0; i < data.length; i++) {
+        if (!predicate(data[i])) {
+            return data.slice(i);
+        }
+    }
+    return [];
+}

package/dist/es/array/drop.js

@@ -0,0 +1,28 @@
+import { purry } from '../function/purry';
+import { reduceLazy } from '../utils/reduce-lazy';
+export function drop(...args) {
+    return purry(_drop, args, drop.lazy);
+}
+function _drop(array, n) {
+    return reduceLazy(array, drop.lazy(n));
+}
+(function (drop) {
+    function lazy(n) {
+        let left = n;
+        return (value) => {
+            if (left > 0) {
+                left--;
+                return {
+                    done: false,
+                    hasNext: false,
+                };
+            }
+            return {
+                done: false,
+                hasNext: true,
+                next: value,
+            };
+        };
+    }
+    drop.lazy = lazy;
+})(drop || (drop = {}));

package/dist/es/array/filter.js

@@ -0,0 +1,37 @@
+import { purry } from '../function/purry';
+import { reduceLazy } from '../utils/reduce-lazy';
+import { toLazyIndexed } from '../utils/to-lazy-indexed';
+export function filter(...args) {
+    return purry(filter_(false), args, filter.lazy);
+}
+function filter_(indexed) {
+    return (array, fn) => {
+        return reduceLazy(array, indexed ? filter.lazyIndexed(fn) : filter.lazy(fn), indexed);
+    };
+}
+function lazy_(indexed) {
+    return (fn) => {
+        return (value, index, array) => {
+            const valid = indexed ? fn(value, index, array) : fn(value);
+            if (valid) {
+                return {
+                    done: false,
+                    hasNext: true,
+                    next: value,
+                };
+            }
+            return {
+                done: false,
+                hasNext: false,
+            };
+        };
+    };
+}
+(function (filter) {
+    function indexed(...args) {
+        return purry(filter_(true), args, filter.lazyIndexed);
+    }
+    filter.indexed = indexed;
+    filter.lazy = lazy_(false);
+    filter.lazyIndexed = toLazyIndexed(lazy_(true));
+})(filter || (filter = {}));

package/dist/es/array/find-index.js

@@ -0,0 +1,42 @@
+import { purry } from '../function/purry';
+import { toLazyIndexed } from '../utils/to-lazy-indexed';
+import { toSingle } from '../utils/to-single';
+export function findIndex(...args) {
+    return purry(_findIndex(false), args, findIndex.lazy);
+}
+function _findIndex(indexed) {
+    return (array, fn) => {
+        if (indexed) {
+            return array.findIndex(fn);
+        }
+        return array.findIndex((x) => fn(x));
+    };
+}
+function _lazy(indexed) {
+    return (fn) => {
+        let i = 0;
+        return (value, index, array) => {
+            const valid = indexed ? fn(value, index, array) : fn(value);
+            if (valid) {
+                return {
+                    done: true,
+                    hasNext: true,
+                    next: i,
+                };
+            }
+            i++;
+            return {
+                done: false,
+                hasNext: false,
+            };
+        };
+    };
+}
+(function (findIndex) {
+    function indexed(...args) {
+        return purry(_findIndex(true), args, findIndex.lazyIndexed);
+    }
+    findIndex.indexed = indexed;
+    findIndex.lazy = toSingle(_lazy(false));
+    findIndex.lazyIndexed = toSingle(toLazyIndexed(_lazy(true)));
+})(findIndex || (findIndex = {}));

package/dist/es/array/find-last-index.js

@@ -0,0 +1,20 @@
+import { purry } from '../function/purry';
+export function findLastIndex(...args) {
+    return purry(_findLastIndex(false), args);
+}
+function _findLastIndex(indexed) {
+    return (array, fn) => {
+        for (let i = array.length - 1; i >= 0; i--) {
+            if (indexed ? fn(array[i], i, array) : fn(array[i])) {
+                return i;
+            }
+        }
+        return -1;
+    };
+}
+(function (findLastIndex) {
+    function indexed(...args) {
+        return purry(_findLastIndex(true), args);
+    }
+    findLastIndex.indexed = indexed;
+})(findLastIndex || (findLastIndex = {}));

package/dist/es/array/find-last.js

@@ -0,0 +1,20 @@
+import { purry } from '../function/purry';
+export function findLast(...args) {
+    return purry(_findLast(false), args);
+}
+function _findLast(indexed) {
+    return (array, fn) => {
+        for (let i = array.length - 1; i >= 0; i--) {
+            if (indexed ? fn(array[i], i, array) : fn(array[i])) {
+                return array[i];
+            }
+        }
+        return undefined;
+    };
+}
+(function (findLast) {
+    function indexed(...args) {
+        return purry(_findLast(true), args);
+    }
+    findLast.indexed = indexed;
+})(findLast || (findLast = {}));

package/dist/es/array/find.js

@@ -0,0 +1,34 @@
+import { purry } from '../function/purry';
+import { toLazyIndexed } from '../utils/to-lazy-indexed';
+import { toSingle } from '../utils/to-single';
+export function find(...args) {
+    return purry(_find(false), args, find.lazy);
+}
+function _find(indexed) {
+    return (array, fn) => {
+        if (indexed) {
+            return array.find(fn);
+        }
+        return array.find((x) => fn(x));
+    };
+}
+function _lazy(indexed) {
+    return (fn) => {
+        return (value, index, array) => {
+            const valid = indexed ? fn(value, index, array) : fn(value);
+            return {
+                done: valid,
+                hasNext: valid,
+                next: value,
+            };
+        };
+    };
+}
+(function (find) {
+    function indexed(...args) {
+        return purry(_find(true), args, find.lazyIndexed);
+    }
+    find.indexed = indexed;
+    find.lazy = toSingle(_lazy(false));
+    find.lazyIndexed = toSingle(toLazyIndexed(_lazy(true)));
+})(find || (find = {}));

package/dist/es/array/first-by.js

@@ -0,0 +1,18 @@
+import { purryOrderRules } from '../utils/purry-order-rules';
+import { hasAtLeast } from './has-at-least';
+export function firstBy(...args) {
+    return purryOrderRules(firstByImplementation, args);
+}
+function firstByImplementation(data, compareFn) {
+    if (!hasAtLeast(data, 2)) {
+        return data[0];
+    }
+    let [currentFirst] = data;
+    const [, ...rest] = data;
+    for (const item of rest) {
+        if (compareFn(item, currentFirst) < 0) {
+            currentFirst = item;
+        }
+    }
+    return currentFirst;
+}

package/dist/es/array/first.js

@@ -0,0 +1,22 @@
+import { purry } from '../function/purry';
+export function first(...args) {
+    return purry(_first, args, first.lazy);
+}
+function _first([first]) {
+    return first;
+}
+(function (first) {
+    function lazy() {
+        return (value) => {
+            return {
+                done: true,
+                hasNext: true,
+                next: value,
+            };
+        };
+    }
+    first.lazy = lazy;
+    (function (lazy) {
+        lazy.single = true;
+    })(lazy = first.lazy || (first.lazy = {}));
+})(first || (first = {}));

package/dist/es/array/flat-map-to-obj.js

@@ -0,0 +1,21 @@
+import { purry } from '../function/purry';
+export function flatMapToObj(...args) {
+    return purry(_flatMapToObj(false), args);
+}
+function _flatMapToObj(indexed) {
+    return (array, fn) => {
+        return array.reduce((result, element, index) => {
+            const items = indexed ? fn(element, index, array) : fn(element);
+            items.forEach(([key, value]) => {
+                result[key] = value;
+            });
+            return result;
+        }, {});
+    };
+}
+(function (flatMapToObj) {
+    function indexed(...args) {
+        return purry(_flatMapToObj(true), args);
+    }
+    flatMapToObj.indexed = indexed;
+})(flatMapToObj || (flatMapToObj = {}));

package/dist/es/array/flat-map.js

@@ -0,0 +1,29 @@
+import { purry } from '../function/purry';
+import { flatten } from './flatten';
+export function flatMap(...args) {
+    return purry(_flatMap, args, flatMap.lazy);
+}
+function _flatMap(array, fn) {
+    return flatten(array.map((item) => fn(item)));
+}
+(function (flatMap) {
+    function lazy(fn) {
+        return (value) => {
+            const next = fn(value);
+            if (Array.isArray(next)) {
+                return {
+                    done: false,
+                    hasMany: true,
+                    hasNext: true,
+                    next,
+                };
+            }
+            return {
+                done: false,
+                hasNext: true,
+                next,
+            };
+        };
+    }
+    flatMap.lazy = lazy;
+})(flatMap || (flatMap = {}));