@vinicunca/perkakas 0.3.1 → 0.3.3

package/dist/commonjs/string/random-string.js

@@ -1,10 +1,16 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.randomString = void 0;
-const range_1 = require("../array/range");
-function randomString(length) {
-    const characterSet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-    const randomChar = () => characterSet[Math.floor(Math.random() * characterSet.length)];
-    return (0, range_1.range)(0, length).reduce((text) => text + randomChar(), '');
+const purry_1 = require("../function/purry");
+const times_1 = require("../function/times");
+const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+function randomString(...args) {
+    return (0, purry_1.purry)(randomStringImplementation, args);
 }
 exports.randomString = randomString;
+function randomStringImplementation(length) {
+    return (0, times_1.times)(length, randomChar).join('');
+}
+function randomChar() {
+    return ALPHABET[Math.floor(Math.random() * ALPHABET.length)];
+}

package/dist/commonjs/string/string-to-path.js

@@ -2,17 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.stringToPath = void 0;
 function stringToPath(path) {
-    return _stringToPath(path);
+    return stringToPath_(path);
 }
 exports.stringToPath = stringToPath;
-function _stringToPath(path) {
+function stringToPath_(path) {
     if (path.length === 0) {
         return [];
     }
-    const match = path.match(/^\[(.+?)\](.*)$/) ?? path.match(/^\.?([^.[\]]+)(.*)$/);
-    if (match) {
+    const match = /^\[(.+?)\](.*)$/u.exec(path) ?? /^\.?([^.[\]]+)(.*)$/u.exec(path);
+    if (match !== null) {
         const [, key, rest] = match;
-        return [key, ..._stringToPath(rest)];
+        return [key, ...stringToPath_(rest)];
     }
     return [path];
 }

package/dist/commonjs/utils/binary-search-cutoff-index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.binarySearchCutoffIndex = void 0;
+function binarySearchCutoffIndex(array, predicate) {
+    let lowIndex = 0;
+    let highIndex = array.length;
+    while (lowIndex < highIndex) {
+        const pivotIndex = (lowIndex + highIndex) >>> 1;
+        const pivot = array[pivotIndex];
+        if (predicate(pivot, pivotIndex)) {
+            lowIndex = pivotIndex + 1;
+        }
+        else {
+            highIndex = pivotIndex;
+        }
+    }
+    return highIndex;
+}
+exports.binarySearchCutoffIndex = binarySearchCutoffIndex;

package/dist/commonjs/utils/heap.js

@@ -13,7 +13,7 @@ function heapMaybeInsert(heap, compareFn, item) {
     if (!(0, has_at_least_1.hasAtLeast)(heap, 1)) {
         return;
     }
-    const head = heap[0];
+    const [head] = heap;
     if (compareFn(item, head) >= 0) {
         return;
     }

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

@@ -33,7 +33,7 @@ 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 { [direction]: comparator } = COMPARATORS;
     const nextComparer = secondaryRule === undefined
         ? undefined
         : orderRuleComparer(secondaryRule, ...otherRules);

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

@@ -5,7 +5,7 @@ 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);
+        : quickSelectImplementation(data.slice(), 0, data.length - 1, index, compareFn);
 }
 exports.quickSelect = quickSelect;
 function quickSelectImplementation(data, left, right, index, compareFn) {
@@ -23,7 +23,7 @@ function partition(data, left, right, compareFn) {
     for (let j = left; j < right; j++) {
         if (compareFn(data[j], pivot) < 0) {
             (0, swap_in_place_1.swapInPlace)(data, i, j);
-            i++;
+            i += 1;
         }
     }
     (0, swap_in_place_1.swapInPlace)(data, i, right);

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

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

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

@@ -2,7 +2,6 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.toSingle = void 0;
 function toSingle(fn) {
-    fn.single = true;
-    return fn;
+    return Object.assign(fn, { single: true });
 }
 exports.toSingle = toSingle;

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

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

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

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

package/dist/es/array/chunk.js

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

package/dist/es/array/concat.js

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

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

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

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

@@ -1,27 +1,17 @@
 import { purry } from '../function/purry';
 import { reduceLazy } from '../utils/reduce-lazy';
 export function differenceWith(...args) {
-    return purry(_differenceWith, args, differenceWith.lazy);
+    return purry(differenceWith_, args, differenceWith.lazy);
 }
-function _differenceWith(array, other, isEquals) {
+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,
-            };
-        };
+        return (value) => other.every((otherValue) => !isEquals(value, otherValue))
+            ? { done: false, hasNext: true, next: value }
+            : { done: false, hasNext: false };
     }
     differenceWith.lazy = lazy;
 })(differenceWith || (differenceWith = {}));

package/dist/es/array/difference.js

@@ -1,28 +1,18 @@
 import { purry } from '../function/purry';
 import { reduceLazy } from '../utils/reduce-lazy';
 export function difference(...args) {
-    return purry(_difference, args, difference.lazy);
+    return purry(difference_, args, difference.lazy);
 }
-function _difference(array, other) {
+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,
-            };
-        };
+        return (value) => set.has(value)
+            ? { done: false, hasNext: false }
+            : { done: false, hasNext: true, next: value };
     }
     difference.lazy = lazy;
 })(difference || (difference = {}));

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

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

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

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

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

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

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

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

package/dist/es/array/drop.js

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

package/dist/es/array/filter.js

@@ -10,22 +10,9 @@ function filter_(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,
-            };
-        };
-    };
+    return (fn) => (value, index, array) => (indexed ? fn(value, index, array) : fn(value))
+        ? { done: false, hasNext: true, next: value }
+        : { done: false, hasNext: false };
 }
 (function (filter) {
     function indexed(...args) {

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

@@ -2,41 +2,28 @@ 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);
+    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 findIndex_(indexed) {
+    return (array, fn) => array.findIndex((item, index, input) => indexed ? fn(item, index, input) : fn(item));
 }
-function _lazy(indexed) {
+function lazy_(indexed) {
     return (fn) => {
-        let i = 0;
+        let actualIndex = 0;
         return (value, index, array) => {
-            const valid = indexed ? fn(value, index, array) : fn(value);
-            if (valid) {
-                return {
-                    done: true,
-                    hasNext: true,
-                    next: i,
-                };
+            if (indexed ? fn(value, index, array) : fn(value)) {
+                return { done: true, hasNext: true, next: actualIndex };
             }
-            i++;
-            return {
-                done: false,
-                hasNext: false,
-            };
+            actualIndex += 1;
+            return { done: false, hasNext: false };
         };
     };
 }
 (function (findIndex) {
     function indexed(...args) {
-        return purry(_findIndex(true), args, findIndex.lazyIndexed);
+        return purry(findIndex_(true), args, findIndex.lazyIndexed);
     }
     findIndex.indexed = indexed;
-    findIndex.lazy = toSingle(_lazy(false));
-    findIndex.lazyIndexed = toSingle(toLazyIndexed(_lazy(true)));
+    findIndex.lazy = toSingle(lazy_(false));
+    findIndex.lazyIndexed = toSingle(toLazyIndexed(lazy_(true)));
 })(findIndex || (findIndex = {}));

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

@@ -1,8 +1,8 @@
 import { purry } from '../function/purry';
 export function findLastIndex(...args) {
-    return purry(_findLastIndex(false), args);
+    return purry(findLastIndex_(false), args);
 }
-function _findLastIndex(indexed) {
+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])) {
@@ -14,7 +14,7 @@ function _findLastIndex(indexed) {
 }
 (function (findLastIndex) {
     function indexed(...args) {
-        return purry(_findLastIndex(true), args);
+        return purry(findLastIndex_(true), args);
     }
     findLastIndex.indexed = indexed;
 })(findLastIndex || (findLastIndex = {}));

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

@@ -1,8 +1,8 @@
 import { purry } from '../function/purry';
 export function findLast(...args) {
-    return purry(_findLast(false), args);
+    return purry(findLast_(false), args);
 }
-function _findLast(indexed) {
+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])) {
@@ -14,7 +14,7 @@ function _findLast(indexed) {
 }
 (function (findLast) {
     function indexed(...args) {
-        return purry(_findLast(true), args);
+        return purry(findLast_(true), args);
     }
     findLast.indexed = indexed;
 })(findLast || (findLast = {}));

package/dist/es/array/find.js

@@ -2,33 +2,21 @@ 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);
+    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 find_(indexed) {
+    return (array, fn) => array.find((item, index, input) => indexed ? fn(item, index, input) : fn(item));
 }
-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 lazy_(indexed) {
+    return (fn) => (value, index, array) => (indexed ? fn(value, index, array) : fn(value))
+        ? { done: true, hasNext: true, next: value }
+        : { done: false, hasNext: false };
 }
 (function (find) {
     function indexed(...args) {
-        return purry(_find(true), args, find.lazyIndexed);
+        return purry(find_(true), args, find.lazyIndexed);
     }
     find.indexed = indexed;
-    find.lazy = toSingle(_lazy(false));
-    find.lazyIndexed = toSingle(toLazyIndexed(_lazy(true)));
+    find.lazy = toSingle(lazy_(false));
+    find.lazyIndexed = toSingle(toLazyIndexed(lazy_(true)));
 })(find || (find = {}));

package/dist/es/array/first.js

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

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

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

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

@@ -1,28 +1,18 @@
 import { purry } from '../function/purry';
 import { flatten } from './flatten';
 export function flatMap(...args) {
-    return purry(_flatMap, args, flatMap.lazy);
+    return purry(flatMap_, args, flatMap.lazy);
 }
-function _flatMap(array, fn) {
+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,
-            };
+            return Array.isArray(next)
+                ? { done: false, hasMany: true, hasNext: true, next }
+                : { done: false, hasNext: true, next };
         };
     }
     flatMap.lazy = lazy;