@valkyriestudios/utils 12.0.0 → 12.1.0

package/array/dedupe.js

@@ -1,19 +1,13 @@
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
-const fnv1A_1 = require("../hash/fnv1A");
 function dedupe(val) {
-    if (!Array.isArray(val) || !val.length)
+    if (!Array.isArray(val))
         return [];
     const set = new Set();
-    const acc = [];
-    let hash;
     for (const item of val) {
-        hash = (0, fnv1A_1.default)(item);
-        if (set.has(hash))
-            continue;
-        set.add(hash);
-        acc.push(item);
+        if (!set.has(item))
+            set.add(item);
     }
-    return acc;
+    return [...set];
 }
 exports.default = dedupe;

package/array/join.d.ts

@@ -27,8 +27,8 @@ interface joinOptions {
 /**
  * Join an array of values while autofiltering any non-string/non-number elements
  *
- * @param val - Array of values to join
- * @param opts - Join options
+ * @param {unknown[]} val - Array of values to join
+ * @param {joinOptions?} opts - Join options
  *
  * @returns Joined array as string
  */

package/array/join.js

@@ -1,24 +1,32 @@
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
 const round_1 = require("../number/round");
-function join(val, opts = {}) {
+function join(val, opts) {
     if (!Array.isArray(val) || !val.length)
         return '';
-    const OPTS = {
-        delim: ' ',
-        trim: true,
-        valtrim: true,
-        ...Object.prototype.toString.call(opts) === '[object Object]' ? opts : {},
-    };
+    let DELIM = ' ';
+    let TRIM = true;
+    let VALTRIM = true;
+    let VALROUND = false;
+    if (opts && Object.prototype.toString.call(opts) === '[object Object]') {
+        if (typeof opts.delim === 'string')
+            DELIM = opts.delim;
+        if (opts.trim === false)
+            TRIM = opts.trim;
+        if (opts.valtrim === false)
+            VALTRIM = opts.valtrim;
+        if (Number.isInteger(opts.valround) && opts.valround >= 0)
+            VALROUND = opts.valround;
+    }
     const filtered = [];
     for (const el of val) {
         if (typeof el === 'string' && el.trim().length) {
-            filtered.push(OPTS.valtrim === true ? el.trim() : el);
+            filtered.push(VALTRIM ? el.trim() : el);
         }
         else if (Number.isFinite(el)) {
-            filtered.push(Number.isFinite(OPTS.valround) ? (0, round_1.default)(el, OPTS.valround) : el);
+            filtered.push(VALROUND !== false ? (0, round_1.default)(el, VALROUND) : el);
         }
     }
-    return OPTS.trim === true ? filtered.join(OPTS.delim).trim() : filtered.join(OPTS.delim);
+    return TRIM ? filtered.join(DELIM).trim() : filtered.join(DELIM);
 }
 exports.default = join;

package/array/mapFn.d.ts

@@ -12,11 +12,10 @@ interface mapOptions {
      */
     merge?: boolean;
 }
-interface kvMap {
-    [key: string]: {
-        [key: string]: any;
-    };
-}
+type mapFn = (entry: {
+    [key: string]: any;
+}) => (string | number | boolean);
+type mapReturn = Record<string, Record<string, any>>;
 /**
  * Map an object array into a kv-object through a function that generates a key. Returning a non-string,
  * non-numeric value from the function (eg: false) will filter out the object.
@@ -26,15 +25,11 @@ interface kvMap {
  * Output:
  *  {12: {uid: 12, name: 'Peter'}, 15: {uid: 15, name: 'Jonas'}}
  *
- * @param val - Array to map
- * @param fn - Handler function which is run for each of the objects and should return a string or number
- * @param opts - Options object to override built-in defaults
+ * @param {Record<string, any>[]} val - Array to map
+ * @param {mapFn} fn - Handler function which is run for each of the objects and should return a string or number
+ * @param {mapOptions?} opts - Options object to override built-in defaults
  *
- * @returns KV-Map object
+ * @returns {mapReturn} KV-Map object
  */
-export default function mapFn(arr: {
-    [key: string]: any;
-}[], fn: (entry: {
-    [key: string]: any;
-}) => (string | number | boolean), opts?: mapOptions): kvMap;
+export default function mapFn(arr: Record<string, any>[], fn: mapFn, opts?: mapOptions): mapReturn;
 export {};

package/array/mapFn.js

@@ -1,13 +1,14 @@
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
-function mapFn(arr, fn, opts = {}) {
+function mapFn(arr, fn, opts) {
     if ((!Array.isArray(arr) || !arr.length) ||
         typeof fn !== 'function')
         return {};
-    const OPTS = {
-        merge: false,
-        ...Object.prototype.toString.call(opts) === '[object Object]' ? opts : {},
-    };
+    let MERGE = false;
+    if (opts && Object.prototype.toString.call(opts) === '[object Object]') {
+        if (opts.merge === true)
+            MERGE = true;
+    }
     const map = {};
     let hash = false;
     for (const el of arr) {
@@ -17,12 +18,7 @@ function mapFn(arr, fn, opts = {}) {
         if (!Number.isFinite(hash) && !(typeof hash === 'string' && hash.trim().length))
             continue;
         hash = `${hash}`;
-        if (OPTS.merge === true && map.hasOwnProperty(hash)) {
-            map[hash] = { ...map[hash], ...el };
-        }
-        else {
-            map[hash] = el;
-        }
+        map[hash] = MERGE && map.hasOwnProperty(hash) ? { ...map[hash], ...el } : el;
     }
     return map;
 }

package/array/mapKey.d.ts

@@ -12,11 +12,7 @@ interface mapOptions {
      */
     merge?: boolean;
 }
-interface kvMap {
-    [key: string]: {
-        [key: string]: any;
-    };
-}
+type kvMap = Record<string, Record<string, any>>;
 /**
  * Map an object array into a kv-object by passing a common key that exists on the objects. Objects for
  * which the key doesn't exist will be filtered out automatically
@@ -26,13 +22,11 @@ interface kvMap {
  * Output:
  *  {12: {uid: 12, name: 'Peter'}, 15: {uid: 15, name: 'Jonas'}}
  *
- * @param val - Array to map
- * @param key - Key to map by
- * @param opts - Options object to override built-in defaults
+ * @param {Record<string,any>[]} val - Array to map
+ * @param {string} key - Key to map by
+ * @param {mapOptions?} opts - Options object to override built-in defaults
  *
- * @returns KV-Map object
+ * @returns {kvMap} KV-Map object
  */
-export default function mapKey(arr: {
-    [key: string]: any;
-}[], key: string, opts?: mapOptions): kvMap;
+export default function mapKey(arr: Record<string, any>[], key: string, opts?: mapOptions): kvMap;
 export {};

package/array/mapKey.js

@@ -1,27 +1,23 @@
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
-function mapKey(arr, key, opts = {}) {
+function mapKey(arr, key, opts) {
     if ((!Array.isArray(arr) || !arr.length) ||
         typeof key !== 'string')
         return {};
     const key_s = key.trim();
     if (!key_s.length)
         return {};
-    const OPTS = {
-        merge: false,
-        ...Object.prototype.toString.call(opts) === '[object Object]' ? opts : {},
-    };
+    let MERGE = false;
+    if (opts && Object.prototype.toString.call(opts) === '[object Object]') {
+        if (opts.merge === true)
+            MERGE = true;
+    }
     const map = {};
     for (const el of arr) {
         if (Object.prototype.toString.call(el) !== '[object Object]' ||
             !Object.prototype.hasOwnProperty.call(el, key_s))
             continue;
-        if (OPTS.merge === true && map.hasOwnProperty(el[key_s])) {
-            map[el[key_s]] = { ...map[el[key_s]], ...el };
-        }
-        else {
-            map[el[key_s]] = el;
-        }
+        map[el[key_s]] = MERGE && map.hasOwnProperty(el[key_s]) ? { ...map[el[key_s]], ...el } : el;
     }
     return map;
 }

package/array/mapPrimitive.d.ts

@@ -19,9 +19,7 @@ interface mapOptions {
      */
     keyround?: boolean;
 }
-interface mapReturn {
-    [key: string]: string | number;
-}
+type mapReturn = Record<string, string | number>;
 /**
  * Map an array of primitive values (numbers/strings) into a kv-object
  * non-numeric and non-string values will be filtered out
@@ -31,10 +29,10 @@ interface mapReturn {
  * Output:
  *  {hello: 'hello', foo: 'foo', bar: 'bar'}
  *
- * @param val - Array to map
- * @param opts - Options object to override built-in defaults
+ * @param {unknown[]} val - Array to map
+ * @param {mapOptions?} opts - Options object to override built-in defaults
  *
- * @returns KV-Map object
+ * @returns {mapReturn} KV-Map object
  */
 export default function mapPrimitive(arr: unknown[], opts?: mapOptions): mapReturn;
 export {};

package/array/mapPrimitive.js

@@ -1,26 +1,35 @@
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
 const round_1 = require("../number/round");
-function mapPrimitive(arr, opts = {}) {
+function mapPrimitive(arr, opts) {
     if (!Array.isArray(arr) || !arr.length)
         return {};
-    const OPTS = {
-        valtrim: false,
-        valround: false,
-        keyround: false,
-        ...Object.prototype.toString.call(opts) === '[object Object]' ? opts : {},
-    };
+    let VALTRIM = false;
+    let VALROUND = false;
+    let KEYROUND = false;
+    if (opts && Object.prototype.toString.call(opts) === '[object Object]') {
+        if (opts.valtrim === true)
+            VALTRIM = true;
+        if (opts.valround === true ||
+            (Number.isInteger(opts.valround) && opts.valround >= 0))
+            VALROUND = opts.valround;
+        if (opts.keyround === true)
+            KEYROUND = true;
+    }
     const map = {};
     for (const el of arr) {
-        if (typeof el === 'string' && el.trim().length) {
-            map[el.trim()] = OPTS.valtrim ? el.trim() : el;
+        if (typeof el === 'string') {
+            const trimmed = el.trim();
+            if (!trimmed.length)
+                continue;
+            map[trimmed] = VALTRIM ? trimmed : el;
         }
         else if (typeof el === 'number' && Number.isFinite(el)) {
-            map[`${OPTS.keyround === true ? Math.round(el) : el}`] = OPTS.valround === false
+            map[`${KEYROUND ? Math.round(el) : el}`] = VALROUND === false
                 ? el
-                : OPTS.valround === true
+                : VALROUND === true
                     ? Math.round(el)
-                    : (0, round_1.default)(el, OPTS.valround);
+                    : (0, round_1.default)(el, VALROUND);
         }
     }
     return map;

package/array/shuffle.js

@@ -1,7 +1,7 @@
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
 function shuffle(arr) {
-    if (!Array.isArray(arr) || !arr.length)
+    if (!Array.isArray(arr))
         return;
     for (let i = arr.length - 1; i > 0; i--) {
         const j = Math.floor(Math.random() * (i + 1));

package/array/sort.js

@@ -1,6 +1,5 @@
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
-const is_1 = require("../boolean/is");
 const isNotEmpty_1 = require("../object/isNotEmpty");
 function partition(arr, start_ix, end_ix) {
     const pivot_val = arr[Math.floor((start_ix + end_ix) / 2)].t;
@@ -29,19 +28,24 @@ function quickSort(arr, start_ix = 0, end_ix = arr.length - 1) {
     }
     return arr;
 }
-function sort(arr, by, dir = 'asc', opts = {}) {
+function sort(arr, by, dir = 'asc', opts) {
     if (!Array.isArray(arr) || !arr.length)
         return [];
     if (dir !== 'asc' && dir !== 'desc')
         throw new Error('Direction should be either asc or desc');
-    const has_opts = Object.prototype.toString.call(opts) === '[object Object]';
-    const OPTS = {
-        filter_fn: has_opts && typeof opts.filter_fn === 'function'
-            ? el => (0, isNotEmpty_1.default)(el) && opts.filter_fn(el)
-            : isNotEmpty_1.default,
-        nokey_hide: has_opts && (0, is_1.default)(opts.nokey_hide) ? opts.nokey_hide : false,
-        nokey_atend: has_opts && (0, is_1.default)(opts.nokey_atend) ? opts.nokey_atend : true,
-    };
+    let NOKEY_HIDE = false;
+    let NOKEY_AT_END = true;
+    let FILTER_FN = isNotEmpty_1.default;
+    if (opts && Object.prototype.toString.call(opts) === '[object Object]') {
+        if (opts.nokey_hide === true)
+            NOKEY_HIDE = true;
+        if (opts.nokey_atend === false)
+            NOKEY_AT_END = false;
+        if (typeof opts.filter_fn === 'function') {
+            const fn = opts.filter_fn;
+            FILTER_FN = el => (0, isNotEmpty_1.default)(el) && fn(el);
+        }
+    }
     const prepared_arr = [];
     const nokey_arr = [];
     if (typeof by === 'string') {
@@ -49,7 +53,7 @@ function sort(arr, by, dir = 'asc', opts = {}) {
         if (!by_s.length)
             throw new Error('Sort by as string should contain content');
         for (const el of arr) {
-            if (!OPTS.filter_fn(el))
+            if (!FILTER_FN(el))
                 continue;
             if (!Object.prototype.hasOwnProperty.call(el, by_s) || el[by_s] === undefined) {
                 nokey_arr.push(el);
@@ -62,7 +66,7 @@ function sort(arr, by, dir = 'asc', opts = {}) {
     else if (typeof by === 'function') {
         let key;
         for (const el of arr) {
-            if (!OPTS.filter_fn(el))
+            if (!FILTER_FN(el))
                 continue;
             key = by(el);
             if (key === undefined) {
@@ -80,11 +84,11 @@ function sort(arr, by, dir = 'asc', opts = {}) {
     if (dir === 'desc')
         prepared_arr.reverse();
     const result = [];
-    if (OPTS.nokey_hide) {
+    if (NOKEY_HIDE) {
         for (const obj of prepared_arr)
             result.push(obj.el);
     }
-    else if (OPTS.nokey_atend) {
+    else if (NOKEY_AT_END) {
         for (const obj of prepared_arr)
             result.push(obj.el);
         for (const el of nokey_arr)

package/date/format.js

@@ -51,7 +51,7 @@ function runIntl(loc, token, props, val) {
 }
 const Tokens = [
     ['YYYY', d => d.getFullYear()],
-    ['Q', d => Math.floor((d.getMonth() + 3) / 3)],
+    ['Q', d => ((d.getMonth() + 3) / 3) | 0],
     ['MMMM', (d, loc) => runIntl(loc, 'MMMM', { month: 'long' }, d)],
     ['MMM', (d, loc) => runIntl(loc, 'MMM', { month: 'short' }, d)],
     ['MM', d => `${d.getMonth() + 1}`.padStart(2, '0')],

package/deep/set.js

@@ -1,12 +1,13 @@
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
+const RGX_MALICIOUS = /__proto__|constructor|prototype/;
 function deepSet(obj, path, value, define = false) {
     if (Object.prototype.toString.call(obj) !== '[object Object]' &&
         !Array.isArray(obj))
         throw new TypeError('Deepset is only supported for objects');
     if (typeof path !== 'string')
         throw new TypeError('No path was given');
-    if (/__proto__|constructor|prototype/.test(path))
+    if (RGX_MALICIOUS.test(path))
         throw new TypeError('Malicious path provided');
     const path_s = path.trim();
     if (!path_s.length)
@@ -16,7 +17,8 @@ function deepSet(obj, path, value, define = false) {
         .replace(/(\.){2,}/g, '.')
         .replace(/(^\.|\.$|\])/g, '')
         .split('.');
-    for (let i = 0; i < parts.length - 1; i++) {
+    const last_part_ix = parts.length - 1;
+    for (let i = 0; i < last_part_ix; i++) {
         if (parts[i] === '')
             continue;
         if (Array.isArray(obj)) {
@@ -36,16 +38,16 @@ function deepSet(obj, path, value, define = false) {
     if (!Array.isArray(obj) && Object.prototype.toString.call(obj) !== '[object Object]')
         return false;
     if (define) {
-        Object.defineProperty(obj, parts[parts.length - 1], value);
+        Object.defineProperty(obj, parts[last_part_ix], value);
     }
     else if (Array.isArray(obj)) {
-        const idx = parseInt(parts[parts.length - 1]);
+        const idx = parseInt(parts[last_part_ix]);
         if (!Number.isInteger(idx) || idx < 0)
             throw new TypeError('Invalid path provided');
         obj[idx] = value;
     }
     else {
-        obj[parts[parts.length - 1]] = value;
+        obj[parts[last_part_ix]] = value;
     }
     return true;
 }

package/hash/guid.js

@@ -1,33 +1,33 @@
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
-const HEXMAP = [];
+const HEX = [];
 for (let i = 0; i < 256; i++) {
-    HEXMAP[i] = (i < 16 ? '0' : '') + i.toString(16);
+    HEX[i] = (i < 16 ? '0' : '') + i.toString(16);
 }
 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] +
+    return HEX[d0 & 0xff] +
+        HEX[(d0 >> 8) & 0xff] +
+        HEX[(d0 >> 16) & 0xff] +
+        HEX[(d0 >> 24) & 0xff] +
         '-' +
-        HEXMAP[d1 & 0xff] +
-        HEXMAP[(d1 >> 8) & 0xff] +
+        HEX[d1 & 0xff] +
+        HEX[(d1 >> 8) & 0xff] +
         '-' +
-        HEXMAP[((d1 >> 16) & 0x0f) | 0x40] +
-        HEXMAP[(d1 >> 24) & 0xff] +
+        HEX[((d1 >> 16) & 0x0f) | 0x40] +
+        HEX[(d1 >> 24) & 0xff] +
         '-' +
-        HEXMAP[(d2 & 0x3f) | 0x80] +
-        HEXMAP[(d2 >> 8) & 0xff] +
+        HEX[(d2 & 0x3f) | 0x80] +
+        HEX[(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];
+        HEX[(d2 >> 16) & 0xff] +
+        HEX[(d2 >> 24) & 0xff] +
+        HEX[d3 & 0xff] +
+        HEX[(d3 >> 8) & 0xff] +
+        HEX[(d3 >> 16) & 0xff] +
+        HEX[(d3 >> 24) & 0xff];
 }
 exports.default = guid;

package/index.d.ts

@@ -156,9 +156,6 @@ declare module "is" {
     }>;
     export default Is;
 }
-declare module "hash/fnv1A" {
-    export default function fnv1A(data: unknown, offset?: number): number;
-}
 declare module "array/dedupe" {
     export default function dedupe<T>(val: T[]): T[];
 }
@@ -178,29 +175,18 @@ declare module "array/mapFn" {
     interface mapOptions {
         merge?: boolean;
     }
-    interface kvMap {
-        [key: string]: {
-            [key: string]: any;
-        };
-    }
-    export default function mapFn(arr: {
-        [key: string]: any;
-    }[], fn: (entry: {
+    type mapFn = (entry: {
         [key: string]: any;
-    }) => (string | number | boolean), opts?: mapOptions): kvMap;
+    }) => (string | number | boolean);
+    type mapReturn = Record<string, Record<string, any>>;
+    export default function mapFn(arr: Record<string, any>[], fn: mapFn, opts?: mapOptions): mapReturn;
 }
 declare module "array/mapKey" {
     interface mapOptions {
         merge?: boolean;
     }
-    interface kvMap {
-        [key: string]: {
-            [key: string]: any;
-        };
-    }
-    export default function mapKey(arr: {
-        [key: string]: any;
-    }[], key: string, opts?: mapOptions): kvMap;
+    type kvMap = Record<string, Record<string, any>>;
+    export default function mapKey(arr: Record<string, any>[], key: string, opts?: mapOptions): kvMap;
 }
 declare module "array/mapPrimitive" {
     interface mapOptions {
@@ -208,9 +194,7 @@ declare module "array/mapPrimitive" {
         valround?: boolean | number;
         keyround?: boolean;
     }
-    interface mapReturn {
-        [key: string]: string | number;
-    }
+    type mapReturn = Record<string, string | number>;
     export default function mapPrimitive(arr: unknown[], opts?: mapOptions): mapReturn;
 }
 declare module "array/shuffle" {
@@ -306,6 +290,9 @@ declare module "function/noopreturn" {
 declare module "function/sleep" {
     export default function sleep(ms?: number): Promise<void>;
 }
+declare module "hash/fnv1A" {
+    export default function fnv1A(data: unknown, offset?: number): number;
+}
 declare module "hash/guid" {
     export default function guid(): string;
 }
@@ -356,7 +343,7 @@ declare module "string/humanizeNumber" {
         divider?: number;
         real?: boolean;
     }
-    export default function humanizeNumber(val: number | string, options?: humanizeNumberOptions): string;
+    export default function humanizeNumber(val: number | string, options?: humanizeNumberOptions | false): string;
 }
 declare module "string/humanizeBytes" {
     interface humanizeBytesOptions {

package/object/pick.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const get_1 = require("../deep/get");
 const set_1 = require("../deep/set");
+const RGX_DEEP = /(\.|\[)/;
 function pick(obj, keys) {
     if (Object.prototype.toString.call(obj) !== '[object Object]' ||
         !Array.isArray(keys) ||
@@ -16,7 +17,7 @@ function pick(obj, keys) {
         sanitized = key.trim();
         if (!sanitized.length)
             continue;
-        if (/(\.|\[)/g.test(sanitized)) {
+        if (RGX_DEEP.test(sanitized)) {
             val = (0, get_1.default)(obj, sanitized);
             if (val === undefined)
                 continue;

package/package.json

@@ -1 +1 @@
-{ "name": "@valkyriestudios/utils", "version": "12.0.0", "description": "A collection of single-function utilities for common tasks", "author": { "name": "Peter Vermeulen", "email": "contact@valkyriestudios.be", "url": "www.valkyriestudios.be" }, "keywords": [ "utility", "library", "javascript", "js", "node", "bun" ], "license": "MIT", "repository": { "type": "git", "url": "git+https://github.com/ValkyrieStudios/utils.git" }, "bugs": { "url": "https://github.com/ValkyrieStudios/utils/issues" }, "homepage": "https://github.com/ValkyrieStudios/utils#readme", "types": "index.d.ts" }
+{ "name": "@valkyriestudios/utils", "version": "12.1.0", "description": "A collection of single-function utilities for common tasks", "author": { "name": "Peter Vermeulen", "email": "contact@valkyriestudios.be", "url": "www.valkyriestudios.be" }, "keywords": [ "utility", "library", "javascript", "js", "node", "bun" ], "license": "MIT", "repository": { "type": "git", "url": "git+https://github.com/ValkyrieStudios/utils.git" }, "bugs": { "url": "https://github.com/ValkyrieStudios/utils/issues" }, "homepage": "https://github.com/ValkyrieStudios/utils#readme", "types": "index.d.ts" }

package/string/humanizeNumber.d.ts

@@ -48,5 +48,5 @@ interface humanizeNumberOptions {
  *
  * @returns Humanized number as string
  */
-export default function humanizeNumber(val: number | string, options?: humanizeNumberOptions): string;
+export default function humanizeNumber(val: number | string, options?: humanizeNumberOptions | false): string;
 export {};

package/string/humanizeNumber.js

@@ -1,57 +1,56 @@
 '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
-            ? 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) || 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;
+const DEFAULT_UNITS = ['', 'k', 'm', 'b', 't', 'q'];
+function humanizeNumber(val, options = false) {
+    let DELIM = ',';
+    let SEPARATOR = '.';
+    let PRECISION = 2;
+    let UNITS = DEFAULT_UNITS;
+    let DIVIDER = 1000;
+    let REAL = false;
+    if (options && Object.prototype.toString.call(options) === '[object Object]') {
+        if (typeof options.delim === 'string')
+            DELIM = options.delim;
+        if (typeof options.separator === 'string' && options.separator.trim().length)
+            SEPARATOR = options.separator;
+        if (Number.isInteger(options.precision) && options.precision >= 0)
+            PRECISION = options.precision;
+        if (Array.isArray(options.units) && options.units.length) {
+            UNITS = options.units;
+        }
+        else if (options.units === false) {
+            UNITS = false;
+        }
+        if (Number.isInteger(options.divider) && options.divider > 1) {
+            DIVIDER = options.divider;
+        }
+        if (options.real === true)
+            REAL = true;
     }
-    else {
-        normalized = typeof val === 'string' ? parseFloat(val) : Number.isFinite(val) ? val : 0;
+    let normalized = 0;
+    if (typeof val === 'string') {
+        normalized = REAL ? parseInt(val.trim(), 10) : parseFloat(val);
     }
-    if (!Number.isFinite(normalized) || normalized === 0) {
-        return `0${Array.isArray(OPTS.units) && OPTS.units.length ? OPTS.units[0] : ''}`;
+    else if (Number.isFinite(val)) {
+        normalized = REAL ? Math.round(val) : val;
     }
+    if (!Number.isFinite(normalized) || normalized === 0)
+        return UNITS ? `0${UNITS[0]}` : '0';
     const sign = normalized < 0 ? '-' : '';
     normalized = Math.abs(normalized);
-    let postfix = '';
-    if (Array.isArray(OPTS.units) && OPTS.units.length) {
-        let unit_ix = 0;
-        for (unit_ix; normalized >= OPTS.divider && unit_ix < OPTS.units.length - 1; unit_ix++) {
-            normalized /= OPTS.divider;
+    let unit_ix = 0;
+    if (UNITS) {
+        for (unit_ix; normalized >= DIVIDER && unit_ix < UNITS.length - 1; unit_ix++) {
+            normalized /= DIVIDER;
         }
-        postfix = OPTS.units[unit_ix];
     }
-    normalized = (0, round_1.default)(normalized, OPTS.precision);
-    const humanized = `${normalized}`.split('.');
+    const humanized = `${(0, round_1.default)(normalized, PRECISION)}`.split('.', 2);
     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 + DELIM;
         return char;
     }).reverse().join('');
-    return `${sign}${humanized.join(OPTS.separator)}${postfix}`;
+    return `${sign}${humanized.join(SEPARATOR)}${UNITS ? UNITS[unit_ix] : ''}`;
 }
 exports.default = humanizeNumber;

package/string/shorten.js

@@ -3,9 +3,9 @@ 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)
+    if (typeof postfix !== 'string' || !Number.isInteger(length) || length <= 0)
         return val;
     const sanitized = val.trim();
-    return sanitized.length <= length ? sanitized : `${sanitized.substr(0, length)}${postfix}`;
+    return sanitized.length <= length ? sanitized : `${sanitized.substring(0, length)}${postfix}`;
 }
 exports.default = shorten;