@vinicunca/perkakas 0.1.0 → 0.3.1

package/dist/commonjs/array/sample.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sample = void 0;
+const purry_1 = require("../function/purry");
+function sample(...args) {
+    return (0, purry_1.purry)(sampleImplementation, args);
+}
+exports.sample = sample;
+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/commonjs/array/shuffle.js

@@ -0,0 +1,18 @@
+"use strict";
+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);
+}
+exports.shuffle = shuffle;
+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;
+}

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

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortBy = void 0;
+const purry_1 = require("../function/purry");
+const ALL_DIRECTIONS = ['asc', 'desc'];
+const COMPARATOR = {
+    asc: (x, y) => x > y,
+    desc: (x, y) => x < y,
+};
+function sortBy(arrayOrSortRule, ...sortRules) {
+    const args = isSortRule(arrayOrSortRule)
+        ? [[arrayOrSortRule, ...sortRules]]
+        : [arrayOrSortRule, sortRules];
+    return (0, purry_1.purry)(_sortBy, args);
+}
+exports.sortBy = sortBy;
+function isSortRule(x) {
+    if (typeof x === 'function') {
+        return true;
+    }
+    const [maybeProjection, maybeDirection, ...rest] = x;
+    if (rest.length > 0) {
+        return false;
+    }
+    return (typeof maybeProjection === 'function'
+        && ALL_DIRECTIONS.includes(maybeDirection));
+}
+function _sortBy(array, sorts) {
+    return [...array].sort(comparer(...sorts));
+}
+function comparer(primaryRule, secondaryRule, ...otherRules) {
+    const projector = typeof primaryRule === 'function' ? primaryRule : primaryRule[0];
+    const direction = typeof primaryRule === 'function' ? 'asc' : primaryRule[1];
+    const comparator = COMPARATOR[direction];
+    const nextComparer = secondaryRule === undefined
+        ? undefined
+        : comparer(secondaryRule, ...otherRules);
+    return (a, b) => {
+        const projectedA = projector(a);
+        const projectedB = projector(b);
+        if (comparator(projectedA, projectedB)) {
+            return 1;
+        }
+        if (comparator(projectedB, projectedA)) {
+            return -1;
+        }
+        return nextComparer?.(a, b) ?? 0;
+    };
+}
+(function (sortBy) {
+    sortBy.strict = sortBy;
+})(sortBy || (exports.sortBy = sortBy = {}));

package/dist/commonjs/array/sort.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sort = void 0;
+const purry_1 = require("../function/purry");
+function sort(...args) {
+    return (0, purry_1.purry)(_sort, args);
+}
+exports.sort = sort;
+function _sort(items, cmp) {
+    const ret = [...items];
+    ret.sort(cmp);
+    return ret;
+}
+(function (sort) {
+    sort.strict = sort;
+})(sort || (exports.sort = sort = {}));

package/dist/commonjs/array/splice.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splice = void 0;
+const purry_1 = require("../function/purry");
+function splice(...args) {
+    return (0, purry_1.purry)(_splice, args);
+}
+exports.splice = splice;
+function _splice(items, start, deleteCount, replacement) {
+    const result = [...items];
+    result.splice(start, deleteCount, ...replacement);
+    return result;
+}

package/dist/commonjs/array/split-at.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitAt = void 0;
+const purry_1 = require("../function/purry");
+function splitAt(...args) {
+    return (0, purry_1.purry)(_splitAt, args);
+}
+exports.splitAt = splitAt;
+function _splitAt(array, index) {
+    const copy = [...array];
+    const tail = copy.splice(index);
+    return [copy, tail];
+}

package/dist/commonjs/array/split-when.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.splitWhen = void 0;
+const purry_1 = require("../function/purry");
+const split_at_1 = require("./split-at");
+function splitWhen(...args) {
+    return (0, purry_1.purry)(_splitWhen, args);
+}
+exports.splitWhen = splitWhen;
+function _splitWhen(array, fn) {
+    for (let i = 0; i < array.length; i++) {
+        if (fn(array[i])) {
+            return (0, split_at_1.splitAt)(array, i);
+        }
+    }
+    return [array, []];
+}

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sumBy = void 0;
+const purry_1 = require("../function/purry");
+function _sumBy(indexed) {
+    return (array, fn) => {
+        let sum = 0;
+        array.forEach((item, i) => {
+            const summand = indexed ? fn(item, i, array) : fn(item);
+            sum += summand;
+        });
+        return sum;
+    };
+}
+function sumBy(...args) {
+    return (0, purry_1.purry)(_sumBy(false), args);
+}
+exports.sumBy = sumBy;
+(function (sumBy) {
+    function indexed(...args) {
+        return (0, purry_1.purry)(_sumBy(true), args);
+    }
+    sumBy.indexed = indexed;
+})(sumBy || (exports.sumBy = sumBy = {}));

package/dist/commonjs/array/swap-indices.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.swapIndices = void 0;
+const purry_1 = require("../function/purry");
+function swapIndices(...args) {
+    return (0, purry_1.purry)(_swapIndices, args);
+}
+exports.swapIndices = swapIndices;
+function _swapIndices(item, index1, index2) {
+    return typeof item === 'string'
+        ? _swapString(item, index1, index2)
+        : _swapArray(item, index1, index2);
+}
+function _swapArray(item, index1, index2) {
+    const result = item.slice();
+    if (Number.isNaN(index1) || Number.isNaN(index2)) {
+        return result;
+    }
+    const positiveIndexA = index1 < 0 ? item.length + index1 : index1;
+    const positiveIndexB = index2 < 0 ? item.length + index2 : index2;
+    if (positiveIndexA < 0 || positiveIndexA > item.length) {
+        return result;
+    }
+    if (positiveIndexB < 0 || positiveIndexB > item.length) {
+        return result;
+    }
+    result[positiveIndexA] = item[positiveIndexB];
+    result[positiveIndexB] = item[positiveIndexA];
+    return result;
+}
+function _swapString(item, index1, index2) {
+    const result = _swapArray(item.split(''), index1, index2);
+    return result.join('');
+}

package/dist/commonjs/array/take-first-by.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.takeFirstBy = void 0;
+const heap_1 = require("../utils/heap");
+const purry_order_rules_1 = require("../utils/purry-order-rules");
+function takeFirstBy(...args) {
+    return (0, purry_order_rules_1.purryOrderRulesWithArgument)(takeFirstByImplementation, args);
+}
+exports.takeFirstBy = takeFirstBy;
+function takeFirstByImplementation(data, compareFn, n) {
+    if (n <= 0) {
+        return [];
+    }
+    if (n >= data.length) {
+        return [...data];
+    }
+    const heap = data.slice(0, n);
+    (0, heap_1.heapify)(heap, compareFn);
+    const rest = data.slice(n);
+    for (const item of rest) {
+        (0, heap_1.heapMaybeInsert)(heap, compareFn, item);
+    }
+    return heap;
+}

package/dist/commonjs/array/take-while.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.takeWhile = void 0;
+const purry_1 = require("../function/purry");
+function takeWhile(...args) {
+    return (0, purry_1.purry)(_takeWhile, args);
+}
+exports.takeWhile = takeWhile;
+function _takeWhile(array, fn) {
+    const ret = [];
+    for (const item of array) {
+        if (!fn(item)) {
+            break;
+        }
+        ret.push(item);
+    }
+    return ret;
+}

package/dist/commonjs/array/take.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.take = void 0;
+const purry_1 = require("../function/purry");
+const reduce_lazy_1 = require("../utils/reduce-lazy");
+function take(...args) {
+    return (0, purry_1.purry)(_take, args, take.lazy);
+}
+exports.take = take;
+function _take(array, n) {
+    return (0, reduce_lazy_1.reduceLazy)(array, take.lazy(n));
+}
+(function (take) {
+    function lazy(n) {
+        return (value) => {
+            if (n === 0) {
+                return {
+                    done: true,
+                    hasNext: false,
+                };
+            }
+            n--;
+            if (n === 0) {
+                return {
+                    done: true,
+                    hasNext: true,
+                    next: value,
+                };
+            }
+            return {
+                done: false,
+                hasNext: true,
+                next: value,
+            };
+        };
+    }
+    take.lazy = lazy;
+})(take || (exports.take = take = {}));

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

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniqBy = void 0;
+const purry_1 = require("../function/purry");
+const reduce_lazy_1 = require("../utils/reduce-lazy");
+function uniqBy(...args) {
+    return (0, purry_1.purry)(_uniqBy, args, lazyUniqBy);
+}
+exports.uniqBy = uniqBy;
+function _uniqBy(array, transformer) {
+    return (0, reduce_lazy_1.reduceLazy)(array, lazyUniqBy(transformer));
+}
+function lazyUniqBy(transformer) {
+    const set = new Set();
+    return (value) => {
+        const appliedItem = transformer(value);
+        if (set.has(appliedItem)) {
+            return {
+                done: false,
+                hasNext: false,
+            };
+        }
+        set.add(appliedItem);
+        return {
+            done: false,
+            hasNext: true,
+            next: value,
+        };
+    };
+}

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniqWith = 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 uniqWith(...args) {
+    return (0, purry_1.purry)(_uniqWith, args, uniqWith.lazy);
+}
+exports.uniqWith = uniqWith;
+function _uniqWith(array, isEquals) {
+    const lazy = uniqWith.lazy(isEquals);
+    return (0, reduce_lazy_1.reduceLazy)(array, lazy, true);
+}
+function _lazy(isEquals) {
+    return (value, index, array) => {
+        if (array
+            && array.findIndex((otherValue) => isEquals(value, otherValue)) === index) {
+            return {
+                done: false,
+                hasNext: true,
+                next: value,
+            };
+        }
+        return {
+            done: false,
+            hasNext: false,
+        };
+    };
+}
+(function (uniqWith) {
+    uniqWith.lazy = (0, to_lazy_indexed_1.toLazyIndexed)(_lazy);
+})(uniqWith || (exports.uniqWith = uniqWith = {}));

package/dist/commonjs/array/uniq.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.uniq = void 0;
+const purry_1 = require("../function/purry");
+const reduce_lazy_1 = require("../utils/reduce-lazy");
+function uniq(...args) {
+    return (0, purry_1.purry)(_uniq, args, uniq.lazy);
+}
+exports.uniq = uniq;
+function _uniq(array) {
+    return (0, reduce_lazy_1.reduceLazy)(array, uniq.lazy());
+}
+(function (uniq) {
+    function lazy() {
+        const set = new Set();
+        return (value) => {
+            if (set.has(value)) {
+                return {
+                    done: false,
+                    hasNext: false,
+                };
+            }
+            set.add(value);
+            return {
+                done: false,
+                hasNext: true,
+                next: value,
+            };
+        };
+    }
+    uniq.lazy = lazy;
+})(uniq || (exports.uniq = uniq = {}));

package/dist/commonjs/array/zip-obj.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zipObj = void 0;
+const purry_1 = require("../function/purry");
+function zipObj(...args) {
+    return (0, purry_1.purry)(_zipObj, args);
+}
+exports.zipObj = zipObj;
+function _zipObj(first, second) {
+    const resultLength = first.length > second.length ? second.length : first.length;
+    const result = {};
+    for (let i = 0; i < resultLength; i++) {
+        result[first[i]] = second[i];
+    }
+    return result;
+}

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

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zipWith = void 0;
+function zipWith(arg0, arg1, arg2) {
+    if (typeof arg0 === 'function') {
+        return arg1 === undefined
+            ? (f, s) => _zipWith(f, s, arg0)
+            : (f) => _zipWith(f, arg1, arg0);
+    }
+    if (arg1 === undefined || arg2 === undefined) {
+        throw new Error('zipWith: Missing arguments in dataFirst function call');
+    }
+    return _zipWith(arg0, arg1, arg2);
+}
+exports.zipWith = zipWith;
+function _zipWith(first, second, fn) {
+    const resultLength = first.length > second.length ? second.length : first.length;
+    const result = [];
+    for (let i = 0; i < resultLength; i++) {
+        result.push(fn(first[i], second[i]));
+    }
+    return result;
+}

package/dist/commonjs/array/zip.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.zip = void 0;
+const purry_1 = require("../function/purry");
+function zip(...args) {
+    return (0, purry_1.purry)(_zip, args);
+}
+exports.zip = zip;
+function _zip(first, second) {
+    const resultLength = first.length > second.length ? second.length : first.length;
+    const result = [];
+    for (let i = 0; i < resultLength; i++) {
+        result.push([first[i], second[i]]);
+    }
+    return result;
+}
+(function (zip) {
+    zip.strict = zip;
+})(zip || (exports.zip = zip = {}));

package/dist/commonjs/function/conditional.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.conditional = void 0;
+const purry_on_1 = require("../utils/purry-on");
+function conditional(...args) {
+    return (0, purry_on_1.purryOn)(isCase, conditionalImplementation, args);
+}
+exports.conditional = conditional;
+function conditionalImplementation(data, ...cases) {
+    for (const [when, then] of cases) {
+        if (when(data)) {
+            return then(data);
+        }
+    }
+    throw new Error('conditional: data failed for all cases');
+}
+function isCase(maybeCase) {
+    if (!Array.isArray(maybeCase)) {
+        return false;
+    }
+    const [when, then, ...rest] = maybeCase;
+    return (typeof when === 'function'
+        && when.length <= 1
+        && typeof then === 'function'
+        && then.length <= 1
+        && rest.length === 0);
+}
+const trivialDefaultCase = () => undefined;
+(function (conditional) {
+    function defaultCase(then = trivialDefaultCase) {
+        return [() => true, then];
+    }
+    conditional.defaultCase = defaultCase;
+})(conditional || (exports.conditional = conditional = {}));

package/dist/commonjs/function/create-pipe.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPipe = void 0;
+const pipe_1 = require("./pipe");
+function createPipe(...operations) {
+    return (value) => pipe_1.pipe(value, ...operations);
+}
+exports.createPipe = createPipe;

package/dist/commonjs/function/debounce.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.debounce = void 0;
+function debounce(func, { maxWaitMs, timing = 'trailing', waitMs, }) {
+    if (maxWaitMs !== undefined && waitMs !== undefined && maxWaitMs < waitMs) {
+        throw new Error(`debounce: maxWaitMs (${maxWaitMs}) cannot be less than waitMs (${waitMs})`);
+    }
+    let coolDownTimeoutId;
+    let maxWaitTimeoutId;
+    let latestCallArgs;
+    let result;
+    function handleDebouncedCall(args) {
+        latestCallArgs = args;
+        if (maxWaitMs !== undefined && maxWaitTimeoutId === undefined) {
+            maxWaitTimeoutId = setTimeout(handleInvoke, maxWaitMs);
+        }
+    }
+    function handleInvoke() {
+        if (latestCallArgs === undefined) {
+            return;
+        }
+        if (maxWaitTimeoutId !== undefined) {
+            const timeoutId = maxWaitTimeoutId;
+            maxWaitTimeoutId = undefined;
+            clearTimeout(timeoutId);
+        }
+        const args = latestCallArgs;
+        latestCallArgs = undefined;
+        result = func(...args);
+    }
+    function handleCoolDownEnd() {
+        if (coolDownTimeoutId === undefined) {
+            return;
+        }
+        const timeoutId = coolDownTimeoutId;
+        coolDownTimeoutId = undefined;
+        clearTimeout(timeoutId);
+        if (latestCallArgs !== undefined) {
+            handleInvoke();
+        }
+    }
+    return {
+        get cachedValue() {
+            return result;
+        },
+        call: (...args) => {
+            if (coolDownTimeoutId === undefined) {
+                if (timing === 'trailing') {
+                    handleDebouncedCall(args);
+                }
+                else {
+                    result = func(...args);
+                }
+            }
+            else {
+                if (timing !== 'leading') {
+                    handleDebouncedCall(args);
+                }
+                const timeoutId = coolDownTimeoutId;
+                coolDownTimeoutId = undefined;
+                clearTimeout(timeoutId);
+            }
+            coolDownTimeoutId = setTimeout(handleCoolDownEnd, waitMs ?? maxWaitMs ?? 0);
+            return result;
+        },
+        cancel: () => {
+            if (coolDownTimeoutId !== undefined) {
+                const timeoutId = coolDownTimeoutId;
+                coolDownTimeoutId = undefined;
+                clearTimeout(timeoutId);
+            }
+            if (maxWaitTimeoutId !== undefined) {
+                const timeoutId = maxWaitTimeoutId;
+                maxWaitTimeoutId = undefined;
+                clearTimeout(timeoutId);
+            }
+            latestCallArgs = undefined;
+        },
+        flush: () => {
+            handleCoolDownEnd();
+            return result;
+        },
+        get isPending() {
+            return coolDownTimeoutId !== undefined;
+        },
+    };
+}
+exports.debounce = debounce;

package/dist/commonjs/function/identity.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.identity = void 0;
+function identity(value) {
+    return value;
+}
+exports.identity = identity;

package/dist/commonjs/function/index.js

@@ -0,0 +1,25 @@
+"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("./conditional"), exports);
+__exportStar(require("./create-pipe"), exports);
+__exportStar(require("./identity"), exports);
+__exportStar(require("./noop"), exports);
+__exportStar(require("./once"), exports);
+__exportStar(require("./debounce"), exports);
+__exportStar(require("./pipe"), exports);
+__exportStar(require("./purry"), exports);
+__exportStar(require("./sleep"), exports);

package/dist/commonjs/function/noop.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.noop = void 0;
+function noop() {
+    return undefined;
+}
+exports.noop = noop;

package/dist/commonjs/function/once.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.once = void 0;
+function once(fn) {
+    let called = false;
+    let ret;
+    return () => {
+        if (!called) {
+            ret = fn();
+            called = true;
+        }
+        return ret;
+    };
+}
+exports.once = once;