@vinicunca/perkakas 0.3.1 → 0.3.5

package/dist/es/number/clamp.js

@@ -1,13 +1,13 @@
 import { purry } from '../function/purry';
 export function clamp(...args) {
-    return purry(_clamp, args);
+    return purry(clamp_, args);
 }
-function _clamp(value, limits) {
-    if (limits.min != null && limits.min > value) {
-        return limits.min;
+function clamp_(value, { max, min }) {
+    if (min !== undefined && value < min) {
+        return min;
     }
-    if (limits.max != null && limits.max < value) {
-        return limits.max;
+    if (max !== undefined && value > max) {
+        return max;
     }
     return value;
 }

package/dist/es/number/divide.js

@@ -1,7 +1,7 @@
 import { purry } from '../function/purry';
 export function divide(...args) {
-    return purry(_divide, args);
+    return purry(divide_, args);
 }
-function _divide(value, divisor) {
+function divide_(value, divisor) {
     return value / divisor;
 }

package/dist/es/number/multiply.js

@@ -1,7 +1,7 @@
 import { purry } from '../function/purry';
 export function multiply(...args) {
-    return purry(_multiply, args);
+    return purry(multiply_, args);
 }
-function _multiply(value, multiplicand) {
+function multiply_(value, multiplicand) {
     return value * multiplicand;
 }

package/dist/es/number/subtract.js

@@ -1,7 +1,7 @@
 import { purry } from '../function/purry';
 export function subtract(...args) {
-    return purry(_subtract, args);
+    return purry(subtract_, args);
 }
-function _subtract(value, subtrahend) {
+function subtract_(value, subtrahend) {
     return value - subtrahend;
 }

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

@@ -1,8 +1,8 @@
 import { purry } from '../function/purry';
 export function addProp(...args) {
-    return purry(_addProp, args);
+    return purry(addProp_, args);
 }
-function _addProp(obj, prop, value) {
+function addProp_(obj, prop, value) {
     return {
         ...obj,
         [prop]: value,

package/dist/es/object/clone.js

@@ -1,12 +1,12 @@
 import { type } from '../type';
-function _cloneRegExp(pattern) {
+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 clone_(value, refFrom, refTo, deep) {
     function copy(copiedValue) {
         const len = refFrom.length;
         let idx = 0;
@@ -20,7 +20,7 @@ function _clone(value, refFrom, refTo, deep) {
         refTo[idx + 1] = copiedValue;
         for (const key in value) {
             copiedValue[key] = deep
-                ? _clone(value[key], refFrom, refTo, true)
+                ? clone_(value[key], refFrom, refTo, true)
                 : value[key];
         }
         return copiedValue;
@@ -33,7 +33,7 @@ function _clone(value, refFrom, refTo, deep) {
         case 'Date':
             return new Date(value.valueOf());
         case 'RegExp':
-            return _cloneRegExp(value);
+            return cloneRegExp_(value);
         default:
             return value;
     }
@@ -41,5 +41,5 @@ function _clone(value, refFrom, refTo, deep) {
 export function clone(value) {
     return value != null && typeof value.clone === 'function'
         ? value.clone()
-        : _clone(value, [], [], true);
+        : clone_(value, [], [], true);
 }

package/dist/es/object/equals.js

@@ -1,67 +1,63 @@
 import { purry } from '../function/purry';
-const isArray = Array.isArray;
-const keyList = Object.keys;
 export function equals(...args) {
-    return purry(_equals, args);
+    return purry(equals_, args);
 }
-function _equals(a, b) {
+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) {
+    if (typeof a === 'number' && typeof b === 'number') {
+        return Number.isNaN(a) && Number.isNaN(b);
+    }
+    if (typeof a !== 'object' || typeof b !== 'object') {
+        return false;
+    }
+    if (a === null || b === null) {
+        return false;
+    }
+    const isArrayA = Array.isArray(a);
+    const isArrayB = Array.isArray(b);
+    if (isArrayA && isArrayB) {
+        if (a.length !== b.length) {
             return false;
         }
-        if (dateA && dateB) {
-            return a.getTime() === b.getTime();
+        for (let i = 0; i < a.length; i++) {
+            if (!equals_(a[i], b[i])) {
+                return false;
+            }
         }
-        const regexpA = a instanceof RegExp;
-        const regexpB = b instanceof RegExp;
-        if (regexpA !== regexpB) {
+        return true;
+    }
+    if (isArrayA !== isArrayB) {
+        return false;
+    }
+    const isDateA = a instanceof Date;
+    const isDateB = b instanceof Date;
+    if (isDateA && isDateB) {
+        return a.getTime() === b.getTime();
+    }
+    if (isDateA !== isDateB) {
+        return false;
+    }
+    const isRegExpA = a instanceof RegExp;
+    const isRegExpB = b instanceof RegExp;
+    if (isRegExpA && isRegExpB) {
+        return a.toString() === b.toString();
+    }
+    if (isRegExpA !== isRegExpB) {
+        return false;
+    }
+    const keys = Object.keys(a);
+    if (keys.length !== Object.keys(b).length) {
+        return false;
+    }
+    for (const key of keys) {
+        if (!Object.prototype.hasOwnProperty.call(b, key)) {
             return false;
         }
-        if (regexpA && regexpB) {
-            return a.toString() === b.toString();
-        }
-        const keys = keyList(a);
-        length = keys.length;
-        if (length !== keyList(b).length) {
+        if (!equals_(a[key], b[key])) {
             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;
+    return true;
 }

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

@@ -1,26 +1,26 @@
 import { purry } from '../function/purry';
 export function forEachObj(...args) {
-    return purry(_forEachObj(false), args);
+    return purry(forEachObj_(false), args);
 }
-function _forEachObj(indexed) {
-    return (object, fn) => {
-        for (const key in object) {
-            if (Object.prototype.hasOwnProperty.call(object, key)) {
-                const val = object[key];
+function forEachObj_(indexed) {
+    return (data, fn) => {
+        for (const key in data) {
+            if (Object.prototype.hasOwnProperty.call(data, key)) {
+                const { [key]: val } = data;
                 if (indexed) {
-                    fn(val, key, object);
+                    fn(val, key, data);
                 }
                 else {
                     fn(val);
                 }
             }
         }
-        return object;
+        return data;
     };
 }
 (function (forEachObj) {
     function indexed(...args) {
-        return purry(_forEachObj(true), args);
+        return purry(forEachObj_(true), args);
     }
     forEachObj.indexed = indexed;
 })(forEachObj || (forEachObj = {}));

package/dist/es/object/from-pairs.js

@@ -1,4 +1,8 @@
-export function fromPairs(entries) {
+import { purry } from '../function/purry';
+export function fromPairs(...args) {
+    return purry(fromPairsImplementation, args);
+}
+function fromPairsImplementation(entries) {
     const out = {};
     for (const [key, value] of entries) {
         out[key] = value;

package/dist/es/object/invert.js

@@ -1,11 +1,13 @@
 import { purry } from '../function/purry';
 export function invert(...args) {
-    return purry(_invert, args);
+    return purry(invert_, args);
 }
-function _invert(object) {
+function invert_(object) {
     const result = {};
     for (const key in object) {
-        result[object[key]] = key;
+        if (Object.prototype.hasOwnProperty.call(object, key)) {
+            result[object[key]] = key;
+        }
     }
     return result;
 }

package/dist/es/object/keys.js

@@ -1,5 +1,6 @@
-export function keys(source) {
-    return Object.keys(source);
+import { purry } from '../function/purry';
+export function keys(...args) {
+    return purry(Object.keys, args);
 }
 (function (keys) {
     keys.strict = keys;

package/dist/es/object/map-keys.js

@@ -1,9 +1,9 @@
 import { purry } from '../function/purry';
 import { toPairs } from './to-pairs';
 export function mapKeys(...args) {
-    return purry(_mapKeys, args);
+    return purry(mapKeys_, args);
 }
-function _mapKeys(data, fn) {
+function mapKeys_(data, fn) {
     const out = {};
     for (const [key, value] of toPairs.strict(data)) {
         out[fn(key, value)] = value;

package/dist/es/object/map-values.js

@@ -1,9 +1,9 @@
 import { purry } from '../function/purry';
 import { toPairs } from './to-pairs';
 export function mapValues(...args) {
-    return purry(_mapValues, args);
+    return purry(mapValues_, args);
 }
-function _mapValues(data, fn) {
+function mapValues_(data, fn) {
     const out = {};
     for (const [key, value] of toPairs.strict(data)) {
         out[key] = fn(value, key);

package/dist/es/object/merge-deep.js

@@ -8,11 +8,11 @@ function mergeDeepImplementation(destination, source) {
         if (!(key in destination)) {
             continue;
         }
-        const destinationValue = destination[key];
+        const { [key]: destinationValue } = destination;
         if (!isRecord(destinationValue)) {
             continue;
         }
-        const sourceValue = source[key];
+        const { [key]: sourceValue } = source;
         if (!isRecord(sourceValue)) {
             continue;
         }

package/dist/es/object/merge.js

@@ -1,7 +1,7 @@
 import { purry } from '../function/purry';
 export function merge(...args) {
-    return purry(_merge, args);
+    return purry(merge_, args);
 }
-function _merge(a, b) {
+function merge_(a, b) {
     return Object.assign({}, a, b);
 }

package/dist/es/object/omit-by.js

@@ -1,16 +1,17 @@
 import { purry } from '../function/purry';
 import { keys } from './keys';
 export function omitBy(...args) {
-    return purry(_omitBy, args);
+    return purry(omitBy_, args);
 }
-function _omitBy(object, fn) {
+function omitBy_(object, fn) {
     if (object === undefined || object === null) {
         return object;
     }
-    return keys.strict(object).reduce((acc, key) => {
+    const out = {};
+    for (const key of keys.strict(object)) {
         if (!fn(object[key], key)) {
-            acc[key] = object[key];
+            out[key] = object[key];
         }
-        return acc;
-    }, {});
+    }
+    return out;
 }

package/dist/es/object/omit.js

@@ -2,9 +2,9 @@ import { hasAtLeast } from '../array/has-at-least';
 import { purry } from '../function/purry';
 import { fromPairs } from './from-pairs';
 export function omit(...args) {
-    return purry(_omit, args);
+    return purry(omit_, args);
 }
-function _omit(data, propNames) {
+function omit_(data, propNames) {
     if (!hasAtLeast(propNames, 1)) {
         return { ...data };
     }

package/dist/es/object/path-or.js

@@ -1,14 +1,14 @@
 import { purry } from '../function/purry';
 export function pathOr(...args) {
-    return purry(_pathOr, args);
+    return purry(pathOr_, args);
 }
-function _pathOr(object, path, defaultValue) {
-    let current = object;
+function pathOr_(data, path, defaultValue) {
+    let current = data;
     for (const prop of path) {
-        if (current == null || current[prop] == null) {
-            return defaultValue;
+        if (current === null || current === undefined) {
+            break;
         }
         current = current[prop];
     }
-    return current;
+    return current ?? defaultValue;
 }

package/dist/es/object/pick-by.js

@@ -1,16 +1,17 @@
 import { purry } from '../function/purry';
 import { keys } from './keys';
 export function pickBy(...args) {
-    return purry(_pickBy, args);
+    return purry(pickBy_, args);
 }
-function _pickBy(object, fn) {
-    if (object == null) {
+function pickBy_(data, fn) {
+    if (data === null || data === undefined) {
         return {};
     }
-    return keys.strict(object).reduce((acc, key) => {
-        if (fn(object[key], key)) {
-            acc[key] = object[key];
+    const out = {};
+    for (const key of keys.strict(data)) {
+        if (fn(data[key], key)) {
+            out[key] = data[key];
         }
-        return acc;
-    }, {});
+    }
+    return out;
 }

package/dist/es/object/pick.js

@@ -1,15 +1,13 @@
 import { purry } from '../function/purry';
 export function pick(...args) {
-    return purry(_pick, args);
+    return purry(pick_, args);
 }
-function _pick(object, names) {
-    if (object == null) {
-        return {};
-    }
-    return names.reduce((acc, name) => {
+function pick_(object, names) {
+    const out = {};
+    for (const name of names) {
         if (name in object) {
-            acc[name] = object[name];
+            out[name] = object[name];
         }
-        return acc;
-    }, {});
+    }
+    return out;
 }

package/dist/es/object/set-path.js

@@ -1,21 +1,20 @@
 import { purry } from '../function/purry';
 export function setPath(...args) {
-    return purry(_setPath, args);
+    return purry(setPath_, args);
 }
-export function _setPath(object, path, defaultValue) {
-    if (path.length === 0) {
-        return defaultValue;
+export function setPath_(data, path, value) {
+    const [current, ...rest] = path;
+    if (current === undefined) {
+        return value;
     }
-    if (Array.isArray(object)) {
-        return object.map((item, index) => {
-            if (index === path[0]) {
-                return _setPath(item, path.slice(1), defaultValue);
-            }
-            return item;
-        });
+    if (Array.isArray(data)) {
+        return data.map((item, index) => index === current ? setPath_(item, rest, value) : item);
+    }
+    if (data === null || data === undefined) {
+        throw new Error('Path doesn\'t exist in object!');
     }
     return {
-        ...object,
-        [path[0]]: _setPath(object[path[0]], path.slice(1), defaultValue),
+        ...data,
+        [current]: setPath_(data[current], rest, value),
     };
 }

package/dist/es/object/set.js

@@ -1,8 +1,8 @@
 import { purry } from '../function/purry';
 export function set(...args) {
-    return purry(_set, args);
+    return purry(set_, args);
 }
-function _set(obj, prop, value) {
+function set_(obj, prop, value) {
     return {
         ...obj,
         [prop]: value,

package/dist/es/object/swap-props.js

@@ -1,8 +1,8 @@
 import { purry } from '../function/purry';
 export function swapProps(...args) {
-    return purry(_swapProps, args);
+    return purry(swapProps_, args);
 }
-function _swapProps(obj, key1, key2) {
+function swapProps_(obj, key1, key2) {
     const { [key1]: value1, [key2]: value2 } = obj;
     return {
         ...obj,

package/dist/es/string/random-string.js

@@ -1,6 +1,12 @@
-import { range } from '../array/range';
-export function randomString(length) {
-    const characterSet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
-    const randomChar = () => characterSet[Math.floor(Math.random() * characterSet.length)];
-    return range(0, length).reduce((text) => text + randomChar(), '');
+import { purry } from '../function/purry';
+import { times } from '../function/times';
+const ALPHABET = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+export function randomString(...args) {
+    return purry(randomStringImplementation, args);
+}
+function randomStringImplementation(length) {
+    return times(length, randomChar).join('');
+}
+function randomChar() {
+    return ALPHABET[Math.floor(Math.random() * ALPHABET.length)];
 }

package/dist/es/string/string-to-path.js

@@ -1,14 +1,14 @@
 export function stringToPath(path) {
-    return _stringToPath(path);
+    return stringToPath_(path);
 }
-function _stringToPath(path) {
+function stringToPath_(path) {
     if (path.length === 0) {
         return [];
     }
-    const match = path.match(/^\[(.+?)\](.*)$/) ?? path.match(/^\.?([^.[\]]+)(.*)$/);
-    if (match) {
+    const match = /^\[(.+?)\](.*)$/u.exec(path) ?? /^\.?([^.[\]]+)(.*)$/u.exec(path);
+    if (match !== null) {
         const [, key, rest] = match;
-        return [key, ..._stringToPath(rest)];
+        return [key, ...stringToPath_(rest)];
     }
     return [path];
 }

package/dist/es/utils/binary-search-cutoff-index.js

@@ -0,0 +1,15 @@
+export function binarySearchCutoffIndex(array, predicate) {
+    let lowIndex = 0;
+    let highIndex = array.length;
+    while (lowIndex < highIndex) {
+        const pivotIndex = (lowIndex + highIndex) >>> 1;
+        const pivot = array[pivotIndex];
+        if (predicate(pivot, pivotIndex)) {
+            lowIndex = pivotIndex + 1;
+        }
+        else {
+            highIndex = pivotIndex;
+        }
+    }
+    return highIndex;
+}

package/dist/es/utils/heap.js

@@ -9,7 +9,7 @@ export function heapMaybeInsert(heap, compareFn, item) {
     if (!hasAtLeast(heap, 1)) {
         return;
     }
-    const head = heap[0];
+    const [head] = heap;
     if (compareFn(item, head) >= 0) {
         return;
     }

package/dist/es/utils/purry-order-rules.js

@@ -28,7 +28,7 @@ export function purryOrderRulesWithArgument(func, inputArgs) {
 function orderRuleComparer(primaryRule, secondaryRule, ...otherRules) {
     const projector = typeof primaryRule === 'function' ? primaryRule : primaryRule[0];
     const direction = typeof primaryRule === 'function' ? 'asc' : primaryRule[1];
-    const comparator = COMPARATORS[direction];
+    const { [direction]: comparator } = COMPARATORS;
     const nextComparer = secondaryRule === undefined
         ? undefined
         : orderRuleComparer(secondaryRule, ...otherRules);

package/dist/es/utils/quick-select.js

@@ -2,7 +2,7 @@ import { swapInPlace } from './swap-in-place';
 export function quickSelect(data, index, compareFn) {
     return index < 0 || index >= data.length
         ? undefined
-        : quickSelectImplementation([...data], 0, data.length - 1, index, compareFn);
+        : quickSelectImplementation(data.slice(), 0, data.length - 1, index, compareFn);
 }
 function quickSelectImplementation(data, left, right, index, compareFn) {
     if (left === right) {
@@ -19,7 +19,7 @@ function partition(data, left, right, compareFn) {
     for (let j = left; j < right; j++) {
         if (compareFn(data[j], pivot) < 0) {
             swapInPlace(data, i, j);
-            i++;
+            i += 1;
         }
     }
     swapInPlace(data, i, right);

package/dist/es/utils/reduce-lazy.js

@@ -1,14 +1,17 @@
-export function reduceLazy(array, lazy, indexed) {
-    const newArray = [];
+export function reduceLazy(array, lazy, isIndexed = false) {
+    const out = [];
     for (let index = 0; index < array.length; index++) {
         const item = array[index];
-        const result = indexed ? lazy(item, index, array) : lazy(item);
+        const result = isIndexed ? lazy(item, index, array) : lazy(item);
         if (result.hasMany === true) {
-            newArray.push(...result.next);
+            out.push(...result.next);
         }
         else if (result.hasNext) {
-            newArray.push(result.next);
+            out.push(result.next);
+        }
+        if (result.done) {
+            break;
         }
     }
-    return newArray;
+    return out;
 }

package/dist/es/utils/to-single.js

@@ -1,4 +1,3 @@
 export function toSingle(fn) {
-    fn.single = true;
-    return fn;
+    return Object.assign(fn, { single: true });
 }