@valkyriestudios/utils 9.0.0 → 11.0.0

package/dist/number/isIntegerBetween.d.ts

@@ -0,0 +1 @@
+export default function isIntegerBetween(val: any, min: number, max: number): boolean;

package/dist/number/isIntegerBetween.js

@@ -0,0 +1,11 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function isIntegerBetween(val, min, max) {
+    if (!Number.isInteger(val) ||
+        !Number.isFinite(min) ||
+        !Number.isFinite(max) ||
+        min >= max)
+        return false;
+    return val >= min && val <= max;
+}
+exports.default = isIntegerBetween;

package/dist/number/isNumericalNaN.d.ts

@@ -0,0 +1 @@
+export default function isNumericalNaN(val: any): boolean;

package/dist/number/isNumericalNaN.js

@@ -0,0 +1,6 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function isNumericalNaN(val) {
+    return Number.isNaN(val) || val === Infinity;
+}
+exports.default = isNumericalNaN;

package/dist/number/randomBetween.d.ts

@@ -0,0 +1 @@
+export default function randomBetween(min?: number, max?: number): number;

package/dist/number/randomBetween.js

@@ -0,0 +1,9 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function randomBetween(min = 0, max = 10) {
+    if (!Number.isFinite(min) ||
+        !Number.isFinite(max))
+        throw new TypeError('Min/Max should be numeric');
+    return (Math.random() * (max - min)) + min;
+}
+exports.default = randomBetween;

package/dist/number/randomIntBetween.d.ts

@@ -0,0 +1 @@
+export default function randomIntBetween(min?: number, max?: number): number;

package/dist/number/randomIntBetween.js

@@ -0,0 +1,9 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function randomIntBetween(min = 0, max = 10) {
+    if (!Number.isFinite(min) ||
+        !Number.isFinite(max))
+        throw new TypeError('Min/Max should be numeric');
+    return Math.floor((Math.random() * (max - min)) + min);
+}
+exports.default = randomIntBetween;

package/dist/number/round.d.ts

@@ -0,0 +1 @@
+export default function round(val: number, precision?: number): number;

package/dist/number/round.js

@@ -0,0 +1,10 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function round(val, precision = 0) {
+    if (!Number.isFinite(val))
+        throw new TypeError('Value should be numeric');
+    const exp = Math.pow(10, Number.isInteger(precision) && precision > 0 ? precision : 0);
+    const num = (val * exp) * (1 + Number.EPSILON);
+    return Math.round(num) / exp;
+}
+exports.default = round;

package/dist/number/toPercentage.d.ts

@@ -0,0 +1 @@
+export default function toPercentage(val: number, precision?: number, min?: number, max?: number): number;

package/dist/number/toPercentage.js

@@ -0,0 +1,11 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const round_1 = require("./round");
+function toPercentage(val, precision = 0, min = 0, max = 1) {
+    if (!Number.isFinite(val) ||
+        !Number.isFinite(min) ||
+        !Number.isFinite(max))
+        throw new TypeError('value/min/max should be numeric');
+    return (0, round_1.default)(((val - min) / (max - min)) * 100, precision);
+}
+exports.default = toPercentage;

package/dist/object/define.d.ts

@@ -0,0 +1,7 @@
+export default function define(props: {
+    [key: string]: any;
+}, obj?: {
+    [key: string]: any;
+}): {
+    [key: string]: any;
+};

package/dist/object/define.js

@@ -0,0 +1,9 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function define(props, obj = {}) {
+    if (Object.prototype.toString.call(props) !== '[object Object]' ||
+        Object.prototype.toString.call(obj) !== '[object Object]')
+        throw new TypeError('Please pass an object as the value for props and obj');
+    return Object.defineProperties(obj, props);
+}
+exports.default = define;

package/dist/object/is.d.ts

@@ -0,0 +1 @@
+export default function isObject(val: any): boolean;

package/dist/object/is.js

@@ -0,0 +1,7 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const PROTO_OBJ = '[object Object]';
+function isObject(val) {
+    return Object.prototype.toString.call(val) === PROTO_OBJ;
+}
+exports.default = isObject;

package/dist/object/isNotEmpty.d.ts

@@ -0,0 +1 @@
+export default function isNotEmptyObject(val: any): boolean;

package/dist/object/isNotEmpty.js

@@ -0,0 +1,6 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function isNotEmptyObject(val) {
+    return Object.prototype.toString.call(val) === '[object Object]' && Object.keys(val).length > 0;
+}
+exports.default = isNotEmptyObject;

package/dist/object/merge.d.ts

@@ -0,0 +1,8 @@
+declare function merge(target: {
+    [key: string]: any;
+}, source?: {
+    [key: string]: any;
+}): {
+    [key: string]: any;
+};
+export default merge;

package/dist/object/merge.js

@@ -0,0 +1,20 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function merge(target, source = {}) {
+    if (Object.prototype.toString.call(target) !== '[object Object]' ||
+        Object.prototype.toString.call(source) !== '[object Object]')
+        throw new TypeError('Please pass a target and object to merge');
+    return Object.keys(target).reduce((acc, key) => {
+        if (Object.prototype.toString.call(target[key]) === '[object Object]' &&
+            !Array.isArray(target[key])) {
+            acc[key] = source[key] ? merge(target[key], source[key]) : target[key];
+        }
+        else {
+            acc[key] = Object.prototype.hasOwnProperty.call(source, key)
+                ? source[key]
+                : target[key];
+        }
+        return acc;
+    }, {});
+}
+exports.default = merge;

package/dist/object/pick.d.ts

@@ -0,0 +1,5 @@
+export default function pick(obj: {
+    [key: string]: any;
+}, keys: string[]): {
+    [key: string]: any;
+};

package/dist/object/pick.js

@@ -0,0 +1,34 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const get_1 = require("../deep/get");
+const set_1 = require("../deep/set");
+function pick(obj, keys) {
+    if (Object.prototype.toString.call(obj) !== '[object Object]' ||
+        !Array.isArray(keys) ||
+        keys.length === 0)
+        throw new TypeError('Please pass an object to pick from and a keys array');
+    const map = {};
+    let key_deep = false;
+    let val;
+    for (const key of keys) {
+        if (typeof key !== 'string')
+            continue;
+        const sanitized = key.trim();
+        if (sanitized.length === 0)
+            continue;
+        key_deep = /(\.|\[)/g.test(sanitized);
+        val = key_deep
+            ? (0, get_1.default)(obj, sanitized)
+            : obj[sanitized];
+        if (val === undefined)
+            continue;
+        if (key_deep) {
+            (0, set_1.default)(map, sanitized, val);
+        }
+        else {
+            map[sanitized] = val;
+        }
+    }
+    return map;
+}
+exports.default = pick;

package/dist/regexp/is.d.ts

@@ -0,0 +1 @@
+export default function isRegExp(val: any): boolean;

package/dist/regexp/is.js

@@ -0,0 +1,6 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function isRegExp(val) {
+    return Object.prototype.toString.call(val) === '[object RegExp]';
+}
+exports.default = isRegExp;

package/dist/regexp/sanitize.d.ts

@@ -0,0 +1 @@
+export default function sanitizeRegExp(val: string): string | false;

package/dist/regexp/sanitize.js

@@ -0,0 +1,8 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function sanitizeRegExp(val) {
+    if (typeof val !== 'string')
+        return false;
+    return val.trim().replace(/[.*+\-?^${}()|[\]\\]/g, '\\$&');
+}
+exports.default = sanitizeRegExp;

package/dist/string/humanizeBytes.d.ts

@@ -0,0 +1,8 @@
+interface humanizeBytesOptions {
+    delim?: string;
+    separator?: string;
+    precision?: number;
+    units?: string[];
+}
+export default function humanizeBytes(val: number | string, options?: humanizeBytesOptions): string;
+export {};

package/dist/string/humanizeBytes.js

@@ -0,0 +1,24 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const humanizeNumber_1 = require("./humanizeNumber");
+const isNotEmpty_1 = require("../string/isNotEmpty");
+function humanizeBytes(val, options = {}) {
+    const has_opts = Object.prototype.toString.call(options) === '[object Object]';
+    return (0, humanizeNumber_1.default)(val, {
+        delim: has_opts && typeof options.delim === 'string'
+            ? options.delim
+            : ',',
+        separator: has_opts && typeof options.separator === 'string' && options.separator.trim().length > 0
+            ? options.separator
+            : '.',
+        precision: has_opts && Number.isInteger(options.precision) && options.precision >= 0
+            ? options.precision
+            : 2,
+        units: has_opts && Array.isArray(options.units) && options.units.length > 0
+            ? options.units.filter(el => (0, isNotEmpty_1.default)(el))
+            : [' bytes', ' KB', ' MB', ' GB', ' TB', ' PB', ' EB', ' ZB', ' YB'],
+        divider: 1024,
+        real: true,
+    });
+}
+exports.default = humanizeBytes;

package/dist/string/humanizeNumber.d.ts

@@ -0,0 +1,10 @@
+interface humanizeNumberOptions {
+    delim?: string;
+    separator?: string;
+    precision?: number;
+    units?: string[] | boolean;
+    divider?: number;
+    real?: boolean;
+}
+export default function humanizeNumber(val: number | string, options?: humanizeNumberOptions): string;
+export {};

package/dist/string/humanizeNumber.js

@@ -0,0 +1,60 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_1 = require("../boolean/is");
+const is_2 = require("../string/is");
+const round_1 = require("../number/round");
+function humanizeNumber(val, options = {}) {
+    const has_opts = Object.prototype.toString.call(options) === '[object Object]';
+    const OPTS = {
+        delim: has_opts && typeof options.delim === 'string'
+            ? options.delim
+            : ',',
+        separator: has_opts && typeof options.separator === 'string' && options.separator.trim().length > 0
+            ? options.separator
+            : '.',
+        precision: has_opts && Number.isInteger(options.precision) && options.precision >= 0
+            ? options.precision
+            : 2,
+        units: has_opts && ((Array.isArray(options.units) && options.units.length > 0) || options.units === false)
+            ? options.units ? options.units.filter(is_2.default) : false
+            : ['', 'k', 'm', 'b', 't', 'q'],
+        divider: has_opts && Number.isInteger(options.divider) && options.divider > 1
+            ? options.divider
+            : 1000,
+        real: has_opts && (0, is_1.default)(options.real)
+            ? options.real
+            : false,
+    };
+    let normalized;
+    if (OPTS.real) {
+        normalized = typeof val === 'string' ? parseInt(val.trim(), 10) : Number.isFinite(val) ? Math.round(val) : 0;
+    }
+    else {
+        normalized = typeof val === 'string' ? parseFloat(val) : Number.isFinite(val) ? val : 0;
+    }
+    if (!Number.isFinite(normalized) || normalized === 0) {
+        return `0${Array.isArray(OPTS.units) && OPTS.units.length > 0 ? OPTS.units[0] : ''}`;
+    }
+    const sign = normalized < 0 ? '-' : '';
+    normalized = Math.abs(normalized);
+    let postfix = '';
+    if (Array.isArray(OPTS.units) && OPTS.units.length > 0) {
+        let unit_ix = 0;
+        while (normalized >= OPTS.divider) {
+            unit_ix++;
+            normalized = normalized / OPTS.divider;
+            if (unit_ix === OPTS.units.length - 1)
+                break;
+        }
+        postfix = OPTS.units[unit_ix];
+    }
+    normalized = (0, round_1.default)(normalized, OPTS.precision);
+    const humanized = `${normalized}`.split('.');
+    humanized[0] = humanized[0].split('').reverse().map((char, ix, original) => {
+        if (ix > 0 && ix < original.length && ix % 3 === 0)
+            return char + OPTS.delim;
+        return char;
+    }).reverse().join('');
+    return `${sign}${humanized.join(OPTS.separator)}${postfix}`;
+}
+exports.default = humanizeNumber;

package/dist/string/is.d.ts

@@ -0,0 +1 @@
+export default function isString(val: any): boolean;

package/dist/string/is.js

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

package/dist/string/isBetween.d.ts

@@ -0,0 +1 @@
+export default function isStringBetween(val: any, min: number, max: number, trimmed?: boolean): boolean;

package/dist/string/isBetween.js

@@ -0,0 +1,14 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function isStringBetween(val, min, max, trimmed = true) {
+    if (typeof val !== 'string' ||
+        !Number.isFinite(min) ||
+        min < 0 ||
+        !Number.isFinite(max) ||
+        max < 0 ||
+        min >= max)
+        return false;
+    const length = (trimmed === true ? val.trim() : val).length;
+    return length >= min && length <= max;
+}
+exports.default = isStringBetween;

package/dist/string/isNotEmpty.d.ts

@@ -0,0 +1 @@
+export default function isNotEmptyString(val: any, trimmed?: boolean): boolean;

package/dist/string/isNotEmpty.js

@@ -0,0 +1,8 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function isNotEmptyString(val, trimmed = true) {
+    if (typeof val !== 'string')
+        return false;
+    return (trimmed === true ? val.trim() : val).length > 0;
+}
+exports.default = isNotEmptyString;

package/dist/string/shorten.d.ts

@@ -0,0 +1 @@
+export default function shorten(val: string, length: number, postfix?: string): string;

package/dist/string/shorten.js

@@ -0,0 +1,11 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+function shorten(val, length, postfix = '...') {
+    if (typeof val !== 'string')
+        return '';
+    if (typeof postfix !== 'string' || !Number.isFinite(length) || length <= 0)
+        return val;
+    const sanitized = val.trim();
+    return sanitized.length <= length ? sanitized : `${sanitized.substr(0, length)}${postfix}`;
+}
+exports.default = shorten;