@vinicunca/perkakas 0.2.1 → 0.3.1

package/dist/commonjs/function/pipe.js

@@ -0,0 +1,106 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pipe = void 0;
+function pipe(input, ...operations) {
+    let output = input;
+    const lazyOperations = operations.map((op) => 'lazy' in op ? toPipedLazy(op) : undefined);
+    let operationIndex = 0;
+    while (operationIndex < operations.length) {
+        const lazyOperation = lazyOperations[operationIndex];
+        if (lazyOperation === undefined || !isIterable(output)) {
+            const operation = operations[operationIndex];
+            output = operation(output);
+            operationIndex++;
+            continue;
+        }
+        const lazySequence = [];
+        for (let j = operationIndex; j < operations.length; j++) {
+            const lazyOp = lazyOperations[j];
+            if (lazyOp === undefined) {
+                break;
+            }
+            lazySequence.push(lazyOp);
+            if (lazyOp.isSingle) {
+                break;
+            }
+        }
+        const accumulator = [];
+        const iterator = output[Symbol.iterator]();
+        while (true) {
+            const result = iterator.next();
+            if (result.done ?? false) {
+                break;
+            }
+            const shouldExitEarly = processItem_(result.value, accumulator, lazySequence);
+            if (shouldExitEarly) {
+                break;
+            }
+        }
+        const { isSingle } = lazySequence[lazySequence.length - 1];
+        if (isSingle) {
+            output = accumulator[0];
+        }
+        else {
+            output = accumulator;
+        }
+        operationIndex += lazySequence.length;
+    }
+    return output;
+}
+exports.pipe = pipe;
+function processItem_(item, accumulator, lazySequence) {
+    if (lazySequence.length === 0) {
+        accumulator.push(item);
+        return false;
+    }
+    let lazyResult = { done: false, hasNext: false };
+    let isDone = false;
+    for (let i = 0; i < lazySequence.length; i++) {
+        const lazyFn = lazySequence[i];
+        const { index, isIndexed, items } = lazyFn;
+        items.push(item);
+        lazyResult = isIndexed ? lazyFn(item, index, items) : lazyFn(item);
+        lazyFn.index++;
+        if (lazyResult.hasNext) {
+            if (lazyResult.hasMany) {
+                const nextValues = lazyResult.next;
+                for (const subItem of nextValues) {
+                    const subResult = processItem_(subItem, accumulator, lazySequence.slice(i + 1));
+                    if (subResult) {
+                        return true;
+                    }
+                }
+                return false;
+            }
+            else {
+                item = lazyResult.next;
+            }
+        }
+        if (!lazyResult.hasNext) {
+            break;
+        }
+        if (lazyResult.done) {
+            isDone = true;
+        }
+    }
+    if (lazyResult.hasNext) {
+        accumulator.push(item);
+    }
+    return isDone;
+}
+function toPipedLazy(op) {
+    const { lazy, lazyArgs } = op;
+    const fn = lazy(...(lazyArgs ?? []));
+    return Object.assign(fn, {
+        index: 0,
+        isIndexed: lazy.indexed,
+        isSingle: lazy.single,
+        items: [],
+    });
+}
+function isIterable(something) {
+    return (typeof something === 'string'
+        || (typeof something === 'object'
+            && something !== null
+            && Symbol.iterator in something));
+}

package/dist/commonjs/function/purry.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.purry = void 0;
+function purry(fn, args, lazy) {
+    const diff = fn.length - args.length;
+    const arrayArgs = Array.from(args);
+    if (diff === 0) {
+        return fn(...arrayArgs);
+    }
+    if (diff === 1) {
+        const ret = (data) => fn(data, ...arrayArgs);
+        if (lazy || fn.lazy) {
+            ret.lazy = lazy || fn.lazy;
+            ret.lazyArgs = args;
+        }
+        return ret;
+    }
+    throw new Error('Wrong number of arguments');
+}
+exports.purry = purry;

package/dist/commonjs/function/sleep.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sleep = void 0;
+function sleep(timeout) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, timeout);
+    });
+}
+exports.sleep = sleep;

package/dist/commonjs/guard/index.js

@@ -0,0 +1,32 @@
+"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("./is-array"), exports);
+__exportStar(require("./is-boolean"), exports);
+__exportStar(require("./is-date"), exports);
+__exportStar(require("./is-defined"), exports);
+__exportStar(require("./is-empty"), exports);
+__exportStar(require("./is-error"), exports);
+__exportStar(require("./is-function"), exports);
+__exportStar(require("./is-nil"), exports);
+__exportStar(require("./is-non-null"), exports);
+__exportStar(require("./is-not"), exports);
+__exportStar(require("./is-number"), exports);
+__exportStar(require("./is-object"), exports);
+__exportStar(require("./is-promise"), exports);
+__exportStar(require("./is-string"), exports);
+__exportStar(require("./is-symbol"), exports);
+__exportStar(require("./is-truthy"), exports);

package/dist/commonjs/guard/is-array.js

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

package/dist/commonjs/guard/is-boolean.js

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

package/dist/commonjs/guard/is-date.js

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

package/dist/commonjs/guard/is-defined.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDefined = void 0;
+function isDefined(data) {
+    return typeof data !== 'undefined' && data !== null;
+}
+exports.isDefined = isDefined;
+(function (isDefined) {
+    function strict(data) {
+        return data !== undefined;
+    }
+    isDefined.strict = strict;
+})(isDefined || (exports.isDefined = isDefined = {}));

package/dist/commonjs/guard/is-empty.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isEmpty = void 0;
+const is_array_1 = require("./is-array");
+const is_object_1 = require("./is-object");
+const is_string_1 = require("./is-string");
+function isEmpty(data) {
+    if ((0, is_array_1.isArray)(data) || (0, is_string_1.isString)(data)) {
+        return data.length === 0;
+    }
+    if ((0, is_object_1.isObject)(data)) {
+        for (const _ in data) {
+            return false;
+        }
+        return !(data instanceof RegExp);
+    }
+    return false;
+}
+exports.isEmpty = isEmpty;

package/dist/commonjs/guard/is-error.js

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

package/dist/commonjs/guard/is-function.js

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

package/dist/commonjs/guard/is-nil.js

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

package/dist/commonjs/guard/is-non-null.js

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

package/dist/commonjs/guard/is-not.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNot = void 0;
+function isNot(predicate) {
+    return (data) => {
+        return !predicate(data);
+    };
+}
+exports.isNot = isNot;

package/dist/commonjs/guard/is-number.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isNumber = void 0;
+function isNumber(data) {
+    return typeof data === 'number' && !Number.isNaN(data);
+}
+exports.isNumber = isNumber;

package/dist/commonjs/guard/is-object.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isObject = void 0;
+function isObject(data) {
+    if (typeof data !== 'object' || data === null) {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(data);
+    return proto === null || proto === Object.prototype;
+}
+exports.isObject = isObject;

package/dist/commonjs/guard/is-promise.js

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

package/dist/commonjs/guard/is-string.js

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

package/dist/commonjs/guard/is-symbol.js

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

package/dist/commonjs/guard/is-truthy.js

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

package/dist/commonjs/index.js

@@ -0,0 +1,26 @@
+"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 });
+exports.isBrowser = void 0;
+__exportStar(require("./aria"), exports);
+__exportStar(require("./array"), exports);
+__exportStar(require("./function"), exports);
+__exportStar(require("./guard"), exports);
+__exportStar(require("./number"), exports);
+__exportStar(require("./object"), exports);
+__exportStar(require("./string"), exports);
+__exportStar(require("./type"), exports);
+exports.isBrowser = typeof window !== 'undefined';

package/dist/commonjs/number/add.js

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

package/dist/commonjs/number/ceil.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ceil = void 0;
+const purry_1 = require("../function/purry");
+const with_precision_1 = require("../utils/with-precision");
+function ceil(...args) {
+    return (0, purry_1.purry)((0, with_precision_1.withPrecision)(Math.ceil), args);
+}
+exports.ceil = ceil;

package/dist/commonjs/number/clamp.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clamp = void 0;
+const purry_1 = require("../function/purry");
+function clamp(...args) {
+    return (0, purry_1.purry)(_clamp, args);
+}
+exports.clamp = clamp;
+function _clamp(value, limits) {
+    if (limits.min != null && limits.min > value) {
+        return limits.min;
+    }
+    if (limits.max != null && limits.max < value) {
+        return limits.max;
+    }
+    return value;
+}

package/dist/commonjs/number/divide.js

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

package/dist/commonjs/number/floor.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.floor = void 0;
+const purry_1 = require("../function/purry");
+const with_precision_1 = require("../utils/with-precision");
+function floor(...args) {
+    return (0, purry_1.purry)((0, with_precision_1.withPrecision)(Math.floor), args);
+}
+exports.floor = floor;

package/dist/commonjs/number/index.js

@@ -0,0 +1,24 @@
+"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("./add"), exports);
+__exportStar(require("./ceil"), exports);
+__exportStar(require("./clamp"), exports);
+__exportStar(require("./divide"), exports);
+__exportStar(require("./floor"), exports);
+__exportStar(require("./multiply"), exports);
+__exportStar(require("./round"), exports);
+__exportStar(require("./subtract"), exports);

package/dist/commonjs/number/multiply.js

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

package/dist/commonjs/number/round.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.round = void 0;
+const purry_1 = require("../function/purry");
+const with_precision_1 = require("../utils/with-precision");
+function round(...args) {
+    return (0, purry_1.purry)((0, with_precision_1.withPrecision)(Math.round), args);
+}
+exports.round = round;

package/dist/commonjs/number/subtract.js

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

package/dist/commonjs/object/add-prop.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addProp = void 0;
+const purry_1 = require("../function/purry");
+function addProp(...args) {
+    return (0, purry_1.purry)(_addProp, args);
+}
+exports.addProp = addProp;
+function _addProp(obj, prop, value) {
+    return {
+        ...obj,
+        [prop]: value,
+    };
+}

package/dist/commonjs/object/clone.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.clone = void 0;
+const type_1 = require("../type");
+function _cloneRegExp(pattern) {
+    return new RegExp(pattern.source, (pattern.global ? 'g' : '')
+        + (pattern.ignoreCase ? 'i' : '')
+        + (pattern.multiline ? 'm' : '')
+        + (pattern.sticky ? 'y' : '')
+        + (pattern.unicode ? 'u' : ''));
+}
+function _clone(value, refFrom, refTo, deep) {
+    function copy(copiedValue) {
+        const len = refFrom.length;
+        let idx = 0;
+        while (idx < len) {
+            if (value === refFrom[idx]) {
+                return refTo[idx];
+            }
+            idx += 1;
+        }
+        refFrom[idx + 1] = value;
+        refTo[idx + 1] = copiedValue;
+        for (const key in value) {
+            copiedValue[key] = deep
+                ? _clone(value[key], refFrom, refTo, true)
+                : value[key];
+        }
+        return copiedValue;
+    }
+    switch ((0, type_1.type)(value)) {
+        case 'Object':
+            return copy({});
+        case 'Array':
+            return copy([]);
+        case 'Date':
+            return new Date(value.valueOf());
+        case 'RegExp':
+            return _cloneRegExp(value);
+        default:
+            return value;
+    }
+}
+function clone(value) {
+    return value != null && typeof value.clone === 'function'
+        ? value.clone()
+        : _clone(value, [], [], true);
+}
+exports.clone = clone;

package/dist/commonjs/object/equals.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.equals = void 0;
+const purry_1 = require("../function/purry");
+const isArray = Array.isArray;
+const keyList = Object.keys;
+function equals(...args) {
+    return (0, purry_1.purry)(_equals, args);
+}
+exports.equals = equals;
+function _equals(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (a && b && typeof a === 'object' && typeof b === 'object') {
+        const arrA = isArray(a);
+        const arrB = isArray(b);
+        let i;
+        let length;
+        let key;
+        if (arrA && arrB) {
+            length = a.length;
+            if (length !== b.length) {
+                return false;
+            }
+            for (i = length; i-- !== 0;) {
+                if (!equals(a[i], b[i])) {
+                    return false;
+                }
+            }
+            return true;
+        }
+        if (arrA !== arrB) {
+            return false;
+        }
+        const dateA = a instanceof Date;
+        const dateB = b instanceof Date;
+        if (dateA !== dateB) {
+            return false;
+        }
+        if (dateA && dateB) {
+            return a.getTime() === b.getTime();
+        }
+        const regexpA = a instanceof RegExp;
+        const regexpB = b instanceof RegExp;
+        if (regexpA !== regexpB) {
+            return false;
+        }
+        if (regexpA && regexpB) {
+            return a.toString() === b.toString();
+        }
+        const keys = keyList(a);
+        length = keys.length;
+        if (length !== keyList(b).length) {
+            return false;
+        }
+        for (i = length; i-- !== 0;) {
+            if (!Object.prototype.hasOwnProperty.call(b, keys[i])) {
+                return false;
+            }
+        }
+        for (i = length; i-- !== 0;) {
+            key = keys[i];
+            if (!equals(a[key], b[key])) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return a !== a && b !== b;
+}

package/dist/commonjs/object/for-each-obj.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forEachObj = void 0;
+const purry_1 = require("../function/purry");
+function forEachObj(...args) {
+    return (0, purry_1.purry)(_forEachObj(false), args);
+}
+exports.forEachObj = forEachObj;
+function _forEachObj(indexed) {
+    return (object, fn) => {
+        for (const key in object) {
+            if (Object.prototype.hasOwnProperty.call(object, key)) {
+                const val = object[key];
+                if (indexed) {
+                    fn(val, key, object);
+                }
+                else {
+                    fn(val);
+                }
+            }
+        }
+        return object;
+    };
+}
+(function (forEachObj) {
+    function indexed(...args) {
+        return (0, purry_1.purry)(_forEachObj(true), args);
+    }
+    forEachObj.indexed = indexed;
+})(forEachObj || (exports.forEachObj = forEachObj = {}));