@valkyriestudios/utils 12.37.0 → 12.38.0

package/esm/string/humanizeBytes.js

@@ -0,0 +1,15 @@
+import { humanizeNumber } from './humanizeNumber';
+const DEFAULT_UNITS = [' bytes', ' KB', ' MB', ' GB', ' TB', ' PB', ' EB', ' ZB', ' YB'];
+function humanizeBytes(val, options = {}) {
+    return humanizeNumber(val, {
+        delim: 'delim' in options ? options.delim : ',',
+        separator: 'separator' in options ? options.separator : '.',
+        precision: 'precision' in options ? options.precision : 2,
+        units: Array.isArray(options?.units) && options.units.length
+            ? options.units
+            : DEFAULT_UNITS,
+        divider: 1024,
+        real: true,
+    });
+}
+export { humanizeBytes, humanizeBytes as default };

package/esm/string/humanizeNumber.js

@@ -0,0 +1,40 @@
+import { round } from '../number/round';
+const DEFAULT_UNITS = ['', 'k', 'm', 'b', 't', 'q'];
+function humanizeNumber(val, options = {}) {
+    const DELIM = typeof options?.delim === 'string' ? options.delim : ',';
+    const SEPARATOR = typeof options?.separator === 'string' && options.separator.length ? options.separator : '.';
+    const PRECISION = Number.isInteger(options?.precision) && options.precision >= 0 ? options.precision : 2;
+    const DIVIDER = Number.isInteger(options?.divider) && options.divider >= 2 ? options.divider : 1000;
+    const REAL = options?.real === true;
+    const UNITS = Array.isArray(options?.units) && options.units.length
+        ? options.units
+        : options?.units === false
+            ? false
+            : DEFAULT_UNITS;
+    let normalized = typeof val === 'string' ? parseFloat(val) : val;
+    if (!Number.isFinite(normalized) || normalized === 0)
+        return UNITS ? '0' + UNITS[0] : '0';
+    if (REAL)
+        normalized = Math.round(normalized);
+    const sign = normalized < 0 ? '-' : '';
+    normalized = Math.abs(normalized);
+    let unit_ix = 0;
+    if (UNITS) {
+        while (normalized >= DIVIDER && unit_ix < UNITS.length - 1) {
+            normalized /= DIVIDER;
+            unit_ix++;
+        }
+    }
+    const humanized = ('' + round(normalized, PRECISION)).split('.', 2);
+    const integer_part = humanized[0];
+    const integer_part_len = integer_part.length;
+    let formattedIntegerPart = '';
+    for (let i = 0; i < integer_part_len; i++) {
+        if (i > 0 && (integer_part_len - i) % 3 === 0) {
+            formattedIntegerPart += DELIM;
+        }
+        formattedIntegerPart += integer_part[i];
+    }
+    return sign + formattedIntegerPart + (humanized[1] ? SEPARATOR + humanized[1] : '') + (UNITS ? UNITS[unit_ix] : '');
+}
+export { humanizeNumber, humanizeNumber as default };

package/esm/string/index.js

@@ -0,0 +1,7 @@
+export { humanizeBytes } from './humanizeBytes';
+export { humanizeNumber } from './humanizeNumber';
+export { shorten } from './shorten';
+export { isString } from './is';
+export { isNotEmptyString } from './isNotEmpty';
+export { isNotEmptyString as isNeString } from './isNotEmpty';
+export { isStringBetween } from './isBetween';

package/esm/string/is.js

@@ -0,0 +1,4 @@
+function isString(val) {
+    return typeof val === 'string';
+}
+export { isString, isString as default };

package/esm/string/isBetween.js

@@ -0,0 +1,12 @@
+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;
+}
+export { isStringBetween, isStringBetween as default };

package/esm/string/isNotEmpty.js

@@ -0,0 +1,20 @@
+function isNotEmptyString(val, trimmed = true) {
+    if (typeof val !== 'string')
+        return false;
+    if (trimmed) {
+        for (let i = 0; i < val.length; i++) {
+            switch (val[i]) {
+                case ' ':
+                case '\t':
+                case '\n':
+                case '\r':
+                    break;
+                default:
+                    return true;
+            }
+        }
+        return false;
+    }
+    return val.length > 0;
+}
+export { isNotEmptyString, isNotEmptyString as default };

package/esm/string/shorten.js

@@ -0,0 +1,18 @@
+function shorten(val, length, postfix = '...', truncate_words = true) {
+    if (typeof val !== 'string')
+        return '';
+    if (typeof postfix !== 'string' || !Number.isInteger(length) || length <= 0)
+        return val;
+    const sanitized = val.trim();
+    if (sanitized.length <= length)
+        return sanitized;
+    const truncated = sanitized.substring(0, length);
+    if (truncate_words)
+        return truncated + postfix;
+    let end = length;
+    while (end && sanitized[end] !== ' ' && sanitized[end - 1] !== ' ') {
+        end--;
+    }
+    return sanitized.substring(0, end).trimEnd() + postfix;
+}
+export { shorten, shorten as default };

package/index.d.ts

@@ -26,7 +26,7 @@ declare module "array/join" {
         valtrim?: boolean;
         valround?: number;
     }
-    function join(val: unknown[], opts?: joinOptions): string;
+    function join<T>(val: T[] | Set<T>, opts?: joinOptions): string;
     export { join, join as default };
 }
 declare module "object/merge" {
@@ -95,8 +95,8 @@ declare module "object/isNotEmpty" {
     export { isNotEmptyObject, isNotEmptyObject as default };
 }
 declare module "array/groupBy" {
-    type Handler<T> = (val: T) => string | number | boolean;
-    function groupBy<T extends Record<string, any>>(arr: T[], handler: Handler<T> | keyof T): Record<string, T[]>;
+    type Handler<T> = (val: T) => string | number | boolean | undefined;
+    function groupBy<T extends Record<string, any>>(val: T[] | Set<T>, handler: Handler<T> | keyof T): Record<string, T[]>;
     export { groupBy, groupBy as default };
 }
 declare module "array/shuffle" {
@@ -107,7 +107,7 @@ declare module "array/split" {
     type SplitOptions<T> = {
         filter_fn?: (el: T) => boolean;
     };
-    function split<T>(arr: T[], size: number, opts?: SplitOptions<T>): T[][];
+    function split<T>(arr: T[] | Set<T>, size: number, opts?: SplitOptions<T>): T[][];
     export { split, split as default };
 }
 declare module "object/is" {
@@ -188,16 +188,20 @@ declare module "caching/LRU" {
     export type LRUCacheOptions = {
         max_size?: number;
     };
-    class LRUCache<K, V> {
+    class LRUCache<V> {
         #private;
         constructor(opts?: LRUCacheOptions);
         get max_size(): number;
         set max_size(max_size: number);
-        has(key: K): boolean;
-        get(key: K): V | undefined;
-        set(key: K, value: V): void;
-        del(key: K): void;
+        has(key: string): boolean;
+        get(key: string): V | undefined;
+        set(key: string, value: V): void;
+        del(key: string): void;
         clear(): void;
+        private addToFront;
+        private removeNode;
+        private moveToFront;
+        private evictTail;
     }
     export { LRUCache, LRUCache as default };
 }
@@ -614,6 +618,12 @@ declare module "is" {
     }>;
     export { Is, Is as default };
 }
+declare module "hash/fnv1A" {
+    export const FNV_32 = 2166136261;
+    export const FNV_64 = 1099511628211;
+    function fnv1A(data: unknown, offset?: number): number;
+    export { fnv1A, fnv1A as default };
+}
 declare module "caching/memoize" {
     function memoize<T extends (...args: any[]) => unknown>(fn: T, resolver?: (...args: Parameters<T>) => any, cache_duration_ms?: number | false, cache_max_size?: number): T;
     export { memoize, memoize as default };
@@ -665,12 +675,6 @@ declare module "deep/index" {
     export { deepSet as set } from "deep/set";
     export { deepSet } from "deep/set";
 }
-declare module "hash/fnv1A" {
-    export const FNV_32 = 2166136261;
-    export const FNV_64 = 1099511628211;
-    function fnv1A(data: unknown, offset?: number): number;
-    export { fnv1A, fnv1A as default };
-}
 declare module "hash/guid" {
     function guid(): string;
     export { guid, guid as default };