@vinicunca/perkakas 0.2.1 → 0.3.1

package/dist/commonjs/array/flatten.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.flatten = void 0;
+const purry_1 = require("../function/purry");
+const reduce_lazy_1 = require("../utils/reduce-lazy");
+function flatten(...args) {
+    return (0, purry_1.purry)(_flatten, args, flatten.lazy);
+}
+exports.flatten = flatten;
+function _flatten(items) {
+    return (0, reduce_lazy_1.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,
+            };
+        };
+    }
+    flatten.lazy = lazy;
+})(flatten || (exports.flatten = flatten = {}));

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forEach = void 0;
+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);
+}
+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 _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 (forEach) {
+    function indexed(...args) {
+        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 || (exports.forEach = forEach = {}));

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

@@ -0,0 +1,33 @@
+"use strict";
+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);
+}
+exports.groupBy = groupBy;
+function _groupBy(indexed) {
+    return (array, fn) => {
+        const ret = {};
+        array.forEach((item, index) => {
+            const key = indexed ? fn(item, index, array) : fn(item);
+            if (key !== undefined) {
+                const actualKey = String(key);
+                let items = ret[actualKey];
+                if (items === undefined) {
+                    items = [];
+                    ret[actualKey] = items;
+                }
+                items.push(item);
+            }
+        });
+        return ret;
+    };
+}
+(function (groupBy) {
+    function indexed(...args) {
+        return (0, purry_1.purry)(_groupBy(true), args);
+    }
+    groupBy.indexed = indexed;
+    groupBy.strict = groupBy;
+})(groupBy || (exports.groupBy = groupBy = {}));

package/dist/commonjs/array/has-at-least.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasAtLeast = void 0;
+const purry_1 = require("../function/purry");
+function hasAtLeast(...args) {
+    return (0, purry_1.purry)(hasAtLeastImplementation, args);
+}
+exports.hasAtLeast = hasAtLeast;
+function hasAtLeastImplementation(data, minimum) {
+    return data.length >= minimum;
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+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);
+}
+exports.indexBy = indexBy;
+function _indexBy(indexed) {
+    return (array, fn) => {
+        return array.reduce((ret, item, index) => {
+            const value = indexed ? fn(item, index, array) : fn(item);
+            const key = String(value);
+            ret[key] = item;
+            return ret;
+        }, {});
+    };
+}
+(function (indexBy) {
+    function indexed(...args) {
+        return (0, purry_1.purry)(_indexBy(true), args);
+    }
+    indexBy.indexed = indexed;
+})(indexBy || (exports.indexBy = indexBy = {}));

package/dist/commonjs/array/index.js

@@ -0,0 +1,81 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./all-pass"), exports);
+__exportStar(require("./any-pass"), exports);
+__exportStar(require("./chunk"), exports);
+__exportStar(require("./compact"), exports);
+__exportStar(require("./concat"), exports);
+__exportStar(require("./count-by"), exports);
+__exportStar(require("./difference-with"), exports);
+__exportStar(require("./difference"), exports);
+__exportStar(require("./drop-last"), exports);
+__exportStar(require("./drop"), exports);
+__exportStar(require("./drop-first-by"), exports);
+__exportStar(require("./drop-last-while"), exports);
+__exportStar(require("./drop-while"), exports);
+__exportStar(require("./filter"), exports);
+__exportStar(require("./find-index"), exports);
+__exportStar(require("./find-last-index"), exports);
+__exportStar(require("./find-last"), exports);
+__exportStar(require("./find"), exports);
+__exportStar(require("./first"), exports);
+__exportStar(require("./first-by"), exports);
+__exportStar(require("./flat-map-to-obj"), exports);
+__exportStar(require("./flat-map"), exports);
+__exportStar(require("./flatten-deep"), exports);
+__exportStar(require("./flatten"), exports);
+__exportStar(require("./for-each"), exports);
+__exportStar(require("./group-by"), exports);
+__exportStar(require("./has-at-least"), exports);
+__exportStar(require("./index-by"), exports);
+__exportStar(require("./intersection"), exports);
+__exportStar(require("./intersection-with"), exports);
+__exportStar(require("./join"), exports);
+__exportStar(require("./last"), exports);
+__exportStar(require("./length"), exports);
+__exportStar(require("./map"), exports);
+__exportStar(require("./map-to-obj"), exports);
+__exportStar(require("./max-by"), exports);
+__exportStar(require("./mean-by"), exports);
+__exportStar(require("./merge-all"), exports);
+__exportStar(require("./min-by"), exports);
+__exportStar(require("./nth-by"), exports);
+__exportStar(require("./only"), exports);
+__exportStar(require("./partition"), exports);
+__exportStar(require("./range"), exports);
+__exportStar(require("./rank-by"), exports);
+__exportStar(require("./reduce"), exports);
+__exportStar(require("./reject"), exports);
+__exportStar(require("./reverse"), exports);
+__exportStar(require("./sample"), exports);
+__exportStar(require("./shuffle"), exports);
+__exportStar(require("./sort"), exports);
+__exportStar(require("./sort-by"), exports);
+__exportStar(require("./splice"), exports);
+__exportStar(require("./split-at"), exports);
+__exportStar(require("./split-when"), exports);
+__exportStar(require("./sum-by"), exports);
+__exportStar(require("./swap-indices"), exports);
+__exportStar(require("./take"), exports);
+__exportStar(require("./take-first-by"), exports);
+__exportStar(require("./take-while"), exports);
+__exportStar(require("./uniq"), exports);
+__exportStar(require("./uniq-by"), exports);
+__exportStar(require("./uniq-with"), exports);
+__exportStar(require("./zip"), exports);
+__exportStar(require("./zip-obj"), exports);
+__exportStar(require("./zip-with"), exports);

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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);
+}
+exports.intersectionWith = intersectionWith;
+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,
+            };
+        };
+    }
+    intersectionWith.lazy = lazy;
+})(intersectionWith || (exports.intersectionWith = intersectionWith = {}));

package/dist/commonjs/array/intersection.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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);
+}
+exports.intersection = intersection;
+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,
+            };
+        };
+    }
+    intersection.lazy = lazy;
+})(intersection || (exports.intersection = intersection = {}));

package/dist/commonjs/array/join.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.join = void 0;
+const purry_1 = require("../function/purry");
+function join(...args) {
+    return (0, purry_1.purry)(joinImplementation, args);
+}
+exports.join = join;
+function joinImplementation(data, glue) {
+    return data.join(glue);
+}

package/dist/commonjs/array/last.js

@@ -0,0 +1,11 @@
+"use strict";
+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);
+}
+exports.last = last;
+function _last(array) {
+    return array[array.length - 1];
+}

package/dist/commonjs/array/length.js

@@ -0,0 +1,11 @@
+"use strict";
+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);
+}
+exports.length = length;
+function _length(items) {
+    return 'length' in items ? items.length : Array.from(items).length;
+}

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

@@ -0,0 +1,23 @@
+"use strict";
+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);
+}
+exports.mapToObj = mapToObj;
+function _mapToObj(indexed) {
+    return (array, fn) => {
+        return array.reduce((result, element, index) => {
+            const [key, value] = indexed ? fn(element, index, array) : fn(element);
+            result[key] = value;
+            return result;
+        }, {});
+    };
+}
+(function (mapToObj) {
+    function indexed(...args) {
+        return (0, purry_1.purry)(_mapToObj(true), args);
+    }
+    mapToObj.indexed = indexed;
+})(mapToObj || (exports.mapToObj = mapToObj = {}));

package/dist/commonjs/array/map.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.map = void 0;
+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);
+}
+exports.map = map;
+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 (map) {
+    function indexed(...args) {
+        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.strict = map;
+})(map || (exports.map = map = {}));

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.maxBy = void 0;
+const purry_1 = require("../function/purry");
+function _maxBy(indexed) {
+    return (array, fn) => {
+        let ret;
+        let retMax;
+        array.forEach((item, i) => {
+            const max = indexed ? fn(item, i, 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);
+}
+exports.maxBy = maxBy;
+(function (maxBy) {
+    function indexed(...args) {
+        return (0, purry_1.purry)(_maxBy(true), args);
+    }
+    maxBy.indexed = indexed;
+})(maxBy || (exports.maxBy = maxBy = {}));

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

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.meanBy = void 0;
+const purry_1 = require("../function/purry");
+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);
+        });
+        return sum / array.length;
+    };
+}
+function meanBy(...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);
+    }
+    meanBy.indexed = indexed;
+})(meanBy || (exports.meanBy = meanBy = {}));

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

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeAll = void 0;
+function mergeAll(items) {
+    return items.reduce((acc, x) => ({ ...acc, ...x }), {});
+}
+exports.mergeAll = mergeAll;

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

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.minBy = void 0;
+const purry_1 = require("../function/purry");
+function _minBy(indexed) {
+    return (array, fn) => {
+        let ret;
+        let retMin;
+        array.forEach((item, i) => {
+            const min = indexed ? fn(item, i, 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);
+}
+exports.minBy = minBy;
+(function (minBy) {
+    function indexed(...args) {
+        return (0, purry_1.purry)(_minBy(true), args);
+    }
+    minBy.indexed = indexed;
+})(minBy || (exports.minBy = minBy = {}));

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nthBy = void 0;
+const purry_order_rules_1 = require("../utils/purry-order-rules");
+const quick_select_1 = require("../utils/quick-select");
+function nthBy(...args) {
+    return (0, purry_order_rules_1.purryOrderRulesWithArgument)(nthByImplementation, args);
+}
+exports.nthBy = nthBy;
+function nthByImplementation(data, compareFn, index) {
+    return (0, quick_select_1.quickSelect)(data, index >= 0 ? index : data.length + index, compareFn);
+}

package/dist/commonjs/array/only.js

@@ -0,0 +1,14 @@
+"use strict";
+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);
+}
+exports.only = only;
+function _only(array) {
+    if (array.length === 1) {
+        return array[0];
+    }
+    return undefined;
+}

package/dist/commonjs/array/partition.js

@@ -0,0 +1,24 @@
+"use strict";
+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);
+}
+exports.partition = partition;
+function _partition(indexed) {
+    return (array, fn) => {
+        const ret = [[], []];
+        array.forEach((item, index) => {
+            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);
+    }
+    partition.indexed = indexed;
+})(partition || (exports.partition = partition = {}));

package/dist/commonjs/array/range.js

@@ -0,0 +1,15 @@
+"use strict";
+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);
+}
+exports.range = range;
+function _range(start, end) {
+    const ret = [];
+    for (let i = start; i < end; i++) {
+        ret.push(i);
+    }
+    return ret;
+}

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

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rankBy = void 0;
+const purry_order_rules_1 = require("../utils/purry-order-rules");
+function rankBy(...args) {
+    return (0, purry_order_rules_1.purryOrderRulesWithArgument)(rankByImplementation, args);
+}
+exports.rankBy = rankBy;
+function rankByImplementation(data, compareFn, targetItem) {
+    let rank = 0;
+    for (const item of data) {
+        if (compareFn(targetItem, item) > 0) {
+            rank++;
+        }
+    }
+    return rank;
+}

package/dist/commonjs/array/reduce.js

@@ -0,0 +1,19 @@
+"use strict";
+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);
+}
+exports.reduce = reduce;
+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);
+    }
+    reduce.indexed = indexed;
+})(reduce || (exports.reduce = reduce = {}));

package/dist/commonjs/array/reject.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reject = void 0;
+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);
+}
+exports.reject = reject;
+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 (reject) {
+    function indexed(...args) {
+        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 || (exports.reject = reject = {}));

package/dist/commonjs/array/reverse.js

@@ -0,0 +1,11 @@
+"use strict";
+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);
+}
+exports.reverse = reverse;
+function _reverse(array) {
+    return array.slice().reverse();
+}