@vinicunca/perkakas 0.3.1 → 0.3.5

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

@@ -1,47 +1,9 @@
-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);
+import { purryOrderRules } from '../utils/purry-order-rules';
+export function sortBy(...args) {
+    return purryOrderRules(_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(data, compareFn) {
+    return data.slice().sort(compareFn);
 }
 (function (sortBy) {
     sortBy.strict = sortBy;

package/dist/es/array/sort.js

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

package/dist/es/array/sorted-index-by.js

@@ -0,0 +1,15 @@
+import { purry } from '../function/purry';
+import { binarySearchCutoffIndex } from '../utils/binary-search-cutoff-index';
+export function sortedIndexBy(...args) {
+    return purry(sortedIndexByImplementation, args);
+}
+(function (sortedIndexBy) {
+    function indexed(...args) {
+        return purry(sortedIndexByImplementation, args);
+    }
+    sortedIndexBy.indexed = indexed;
+})(sortedIndexBy || (sortedIndexBy = {}));
+function sortedIndexByImplementation(array, item, valueFunction) {
+    const value = valueFunction(item);
+    return binarySearchCutoffIndex(array, (pivot, index) => valueFunction(pivot, index) < value);
+}

package/dist/es/array/sorted-index-with.js

@@ -0,0 +1,11 @@
+import { purry } from '../function/purry';
+import { binarySearchCutoffIndex } from '../utils/binary-search-cutoff-index';
+export function sortedIndexWith(...args) {
+    return purry(binarySearchCutoffIndex, args);
+}
+(function (sortedIndexWith) {
+    function indexed(...args) {
+        return purry(binarySearchCutoffIndex, args);
+    }
+    sortedIndexWith.indexed = indexed;
+})(sortedIndexWith || (sortedIndexWith = {}));

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

@@ -0,0 +1,8 @@
+import { purry } from '../function/purry';
+import { binarySearchCutoffIndex } from '../utils/binary-search-cutoff-index';
+export function sortedIndex(...args) {
+    return purry(sortedIndexImplementation, args);
+}
+function sortedIndexImplementation(array, item) {
+    return binarySearchCutoffIndex(array, (pivot) => pivot < item);
+}

package/dist/es/array/sorted-last-index-by.js

@@ -0,0 +1,15 @@
+import { purry } from '../function/purry';
+import { binarySearchCutoffIndex } from '../utils/binary-search-cutoff-index';
+export function sortedLastIndexBy(...args) {
+    return purry(sortedLastIndexByImplementation, args);
+}
+(function (sortedLastIndexBy) {
+    function indexed(...args) {
+        return purry(sortedLastIndexByImplementation, args);
+    }
+    sortedLastIndexBy.indexed = indexed;
+})(sortedLastIndexBy || (sortedLastIndexBy = {}));
+function sortedLastIndexByImplementation(array, item, valueFunction) {
+    const value = valueFunction(item);
+    return binarySearchCutoffIndex(array, (pivot, index) => valueFunction(pivot, index) <= value);
+}

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

@@ -0,0 +1,8 @@
+import { purry } from '../function/purry';
+import { binarySearchCutoffIndex } from '../utils/binary-search-cutoff-index';
+export function sortedLastIndex(...args) {
+    return purry(sortedLastIndexImplementation, args);
+}
+function sortedLastIndexImplementation(array, item) {
+    return binarySearchCutoffIndex(array, (pivot) => pivot <= item);
+}

package/dist/es/array/splice.js

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

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

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

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

@@ -1,13 +1,13 @@
 import { purry } from '../function/purry';
 import { splitAt } from './split-at';
 export function splitWhen(...args) {
-    return purry(_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);
+function splitWhen_(array, fn) {
+    for (const [index, item] of array.entries()) {
+        if (fn(item)) {
+            return splitAt(array, index);
         }
     }
-    return [array, []];
+    return [array.slice(), []];
 }

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

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

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

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

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

@@ -8,7 +8,7 @@ function takeFirstByImplementation(data, compareFn, n) {
         return [];
     }
     if (n >= data.length) {
-        return [...data];
+        return data.slice();
     }
     const heap = data.slice(0, n);
     heapify(heap, compareFn);

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

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

package/dist/es/array/take.js

@@ -1,33 +1,20 @@
 import { purry } from '../function/purry';
 import { reduceLazy } from '../utils/reduce-lazy';
 export function take(...args) {
-    return purry(_take, args, take.lazy);
+    return purry(take_, args, take.lazy);
 }
-function _take(array, n) {
+function take_(array, n) {
     return reduceLazy(array, take.lazy(n));
 }
 (function (take) {
     function lazy(n) {
+        if (n <= 0) {
+            return () => ({ done: true, hasNext: false });
+        }
+        let remaining = 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,
-            };
+            remaining -= 1;
+            return { done: remaining <= 0, hasNext: true, next: value };
         };
     }
     take.lazy = lazy;

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

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

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

@@ -2,28 +2,18 @@ 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);
+    return purry(uniqWith_, args, uniqWith.lazy);
 }
-function _uniqWith(array, isEquals) {
+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 lazy_(isEquals) {
+    return (value, index, array) => array !== undefined
+        && array.findIndex((otherValue) => isEquals(value, otherValue)) === index
+        ? { done: false, hasNext: true, next: value }
+        : { done: false, hasNext: false };
 }
 (function (uniqWith) {
-    uniqWith.lazy = toLazyIndexed(_lazy);
+    uniqWith.lazy = toLazyIndexed(lazy_);
 })(uniqWith || (uniqWith = {}));

package/dist/es/array/uniq.js

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

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

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

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

@@ -1,15 +1,15 @@
 export function zipWith(arg0, arg1, arg2) {
     if (typeof arg0 === 'function') {
         return arg1 === undefined
-            ? (f, s) => _zipWith(f, s, arg0)
-            : (f) => _zipWith(f, arg1, arg0);
+            ? (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);
+    return zipWith_(arg0, arg1, arg2);
 }
-function _zipWith(first, second, fn) {
+function zipWith_(first, second, fn) {
     const resultLength = first.length > second.length ? second.length : first.length;
     const result = [];
     for (let i = 0; i < resultLength; i++) {

package/dist/es/array/zip.js

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

package/dist/es/function/index.js

@@ -7,3 +7,4 @@ export * from './debounce';
 export * from './pipe';
 export * from './purry';
 export * from './sleep';
+export * from './times';

package/dist/es/function/pipe.js

@@ -1,18 +1,18 @@
 export function pipe(input, ...operations) {
     let output = input;
-    const lazyOperations = operations.map((op) => 'lazy' in op ? toPipedLazy(op) : undefined);
+    const lazyOperations = operations.map((op) => 'lazy' in op ? prepareLazyOperation(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++;
+            operationIndex += 1;
             continue;
         }
         const lazySequence = [];
-        for (let j = operationIndex; j < operations.length; j++) {
-            const lazyOp = lazyOperations[j];
+        for (let index = operationIndex; index < operations.length; index++) {
+            const lazyOp = lazyOperations[index];
             if (lazyOp === undefined) {
                 break;
             }
@@ -34,12 +34,7 @@ export function pipe(input, ...operations) {
             }
         }
         const { isSingle } = lazySequence[lazySequence.length - 1];
-        if (isSingle) {
-            output = accumulator[0];
-        }
-        else {
-            output = accumulator;
-        }
+        output = isSingle ? accumulator[0] : accumulator;
         operationIndex += lazySequence.length;
     }
     return output;
@@ -49,28 +44,27 @@ function processItem_(item, accumulator, lazySequence) {
         accumulator.push(item);
         return false;
     }
+    let currentItem = item;
     let lazyResult = { done: false, hasNext: false };
     let isDone = false;
-    for (let i = 0; i < lazySequence.length; i++) {
-        const lazyFn = lazySequence[i];
+    for (const [operationsIndex, lazyFn] of lazySequence.entries()) {
         const { index, isIndexed, items } = lazyFn;
-        items.push(item);
-        lazyResult = isIndexed ? lazyFn(item, index, items) : lazyFn(item);
-        lazyFn.index++;
+        items.push(currentItem);
+        lazyResult = isIndexed
+            ? lazyFn(currentItem, index, items)
+            : lazyFn(currentItem);
+        lazyFn.index += 1;
         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 (lazyResult.hasMany ?? false) {
+                for (const subItem of lazyResult.next) {
+                    const subResult = processItem_(subItem, accumulator, lazySequence.slice(operationsIndex + 1));
                     if (subResult) {
                         return true;
                     }
                 }
                 return false;
             }
-            else {
-                item = lazyResult.next;
-            }
+            currentItem = lazyResult.next;
         }
         if (!lazyResult.hasNext) {
             break;
@@ -80,11 +74,11 @@ function processItem_(item, accumulator, lazySequence) {
         }
     }
     if (lazyResult.hasNext) {
-        accumulator.push(item);
+        accumulator.push(currentItem);
     }
     return isDone;
 }
-function toPipedLazy(op) {
+function prepareLazyOperation(op) {
     const { lazy, lazyArgs } = op;
     const fn = lazy(...(lazyArgs ?? []));
     return Object.assign(fn, {

package/dist/es/function/purry.js

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

package/dist/es/function/times.js

@@ -0,0 +1,14 @@
+import { purry } from './purry';
+export function times(...args) {
+    return purry(times_, args);
+}
+function times_(count, fn) {
+    if (count < 0) {
+        throw new RangeError('n must be a non-negative number');
+    }
+    const res = [];
+    for (let i = 0; i < count; i++) {
+        res.push(fn(i));
+    }
+    return res;
+}

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

@@ -1,5 +1,5 @@
 export function isDefined(data) {
-    return typeof data !== 'undefined' && data !== null;
+    return data !== undefined && data !== null;
 }
 (function (isDefined) {
     function strict(data) {

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

@@ -2,14 +2,14 @@ import { isArray } from './is-array';
 import { isObject } from './is-object';
 import { isString } from './is-string';
 export function isEmpty(data) {
+    if (data === undefined) {
+        return true;
+    }
     if (isArray(data) || isString(data)) {
         return data.length === 0;
     }
     if (isObject(data)) {
-        for (const _ in data) {
-            return false;
-        }
-        return !(data instanceof RegExp);
+        return Object.keys(data).length === 0;
     }
     return false;
 }

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

@@ -1,3 +1,3 @@
 export function isNil(data) {
-    return data == null;
+    return data === null || data === undefined;
 }

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

@@ -1,5 +1,3 @@
 export function isNot(predicate) {
-    return (data) => {
-        return !predicate(data);
-    };
+    return (data) => !predicate(data);
 }

package/dist/es/number/add.js

@@ -1,7 +1,7 @@
 import { purry } from '../function/purry';
 export function add(...args) {
-    return purry(_add, args);
+    return purry(add_, args);
 }
-function _add(value, addend) {
+function add_(value, addend) {
     return value + addend;
 }