@valkyriestudios/utils 11.7.0 → 12.1.0

package/date/format.js

@@ -0,0 +1,125 @@
+'use strict';
+Object.defineProperty(exports, "__esModule", { value: true });
+const is_1 = require("./is");
+const DEFAULT_LOCALE = 'en-US';
+let DEFAULT_TZ = 'UTC';
+try {
+    DEFAULT_TZ = Intl.DateTimeFormat().resolvedOptions().timeZone;
+}
+catch (err) {
+}
+finally {
+    if (typeof DEFAULT_TZ !== 'string')
+        DEFAULT_TZ = 'UTC';
+}
+const escape_rgx = /\[[\s\S]+?]/g;
+const intl_formatters = new Map();
+const spec_cache = new Map();
+const zone_offset_cache = new Map();
+function DOY(d) {
+    return Math.floor((d - new Date(d.getFullYear(), 0, 0)) / 86400000);
+}
+function toZone(date, zone) {
+    const ckey = `${zone}:${date.getUTCFullYear()}${DOY(date)}`;
+    if (zone_offset_cache.has(ckey))
+        return new Date(date.getTime() + zone_offset_cache.get(ckey));
+    const client_time = date.getTime();
+    let zone_time = false;
+    try {
+        zone_time = new Date(date.toLocaleString(DEFAULT_LOCALE, { timeZone: zone })).getTime();
+    }
+    catch (err) {
+    }
+    if (!Number.isInteger(zone_time))
+        throw new Error(`format: Invalid zone passed - ${zone}`);
+    const offset = zone_time - client_time;
+    zone_offset_cache.set(ckey, offset);
+    return new Date(date.getTime() + offset);
+}
+function runIntl(loc, token, props, val) {
+    const hash = `${loc}:${token}`;
+    if (intl_formatters.has(hash))
+        return intl_formatters.get(hash).format(val);
+    try {
+        const instance = new Intl.DateTimeFormat(loc, props);
+        intl_formatters.set(hash, instance);
+        return instance.format(val);
+    }
+    catch (err) {
+        throw new Error(`format: Failed to run conversion for ${token} with locale ${loc}`);
+    }
+}
+const Tokens = [
+    ['YYYY', d => d.getFullYear()],
+    ['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')],
+    ['M', d => d.getMonth() + 1],
+    ['DD', d => `${d.getDate()}`.padStart(2, '0')],
+    ['D', d => d.getDate()],
+    ['dddd', (d, loc) => runIntl(loc, 'dddd', { weekday: 'long' }, d)],
+    ['ddd', (d, loc) => runIntl(loc, 'ddd', { weekday: 'short' }, d)],
+    ['HH', d => `${d.getHours()}`.padStart(2, '0')],
+    ['H', d => d.getHours()],
+    ['hh', d => `${((d.getHours() + 11) % 12) + 1}`.padStart(2, '0')],
+    ['h', d => ((d.getHours() + 11) % 12) + 1],
+    ['mm', d => `${d.getMinutes()}`.padStart(2, '0')],
+    ['m', d => d.getMinutes()],
+    ['ss', d => `${d.getSeconds()}`.padStart(2, '0')],
+    ['s', d => d.getSeconds()],
+    ['SSS', d => `${d.getMilliseconds()}`.padStart(3, '0')],
+    ['A', d => d.getHours() < 12 ? 'AM' : 'PM'],
+    ['a', d => d.getHours() < 12 ? 'am' : 'pm'],
+]
+    .sort((a, b) => a[0].length > b[0].length ? -1 : 1)
+    .map((el) => [el[0], new RegExp(el[0], 'g'), el[1]]);
+function getSpecChain(spec) {
+    if (spec_cache.has(spec))
+        return spec_cache.get(spec);
+    const spec_chain = [];
+    let cursor;
+    for (let i = 0; i < Tokens.length; i++) {
+        cursor = Tokens[i];
+        if (spec.indexOf(cursor[0]) < 0)
+            continue;
+        spec_chain.push(cursor);
+    }
+    if (spec_chain.length === 0)
+        return false;
+    spec_cache.set(spec, spec_chain);
+    return spec_chain;
+}
+function format(val, spec, locale = DEFAULT_LOCALE, zone = DEFAULT_TZ) {
+    if (!(0, is_1.default)(val))
+        throw new TypeError('format: val must be a Date');
+    if (typeof spec !== 'string' || !spec.trim().length)
+        throw new TypeError('format: spec must be a non-empty string');
+    if (typeof locale !== 'string' || !locale.trim().length)
+        throw new TypeError('format: locale must be a non-empty string');
+    if (typeof zone !== 'string' || !zone.trim().length)
+        throw new TypeError('format: zone must be a non-empty string');
+    let formatted_string = spec;
+    const escaped_acc = [];
+    if (formatted_string.indexOf('[') >= 0) {
+        formatted_string = formatted_string.replace(escape_rgx, match => {
+            const escape_token = `$R${escaped_acc.length}$`;
+            escaped_acc.push([escape_token, match.replace('[', '').replace(']', '')]);
+            return escape_token;
+        });
+    }
+    const spec_chain = getSpecChain(formatted_string);
+    if (!spec_chain)
+        return val.toISOString();
+    const d = toZone(val, zone);
+    for (const el of spec_chain) {
+        formatted_string = formatted_string.replace(el[1], el[2](d, locale));
+    }
+    if (escaped_acc.length) {
+        for (const escape_token of escaped_acc) {
+            formatted_string = formatted_string.replace(escape_token[0], escape_token[1]);
+        }
+    }
+    return formatted_string;
+}
+exports.default = format;

package/date/is.js

@@ -1,6 +1,6 @@
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
 function isDate(val) {
-    return Object.prototype.toString.call(val) === '[object Date]' && !isNaN(val);
+    return val instanceof Date && !isNaN(val);
 }
 exports.default = isDate;

package/date/startOfUTC.js

@@ -1,16 +1,16 @@
 'use strict';
 Object.defineProperty(exports, "__esModule", { value: true });
 const is_1 = require("./is");
-const WEEK_START = {
-    week: 1,
-    week_sun: 0,
-    week_mon: 1,
-    week_tue: 2,
-    week_wed: 3,
-    week_thu: 4,
-    week_fri: 5,
-    week_sat: 6,
-};
+const WEEK_START = new Map([
+    ['week', 1],
+    ['week_sun', 0],
+    ['week_mon', 1],
+    ['week_tue', 2],
+    ['week_wed', 3],
+    ['week_thu', 4],
+    ['week_fri', 5],
+    ['week_sat', 6],
+]);
 function startOfUTC(val, key = 'millisecond') {
     if (!(0, is_1.default)(val))
         throw new TypeError('startOfUTC requires a date object');
@@ -20,7 +20,8 @@ function startOfUTC(val, key = 'millisecond') {
         case 'year':
             return new Date(Date.UTC(val.getUTCFullYear(), 0, 1, 0, 0, 0, 0));
         case 'quarter': {
-            return new Date(Date.UTC(val.getUTCFullYear(), val.getUTCMonth() - (val.getUTCMonth() % 3), 1, 0, 0, 0, 0));
+            const UTC_MONTH = val.getUTCMonth();
+            return new Date(Date.UTC(val.getUTCFullYear(), UTC_MONTH - (UTC_MONTH % 3), 1, 0, 0, 0, 0));
         }
         case 'month':
             return new Date(Date.UTC(val.getUTCFullYear(), val.getUTCMonth(), 1, 0, 0, 0, 0));
@@ -33,7 +34,7 @@ function startOfUTC(val, key = 'millisecond') {
         case 'week_fri':
         case 'week_sat': {
             const UTC_DAY = val.getUTCDay();
-            const UTC_SOD = WEEK_START[key];
+            const UTC_SOD = WEEK_START.get(key);
             return new Date(Date.UTC(val.getUTCFullYear(), val.getUTCMonth(), val.getUTCDate() - (UTC_DAY < UTC_SOD ? (7 - UTC_SOD) + UTC_DAY : UTC_DAY - UTC_SOD), 0, 0, 0, 0));
         }
         case 'day':
@@ -44,7 +45,6 @@ function startOfUTC(val, key = 'millisecond') {
             return new Date(Date.UTC(val.getUTCFullYear(), val.getUTCMonth(), val.getUTCDate(), val.getUTCHours(), val.getUTCMinutes(), 0, 0));
         case 'second':
             return new Date(Date.UTC(val.getUTCFullYear(), val.getUTCMonth(), val.getUTCDate(), val.getUTCHours(), val.getUTCMinutes(), val.getUTCSeconds(), 0));
-        case 'millisecond':
         default:
             return new Date(Date.UTC(val.getUTCFullYear(), val.getUTCMonth(), val.getUTCDate(), val.getUTCHours(), val.getUTCMinutes(), val.getUTCSeconds(), val.getUTCMilliseconds()));
     }

package/deep/get.js

@@ -7,19 +7,19 @@ function deepGet(obj, path, get_parent = false) {
     if (typeof path !== 'string')
         throw new TypeError('No path was given');
     const path_s = path.trim();
-    if (path_s.length === 0)
+    if (!path_s.length)
         throw new TypeError('No path was given');
     const parts = path_s
         .replace(/\[/g, '.')
         .replace(/(\.){2,}/g, '.')
         .replace(/(^\.|\.$|\])/g, '')
         .split('.');
-    if (parts.length === 0 || (parts.length === 1 && get_parent))
+    if (!parts.length || (parts.length === 1 && get_parent))
         return obj;
     if (get_parent)
         parts.pop();
     let cursor = obj;
-    while (parts.length > 0) {
+    while (parts.length) {
         if (Array.isArray(cursor)) {
             const ix = parseInt(parts.shift());
             if (!Number.isInteger(ix) || ix < 0 || ix > (cursor.length - 1))
@@ -33,7 +33,7 @@ function deepGet(obj, path, get_parent = false) {
             cursor = cursor[key];
         }
         if ((!Array.isArray(cursor) && Object.prototype.toString.call(cursor) !== '[object Object]') &&
-            parts.length > 0)
+            parts.length)
             return undefined;
     }
     return cursor;

package/deep/set.js

@@ -1,22 +1,24 @@
 '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 === 0)
+    if (!path_s.length)
         throw new TypeError('No path was given');
     const parts = path_s
         .replace(/\[/g, '.')
         .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/equal.js

@@ -23,21 +23,17 @@ function isObjectEqual(a, b) {
     return true;
 }
 function equal(a, b) {
-    if (a instanceof Date &&
-        b instanceof Date)
-        return a.valueOf() === b.valueOf();
-    if (Object.prototype.toString.call(a) === '[object RegExp]' &&
-        Object.prototype.toString.call(b) === '[object RegExp]')
-        return String(a) === String(b);
-    if (Array.isArray(a) &&
-        Array.isArray(b))
-        return isArrayEqual(a, b);
-    if (Object.prototype.toString.call(a) === '[object Object]' &&
-        Object.prototype.toString.call(b) === '[object Object]')
-        return isObjectEqual(a, b);
-    if ((0, isNumericalNaN_1.default)(a)) {
-        return (0, isNumericalNaN_1.default)(b);
+    if (a instanceof Date)
+        return b instanceof Date && a.valueOf() === b.valueOf();
+    if (a instanceof RegExp)
+        return b instanceof RegExp && String(a) === String(b);
+    if (Array.isArray(a))
+        return Array.isArray(b) && isArrayEqual(a, b);
+    if (Object.prototype.toString.call(a) === '[object Object]') {
+        return Object.prototype.toString.call(b) === '[object Object]' && isObjectEqual(a, b);
     }
+    if ((0, isNumericalNaN_1.default)(a))
+        return (0, isNumericalNaN_1.default)(b);
     return a === b;
 }
 exports.default = equal;

package/hash/fnv1A.js

@@ -18,7 +18,7 @@ function fnv1A(data, offset = FNV_32) {
     else if (Array.isArray(data) || Object.prototype.toString.call(data) === '[object Object]') {
         sanitized = JSON.stringify(data);
     }
-    else if (Object.prototype.toString.call(data) === '[object RegExp]') {
+    else if (data instanceof RegExp) {
         sanitized = data.toString();
     }
     else if (data instanceof Date) {

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" {
@@ -232,7 +216,7 @@ declare module "caching/memoize" {
     export default function memoize(fn: Function, resolver?: Function): Function;
 }
 declare module "date/addUTC" {
-    export default function addUTC(val: Date, amount?: number, key?: 'years' | 'year' | 'months' | 'month' | 'days' | 'day' | 'hours' | 'hour' | 'minutes' | 'minute' | 'seconds' | 'second' | 'milliseconds' | 'millisecond'): Date;
+    export default function addUTC(val: Date, amt?: number, key?: 'years' | 'year' | 'months' | 'month' | 'days' | 'day' | 'hours' | 'hour' | 'minutes' | 'minute' | 'seconds' | 'second' | 'milliseconds' | 'millisecond'): Date;
 }
 declare module "date/diff" {
     export default function diff(val_a: Date, val_b: Date, key?: 'week' | 'weeks' | 'day' | 'days' | 'hour' | 'hours' | 'minute' | 'minutes' | 'second' | 'seconds' | 'millisecond' | 'milliseconds'): number;
@@ -240,6 +224,9 @@ declare module "date/diff" {
 declare module "date/endOfUTC" {
     export default function endOfUTC(val: Date, key?: 'year' | 'quarter' | 'month' | 'week' | 'week_sun' | 'week_mon' | 'week_tue' | 'week_wed' | 'week_thu' | 'week_fri' | 'week_sat' | 'day' | 'hour' | 'minute' | 'second' | 'millisecond'): Date;
 }
+declare module "date/format" {
+    export default function format(val: Date, spec: string, locale?: string, zone?: string): string;
+}
 declare module "date/nowUnix" {
     export default function nowUnix(): number;
 }
@@ -303,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;
 }
@@ -353,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,10 +2,11 @@
 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) ||
-        keys.length === 0)
+        !keys.length)
         throw new TypeError('Please pass an object to pick from and a keys array');
     const map = {};
     let val;
@@ -14,9 +15,9 @@ function pick(obj, keys) {
         if (typeof key !== 'string')
             continue;
         sanitized = key.trim();
-        if (sanitized.length === 0)
+        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": "11.7.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/regexp/is.js

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

package/string/humanizeBytes.js

@@ -8,13 +8,13 @@ function humanizeBytes(val, options = {}) {
         delim: has_opts && typeof options.delim === 'string'
             ? options.delim
             : ',',
-        separator: has_opts && typeof options.separator === 'string' && options.separator.trim().length > 0
+        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 > 0
+        units: has_opts && Array.isArray(options.units) && options.units.length
             ? options.units.filter(el => (0, isNotEmpty_1.default)(el))
             : [' bytes', ' KB', ' MB', ' GB', ' TB', ' PB', ' EB', ' ZB', ' YB'],
         divider: 1024,

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,60 +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 > 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;
+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 > 0 ? 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 > 0) {
-        let unit_ix = 0;
-        while (normalized >= OPTS.divider) {
-            unit_ix++;
-            normalized = normalized / OPTS.divider;
-            if (unit_ix === OPTS.units.length - 1)
-                break;
+    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;