@vinicunca/perkakas 0.3.1 → 0.3.5

package/dist/commonjs/array/for-each.js

@@ -5,36 +5,32 @@ const purry_1 = require("../function/purry");
 const reduce_lazy_1 = require("../utils/reduce-lazy");
 const to_lazy_indexed_1 = require("../utils/to-lazy-indexed");
 function forEach(...args) {
-    return (0, purry_1.purry)(_forEach(false), args, forEach.lazy);
+    return (0, purry_1.purry)(forEach_(false), args, forEach.lazy);
 }
 exports.forEach = forEach;
-function _forEach(indexed) {
-    return (array, fn) => {
-        return (0, reduce_lazy_1.reduceLazy)(array, indexed ? forEach.lazyIndexed(fn) : forEach.lazy(fn), indexed);
-    };
+function forEach_(indexed) {
+    return (array, fn) => (0, reduce_lazy_1.reduceLazy)(array, indexed ? forEach.lazyIndexed(fn) : forEach.lazy(fn), indexed);
 }
-function _lazy(indexed) {
-    return (fn) => {
-        return (value, index, array) => {
-            if (indexed) {
-                fn(value, index, array);
-            }
-            else {
-                fn(value);
-            }
-            return {
-                done: false,
-                hasNext: true,
-                next: value,
-            };
+function lazy_(indexed) {
+    return (fn) => (value, index, array) => {
+        if (indexed) {
+            fn(value, index, array);
+        }
+        else {
+            fn(value);
+        }
+        return {
+            done: false,
+            hasNext: true,
+            next: value,
         };
     };
 }
 (function (forEach) {
     function indexed(...args) {
-        return (0, purry_1.purry)(_forEach(true), args, forEach.lazyIndexed);
+        return (0, purry_1.purry)(forEach_(true), args, forEach.lazyIndexed);
     }
     forEach.indexed = indexed;
-    forEach.lazy = _lazy(false);
-    forEach.lazyIndexed = (0, to_lazy_indexed_1.toLazyIndexed)(_lazy(true));
+    forEach.lazy = lazy_(false);
+    forEach.lazyIndexed = (0, to_lazy_indexed_1.toLazyIndexed)(lazy_(true));
 })(forEach || (exports.forEach = forEach = {}));

package/dist/commonjs/array/group-by.js

@@ -3,13 +3,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.groupBy = void 0;
 const purry_1 = require("../function/purry");
 function groupBy(...args) {
-    return (0, purry_1.purry)(_groupBy(false), args);
+    return (0, purry_1.purry)(groupBy_(false), args);
 }
 exports.groupBy = groupBy;
-function _groupBy(indexed) {
+function groupBy_(indexed) {
     return (array, fn) => {
         const ret = {};
-        array.forEach((item, index) => {
+        for (const [index, item] of array.entries()) {
             const key = indexed ? fn(item, index, array) : fn(item);
             if (key !== undefined) {
                 const actualKey = String(key);
@@ -20,13 +20,13 @@ function _groupBy(indexed) {
                 }
                 items.push(item);
             }
-        });
+        }
         return ret;
     };
 }
 (function (groupBy) {
     function indexed(...args) {
-        return (0, purry_1.purry)(_groupBy(true), args);
+        return (0, purry_1.purry)(groupBy_(true), args);
     }
     groupBy.indexed = indexed;
     groupBy.strict = groupBy;

package/dist/commonjs/array/index-by.js

@@ -3,22 +3,35 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.indexBy = void 0;
 const purry_1 = require("../function/purry");
 function indexBy(...args) {
-    return (0, purry_1.purry)(_indexBy(false), args);
+    return (0, purry_1.purry)(indexBy_(false), args);
 }
 exports.indexBy = indexBy;
-function _indexBy(indexed) {
+function indexBy_(indexed) {
     return (array, fn) => {
-        return array.reduce((ret, item, index) => {
+        const out = {};
+        for (const [index, item] of array.entries()) {
             const value = indexed ? fn(item, index, array) : fn(item);
             const key = String(value);
-            ret[key] = item;
-            return ret;
-        }, {});
+            out[key] = item;
+        }
+        return out;
     };
 }
+function indexByStrict(...args) {
+    return (0, purry_1.purry)(indexByStrict_, args);
+}
+function indexByStrict_(array, fn) {
+    const out = {};
+    for (const item of array) {
+        const key = fn(item);
+        out[key] = item;
+    }
+    return out;
+}
 (function (indexBy) {
     function indexed(...args) {
-        return (0, purry_1.purry)(_indexBy(true), args);
+        return (0, purry_1.purry)(indexBy_(true), args);
     }
     indexBy.indexed = indexed;
+    indexBy.strict = indexByStrict;
 })(indexBy || (exports.indexBy = indexBy = {}));

package/dist/commonjs/array/index.js

@@ -65,6 +65,10 @@ __exportStar(require("./sample"), exports);
 __exportStar(require("./shuffle"), exports);
 __exportStar(require("./sort"), exports);
 __exportStar(require("./sort-by"), exports);
+__exportStar(require("./sorted-index"), exports);
+__exportStar(require("./sorted-index-with"), exports);
+__exportStar(require("./sorted-index-by"), exports);
+__exportStar(require("./sorted-last-index"), exports);
 __exportStar(require("./splice"), exports);
 __exportStar(require("./split-at"), exports);
 __exportStar(require("./split-when"), exports);

package/dist/commonjs/array/intersection-with.js

@@ -4,28 +4,18 @@ exports.intersectionWith = void 0;
 const purry_1 = require("../function/purry");
 const reduce_lazy_1 = require("../utils/reduce-lazy");
 function intersectionWith(...args) {
-    return (0, purry_1.purry)(_intersectionWith, args, intersectionWith.lazy);
+    return (0, purry_1.purry)(intersectionWith_, args, intersectionWith.lazy);
 }
 exports.intersectionWith = intersectionWith;
-function _intersectionWith(array, other, comparator) {
+function intersectionWith_(array, other, comparator) {
     const lazy = intersectionWith.lazy(other, comparator);
     return (0, reduce_lazy_1.reduceLazy)(array, lazy);
 }
 (function (intersectionWith) {
     function lazy(other, comparator) {
-        return (value) => {
-            if (other.some((otherValue) => comparator(value, otherValue))) {
-                return {
-                    done: false,
-                    hasNext: true,
-                    next: value,
-                };
-            }
-            return {
-                done: false,
-                hasNext: false,
-            };
-        };
+        return (value) => other.some((otherValue) => comparator(value, otherValue))
+            ? { done: false, hasNext: true, next: value }
+            : { done: false, hasNext: false };
     }
     intersectionWith.lazy = lazy;
 })(intersectionWith || (exports.intersectionWith = intersectionWith = {}));

package/dist/commonjs/array/intersection.js

@@ -4,29 +4,19 @@ exports.intersection = void 0;
 const purry_1 = require("../function/purry");
 const reduce_lazy_1 = require("../utils/reduce-lazy");
 function intersection(...args) {
-    return (0, purry_1.purry)(_intersection, args, intersection.lazy);
+    return (0, purry_1.purry)(intersection_, args, intersection.lazy);
 }
 exports.intersection = intersection;
-function _intersection(array, other) {
+function intersection_(array, other) {
     const lazy = intersection.lazy(other);
     return (0, reduce_lazy_1.reduceLazy)(array, lazy);
 }
 (function (intersection) {
     function lazy(other) {
-        return (value) => {
-            const set = new Set(other);
-            if (set.has(value)) {
-                return {
-                    done: false,
-                    hasNext: true,
-                    next: value,
-                };
-            }
-            return {
-                done: false,
-                hasNext: false,
-            };
-        };
+        const set = new Set(other);
+        return (value) => set.has(value)
+            ? { done: false, hasNext: true, next: value }
+            : { done: false, hasNext: false };
     }
     intersection.lazy = lazy;
 })(intersection || (exports.intersection = intersection = {}));

package/dist/commonjs/array/last.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.last = void 0;
 const purry_1 = require("../function/purry");
 function last(...args) {
-    return (0, purry_1.purry)(_last, args);
+    return (0, purry_1.purry)(last_, args);
 }
 exports.last = last;
-function _last(array) {
+function last_(array) {
     return array[array.length - 1];
 }

package/dist/commonjs/array/length.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.length = void 0;
 const purry_1 = require("../function/purry");
 function length(...args) {
-    return (0, purry_1.purry)(_length, args);
+    return (0, purry_1.purry)(length_, args);
 }
 exports.length = length;
-function _length(items) {
+function length_(items) {
     return 'length' in items ? items.length : Array.from(items).length;
 }

package/dist/commonjs/array/map-to-obj.js

@@ -3,21 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.mapToObj = void 0;
 const purry_1 = require("../function/purry");
 function mapToObj(...args) {
-    return (0, purry_1.purry)(_mapToObj(false), args);
+    return (0, purry_1.purry)(mapToObj_(false), args);
 }
 exports.mapToObj = mapToObj;
-function _mapToObj(indexed) {
+function mapToObj_(indexed) {
     return (array, fn) => {
-        return array.reduce((result, element, index) => {
+        const out = {};
+        for (const [index, element] of array.entries()) {
             const [key, value] = indexed ? fn(element, index, array) : fn(element);
-            result[key] = value;
-            return result;
-        }, {});
+            out[key] = value;
+        }
+        return out;
     };
 }
 (function (mapToObj) {
     function indexed(...args) {
-        return (0, purry_1.purry)(_mapToObj(true), args);
+        return (0, purry_1.purry)(mapToObj_(true), args);
     }
     mapToObj.indexed = indexed;
 })(mapToObj || (exports.mapToObj = mapToObj = {}));

package/dist/commonjs/array/map.js

@@ -5,31 +5,27 @@ const purry_1 = require("../function/purry");
 const reduce_lazy_1 = require("../utils/reduce-lazy");
 const to_lazy_indexed_1 = require("../utils/to-lazy-indexed");
 function map(...args) {
-    return (0, purry_1.purry)(_map(false), args, map.lazy);
+    return (0, purry_1.purry)(map_(false), args, map.lazy);
 }
 exports.map = map;
-function _map(indexed) {
+function map_(indexed) {
     return (array, fn) => {
         return (0, reduce_lazy_1.reduceLazy)(array, indexed ? map.lazyIndexed(fn) : map.lazy(fn), indexed);
     };
 }
-function _lazy(indexed) {
-    return (fn) => {
-        return (value, index, array) => {
-            return {
-                done: false,
-                hasNext: true,
-                next: indexed ? fn(value, index, array) : fn(value),
-            };
-        };
-    };
+function lazy_(indexed) {
+    return (fn) => (value, index, array) => ({
+        done: false,
+        hasNext: true,
+        next: indexed ? fn(value, index, array) : fn(value),
+    });
 }
 (function (map) {
     function indexed(...args) {
-        return (0, purry_1.purry)(_map(true), args, map.lazyIndexed);
+        return (0, purry_1.purry)(map_(true), args, map.lazyIndexed);
     }
     map.indexed = indexed;
-    map.lazy = _lazy(false);
-    map.lazyIndexed = (0, to_lazy_indexed_1.toLazyIndexed)(_lazy(true));
+    map.lazy = lazy_(false);
+    map.lazyIndexed = (0, to_lazy_indexed_1.toLazyIndexed)(lazy_(true));
     map.strict = map;
 })(map || (exports.map = map = {}));

package/dist/commonjs/array/max-by.js

@@ -2,27 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.maxBy = void 0;
 const purry_1 = require("../function/purry");
-function _maxBy(indexed) {
+function maxBy_(indexed) {
     return (array, fn) => {
         let ret;
         let retMax;
-        array.forEach((item, i) => {
-            const max = indexed ? fn(item, i, array) : fn(item);
+        for (const [index, item] of array.entries()) {
+            const max = indexed ? fn(item, index, array) : fn(item);
             if (retMax === undefined || max > retMax) {
                 ret = item;
                 retMax = max;
             }
-        });
+        }
         return ret;
     };
 }
 function maxBy(...args) {
-    return (0, purry_1.purry)(_maxBy(false), args);
+    return (0, purry_1.purry)(maxBy_(false), args);
 }
 exports.maxBy = maxBy;
 (function (maxBy) {
     function indexed(...args) {
-        return (0, purry_1.purry)(_maxBy(true), args);
+        return (0, purry_1.purry)(maxBy_(true), args);
     }
     maxBy.indexed = indexed;
 })(maxBy || (exports.maxBy = maxBy = {}));

package/dist/commonjs/array/mean-by.js

@@ -2,25 +2,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.meanBy = void 0;
 const purry_1 = require("../function/purry");
-function _meanBy(indexed) {
+function meanBy_(indexed) {
     return (array, fn) => {
         if (array.length === 0) {
             return Number.NaN;
         }
         let sum = 0;
-        array.forEach((item, i) => {
-            sum += indexed ? fn(item, i, array) : fn(item);
-        });
+        for (const [index, item] of array.entries()) {
+            sum += indexed ? fn(item, index, array) : fn(item);
+        }
         return sum / array.length;
     };
 }
 function meanBy(...args) {
-    return (0, purry_1.purry)(_meanBy(false), args);
+    return (0, purry_1.purry)(meanBy_(false), args);
 }
 exports.meanBy = meanBy;
 (function (meanBy) {
     function indexed(...args) {
-        return (0, purry_1.purry)(_meanBy(true), args);
+        return (0, purry_1.purry)(meanBy_(true), args);
     }
     meanBy.indexed = indexed;
 })(meanBy || (exports.meanBy = meanBy = {}));

package/dist/commonjs/array/merge-all.js

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.mergeAll = void 0;
 function mergeAll(items) {
-    return items.reduce((acc, x) => ({ ...acc, ...x }), {});
+    let out = {};
+    for (const item of items) {
+        out = { ...out, ...item };
+    }
+    return out;
 }
 exports.mergeAll = mergeAll;

package/dist/commonjs/array/min-by.js

@@ -2,27 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.minBy = void 0;
 const purry_1 = require("../function/purry");
-function _minBy(indexed) {
+function minBy_(indexed) {
     return (array, fn) => {
         let ret;
         let retMin;
-        array.forEach((item, i) => {
-            const min = indexed ? fn(item, i, array) : fn(item);
+        for (const [index, item] of array.entries()) {
+            const min = indexed ? fn(item, index, array) : fn(item);
             if (retMin === undefined || min < retMin) {
                 ret = item;
                 retMin = min;
             }
-        });
+        }
         return ret;
     };
 }
 function minBy(...args) {
-    return (0, purry_1.purry)(_minBy(false), args);
+    return (0, purry_1.purry)(minBy_(false), args);
 }
 exports.minBy = minBy;
 (function (minBy) {
     function indexed(...args) {
-        return (0, purry_1.purry)(_minBy(true), args);
+        return (0, purry_1.purry)(minBy_(true), args);
     }
     minBy.indexed = indexed;
 })(minBy || (exports.minBy = minBy = {}));

package/dist/commonjs/array/only.js

@@ -3,12 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.only = void 0;
 const purry_1 = require("../function/purry");
 function only(...args) {
-    return (0, purry_1.purry)(_only, args);
+    return (0, purry_1.purry)(only_, args);
 }
 exports.only = only;
-function _only(array) {
-    if (array.length === 1) {
-        return array[0];
-    }
-    return undefined;
+function only_(array) {
+    return array.length === 1 ? array[0] : undefined;
 }

package/dist/commonjs/array/partition.js

@@ -3,22 +3,22 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.partition = void 0;
 const purry_1 = require("../function/purry");
 function partition(...args) {
-    return (0, purry_1.purry)(_partition(false), args);
+    return (0, purry_1.purry)(partition_(false), args);
 }
 exports.partition = partition;
-function _partition(indexed) {
+function partition_(indexed) {
     return (array, fn) => {
         const ret = [[], []];
-        array.forEach((item, index) => {
+        for (const [index, item] of array.entries()) {
             const matches = indexed ? fn(item, index, array) : fn(item);
             ret[matches ? 0 : 1].push(item);
-        });
+        }
         return ret;
     };
 }
 (function (partition) {
     function indexed(...args) {
-        return (0, purry_1.purry)(_partition(true), args);
+        return (0, purry_1.purry)(partition_(true), args);
     }
     partition.indexed = indexed;
 })(partition || (exports.partition = partition = {}));

package/dist/commonjs/array/range.js

@@ -3,10 +3,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.range = void 0;
 const purry_1 = require("../function/purry");
 function range(...args) {
-    return (0, purry_1.purry)(_range, args);
+    return (0, purry_1.purry)(range_, args);
 }
 exports.range = range;
-function _range(start, end) {
+function range_(start, end) {
     const ret = [];
     for (let i = start; i < end; i++) {
         ret.push(i);

package/dist/commonjs/array/rank-by.js

@@ -10,7 +10,7 @@ function rankByImplementation(data, compareFn, targetItem) {
     let rank = 0;
     for (const item of data) {
         if (compareFn(targetItem, item) > 0) {
-            rank++;
+            rank += 1;
         }
     }
     return rank;

package/dist/commonjs/array/reduce.js

@@ -3,17 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.reduce = void 0;
 const purry_1 = require("../function/purry");
 function reduce(...args) {
-    return (0, purry_1.purry)(_reduce(false), args);
+    return (0, purry_1.purry)(reduce_(false), args);
 }
 exports.reduce = reduce;
-function _reduce(indexed) {
+function reduce_(indexed) {
     return (items, fn, initialValue) => {
         return items.reduce((acc, item, index) => indexed ? fn(acc, item, index, items) : fn(acc, item), initialValue);
     };
 }
 (function (reduce) {
     function indexed(...args) {
-        return (0, purry_1.purry)(_reduce(true), args);
+        return (0, purry_1.purry)(reduce_(true), args);
     }
     reduce.indexed = indexed;
 })(reduce || (exports.reduce = reduce = {}));

package/dist/commonjs/array/reject.js

@@ -5,37 +5,24 @@ const purry_1 = require("../function/purry");
 const reduce_lazy_1 = require("../utils/reduce-lazy");
 const to_lazy_indexed_1 = require("../utils/to-lazy-indexed");
 function reject(...args) {
-    return (0, purry_1.purry)(_reject(false), args, reject.lazy);
+    return (0, purry_1.purry)(reject_(false), args, reject.lazy);
 }
 exports.reject = reject;
-function _reject(indexed) {
+function reject_(indexed) {
     return (array, fn) => {
         return (0, reduce_lazy_1.reduceLazy)(array, indexed ? reject.lazyIndexed(fn) : reject.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 lazy_(indexed) {
+    return (fn) => (item, index, data) => (indexed ? fn(item, index, data) : fn(item))
+        ? { done: false, hasNext: false }
+        : { done: false, hasNext: true, next: item };
 }
 (function (reject) {
     function indexed(...args) {
-        return (0, purry_1.purry)(_reject(true), args, reject.lazyIndexed);
+        return (0, purry_1.purry)(reject_(true), args, reject.lazyIndexed);
     }
     reject.indexed = indexed;
-    reject.lazy = _lazy(false);
-    reject.lazyIndexed = (0, to_lazy_indexed_1.toLazyIndexed)(_lazy(true));
+    reject.lazy = lazy_(false);
+    reject.lazyIndexed = (0, to_lazy_indexed_1.toLazyIndexed)(lazy_(true));
 })(reject || (exports.reject = reject = {}));

package/dist/commonjs/array/reverse.js

@@ -3,9 +3,9 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.reverse = void 0;
 const purry_1 = require("../function/purry");
 function reverse(...args) {
-    return (0, purry_1.purry)(_reverse, args);
+    return (0, purry_1.purry)(reverse_, args);
 }
 exports.reverse = reverse;
-function _reverse(array) {
+function reverse_(array) {
     return array.slice().reverse();
 }

package/dist/commonjs/array/sample.js

@@ -14,7 +14,7 @@ function sampleImplementation(data, sampleSize) {
         throw new TypeError(`sampleSize must be an integer: ${sampleSize}`);
     }
     if (sampleSize >= data.length) {
-        return data;
+        return data.slice();
     }
     if (sampleSize === 0) {
         return [];

package/dist/commonjs/array/shuffle.js

@@ -3,12 +3,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.shuffle = void 0;
 const purry_1 = require("../function/purry");
 function shuffle(...args) {
-    return (0, purry_1.purry)(_shuffle, args);
+    return (0, purry_1.purry)(shuffle_, args);
 }
 exports.shuffle = shuffle;
-function _shuffle(items) {
+function shuffle_(items) {
     const result = items.slice();
-    for (let index = 0; index < items.length; index += 1) {
+    for (let index = 0; index < items.length; index++) {
         const rand = index + Math.floor(Math.random() * (items.length - index));
         const value = result[rand];
         result[rand] = result[index];