@vinicunca/perkakas 0.2.1 → 0.3.1

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

@@ -0,0 +1,9 @@
+export function isDefined(data) {
+    return typeof data !== 'undefined' && data !== null;
+}
+(function (isDefined) {
+    function strict(data) {
+        return data !== undefined;
+    }
+    isDefined.strict = strict;
+})(isDefined || (isDefined = {}));

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

@@ -0,0 +1,15 @@
+import { isArray } from './is-array';
+import { isObject } from './is-object';
+import { isString } from './is-string';
+export function isEmpty(data) {
+    if (isArray(data) || isString(data)) {
+        return data.length === 0;
+    }
+    if (isObject(data)) {
+        for (const _ in data) {
+            return false;
+        }
+        return !(data instanceof RegExp);
+    }
+    return false;
+}

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

@@ -0,0 +1,3 @@
+export function isError(data) {
+    return data instanceof Error;
+}

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

@@ -0,0 +1,3 @@
+export function isFunction(data) {
+    return typeof data === 'function';
+}

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

@@ -0,0 +1,3 @@
+export function isNil(data) {
+    return data == null;
+}

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

@@ -0,0 +1,3 @@
+export function isNonNull(data) {
+    return data !== null;
+}

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

@@ -0,0 +1,5 @@
+export function isNot(predicate) {
+    return (data) => {
+        return !predicate(data);
+    };
+}

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

@@ -0,0 +1,3 @@
+export function isNumber(data) {
+    return typeof data === 'number' && !Number.isNaN(data);
+}

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

@@ -0,0 +1,7 @@
+export function isObject(data) {
+    if (typeof data !== 'object' || data === null) {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(data);
+    return proto === null || proto === Object.prototype;
+}

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

@@ -0,0 +1,3 @@
+export function isPromise(data) {
+    return data instanceof Promise;
+}

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

@@ -0,0 +1,3 @@
+export function isString(data) {
+    return typeof data === 'string';
+}

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

@@ -0,0 +1,3 @@
+export function isSymbol(data) {
+    return typeof data === 'symbol';
+}

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

@@ -0,0 +1,3 @@
+export function isTruthy(data) {
+    return !!data;
+}

package/dist/es/index.js

@@ -0,0 +1,9 @@
+export * from './aria';
+export * from './array';
+export * from './function';
+export * from './guard';
+export * from './number';
+export * from './object';
+export * from './string';
+export * from './type';
+export const isBrowser = typeof window !== 'undefined';

package/dist/es/number/add.js

@@ -0,0 +1,7 @@
+import { purry } from '../function/purry';
+export function add(...args) {
+    return purry(_add, args);
+}
+function _add(value, addend) {
+    return value + addend;
+}

package/dist/es/number/ceil.js

@@ -0,0 +1,5 @@
+import { purry } from '../function/purry';
+import { withPrecision } from '../utils/with-precision';
+export function ceil(...args) {
+    return purry(withPrecision(Math.ceil), args);
+}

package/dist/es/number/clamp.js

@@ -0,0 +1,13 @@
+import { purry } from '../function/purry';
+export function clamp(...args) {
+    return purry(_clamp, args);
+}
+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/es/number/divide.js

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

package/dist/es/number/floor.js

@@ -0,0 +1,5 @@
+import { purry } from '../function/purry';
+import { withPrecision } from '../utils/with-precision';
+export function floor(...args) {
+    return purry(withPrecision(Math.floor), args);
+}

package/dist/es/number/index.js

@@ -0,0 +1,8 @@
+export * from './add';
+export * from './ceil';
+export * from './clamp';
+export * from './divide';
+export * from './floor';
+export * from './multiply';
+export * from './round';
+export * from './subtract';

package/dist/es/number/multiply.js

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

package/dist/es/number/round.js

@@ -0,0 +1,5 @@
+import { purry } from '../function/purry';
+import { withPrecision } from '../utils/with-precision';
+export function round(...args) {
+    return purry(withPrecision(Math.round), args);
+}

package/dist/es/number/subtract.js

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

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

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

package/dist/es/object/clone.js

@@ -0,0 +1,45 @@
+import { type } from '../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 (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;
+    }
+}
+export function clone(value) {
+    return value != null && typeof value.clone === 'function'
+        ? value.clone()
+        : _clone(value, [], [], true);
+}

package/dist/es/object/equals.js

@@ -0,0 +1,67 @@
+import { purry } from '../function/purry';
+const isArray = Array.isArray;
+const keyList = Object.keys;
+export function equals(...args) {
+    return purry(_equals, args);
+}
+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/es/object/for-each-obj.js

@@ -0,0 +1,26 @@
+import { purry } from '../function/purry';
+export function forEachObj(...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];
+                if (indexed) {
+                    fn(val, key, object);
+                }
+                else {
+                    fn(val);
+                }
+            }
+        }
+        return object;
+    };
+}
+(function (forEachObj) {
+    function indexed(...args) {
+        return purry(_forEachObj(true), args);
+    }
+    forEachObj.indexed = indexed;
+})(forEachObj || (forEachObj = {}));

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

@@ -0,0 +1,10 @@
+export function fromPairs(entries) {
+    const out = {};
+    for (const [key, value] of entries) {
+        out[key] = value;
+    }
+    return out;
+}
+(function (fromPairs) {
+    fromPairs.strict = fromPairs;
+})(fromPairs || (fromPairs = {}));

package/dist/es/object/index.js

@@ -0,0 +1,23 @@
+export * from './add-prop';
+export * from './clone';
+export * from './equals';
+export * from './for-each-obj';
+export * from './from-pairs';
+export * from './index';
+export * from './invert';
+export * from './keys';
+export * from './map-keys';
+export * from './map-values';
+export * from './merge';
+export * from './merge-deep';
+export * from './omit';
+export * from './omit-by';
+export * from './path-or';
+export * from './pick';
+export * from './pick-by';
+export * from './prop';
+export * from './set';
+export * from './set-path';
+export * from './swap-props';
+export * from './to-pairs';
+export * from './values';

package/dist/es/object/invert.js

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

package/dist/es/object/keys.js

@@ -0,0 +1,6 @@
+export function keys(source) {
+    return Object.keys(source);
+}
+(function (keys) {
+    keys.strict = keys;
+})(keys || (keys = {}));

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

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

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

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

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

@@ -0,0 +1,27 @@
+import { purry } from '../function/purry';
+export function mergeDeep(...args) {
+    return purry(mergeDeepImplementation, args);
+}
+function mergeDeepImplementation(destination, source) {
+    const output = { ...destination, ...source };
+    for (const key in source) {
+        if (!(key in destination)) {
+            continue;
+        }
+        const destinationValue = destination[key];
+        if (!isRecord(destinationValue)) {
+            continue;
+        }
+        const sourceValue = source[key];
+        if (!isRecord(sourceValue)) {
+            continue;
+        }
+        output[key] = mergeDeepImplementation(destinationValue, sourceValue);
+    }
+    return output;
+}
+function isRecord(object) {
+    return (typeof object === 'object'
+        && object !== null
+        && Object.getPrototypeOf(object) === Object.prototype);
+}

package/dist/es/object/merge.js

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

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

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

package/dist/es/object/omit.js

@@ -0,0 +1,21 @@
+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);
+}
+function _omit(data, propNames) {
+    if (!hasAtLeast(propNames, 1)) {
+        return { ...data };
+    }
+    if (!hasAtLeast(propNames, 2)) {
+        const [propName] = propNames;
+        const { [propName]: omitted, ...remaining } = data;
+        return remaining;
+    }
+    if (!propNames.some((propName) => propName in data)) {
+        return { ...data };
+    }
+    const asSet = new Set(propNames);
+    return fromPairs(Object.entries(data).filter(([key]) => !asSet.has(key)));
+}

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

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

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

@@ -0,0 +1,16 @@
+import { purry } from '../function/purry';
+import { keys } from './keys';
+export function pickBy(...args) {
+    return purry(_pickBy, args);
+}
+function _pickBy(object, fn) {
+    if (object == null) {
+        return {};
+    }
+    return keys.strict(object).reduce((acc, key) => {
+        if (fn(object[key], key)) {
+            acc[key] = object[key];
+        }
+        return acc;
+    }, {});
+}

package/dist/es/object/pick.js

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

package/dist/es/object/prop.js

@@ -0,0 +1,3 @@
+export function prop(propName) {
+    return ({ [propName]: value }) => value;
+}

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

@@ -0,0 +1,21 @@
+import { purry } from '../function/purry';
+export function setPath(...args) {
+    return purry(_setPath, args);
+}
+export function _setPath(object, path, defaultValue) {
+    if (path.length === 0) {
+        return defaultValue;
+    }
+    if (Array.isArray(object)) {
+        return object.map((item, index) => {
+            if (index === path[0]) {
+                return _setPath(item, path.slice(1), defaultValue);
+            }
+            return item;
+        });
+    }
+    return {
+        ...object,
+        [path[0]]: _setPath(object[path[0]], path.slice(1), defaultValue),
+    };
+}

package/dist/es/object/set.js

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

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

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

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

@@ -0,0 +1,7 @@
+import { purry } from '../function/purry';
+export function toPairs(...args) {
+    return purry(Object.entries, args);
+}
+(function (toPairs) {
+    toPairs.strict = toPairs;
+})(toPairs || (toPairs = {}));

package/dist/es/object/values.js

@@ -0,0 +1,3 @@
+export function values(source) {
+    return Object.values(source);
+}

package/dist/es/string/cases-types.js

@@ -0,0 +1 @@
+export {};