@vinicunca/perkakas 0.2.1 → 0.3.1

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

@@ -0,0 +1,44 @@
+import { purry } from '../function/purry';
+import { reduceLazy } from '../utils/reduce-lazy';
+export function flattenDeep(...args) {
+    return purry(_flattenDeep, args, flattenDeep.lazy);
+}
+function _flattenDeep(items) {
+    return reduceLazy(items, flattenDeep.lazy());
+}
+function _flattenDeepValue(value) {
+    if (!Array.isArray(value)) {
+        return value;
+    }
+    const ret = [];
+    value.forEach((item) => {
+        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,
+            };
+        };
+    }
+    flattenDeep.lazy = lazy;
+})(flattenDeep || (flattenDeep = {}));

package/dist/es/array/flatten.js

@@ -0,0 +1,28 @@
+import { purry } from '../function/purry';
+import { reduceLazy } from '../utils/reduce-lazy';
+export function flatten(...args) {
+    return purry(_flatten, args, flatten.lazy);
+}
+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,
+            };
+        };
+    }
+    flatten.lazy = lazy;
+})(flatten || (flatten = {}));

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

@@ -0,0 +1,36 @@
+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);
+}
+function _forEach(indexed) {
+    return (array, fn) => {
+        return 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 purry(_forEach(true), args, forEach.lazyIndexed);
+    }
+    forEach.indexed = indexed;
+    forEach.lazy = _lazy(false);
+    forEach.lazyIndexed = toLazyIndexed(_lazy(true));
+})(forEach || (forEach = {}));

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

@@ -0,0 +1,29 @@
+import { purry } from '../function/purry';
+export function groupBy(...args) {
+    return purry(_groupBy(false), args);
+}
+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 purry(_groupBy(true), args);
+    }
+    groupBy.indexed = indexed;
+    groupBy.strict = groupBy;
+})(groupBy || (groupBy = {}));

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

@@ -0,0 +1,7 @@
+import { purry } from '../function/purry';
+export function hasAtLeast(...args) {
+    return purry(hasAtLeastImplementation, args);
+}
+function hasAtLeastImplementation(data, minimum) {
+    return data.length >= minimum;
+}

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

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

package/dist/es/array/index.js

@@ -0,0 +1,65 @@
+export * from './all-pass';
+export * from './any-pass';
+export * from './chunk';
+export * from './compact';
+export * from './concat';
+export * from './count-by';
+export * from './difference-with';
+export * from './difference';
+export * from './drop-last';
+export * from './drop';
+export * from './drop-first-by';
+export * from './drop-last-while';
+export * from './drop-while';
+export * from './filter';
+export * from './find-index';
+export * from './find-last-index';
+export * from './find-last';
+export * from './find';
+export * from './first';
+export * from './first-by';
+export * from './flat-map-to-obj';
+export * from './flat-map';
+export * from './flatten-deep';
+export * from './flatten';
+export * from './for-each';
+export * from './group-by';
+export * from './has-at-least';
+export * from './index-by';
+export * from './intersection';
+export * from './intersection-with';
+export * from './join';
+export * from './last';
+export * from './length';
+export * from './map';
+export * from './map-to-obj';
+export * from './max-by';
+export * from './mean-by';
+export * from './merge-all';
+export * from './min-by';
+export * from './nth-by';
+export * from './only';
+export * from './partition';
+export * from './range';
+export * from './rank-by';
+export * from './reduce';
+export * from './reject';
+export * from './reverse';
+export * from './sample';
+export * from './shuffle';
+export * from './sort';
+export * from './sort-by';
+export * from './splice';
+export * from './split-at';
+export * from './split-when';
+export * from './sum-by';
+export * from './swap-indices';
+export * from './take';
+export * from './take-first-by';
+export * from './take-while';
+export * from './uniq';
+export * from './uniq-by';
+export * from './uniq-with';
+export * from './zip';
+export * from './zip-obj';
+export * from './zip-with';

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

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

package/dist/es/array/intersection.js

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

package/dist/es/array/join.js

@@ -0,0 +1,7 @@
+import { purry } from '../function/purry';
+export function join(...args) {
+    return purry(joinImplementation, args);
+}
+function joinImplementation(data, glue) {
+    return data.join(glue);
+}

package/dist/es/array/last.js

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

package/dist/es/array/length.js

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

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

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

package/dist/es/array/map.js

@@ -0,0 +1,31 @@
+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);
+}
+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 (map) {
+    function indexed(...args) {
+        return purry(_map(true), args, map.lazyIndexed);
+    }
+    map.indexed = indexed;
+    map.lazy = _lazy(false);
+    map.lazyIndexed = toLazyIndexed(_lazy(true));
+    map.strict = map;
+})(map || (map = {}));

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

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

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

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

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

@@ -0,0 +1,3 @@
+export function mergeAll(items) {
+    return items.reduce((acc, x) => ({ ...acc, ...x }), {});
+}

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

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

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

@@ -0,0 +1,8 @@
+import { purryOrderRulesWithArgument } from '../utils/purry-order-rules';
+import { quickSelect } from '../utils/quick-select';
+export function nthBy(...args) {
+    return purryOrderRulesWithArgument(nthByImplementation, args);
+}
+function nthByImplementation(data, compareFn, index) {
+    return quickSelect(data, index >= 0 ? index : data.length + index, compareFn);
+}

package/dist/es/array/only.js

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

package/dist/es/array/partition.js

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

package/dist/es/array/range.js

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

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

@@ -0,0 +1,13 @@
+import { purryOrderRulesWithArgument } from '../utils/purry-order-rules';
+export function rankBy(...args) {
+    return purryOrderRulesWithArgument(rankByImplementation, args);
+}
+function rankByImplementation(data, compareFn, targetItem) {
+    let rank = 0;
+    for (const item of data) {
+        if (compareFn(targetItem, item) > 0) {
+            rank++;
+        }
+    }
+    return rank;
+}

package/dist/es/array/reduce.js

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

package/dist/es/array/reject.js

@@ -0,0 +1,37 @@
+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);
+}
+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 (reject) {
+    function indexed(...args) {
+        return purry(_reject(true), args, reject.lazyIndexed);
+    }
+    reject.indexed = indexed;
+    reject.lazy = _lazy(false);
+    reject.lazyIndexed = toLazyIndexed(_lazy(true));
+})(reject || (reject = {}));

package/dist/es/array/reverse.js

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

package/dist/es/array/sample.js

@@ -0,0 +1,30 @@
+import { purry } from '../function/purry';
+export function sample(...args) {
+    return purry(sampleImplementation, args);
+}
+function sampleImplementation(data, sampleSize) {
+    if (sampleSize < 0) {
+        throw new RangeError(`sampleSize must cannot be negative: ${sampleSize}`);
+    }
+    if (!Number.isInteger(sampleSize)) {
+        throw new TypeError(`sampleSize must be an integer: ${sampleSize}`);
+    }
+    if (sampleSize >= data.length) {
+        return data;
+    }
+    if (sampleSize === 0) {
+        return [];
+    }
+    const actualSampleSize = Math.min(sampleSize, data.length - sampleSize);
+    const sampleIndices = new Set();
+    while (sampleIndices.size < actualSampleSize) {
+        const randomIndex = Math.floor(Math.random() * data.length);
+        sampleIndices.add(randomIndex);
+    }
+    if (sampleSize === actualSampleSize) {
+        return Array.from(sampleIndices)
+            .sort((a, b) => a - b)
+            .map((index) => data[index]);
+    }
+    return data.filter((_, index) => !sampleIndices.has(index));
+}

package/dist/es/array/shuffle.js

@@ -0,0 +1,14 @@
+import { purry } from '../function/purry';
+export function shuffle(...args) {
+    return purry(_shuffle, args);
+}
+function _shuffle(items) {
+    const result = items.slice();
+    for (let index = 0; index < items.length; index += 1) {
+        const rand = index + Math.floor(Math.random() * (items.length - index));
+        const value = result[rand];
+        result[rand] = result[index];
+        result[index] = value;
+    }
+    return result;
+}