@valkyriestudios/utils 7.5.0 → 8.1.0

package/src/function/sleep.mjs

@@ -0,0 +1,12 @@
+'use strict';
+
+//  Return a promise that only resolves after X milliseconds (interesting for async/await structures
+//  where we want to sleep for X milliseconds)
+//  example usage: await sleep(1000);
+//
+//  (default sleep = 1000ms)
+export default function sleep (milliseconds = 1000) {
+    return new Promise(resolve => {
+        setTimeout(() => resolve(), milliseconds);
+    });
+}

package/src/hash/fnv1A.mjs

@@ -0,0 +1,58 @@
+'use strict';
+
+/* eslint-disable no-bitwise */
+
+import isString         from '../string/is.mjs';
+import isNumericalNaN   from '../number/isNumericalNaN.mjs';
+import {PROTO_RGX}      from '../regexp/is.mjs';
+import {PROTO_OBJ}      from '../object/is.mjs';
+
+//  https://tools.ietf.org/html/draft-eastlake-fnv-03
+
+const FNV_32        = 2166136261;
+const REPL_NAN      = 'nan';
+const REPL_TRUE     = 'true';
+const REPL_FALSE    = 'false';
+const REPL_UNDEF    = 'undefined';
+const REPL_NULL     = 'null';
+
+export default function fnv1A (data, offset = FNV_32) {
+    let hash = offset;
+    let sanitized;
+
+    //  Convert data to a format that is hashable
+    if (isString(data)) {
+        sanitized = data;
+    } else if (Number.isFinite(data)) {
+        sanitized = `${data}`;
+    } else if (Array.isArray(data) || Object.prototype.toString.call(data) === PROTO_OBJ) {
+        sanitized = JSON.stringify(data);
+    } else if (Object.prototype.toString.call(data) === PROTO_RGX) {
+        sanitized = data.toString();
+    } else if (data instanceof Date) {
+        sanitized = `${data.getTime()}`;
+    } else if (isNumericalNaN(data)) {
+        sanitized = REPL_NAN;
+    } else if (data === false) {
+        sanitized = REPL_FALSE;
+    } else if (data === true) {
+        sanitized = REPL_TRUE;
+    } else if (data === null) {
+        sanitized = REPL_NULL;
+    } else if (data === undefined) {
+        sanitized = REPL_UNDEF;
+    } else {
+        throw new TypeError('An FNV1A Hash could not be calculated for this datatype');
+    }
+
+    //  Calculate the hash of the sanitized data by looping over each char
+    for (let i = 0; i < sanitized.length; i++) {
+        hash ^= sanitized.charCodeAt(i);
+
+        //  32-bit FNV prime: 2**24 + 2**8 + 0x93 = 16777619
+        //  Using bitshift for accuracy and performance. Numbers in JS suck.
+        hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
+    }
+
+    return hash >>> 0;
+}

package/src/hash/guid.mjs

@@ -0,0 +1,38 @@
+'use strict';
+
+/* eslint-disable no-bitwise, prefer-template */
+
+//  RFC4122 Compliant
+
+//  Generates a prebuilt hexmap from 0 to 255
+const HEXMAP = [];
+for (let i = 0; i < 256; i++) {
+    HEXMAP[i] = (i < 16 ? '0' : '') + i.toString(16);
+}
+
+export default function guid () {
+    const d0 = (Math.random()*0xffffffff) | 0;
+    const d1 = (Math.random()*0xffffffff) | 0;
+    const d2 = (Math.random()*0xffffffff) | 0;
+    const d3 = (Math.random()*0xffffffff) | 0;
+    return HEXMAP[d0 & 0xff] +
+        HEXMAP[(d0 >> 8) & 0xff] +
+        HEXMAP[(d0 >> 16) & 0xff] +
+        HEXMAP[(d0 >> 24) & 0xff] +
+        '-' +
+        HEXMAP[d1 & 0xff] +
+        HEXMAP[(d1 >> 8) & 0xff] +
+        '-' +
+        HEXMAP[((d1>>16) & 0x0f) | 0x40] +
+        HEXMAP[(d1>>24) & 0xff] +
+        '-' +
+        HEXMAP[(d2 & 0x3f) | 0x80] +
+        HEXMAP[(d2 >> 8) & 0xff] +
+        '-' +
+        HEXMAP[(d2 >> 16) & 0xff] +
+        HEXMAP[(d2 >> 24) & 0xff] +
+        HEXMAP[d3 & 0xff] +
+        HEXMAP[(d3 >> 8) & 0xff] +
+        HEXMAP[(d3 >> 16) & 0xff] +
+        HEXMAP[(d3 >> 24) & 0xff];
+}

package/src/is.mjs

@@ -0,0 +1,86 @@
+'use strict';
+
+import equal                    from './equal.mjs';
+import isNotEmptyArray          from './array/isNotEmpty.mjs';
+import isBoolean                from './boolean/is.mjs';
+import isDate                   from './date/is.mjs';
+import isFunction               from './function/is.mjs';
+import isNumberBetween          from './number/isBetween.mjs';
+import isNumberBelow            from './number/isBelow.mjs';
+import isNumberBelowOrEqual     from './number/isBelowOrEqual.mjs';
+import isNumberAbove            from './number/isAbove.mjs';
+import isNumberAboveOrEqual     from './number/isAboveOrEqual.mjs';
+import isIntegerBetween         from './number/isIntegerBetween.mjs';
+import isIntegerBelow           from './number/isIntegerBelow.mjs';
+import isIntegerBelowOrEqual    from './number/isIntegerBelowOrEqual.mjs';
+import isIntegerAbove           from './number/isIntegerAbove.mjs';
+import isIntegerAboveOrEqual    from './number/isIntegerAboveOrEqual.mjs';
+import isRegExp                 from './regexp/is.mjs';
+import isObject                 from './object/is.mjs';
+import isNotEmptyObject         from './object/isNotEmpty.mjs';
+import isString                 from './string/is.mjs';
+import isStringBetween          from './string/isBetween.mjs';
+import isNotEmptyString         from './string/isNotEmpty.mjs';
+
+const Is = Object.freeze(Object.defineProperties(Object.create(null), {
+    //  Array -----------------------------------------------------------------------------------------------
+    Array               : {enumerable: true, writable: false, configurable: false, value: Array.isArray},
+    NeArray             : {enumerable: true, writable: false, configurable: false, value: isNotEmptyArray},
+    NotEmptyArray       : {enumerable: true, writable: false, configurable: false, value: isNotEmptyArray},
+    //  Boolean ---------------------------------------------------------------------------------------------
+    Boolean             : {enumerable: true, writable: false, configurable: false, value: isBoolean},
+    //  Date ------------------------------------------------------------------------------------------------
+    Date                : {enumerable: true, writable: false, configurable: false, value: isDate},
+    //  Function --------------------------------------------------------------------------------------------
+    Function            : {enumerable: true, writable: false, configurable: false, value: isFunction},
+    //  Number ----------------------------------------------------------------------------------------------
+    Num                 : {enumerable: true, writable: false, configurable: false, value: Number.isFinite},
+    NumBetween          : {enumerable: true, writable: false, configurable: false, value: isNumberBetween},
+    NumAbove            : {enumerable: true, writable: false, configurable: false, value: isNumberAbove},
+    NumAboveOrEqual     : {enumerable: true, writable: false, configurable: false, value: isNumberAboveOrEqual},
+    NumBelow            : {enumerable: true, writable: false, configurable: false, value: isNumberBelow},
+    NumBelowOrEqual     : {enumerable: true, writable: false, configurable: false, value: isNumberBelowOrEqual},
+    NumGt               : {enumerable: true, writable: false, configurable: false, value: isNumberAbove},
+    NumGte              : {enumerable: true, writable: false, configurable: false, value: isNumberAboveOrEqual},
+    NumLt               : {enumerable: true, writable: false, configurable: false, value: isNumberBelow},
+    NumLte              : {enumerable: true, writable: false, configurable: false, value: isNumberBelowOrEqual},
+    Number              : {enumerable: true, writable: false, configurable: false, value: Number.isFinite},
+    NumberBetween       : {enumerable: true, writable: false, configurable: false, value: isNumberBetween},
+    NumberAbove         : {enumerable: true, writable: false, configurable: false, value: isNumberAbove},
+    NumberAboveOrEqual  : {enumerable: true, writable: false, configurable: false, value: isNumberAboveOrEqual},
+    NumberBelow         : {enumerable: true, writable: false, configurable: false, value: isNumberBelow},
+    NumberBelowOrEqual  : {enumerable: true, writable: false, configurable: false, value: isNumberBelowOrEqual},
+    //  Integer ---------------------------------------------------------------------------------------------
+    Int                 : {enumerable: true, writable: false, configurable: false, value: Number.isInteger},
+    IntBetween          : {enumerable: true, writable: false, configurable: false, value: isIntegerBetween},
+    IntAbove            : {enumerable: true, writable: false, configurable: false, value: isIntegerAbove},
+    IntAboveOrEqual     : {enumerable: true, writable: false, configurable: false, value: isIntegerAboveOrEqual},
+    IntBelow            : {enumerable: true, writable: false, configurable: false, value: isIntegerBelow},
+    IntBelowOrEqual     : {enumerable: true, writable: false, configurable: false, value: isIntegerBelowOrEqual},
+    IntGt               : {enumerable: true, writable: false, configurable: false, value: isIntegerAbove},
+    IntGte              : {enumerable: true, writable: false, configurable: false, value: isIntegerAboveOrEqual},
+    IntLt               : {enumerable: true, writable: false, configurable: false, value: isIntegerBelow},
+    IntLte              : {enumerable: true, writable: false, configurable: false, value: isIntegerBelowOrEqual},
+    Integer             : {enumerable: true, writable: false, configurable: false, value: Number.isInteger},
+    IntegerBetween      : {enumerable: true, writable: false, configurable: false, value: isIntegerBetween},
+    IntegerBelow        : {enumerable: true, writable: false, configurable: false, value: isIntegerBelow},
+    IntegerBelowOrEqual : {enumerable: true, writable: false, configurable: false, value: isIntegerBelowOrEqual},
+    IntegerAbove        : {enumerable: true, writable: false, configurable: false, value: isIntegerAbove},
+    IntegerAboveOrEqual : {enumerable: true, writable: false, configurable: false, value: isIntegerAboveOrEqual},
+    //  Regex -----------------------------------------------------------------------------------------------
+    RegExp              : {enumerable: true, writable: false, configurable: false, value: isRegExp},
+    //  Object ----------------------------------------------------------------------------------------------
+    Object              : {enumerable: true, writable: false, configurable: false, value: isObject},
+    NeObject            : {enumerable: true, writable: false, configurable: false, value: isNotEmptyObject},
+    NotEmptyObject      : {enumerable: true, writable: false, configurable: false, value: isNotEmptyObject},
+    //  String ----------------------------------------------------------------------------------------------
+    String              : {enumerable: true, writable: false, configurable: false, value: isString},
+    StringBetween       : {enumerable: true, writable: false, configurable: false, value: isStringBetween},
+    NeString            : {enumerable: true, writable: false, configurable: false, value: isNotEmptyString},
+    NotEmptyString      : {enumerable: true, writable: false, configurable: false, value: isNotEmptyString},
+    //  Utils -----------------------------------------------------------------------------------------------
+    Equal               : {enumerable: true, writable: false, configurable: false, value: equal},
+    Eq                  : {enumerable: true, writable: false, configurable: false, value: equal},
+}));
+
+export default Is;

package/src/number/is.mjs

@@ -0,0 +1,5 @@
+'use strict';
+
+export default function isNumber (val) {
+    return Number.isFinite(val);
+}

package/src/number/isAbove.mjs

@@ -0,0 +1,6 @@
+'use strict';
+
+//  Check if a number is above a reference number
+export default function isNumberAbove (val, ref) {
+    return !Number.isFinite(val) || !Number.isFinite(ref) ? false : val > ref;
+}

package/src/number/isAboveOrEqual.mjs

@@ -0,0 +1,6 @@
+'use strict';
+
+//  Check if a number is above or equal to a reference number
+export default function isNumberAboveOrEqual (val, ref) {
+    return !Number.isFinite(val) || !Number.isFinite(ref) ? false : val >= ref;
+}

package/src/number/isBelow.mjs

@@ -0,0 +1,6 @@
+'use strict';
+
+//  Check if a number is below a reference number
+export default function isBelow (val, ref) {
+    return !Number.isFinite(val) || !Number.isFinite(ref) ? false : val < ref;
+}

package/src/number/isBelowOrEqual.mjs

@@ -0,0 +1,6 @@
+'use strict';
+
+//  Check if a number is below or equal to a reference number
+export default function isBelowOrEqual (val, ref) {
+    return !Number.isFinite(val) || !Number.isFinite(ref) ? false : val <= ref;
+}

package/src/number/isBetween.mjs

@@ -0,0 +1,13 @@
+'use strict';
+
+//  Check if a number is between a range
+export default function isBetween (val, min, max) {
+    if (
+        !Number.isFinite(val) ||
+        !Number.isFinite(min) ||
+        !Number.isFinite(max) ||
+        min >= max
+    ) return false;
+
+    return val >= min && val <= max;
+}

package/src/number/isInteger.mjs

@@ -0,0 +1,5 @@
+'use strict';
+
+export default function isInteger (val) {
+    return Number.isInteger(val);
+}

package/src/number/isIntegerAbove.mjs

@@ -0,0 +1,6 @@
+'use strict';
+
+//  Check if a number is an integer above a reference number
+export default function isIntegerAbove (val, ref) {
+    return !Number.isInteger(val) || !Number.isFinite(ref) ? false : val > ref;
+}

package/src/number/isIntegerAboveOrEqual.mjs

@@ -0,0 +1,6 @@
+'use strict';
+
+//  Check if a number is an integer above or equal to a reference number
+export default function isIntegerAboveOrEqual (val, ref) {
+    return !Number.isInteger(val) || !Number.isFinite(ref) ? false : val >= ref;
+}

package/src/number/isIntegerBelow.mjs

@@ -0,0 +1,6 @@
+'use strict';
+
+//  Check if a number is an integer below a reference number
+export default function isIntegerBelow (val, ref) {
+    return !Number.isInteger(val) || !Number.isFinite(ref) ? false : val < ref;
+}

package/src/number/isIntegerBelowOrEqual.mjs

@@ -0,0 +1,6 @@
+'use strict';
+
+//  Check if a number is an integer below or equal to a reference number
+export default function isIntegerBelowOrEqual (val, ref) {
+    return !Number.isInteger(val) || !Number.isFinite(ref) ? false : val <= ref;
+}

package/src/number/isIntegerBetween.mjs

@@ -0,0 +1,13 @@
+'use strict';
+
+//  Check if a number is an integer between a range
+export default function isIntegerBetween (val, min, max) {
+    if (
+        !Number.isInteger(val) ||
+        !Number.isFinite(min) ||
+        !Number.isFinite(max) ||
+        min >= max
+    ) return false;
+
+    return val >= min && val <= max;
+}

package/src/number/isNumericalNaN.mjs

@@ -0,0 +1,5 @@
+'use strict';
+
+export default function isNumericalNaN (val) {
+    return Number.isNaN(val) || val === Infinity;
+}

package/src/number/randomBetween.mjs

@@ -0,0 +1,11 @@
+'use strict';
+
+//  Generate random between min and max
+export default 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;
+}

package/src/number/randomIntBetween.mjs

@@ -0,0 +1,11 @@
+'use strict';
+
+//  Generate random between min and max (max not inclusive)
+export default 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);
+}

package/src/number/round.mjs

@@ -0,0 +1,10 @@
+'use strict';
+
+//  Round a numeric value to a certain precision
+export default 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;
+}

package/src/number/toPercentage.mjs

@@ -0,0 +1,14 @@
+'use strict';
+
+import round from './round.mjs';
+
+//  Convert a float value to a percentage
+export default 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 round(((val - min)/ (max - min)) * 100, precision);
+}

package/src/object/define.mjs

@@ -0,0 +1,12 @@
+'use strict';
+
+import {PROTO_OBJ} from './is.mjs';
+
+export default function define (props, obj = {}) {
+    if (
+        Object.prototype.toString.call(props) !== PROTO_OBJ ||
+        Object.prototype.toString.call(obj) !== PROTO_OBJ
+    ) throw new TypeError('Please pass an object as the value for props and obj');
+
+    return Object.defineProperties(obj, props);
+}

package/src/object/is.mjs

@@ -0,0 +1,7 @@
+'use strict';
+
+export const PROTO_OBJ = '[object Object]';
+
+export default function isObject (val) {
+    return Object.prototype.toString.call(val) === PROTO_OBJ;
+}

package/src/object/isNotEmpty.mjs

@@ -0,0 +1,7 @@
+'use strict';
+
+import {PROTO_OBJ} from './is.mjs';
+
+export default function isNotEmptyObject (val) {
+    return Object.prototype.toString.call(val) === PROTO_OBJ && Object.keys(val).length > 0;
+}

package/src/object/merge.mjs

@@ -0,0 +1,27 @@
+'use strict';
+
+import {PROTO_OBJ} from './is.mjs';
+
+const merge = (target, source = {}) => {
+    if (
+        Object.prototype.toString.call(target) !== PROTO_OBJ ||
+        Object.prototype.toString.call(source) !== PROTO_OBJ
+    ) 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]) === PROTO_OBJ &&
+            !Array.isArray(target[key])
+        ) {
+            acc[key] = merge(target[key], source[key] || {});
+        } else {
+            acc[key] = source.hasOwnProperty(key)
+                ? source[key]
+                : target[key];
+        }
+        return acc;
+    }, {});
+};
+
+
+export default merge;

package/src/object/pick.mjs

@@ -0,0 +1,33 @@
+'use strict';
+
+import deepGet          from '../deep/get.mjs';
+import deepSet          from '../deep/set.mjs';
+import isNotEmptyString from '../string/isNotEmpty.mjs';
+import {PROTO_OBJ}      from './is.mjs';
+
+export default function pick (obj, keys) {
+    if (
+        Object.prototype.toString.call(obj) !== PROTO_OBJ ||
+        !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 (!isNotEmptyString(key)) continue;
+        key_deep = key.match(/(\.|\[)/g);
+        val = key_deep
+            ? deepGet(obj, key.trim())
+            : obj[key.trim()];
+        if (val === undefined) continue;
+
+        if (key_deep) {
+            deepSet(map, key.trim(), val);
+        } else {
+            map[key.trim()] = val;
+        }
+    }
+    return map;
+}

package/src/regexp/is.mjs

@@ -0,0 +1,7 @@
+'use strict';
+
+export const PROTO_RGX = '[object RegExp]';
+
+export default function isRegExp (val) {
+    return Object.prototype.toString.call(val) === PROTO_RGX;
+}

package/src/regexp/sanitize.mjs

@@ -0,0 +1,12 @@
+'use strict';
+
+import isNotEmptyString from '../string/isNotEmpty.mjs';
+
+//  Escapes a value to be used inside of a regular expression (eg: new RegExp(...))
+//  For more info: https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Escaping
+//
+//  @param string   val     Value to escape
+export default function sanitizeRegExp (val) {
+    if (!isNotEmptyString(val)) return false;
+    return val.trim().replace(/[.*+\-?^${}()|[\]\\]/g, '\\$&');
+}

package/src/string/humanizeBytes.mjs

@@ -0,0 +1,29 @@
+'use strict';
+
+import isString         from '../string/is.mjs';
+import isNotEmptyString from '../string/isNotEmpty.mjs';
+import {PROTO_OBJ}      from '../object/is.mjs';
+import humanizeNumber   from './humanizeNumber.mjs';
+
+//  Humanize a numerical byte value into a readable file size
+//
+//  @param int  val     Amount of bytes
+export default function humanizeBytes (val, options = {}) {
+    const has_opts = Object.prototype.toString.call(options) === PROTO_OBJ;
+    return humanizeNumber(val, {
+        delim: has_opts && isString(options.delim)
+            ? options.delim
+            : ',',
+        separator: has_opts && isNotEmptyString(options.separator)
+            ? 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(isNotEmptyString)
+            : [' bytes', ' KB', ' MB', ' GB', ' TB', ' PB', ' EB', ' ZB', ' YB'],
+        divider: 1024,
+        real: true,
+    });
+}

package/src/string/humanizeNumber.mjs

@@ -0,0 +1,84 @@
+'use strict';
+
+import isBoolean        from '../boolean/is.mjs';
+import isString         from '../string/is.mjs';
+import isNotEmptyString from '../string/isNotEmpty.mjs';
+import round            from '../number/round.mjs';
+import {PROTO_OBJ}      from '../object/is.mjs';
+
+//  Humanize a numerical value into a unit base
+//
+//  @param int  val     Amount of bytes
+export default function humanizeNumber (val, options = {}) {
+    const has_opts = Object.prototype.toString.call(options) === PROTO_OBJ;
+    const OPTS = {
+        delim: has_opts && isString(options.delim)
+            ? options.delim
+            : ',',
+        separator: has_opts && isNotEmptyString(options.separator)
+            ? 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(isString) : false
+            : ['', 'k', 'm', 'b', 't', 'q'],
+        //  Have to have at least bigger than 1 to not end in infinite loop
+        divider: has_opts && Number.isInteger(options.divider) && options.divider > 1
+            ? options.divider
+            : 1000,
+        //  Should we auto parse as integer (true) or not (false)
+        real: has_opts && isBoolean(options.real)
+            ? options.real
+            : false,
+    };
+
+    //  If not a valid value, return
+    if (!(Number.isFinite(val) || isNotEmptyString(val))) {
+        return `0${OPTS.units.length > 0 ? OPTS.units[0] : ''}`;
+    }
+
+    //  Ensure we are working with an integer
+    let normalized;
+    if (OPTS.real) {
+        normalized = parseInt(isString(val) ? val.trim() : val) || 0;
+    } else {
+        normalized = parseFloat(isString(val) ? val.trim() : val) || 0;
+    }
+    if (!Number.isFinite(normalized) || normalized === 0) {
+        return `0${OPTS.units.length > 0 ? OPTS.units[0] : ''}`;
+    }
+
+    //  Determine sign
+    const sign = normalized < 0 ? '-' : '';
+
+    //  Ensure val here is absolute
+    normalized = Math.abs(normalized);
+
+    //  At each step, divide by divider, based on that we get the unit size
+    let postfix = '';
+    if (OPTS.units) {
+        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];
+    }
+
+    //  Round with precision
+    normalized = round(normalized, OPTS.precision);
+
+    //  Humanize from eg: 10023 to 10,023
+    normalized    = `${normalized}`.split('.');
+    normalized[0] = normalized[0].split('').reverse().map((char, ix, original) => {
+        if (ix > 0 && ix < original.length && ix % 3 === 0) return char + OPTS.delim;
+        return char;
+    }).reverse().join('');
+    normalized    = normalized.join(OPTS.separator);
+
+    //  Include a decimal point and a tenths-place digit if presenting less than then of KB or greater units
+    return `${sign}${normalized}${postfix}`;
+}

package/src/string/is.mjs

@@ -0,0 +1,5 @@
+'use strict';
+
+export default function isString (val) {
+    return typeof val === 'string' || val instanceof String;
+}

package/src/string/isBetween.mjs

@@ -0,0 +1,18 @@
+'use strict';
+
+import isString from './is.mjs';
+
+//  Check if a string is between a range in length
+export default function isStringBetween (val, min, max, trimmed = true) {
+    if (
+        !isString(val) ||
+        !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;
+}

package/src/string/isNotEmpty.mjs

@@ -0,0 +1,6 @@
+'use strict';
+
+export default function isNotEmptyString (val, trimmed = true) {
+    if (typeof val !== 'string' && !(val instanceof String)) return false;
+    return (trimmed === true ? val.trim() : val).length > 0;
+}

package/src/string/shorten.mjs

@@ -0,0 +1,21 @@
+'use strict';
+
+import isString 		from './is.mjs';
+import isNumberAbove    from '../number/isAbove.mjs';
+
+//  Shorten a string and add a postfix if it goes over a specific length, will autotrim value
+//
+//  @param string   val         Value to shorten, returns false a string is not passed
+//  @param int      length      Length to shorten it at
+//  @param string   postfix     (default='...') Postfix to use when shortened
+export default function shorten (val, length, postfix = '...') {
+    if (
+        !isString(val) ||
+        !isString(postfix) ||
+        !isNumberAbove(length, 0)
+    ) return false;
+
+    if (val.trim().length <= length) return val.trim();
+
+    return `${val.trim().substr(0, length)}${postfix}`;
+}