@vinicunca/perkakas 0.2.1 → 0.3.1

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

@@ -0,0 +1,48 @@
+import { purry } from '../function/purry';
+const ALL_DIRECTIONS = ['asc', 'desc'];
+const COMPARATOR = {
+    asc: (x, y) => x > y,
+    desc: (x, y) => x < y,
+};
+export function sortBy(arrayOrSortRule, ...sortRules) {
+    const args = isSortRule(arrayOrSortRule)
+        ? [[arrayOrSortRule, ...sortRules]]
+        : [arrayOrSortRule, sortRules];
+    return purry(_sortBy, args);
+}
+function isSortRule(x) {
+    if (typeof x === 'function') {
+        return true;
+    }
+    const [maybeProjection, maybeDirection, ...rest] = x;
+    if (rest.length > 0) {
+        return false;
+    }
+    return (typeof maybeProjection === 'function'
+        && ALL_DIRECTIONS.includes(maybeDirection));
+}
+function _sortBy(array, sorts) {
+    return [...array].sort(comparer(...sorts));
+}
+function comparer(primaryRule, secondaryRule, ...otherRules) {
+    const projector = typeof primaryRule === 'function' ? primaryRule : primaryRule[0];
+    const direction = typeof primaryRule === 'function' ? 'asc' : primaryRule[1];
+    const comparator = COMPARATOR[direction];
+    const nextComparer = secondaryRule === undefined
+        ? undefined
+        : comparer(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 (sortBy) {
+    sortBy.strict = sortBy;
+})(sortBy || (sortBy = {}));

package/dist/es/array/sort.js

@@ -0,0 +1,12 @@
+import { purry } from '../function/purry';
+export function sort(...args) {
+    return purry(_sort, args);
+}
+function _sort(items, cmp) {
+    const ret = [...items];
+    ret.sort(cmp);
+    return ret;
+}
+(function (sort) {
+    sort.strict = sort;
+})(sort || (sort = {}));

package/dist/es/array/splice.js

@@ -0,0 +1,9 @@
+import { purry } from '../function/purry';
+export function splice(...args) {
+    return purry(_splice, args);
+}
+function _splice(items, start, deleteCount, replacement) {
+    const result = [...items];
+    result.splice(start, deleteCount, ...replacement);
+    return result;
+}

package/dist/es/array/split-at.js

@@ -0,0 +1,9 @@
+import { purry } from '../function/purry';
+export function splitAt(...args) {
+    return purry(_splitAt, args);
+}
+function _splitAt(array, index) {
+    const copy = [...array];
+    const tail = copy.splice(index);
+    return [copy, tail];
+}

package/dist/es/array/split-when.js

@@ -0,0 +1,13 @@
+import { purry } from '../function/purry';
+import { splitAt } from './split-at';
+export function splitWhen(...args) {
+    return purry(_splitWhen, args);
+}
+function _splitWhen(array, fn) {
+    for (let i = 0; i < array.length; i++) {
+        if (fn(array[i])) {
+            return splitAt(array, i);
+        }
+    }
+    return [array, []];
+}

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

@@ -0,0 +1,20 @@
+import { purry } from '../function/purry';
+function _sumBy(indexed) {
+    return (array, fn) => {
+        let sum = 0;
+        array.forEach((item, i) => {
+            const summand = indexed ? fn(item, i, array) : fn(item);
+            sum += summand;
+        });
+        return sum;
+    };
+}
+export function sumBy(...args) {
+    return purry(_sumBy(false), args);
+}
+(function (sumBy) {
+    function indexed(...args) {
+        return purry(_sumBy(true), args);
+    }
+    sumBy.indexed = indexed;
+})(sumBy || (sumBy = {}));

package/dist/es/array/swap-indices.js

@@ -0,0 +1,30 @@
+import { purry } from '../function/purry';
+export function swapIndices(...args) {
+    return purry(_swapIndices, args);
+}
+function _swapIndices(item, index1, index2) {
+    return typeof item === 'string'
+        ? _swapString(item, index1, index2)
+        : _swapArray(item, index1, index2);
+}
+function _swapArray(item, index1, index2) {
+    const result = item.slice();
+    if (Number.isNaN(index1) || Number.isNaN(index2)) {
+        return result;
+    }
+    const positiveIndexA = index1 < 0 ? item.length + index1 : index1;
+    const positiveIndexB = index2 < 0 ? item.length + index2 : index2;
+    if (positiveIndexA < 0 || positiveIndexA > item.length) {
+        return result;
+    }
+    if (positiveIndexB < 0 || positiveIndexB > item.length) {
+        return result;
+    }
+    result[positiveIndexA] = item[positiveIndexB];
+    result[positiveIndexB] = item[positiveIndexA];
+    return result;
+}
+function _swapString(item, index1, index2) {
+    const result = _swapArray(item.split(''), index1, index2);
+    return result.join('');
+}

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

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

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

@@ -0,0 +1,14 @@
+import { purry } from '../function/purry';
+export function takeWhile(...args) {
+    return purry(_takeWhile, args);
+}
+function _takeWhile(array, fn) {
+    const ret = [];
+    for (const item of array) {
+        if (!fn(item)) {
+            break;
+        }
+        ret.push(item);
+    }
+    return ret;
+}

package/dist/es/array/take.js

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

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

@@ -0,0 +1,26 @@
+import { purry } from '../function/purry';
+import { reduceLazy } from '../utils/reduce-lazy';
+export function uniqBy(...args) {
+    return purry(_uniqBy, args, lazyUniqBy);
+}
+function _uniqBy(array, transformer) {
+    return reduceLazy(array, lazyUniqBy(transformer));
+}
+function lazyUniqBy(transformer) {
+    const set = new Set();
+    return (value) => {
+        const appliedItem = transformer(value);
+        if (set.has(appliedItem)) {
+            return {
+                done: false,
+                hasNext: false,
+            };
+        }
+        set.add(appliedItem);
+        return {
+            done: false,
+            hasNext: true,
+            next: value,
+        };
+    };
+}

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

@@ -0,0 +1,29 @@
+import { purry } from '../function/purry';
+import { reduceLazy } from '../utils/reduce-lazy';
+import { toLazyIndexed } from '../utils/to-lazy-indexed';
+export function uniqWith(...args) {
+    return purry(_uniqWith, args, uniqWith.lazy);
+}
+function _uniqWith(array, isEquals) {
+    const lazy = uniqWith.lazy(isEquals);
+    return reduceLazy(array, lazy, true);
+}
+function _lazy(isEquals) {
+    return (value, index, array) => {
+        if (array
+            && array.findIndex((otherValue) => isEquals(value, otherValue)) === index) {
+            return {
+                done: false,
+                hasNext: true,
+                next: value,
+            };
+        }
+        return {
+            done: false,
+            hasNext: false,
+        };
+    };
+}
+(function (uniqWith) {
+    uniqWith.lazy = toLazyIndexed(_lazy);
+})(uniqWith || (uniqWith = {}));

package/dist/es/array/uniq.js

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

package/dist/es/array/zip-obj.js

@@ -0,0 +1,12 @@
+import { purry } from '../function/purry';
+export function zipObj(...args) {
+    return purry(_zipObj, args);
+}
+function _zipObj(first, second) {
+    const resultLength = first.length > second.length ? second.length : first.length;
+    const result = {};
+    for (let i = 0; i < resultLength; i++) {
+        result[first[i]] = second[i];
+    }
+    return result;
+}

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

@@ -0,0 +1,19 @@
+export function zipWith(arg0, arg1, arg2) {
+    if (typeof arg0 === 'function') {
+        return arg1 === undefined
+            ? (f, s) => _zipWith(f, s, arg0)
+            : (f) => _zipWith(f, arg1, arg0);
+    }
+    if (arg1 === undefined || arg2 === undefined) {
+        throw new Error('zipWith: Missing arguments in dataFirst function call');
+    }
+    return _zipWith(arg0, arg1, arg2);
+}
+function _zipWith(first, second, fn) {
+    const resultLength = first.length > second.length ? second.length : first.length;
+    const result = [];
+    for (let i = 0; i < resultLength; i++) {
+        result.push(fn(first[i], second[i]));
+    }
+    return result;
+}

package/dist/es/array/zip.js

@@ -0,0 +1,15 @@
+import { purry } from '../function/purry';
+export function zip(...args) {
+    return purry(_zip, args);
+}
+function _zip(first, second) {
+    const resultLength = first.length > second.length ? second.length : first.length;
+    const result = [];
+    for (let i = 0; i < resultLength; i++) {
+        result.push([first[i], second[i]]);
+    }
+    return result;
+}
+(function (zip) {
+    zip.strict = zip;
+})(zip || (zip = {}));

package/dist/es/function/conditional.js

@@ -0,0 +1,30 @@
+import { purryOn } from '../utils/purry-on';
+export function conditional(...args) {
+    return purryOn(isCase, conditionalImplementation, args);
+}
+function conditionalImplementation(data, ...cases) {
+    for (const [when, then] of cases) {
+        if (when(data)) {
+            return then(data);
+        }
+    }
+    throw new Error('conditional: data failed for all cases');
+}
+function isCase(maybeCase) {
+    if (!Array.isArray(maybeCase)) {
+        return false;
+    }
+    const [when, then, ...rest] = maybeCase;
+    return (typeof when === 'function'
+        && when.length <= 1
+        && typeof then === 'function'
+        && then.length <= 1
+        && rest.length === 0);
+}
+const trivialDefaultCase = () => undefined;
+(function (conditional) {
+    function defaultCase(then = trivialDefaultCase) {
+        return [() => true, then];
+    }
+    conditional.defaultCase = defaultCase;
+})(conditional || (conditional = {}));

package/dist/es/function/create-pipe.js

@@ -0,0 +1,4 @@
+import { pipe } from './pipe';
+export function createPipe(...operations) {
+    return (value) => pipe(value, ...operations);
+}

package/dist/es/function/debounce.js

@@ -0,0 +1,84 @@
+export function debounce(func, { maxWaitMs, timing = 'trailing', waitMs, }) {
+    if (maxWaitMs !== undefined && waitMs !== undefined && maxWaitMs < waitMs) {
+        throw new Error(`debounce: maxWaitMs (${maxWaitMs}) cannot be less than waitMs (${waitMs})`);
+    }
+    let coolDownTimeoutId;
+    let maxWaitTimeoutId;
+    let latestCallArgs;
+    let result;
+    function handleDebouncedCall(args) {
+        latestCallArgs = args;
+        if (maxWaitMs !== undefined && maxWaitTimeoutId === undefined) {
+            maxWaitTimeoutId = setTimeout(handleInvoke, maxWaitMs);
+        }
+    }
+    function handleInvoke() {
+        if (latestCallArgs === undefined) {
+            return;
+        }
+        if (maxWaitTimeoutId !== undefined) {
+            const timeoutId = maxWaitTimeoutId;
+            maxWaitTimeoutId = undefined;
+            clearTimeout(timeoutId);
+        }
+        const args = latestCallArgs;
+        latestCallArgs = undefined;
+        result = func(...args);
+    }
+    function handleCoolDownEnd() {
+        if (coolDownTimeoutId === undefined) {
+            return;
+        }
+        const timeoutId = coolDownTimeoutId;
+        coolDownTimeoutId = undefined;
+        clearTimeout(timeoutId);
+        if (latestCallArgs !== undefined) {
+            handleInvoke();
+        }
+    }
+    return {
+        get cachedValue() {
+            return result;
+        },
+        call: (...args) => {
+            if (coolDownTimeoutId === undefined) {
+                if (timing === 'trailing') {
+                    handleDebouncedCall(args);
+                }
+                else {
+                    result = func(...args);
+                }
+            }
+            else {
+                if (timing !== 'leading') {
+                    handleDebouncedCall(args);
+                }
+                const timeoutId = coolDownTimeoutId;
+                coolDownTimeoutId = undefined;
+                clearTimeout(timeoutId);
+            }
+            coolDownTimeoutId = setTimeout(handleCoolDownEnd, waitMs ?? maxWaitMs ?? 0);
+            return result;
+        },
+        cancel: () => {
+            if (coolDownTimeoutId !== undefined) {
+                const timeoutId = coolDownTimeoutId;
+                coolDownTimeoutId = undefined;
+                clearTimeout(timeoutId);
+            }
+            if (maxWaitTimeoutId !== undefined) {
+                const timeoutId = maxWaitTimeoutId;
+                maxWaitTimeoutId = undefined;
+                clearTimeout(timeoutId);
+            }
+            latestCallArgs = undefined;
+        },
+        flush: () => {
+            handleCoolDownEnd();
+            return result;
+        },
+        get isPending() {
+            return coolDownTimeoutId !== undefined;
+        },
+    };
+}

package/dist/es/function/identity.js

@@ -0,0 +1,3 @@
+export function identity(value) {
+    return value;
+}

package/dist/es/function/index.js

@@ -0,0 +1,9 @@
+export * from './conditional';
+export * from './create-pipe';
+export * from './identity';
+export * from './noop';
+export * from './once';
+export * from './debounce';
+export * from './pipe';
+export * from './purry';
+export * from './sleep';

package/dist/es/function/noop.js

@@ -0,0 +1,3 @@
+export function noop() {
+    return undefined;
+}

package/dist/es/function/once.js

@@ -0,0 +1,11 @@
+export function once(fn) {
+    let called = false;
+    let ret;
+    return () => {
+        if (!called) {
+            ret = fn();
+            called = true;
+        }
+        return ret;
+    };
+}

package/dist/es/function/pipe.js

@@ -0,0 +1,102 @@
+export function pipe(input, ...operations) {
+    let output = input;
+    const lazyOperations = operations.map((op) => 'lazy' in op ? toPipedLazy(op) : undefined);
+    let operationIndex = 0;
+    while (operationIndex < operations.length) {
+        const lazyOperation = lazyOperations[operationIndex];
+        if (lazyOperation === undefined || !isIterable(output)) {
+            const operation = operations[operationIndex];
+            output = operation(output);
+            operationIndex++;
+            continue;
+        }
+        const lazySequence = [];
+        for (let j = operationIndex; j < operations.length; j++) {
+            const lazyOp = lazyOperations[j];
+            if (lazyOp === undefined) {
+                break;
+            }
+            lazySequence.push(lazyOp);
+            if (lazyOp.isSingle) {
+                break;
+            }
+        }
+        const accumulator = [];
+        const iterator = output[Symbol.iterator]();
+        while (true) {
+            const result = iterator.next();
+            if (result.done ?? false) {
+                break;
+            }
+            const shouldExitEarly = processItem_(result.value, accumulator, lazySequence);
+            if (shouldExitEarly) {
+                break;
+            }
+        }
+        const { isSingle } = lazySequence[lazySequence.length - 1];
+        if (isSingle) {
+            output = accumulator[0];
+        }
+        else {
+            output = accumulator;
+        }
+        operationIndex += lazySequence.length;
+    }
+    return output;
+}
+function processItem_(item, accumulator, lazySequence) {
+    if (lazySequence.length === 0) {
+        accumulator.push(item);
+        return false;
+    }
+    let lazyResult = { done: false, hasNext: false };
+    let isDone = false;
+    for (let i = 0; i < lazySequence.length; i++) {
+        const lazyFn = lazySequence[i];
+        const { index, isIndexed, items } = lazyFn;
+        items.push(item);
+        lazyResult = isIndexed ? lazyFn(item, index, items) : lazyFn(item);
+        lazyFn.index++;
+        if (lazyResult.hasNext) {
+            if (lazyResult.hasMany) {
+                const nextValues = lazyResult.next;
+                for (const subItem of nextValues) {
+                    const subResult = processItem_(subItem, accumulator, lazySequence.slice(i + 1));
+                    if (subResult) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            else {
+                item = lazyResult.next;
+            }
+        }
+        if (!lazyResult.hasNext) {
+            break;
+        }
+        if (lazyResult.done) {
+            isDone = true;
+        }
+    }
+    if (lazyResult.hasNext) {
+        accumulator.push(item);
+    }
+    return isDone;
+}
+function toPipedLazy(op) {
+    const { lazy, lazyArgs } = op;
+    const fn = lazy(...(lazyArgs ?? []));
+    return Object.assign(fn, {
+        index: 0,
+        isIndexed: lazy.indexed,
+        isSingle: lazy.single,
+        items: [],
+    });
+}
+function isIterable(something) {
+    return (typeof something === 'string'
+        || (typeof something === 'object'
+            && something !== null
+            && Symbol.iterator in something));
+}

package/dist/es/function/purry.js

@@ -0,0 +1,16 @@
+export function purry(fn, args, lazy) {
+    const diff = fn.length - args.length;
+    const arrayArgs = Array.from(args);
+    if (diff === 0) {
+        return fn(...arrayArgs);
+    }
+    if (diff === 1) {
+        const ret = (data) => fn(data, ...arrayArgs);
+        if (lazy || fn.lazy) {
+            ret.lazy = lazy || fn.lazy;
+            ret.lazyArgs = args;
+        }
+        return ret;
+    }
+    throw new Error('Wrong number of arguments');
+}

package/dist/es/function/sleep.js

@@ -0,0 +1,5 @@
+export function sleep(timeout) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, timeout);
+    });
+}

package/dist/es/guard/index.js

@@ -0,0 +1,16 @@
+export * from './is-array';
+export * from './is-boolean';
+export * from './is-date';
+export * from './is-defined';
+export * from './is-empty';
+export * from './is-error';
+export * from './is-function';
+export * from './is-nil';
+export * from './is-non-null';
+export * from './is-not';
+export * from './is-number';
+export * from './is-object';
+export * from './is-promise';
+export * from './is-string';
+export * from './is-symbol';
+export * from './is-truthy';

package/dist/es/guard/is-array.js

@@ -0,0 +1,3 @@
+export function isArray(data) {
+    return Array.isArray(data);
+}

package/dist/es/guard/is-boolean.js

@@ -0,0 +1,3 @@
+export function isBoolean(data) {
+    return typeof data === 'boolean';
+}

package/dist/es/guard/is-date.js

@@ -0,0 +1,3 @@
+export function isDate(data) {
+    return data instanceof Date;
+}