@vinicunca/perkakas 0.3.1 → 0.3.5

package/dist/es/array/flatten-deep.js

@@ -1,43 +1,33 @@
 import { purry } from '../function/purry';
 import { reduceLazy } from '../utils/reduce-lazy';
 export function flattenDeep(...args) {
-    return purry(_flattenDeep, args, flattenDeep.lazy);
+    return purry(flattenDeep_, args, flattenDeep.lazy);
 }
-function _flattenDeep(items) {
+function flattenDeep_(items) {
     return reduceLazy(items, flattenDeep.lazy());
 }
-function _flattenDeepValue(value) {
+function flattenDeepValue_(value) {
     if (!Array.isArray(value)) {
         return value;
     }
     const ret = [];
-    value.forEach((item) => {
+    for (const item of value) {
         if (Array.isArray(item)) {
             ret.push(...flattenDeep(item));
         }
         else {
             ret.push(item);
         }
-    });
+    }
     return ret;
 }
 (function (flattenDeep) {
     function lazy() {
         return (value) => {
-            const next = _flattenDeepValue(value);
-            if (Array.isArray(next)) {
-                return {
-                    done: false,
-                    hasMany: true,
-                    hasNext: true,
-                    next,
-                };
-            }
-            return {
-                done: false,
-                hasNext: true,
-                next,
-            };
+            const next = flattenDeepValue_(value);
+            return Array.isArray(next)
+                ? { done: false, hasMany: true, hasNext: true, next }
+                : { done: false, hasNext: true, next };
         };
     }
     flattenDeep.lazy = lazy;

package/dist/es/array/flatten.js

@@ -1,28 +1,16 @@
 import { purry } from '../function/purry';
 import { reduceLazy } from '../utils/reduce-lazy';
 export function flatten(...args) {
-    return purry(_flatten, args, flatten.lazy);
+    return purry(flatten_, args, flatten.lazy);
 }
-function _flatten(items) {
+function flatten_(items) {
     return reduceLazy(items, flatten.lazy());
 }
 (function (flatten) {
     function lazy() {
-        return (next) => {
-            if (Array.isArray(next)) {
-                return {
-                    done: false,
-                    hasMany: true,
-                    hasNext: true,
-                    next,
-                };
-            }
-            return {
-                done: false,
-                hasNext: true,
-                next,
-            };
-        };
+        return (item) => Array.isArray(item)
+            ? { done: false, hasMany: true, hasNext: true, next: item }
+            : { done: false, hasNext: true, next: item };
     }
     flatten.lazy = lazy;
 })(flatten || (flatten = {}));

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

@@ -2,35 +2,31 @@ import { purry } from '../function/purry';
 import { reduceLazy } from '../utils/reduce-lazy';
 import { toLazyIndexed } from '../utils/to-lazy-indexed';
 export function forEach(...args) {
-    return purry(_forEach(false), args, forEach.lazy);
+    return purry(forEach_(false), args, forEach.lazy);
 }
-function _forEach(indexed) {
-    return (array, fn) => {
-        return reduceLazy(array, indexed ? forEach.lazyIndexed(fn) : forEach.lazy(fn), indexed);
-    };
+function forEach_(indexed) {
+    return (array, fn) => 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 purry(_forEach(true), args, forEach.lazyIndexed);
+        return purry(forEach_(true), args, forEach.lazyIndexed);
     }
     forEach.indexed = indexed;
-    forEach.lazy = _lazy(false);
-    forEach.lazyIndexed = toLazyIndexed(_lazy(true));
+    forEach.lazy = lazy_(false);
+    forEach.lazyIndexed = toLazyIndexed(lazy_(true));
 })(forEach || (forEach = {}));

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

@@ -1,11 +1,11 @@
 import { purry } from '../function/purry';
 export function groupBy(...args) {
-    return purry(_groupBy(false), args);
+    return purry(groupBy_(false), args);
 }
-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);
@@ -16,13 +16,13 @@ function _groupBy(indexed) {
                 }
                 items.push(item);
             }
-        });
+        }
         return ret;
     };
 }
 (function (groupBy) {
     function indexed(...args) {
-        return purry(_groupBy(true), args);
+        return purry(groupBy_(true), args);
     }
     groupBy.indexed = indexed;
     groupBy.strict = groupBy;

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

@@ -1,20 +1,33 @@
 import { purry } from '../function/purry';
 export function indexBy(...args) {
-    return purry(_indexBy(false), args);
+    return purry(indexBy_(false), args);
 }
-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 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 purry(_indexBy(true), args);
+        return purry(indexBy_(true), args);
     }
     indexBy.indexed = indexed;
+    indexBy.strict = indexByStrict;
 })(indexBy || (indexBy = {}));

package/dist/es/array/index.js

@@ -49,6 +49,10 @@ export * from './sample';
 export * from './shuffle';
 export * from './sort';
 export * from './sort-by';
+export * from './sorted-index';
+export * from './sorted-index-with';
+export * from './sorted-index-by';
+export * from './sorted-last-index';
 export * from './splice';
 export * from './split-at';
 export * from './split-when';

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

@@ -1,27 +1,17 @@
 import { purry } from '../function/purry';
 import { reduceLazy } from '../utils/reduce-lazy';
 export function intersectionWith(...args) {
-    return purry(_intersectionWith, args, intersectionWith.lazy);
+    return purry(intersectionWith_, args, intersectionWith.lazy);
 }
-function _intersectionWith(array, other, comparator) {
+function intersectionWith_(array, other, comparator) {
     const lazy = intersectionWith.lazy(other, comparator);
     return 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 || (intersectionWith = {}));

package/dist/es/array/intersection.js

@@ -1,28 +1,18 @@
 import { purry } from '../function/purry';
 import { reduceLazy } from '../utils/reduce-lazy';
 export function intersection(...args) {
-    return purry(_intersection, args, intersection.lazy);
+    return purry(intersection_, args, intersection.lazy);
 }
-function _intersection(array, other) {
+function intersection_(array, other) {
     const lazy = intersection.lazy(other);
     return 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 || (intersection = {}));

package/dist/es/array/last.js

@@ -1,7 +1,7 @@
 import { purry } from '../function/purry';
 export function last(...args) {
-    return purry(_last, args);
+    return purry(last_, args);
 }
-function _last(array) {
+function last_(array) {
     return array[array.length - 1];
 }

package/dist/es/array/length.js

@@ -1,7 +1,7 @@
 import { purry } from '../function/purry';
 export function length(...args) {
-    return purry(_length, args);
+    return purry(length_, args);
 }
-function _length(items) {
+function length_(items) {
     return 'length' in items ? items.length : Array.from(items).length;
 }

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

@@ -1,19 +1,20 @@
 import { purry } from '../function/purry';
 export function mapToObj(...args) {
-    return purry(_mapToObj(false), args);
+    return purry(mapToObj_(false), args);
 }
-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 purry(_mapToObj(true), args);
+        return purry(mapToObj_(true), args);
     }
     mapToObj.indexed = indexed;
 })(mapToObj || (mapToObj = {}));

package/dist/es/array/map.js

@@ -2,30 +2,26 @@ import { purry } from '../function/purry';
 import { reduceLazy } from '../utils/reduce-lazy';
 import { toLazyIndexed } from '../utils/to-lazy-indexed';
 export function map(...args) {
-    return purry(_map(false), args, map.lazy);
+    return purry(map_(false), args, map.lazy);
 }
-function _map(indexed) {
+function map_(indexed) {
     return (array, fn) => {
         return 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 purry(_map(true), args, map.lazyIndexed);
+        return purry(map_(true), args, map.lazyIndexed);
     }
     map.indexed = indexed;
-    map.lazy = _lazy(false);
-    map.lazyIndexed = toLazyIndexed(_lazy(true));
+    map.lazy = lazy_(false);
+    map.lazyIndexed = toLazyIndexed(lazy_(true));
     map.strict = map;
 })(map || (map = {}));

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

@@ -1,24 +1,24 @@
 import { purry } from '../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;
     };
 }
 export function maxBy(...args) {
-    return purry(_maxBy(false), args);
+    return purry(maxBy_(false), args);
 }
 (function (maxBy) {
     function indexed(...args) {
-        return purry(_maxBy(true), args);
+        return purry(maxBy_(true), args);
     }
     maxBy.indexed = indexed;
 })(maxBy || (maxBy = {}));

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

@@ -1,22 +1,22 @@
 import { purry } from '../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;
     };
 }
 export function meanBy(...args) {
-    return purry(_meanBy(false), args);
+    return purry(meanBy_(false), args);
 }
 (function (meanBy) {
     function indexed(...args) {
-        return purry(_meanBy(true), args);
+        return purry(meanBy_(true), args);
     }
     meanBy.indexed = indexed;
 })(meanBy || (meanBy = {}));

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

@@ -1,3 +1,7 @@
 export function mergeAll(items) {
-    return items.reduce((acc, x) => ({ ...acc, ...x }), {});
+    let out = {};
+    for (const item of items) {
+        out = { ...out, ...item };
+    }
+    return out;
 }

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

@@ -1,24 +1,24 @@
 import { purry } from '../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;
     };
 }
 export function minBy(...args) {
-    return purry(_minBy(false), args);
+    return purry(minBy_(false), args);
 }
 (function (minBy) {
     function indexed(...args) {
-        return purry(_minBy(true), args);
+        return purry(minBy_(true), args);
     }
     minBy.indexed = indexed;
 })(minBy || (minBy = {}));

package/dist/es/array/only.js

@@ -1,10 +1,7 @@
 import { purry } from '../function/purry';
 export function only(...args) {
-    return purry(_only, args);
+    return purry(only_, args);
 }
-function _only(array) {
-    if (array.length === 1) {
-        return array[0];
-    }
-    return undefined;
+function only_(array) {
+    return array.length === 1 ? array[0] : undefined;
 }

package/dist/es/array/partition.js

@@ -1,20 +1,20 @@
 import { purry } from '../function/purry';
 export function partition(...args) {
-    return purry(_partition(false), args);
+    return purry(partition_(false), args);
 }
-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 purry(_partition(true), args);
+        return purry(partition_(true), args);
     }
     partition.indexed = indexed;
 })(partition || (partition = {}));

package/dist/es/array/range.js

@@ -1,8 +1,8 @@
 import { purry } from '../function/purry';
 export function range(...args) {
-    return purry(_range, args);
+    return purry(range_, args);
 }
-function _range(start, end) {
+function range_(start, end) {
     const ret = [];
     for (let i = start; i < end; i++) {
         ret.push(i);

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

@@ -6,7 +6,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/es/array/reduce.js

@@ -1,15 +1,15 @@
 import { purry } from '../function/purry';
 export function reduce(...args) {
-    return purry(_reduce(false), args);
+    return purry(reduce_(false), args);
 }
-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 purry(_reduce(true), args);
+        return purry(reduce_(true), args);
     }
     reduce.indexed = indexed;
 })(reduce || (reduce = {}));

package/dist/es/array/reject.js

@@ -2,36 +2,23 @@ import { purry } from '../function/purry';
 import { reduceLazy } from '../utils/reduce-lazy';
 import { toLazyIndexed } from '../utils/to-lazy-indexed';
 export function reject(...args) {
-    return purry(_reject(false), args, reject.lazy);
+    return purry(reject_(false), args, reject.lazy);
 }
-function _reject(indexed) {
+function reject_(indexed) {
     return (array, fn) => {
         return 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 purry(_reject(true), args, reject.lazyIndexed);
+        return purry(reject_(true), args, reject.lazyIndexed);
     }
     reject.indexed = indexed;
-    reject.lazy = _lazy(false);
-    reject.lazyIndexed = toLazyIndexed(_lazy(true));
+    reject.lazy = lazy_(false);
+    reject.lazyIndexed = toLazyIndexed(lazy_(true));
 })(reject || (reject = {}));

package/dist/es/array/reverse.js

@@ -1,7 +1,7 @@
 import { purry } from '../function/purry';
 export function reverse(...args) {
-    return purry(_reverse, args);
+    return purry(reverse_, args);
 }
-function _reverse(array) {
+function reverse_(array) {
     return array.slice().reverse();
 }

package/dist/es/array/sample.js

@@ -10,7 +10,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/es/array/shuffle.js

@@ -1,10 +1,10 @@
 import { purry } from '../function/purry';
 export function shuffle(...args) {
-    return purry(_shuffle, args);
+    return purry(shuffle_, args);
 }
-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];