@valkyriestudios/utils 12.27.1 → 12.28.0

package/README.md

@@ -220,7 +220,7 @@ dedupe(['hello', 'hello', 'world', false, 'world'], {filter_fn: el => isNotEmpty
 
 Take Note: The filtering is applied while deduping, ensuring O(n) performance, as such this is faster than dedupe(arr.filter(...))
 
-### array/join(val:Array, opts:object={delim:' ',trim:true,valtrim:true,innertrim:true,valround:false})
+### array/join(val:Array, opts:object={delim:' ',trim:true,valtrim:true,innertrim:true,valround:false,dedupe:false})
 Concatenate the values within an array into a string, behind the scenes this will automatically filter out any value that is not a string or numerical value. For strings it will automatically trim (and remove if empty after trimming) before joining.
 
 ```typescript
@@ -231,6 +231,7 @@ join(['peter   ', '  valkyrie  '], {delim: '@'}); // 'peter@valkyrie'
 join([user.first_name, user.last_name]); // 'John' (where user is {first_name: 'John', last_name: false})
 join(['  a', 1], {delim: '', valtrim: false, trim: false}); // '  a1'
 join(['  hello  world  ', 'this   is    peter   '], {valtrim:true, innertrim: true, delim: ' '}); // 'hello world this is peter'
+join(['  prop_1 ', 'prop_2', ' prop_1', '  prop_2'], {delim: ',', dedupe: true}); // 'prop_1,prop_2'
 ```
 
 ### array/shuffle(val:Array)
@@ -365,7 +366,43 @@ isBoolean(false); // TRUE
 isBoolean(true); // TRUE
 ```
 
-### caching/memoize(fn:Function, resolver:Function=false, memoize_for:number|false)
+### caching/LRU({max_size?:number})
+Class-based LRU (Least Recently Used) cache utility with configurable max_size (defaults to 100). The LRU cache is internally used in `caching/memoize`, `date/format`, `date/isFormat` to reduce setup times and runtime memory usage but can also be used independently.
+
+Entries are automatically removed from cache based on the max size of the cache and how recently they were used
+
+```typescript
+import LRU from '@valkyriestudios/utils/caching/LRU';
+
+const cache = new LRU({max_size: 10});
+
+/* .set sets a value */
+cache.set('hello', 'World');
+
+/* .has checks if a value exists */
+cache.has('hello'); // true
+cache.has('holle'); // false
+
+/* .get retrieves the value */
+console.log(cache.get('hello')); // world
+
+/* .del deletes a key */
+cache.del('hello');
+console.log(cache.get('hello')); // undefined
+
+/* .clear clears the entire cache */
+cache.clear();
+```
+
+Take Note: The cache max_size can be reconfigured at runtime, eg:
+```typescript
+import LRU from '@valkyriestudios/utils/caching/LRU';
+
+const cache = new LRU({max_size: 10});
+cache.max_size = 20;
+```
+
+### caching/memoize(fn:Function, resolver:Function=false, cache_duration_ms?:number|false = false, cache_max_size?:number = 100)
 memoize the output of a function. An optional resolver function can be passed which allows custom cache key generation.
 
 ```typescript
@@ -390,13 +427,16 @@ await memoized('123456'); /* Original function will be called */
 await memoized('123456'); /* Original function will not be called and memoized cache will be returned */
 
 /* Async with cache busting after 5 seconds */
-const memoized = memoize(retrieveUser, null, 5000);
+const memoized = memoize(retrieveUser, undefined, 5000);
 await memoized('123456'); /* Original function will be called */
 await memoized('123456'); /* Original function will not be called and memoized cache will be returned */
 
 ... (some time longer than 5 seconds passes)
 
 await memoized('123456'); /* Original function will be called and re-cached */
+
+/* Async with cache busting after 60 seconds and a max cache size of 50 entries*/
+const memoized = memoize(retrieveUser, undefined, 60000, 50);
 ```
 
 ### date/is(val:unknown)

package/array/join.d.ts

@@ -5,6 +5,12 @@ interface joinOptions {
      * eg: join(['hello', 'world', {delim: '_'}]) -> 'hello_world'
      */
     delim?: string;
+    /**
+     * Dedupe the provided array while joining or not?
+     * (default=false)
+     * eg: join(['val_a', 'val_b', 'val_'a], {dedupe: true, delim:','}) -> 'val_a,val_b'
+     */
+    dedupe?: boolean;
     /**
      * Trim after joining or not
      * (default=true)
@@ -14,7 +20,7 @@ interface joinOptions {
     /**
      * Trim internals of values or not
      * (default=false)
-     * eg: join(['   hello    world', 'this   is ', 'Peter'], {trimBetween: true, trim: true}) -> 'hello world this is peter'
+     * eg: join(['   hello    world', 'this   is ', 'Peter'], {innertrim: true, trim: true}) -> 'hello world this is peter'
      */
     innertrim?: boolean;
     /**

package/array/join.js

@@ -9,26 +9,41 @@ function join(val, opts) {
     if (!Array.isArray(val) || !val.length)
         return '';
     const DELIM = typeof opts?.delim === 'string' ? opts.delim : ' ';
-    const TRIM = opts?.trim ?? true;
+    const DEDUPE = opts?.dedupe === true ? new Set() : null;
     const VALTRIM = opts?.valtrim ?? true;
     const INNERTRIM = opts?.innertrim ?? false;
     const VALROUND = (0, isIntegerAboveOrEqual_1.isIntegerAboveOrEqual)(opts?.valround, 0) ? opts.valround : false;
     let result = '';
-    let hasVal = false;
+    let has_val = false;
     for (let i = 0; i < val.length; i++) {
         const el = val[i];
+        let n_el;
         if (typeof el === 'string') {
             const trimmed = el.trim();
             if (!trimmed)
                 continue;
-            const n_el = VALTRIM ? trimmed : el;
-            result = result + (hasVal ? DELIM : '') + (INNERTRIM ? n_el.replace(SPACE_RGX, ' ') : n_el);
-            hasVal = true;
+            n_el = VALTRIM ? trimmed : el;
+            if (INNERTRIM)
+                n_el = n_el.replace(SPACE_RGX, ' ');
         }
         else if (Number.isFinite(el)) {
-            result = result + (hasVal ? DELIM : '') + (VALROUND !== false ? (0, round_1.round)(el, VALROUND) : el);
-            hasVal = true;
+            n_el = '' + (VALROUND !== false ? (0, round_1.round)(el, VALROUND) : el);
+        }
+        else {
+            continue;
+        }
+        if (DEDUPE) {
+            if (DEDUPE.has(n_el))
+                continue;
+            DEDUPE.add(n_el);
+        }
+        if (has_val) {
+            result = result + DELIM + n_el;
+        }
+        else {
+            result = n_el;
+            has_val = true;
         }
     }
-    return TRIM ? result.trim() : result;
+    return opts?.trim ?? true ? result.trim() : result;
 }

package/caching/LRU.d.ts

@@ -0,0 +1,55 @@
+export type LRUCacheOptions = {
+    /**
+     * Maximum amount of entries the cache can have
+     * (defaults to 100)
+     */
+    max_size?: number;
+};
+/**
+ * Least-Recently-Used (LRU) Cache
+ */
+declare class LRUCache<K, V> {
+    #private;
+    constructor(opts?: LRUCacheOptions);
+    /**
+     * Get the currently configured max size of the cache
+     */
+    get max_size(): number;
+    /**
+     * Reconfigure the max size of the cache
+     *
+     * @param {number} max_size - New max size
+     */
+    set max_size(max_size: number);
+    /**
+     * Returns whether or not a key exists in cache
+     *
+     * @param {K} key - Key to retrieve
+     */
+    has(key: K): boolean;
+    /**
+     * Retrieves a value from the cache
+     *
+     * @param {K} key - Key to retrieve
+     * @returns {V | undefined} Either the found value or undefined
+     */
+    get(key: K): V | undefined;
+    /**
+     * Sets a value on to the cache
+     *
+     * @param {K} key - Key to set
+     * @param {V} value - Value to set for the key
+     */
+    set(key: K, value: V): void;
+    /**
+     * Removes a single value from the cache
+     *
+     * @param {K} key - Key to remove
+     */
+    del(key: K): void;
+    /**
+     * Clears all contents of the cache
+     */
+    clear(): void;
+}
+export { LRUCache, LRUCache as default };

package/caching/LRU.js

@@ -0,0 +1,72 @@
+"use strict";
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var _LRUCache_cache, _LRUCache_max_size;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.LRUCache = void 0;
+const is_1 = require("../object/is");
+const isIntegerAbove_1 = require("../number/isIntegerAbove");
+class LRUCache {
+    constructor(opts = {}) {
+        _LRUCache_cache.set(this, void 0);
+        _LRUCache_max_size.set(this, void 0);
+        const { max_size = 100 } = (0, is_1.default)(opts) ? opts : {};
+        __classPrivateFieldSet(this, _LRUCache_cache, new Map(), "f");
+        __classPrivateFieldSet(this, _LRUCache_max_size, (0, isIntegerAbove_1.default)(max_size, 0) ? max_size : 100, "f");
+    }
+    get max_size() {
+        return __classPrivateFieldGet(this, _LRUCache_max_size, "f");
+    }
+    set max_size(max_size) {
+        if (!(0, isIntegerAbove_1.default)(max_size, 0))
+            throw new Error('max_size must be a positive integer');
+        __classPrivateFieldSet(this, _LRUCache_max_size, max_size, "f");
+        if (__classPrivateFieldGet(this, _LRUCache_cache, "f").size > max_size) {
+            const excess = __classPrivateFieldGet(this, _LRUCache_cache, "f").size - max_size;
+            const keys = [...__classPrivateFieldGet(this, _LRUCache_cache, "f").keys()];
+            for (let i = 0; i < excess; i++) {
+                __classPrivateFieldGet(this, _LRUCache_cache, "f").delete(keys[i]);
+            }
+        }
+    }
+    has(key) {
+        return __classPrivateFieldGet(this, _LRUCache_cache, "f").has(key);
+    }
+    get(key) {
+        const value = __classPrivateFieldGet(this, _LRUCache_cache, "f").get(key);
+        if (value === undefined)
+            return undefined;
+        __classPrivateFieldGet(this, _LRUCache_cache, "f").delete(key);
+        __classPrivateFieldGet(this, _LRUCache_cache, "f").set(key, value);
+        return value;
+    }
+    set(key, value) {
+        if (__classPrivateFieldGet(this, _LRUCache_cache, "f").has(key)) {
+            __classPrivateFieldGet(this, _LRUCache_cache, "f").delete(key);
+        }
+        else if (__classPrivateFieldGet(this, _LRUCache_cache, "f").size >= this.max_size) {
+            __classPrivateFieldGet(this, _LRUCache_cache, "f").delete(__classPrivateFieldGet(this, _LRUCache_cache, "f").keys().next().value);
+        }
+        __classPrivateFieldGet(this, _LRUCache_cache, "f").set(key, value);
+    }
+    del(key) {
+        if (key === undefined || !__classPrivateFieldGet(this, _LRUCache_cache, "f").has(key))
+            return;
+        __classPrivateFieldGet(this, _LRUCache_cache, "f").delete(key);
+    }
+    clear() {
+        __classPrivateFieldGet(this, _LRUCache_cache, "f").clear();
+    }
+}
+exports.LRUCache = LRUCache;
+exports.default = LRUCache;
+_LRUCache_cache = new WeakMap(), _LRUCache_max_size = new WeakMap();

package/caching/index.d.ts

@@ -1,2 +1,3 @@
+import { LRUCache } from './LRU';
 import { memoize } from './memoize';
-export { memoize };
+export { LRUCache, LRUCache as LRU, memoize };

package/caching/index.js

@@ -1,5 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.memoize = void 0;
+exports.memoize = exports.LRU = exports.LRUCache = void 0;
+const LRU_1 = require("./LRU");
+Object.defineProperty(exports, "LRUCache", { enumerable: true, get: function () { return LRU_1.LRUCache; } });
+Object.defineProperty(exports, "LRU", { enumerable: true, get: function () { return LRU_1.LRUCache; } });
 const memoize_1 = require("./memoize");
 Object.defineProperty(exports, "memoize", { enumerable: true, get: function () { return memoize_1.memoize; } });

package/caching/memoize.d.ts

@@ -6,7 +6,8 @@
  *
  * @param fn - Function to memoize
  * @param resolver - Optional resolver function to generate cache key. If not passed the first argument is used as map key
- * @param {false|number?} memoize_for - Memoize for X milliseconds, if passed false will indefinitely memoize (default = false)
+ * @param {false|number?} cache_duration_ms - Memoize for X milliseconds, if passed false will indefinitely memoize (default = false)
+ * @param {number?} cache_max_size - Memoize at max X entries, defaults to 100
  */
-declare function memoize<T extends (...args: any[]) => unknown>(fn: T, resolver?: (...args: Parameters<T>) => any, memoize_for?: number | false): T;
+declare 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 };

package/caching/memoize.js

@@ -4,40 +4,34 @@ exports.memoize = memoize;
 exports.default = memoize;
 const isAsync_1 = require("../function/isAsync");
 const isIntegerAbove_1 = require("../number/isIntegerAbove");
-const toUTC_1 = require("../date/toUTC");
-const diff_1 = require("../date/diff");
-function memoize(fn, resolver, memoize_for = false) {
-    const cache_for = (0, isIntegerAbove_1.default)(memoize_for, 0) ? memoize_for : false;
-    if ((0, isAsync_1.default)(fn)) {
-        const memoized = async function (...args) {
-            const key = typeof resolver === 'function' ? resolver(...args) : args[0];
-            if (memoized.cache.has(key)) {
-                const cached_val = memoized.cache.get(key);
-                if (cache_for === false || (0, diff_1.default)((0, toUTC_1.default)(new Date()), cached_val.d) < cache_for) {
-                    return cached_val.r;
-                }
+const LRU_1 = require("./LRU");
+function memoize(fn, resolver, cache_duration_ms = false, cache_max_size = 100) {
+    const cache_duration = (0, isIntegerAbove_1.default)(cache_duration_ms, 0) ? cache_duration_ms : false;
+    const cache = new LRU_1.default({ max_size: cache_max_size });
+    const isResolverFn = typeof resolver === 'function';
+    const memoized = (0, isAsync_1.default)(fn)
+        ? async function (...args) {
+            const key = isResolverFn ? resolver(...args) : args[0];
+            const cached_val = cache.get(key);
+            const now = Date.now();
+            if (cached_val !== undefined && (cache_duration === false || (now - cached_val.ts) < cache_duration)) {
+                return cached_val.r;
             }
             const result = await fn(...args);
-            memoized.cache.set(key, { r: result, d: (0, toUTC_1.default)(new Date()) });
+            cache.set(key, { r: result, ts: now });
             return result;
-        };
-        memoized.cache = new Map();
-        return memoized;
-    }
-    else {
-        const memoized = function (...args) {
-            const key = typeof resolver === 'function' ? resolver(...args) : args[0];
-            if (memoized.cache.has(key)) {
-                const cached_val = memoized.cache.get(key);
-                if (cache_for === false || (0, diff_1.default)((0, toUTC_1.default)(new Date()), cached_val.d) < cache_for) {
-                    return cached_val.r;
-                }
+        }
+        : function (...args) {
+            const key = isResolverFn ? resolver(...args) : args[0];
+            const cached_val = cache.get(key);
+            const now = Date.now();
+            if (cached_val !== undefined && (cache_duration === false || (now - cached_val.ts) < cache_duration)) {
+                return cached_val.r;
             }
             const result = fn(...args);
-            memoized.cache.set(key, { r: result, d: (0, toUTC_1.default)(new Date()) });
+            cache.set(key, { r: result, ts: now });
             return result;
         };
-        memoized.cache = new Map();
-        return memoized;
-    }
+    memoized.cache = cache;
+    return memoized;
 }

package/date/format.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.format = format;
 exports.default = format;
 const convertToDate_1 = require("./convertToDate");
+const LRU_1 = require("../caching/LRU");
 const WEEK_STARTS = {
     mon: 'mon',
     sun: 'sun',
@@ -21,9 +22,9 @@ finally {
         DEFAULT_TZ = 'UTC';
 }
 const ESCAPE_RGX = /\[[\s\S]+?]/g;
-const intl_formatters = Object.create(null);
-const spec_cache = Object.create(null);
-const zone_offset_cache = Object.create(null);
+const intl_formatters = new LRU_1.default({ max_size: 100 });
+const spec_cache = new LRU_1.default({ max_size: 100 });
+const zone_offset_cache = new LRU_1.default({ max_size: 100 });
 function WeekNr(d, sow) {
     switch (sow) {
         case 'sun':
@@ -55,8 +56,9 @@ function toZone(d, zone) {
     for (let i = 0; i <= month; i++)
         doy += daysInMonths[i];
     const ckey = zone + ':' + year + ':' + doy;
-    if (zone_offset_cache[ckey] !== undefined)
-        return new Date(time + zone_offset_cache[ckey]);
+    const cached = zone_offset_cache.get(ckey);
+    if (cached !== undefined)
+        return new Date(time + cached);
     let zone_time = null;
     try {
         zone_time = new Date(d.toLocaleString(DEFAULT_LOCALE, { timeZone: zone })).getTime() + d.getMilliseconds();
@@ -65,16 +67,16 @@ function toZone(d, zone) {
         throw new Error(`format: Invalid zone passed - ${zone}`);
     }
     const offset = zone_time - time;
-    zone_offset_cache[ckey] = offset;
+    zone_offset_cache.set(ckey, offset);
     return new Date(time + offset);
 }
 function runIntl(loc, token, props, val) {
     const hash = loc + ':' + token;
-    let formatter = intl_formatters[hash];
+    let formatter = intl_formatters.get(hash);
     if (!formatter) {
         try {
             formatter = new Intl.DateTimeFormat(loc, props);
-            intl_formatters[hash] = formatter;
+            intl_formatters.set(hash, formatter);
         }
         catch {
             throw new Error(`format: Failed to run conversion for ${token} with locale ${loc}`);
@@ -142,8 +144,9 @@ const Tokens = [
     .map(el => [el[0], el[1], el[0].length])
     .sort((a, b) => a[0].length > b[0].length ? -1 : 1);
 function getSpecChain(spec) {
-    if (spec_cache[spec] !== undefined)
-        return spec_cache[spec];
+    const cached = spec_cache.get(spec);
+    if (cached !== undefined)
+        return cached;
     let base = spec;
     const repl = [];
     let repl_len = 0;
@@ -172,7 +175,7 @@ function getSpecChain(spec) {
     }
     const chain_len = chain.length;
     const result = chain_len ? { base, chain, chain_len, repl } : null;
-    spec_cache[spec] = result;
+    spec_cache.set(spec, result);
     return result;
 }
 function format(val, spec, locale = DEFAULT_LOCALE, zone = DEFAULT_TZ, sow = DEFAULT_SOW) {

package/date/isFormat.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.isDateFormat = isDateFormat;
 exports.default = isDateFormat;
+const LRU_1 = require("../caching/LRU");
 const SPECIAL_CHARS = /[.*+?^${}()|[\]\\]/g;
 const TOKENS = [
     ['YYYY', /\d{4}/.source, (raw, context) => {
@@ -47,10 +48,11 @@ const TOKENS = [
 const SPEC_ALIASES = {
     ISO: 'YYYY-MM-DDTHH:mm:ss{.SSS}Z',
 };
-const spec_pat_cache = {};
+const spec_pat_cache = new LRU_1.default({ max_size: 100 });
 function compileSpec(spec, is_chunk = false) {
-    if (spec in spec_pat_cache)
-        return spec_pat_cache[spec];
+    let cached = spec_pat_cache.get(spec);
+    if (cached !== undefined)
+        return cached;
     const tokens = [];
     let pat = '';
     let cursor = 0;
@@ -85,8 +87,9 @@ function compileSpec(spec, is_chunk = false) {
             }
         }
     }
-    spec_pat_cache[spec] = { rgx: is_chunk ? RegExp(pat) : RegExp('^' + pat + '$'), tokens };
-    return spec_pat_cache[spec];
+    cached = { rgx: is_chunk ? RegExp(pat) : RegExp('^' + pat + '$'), tokens };
+    spec_pat_cache.set(spec, cached);
+    return cached;
 }
 function isDateFormat(input, spec) {
     if (typeof input !== 'string' || input.trim().length === 0) {

package/index.d.ts

@@ -28,6 +28,7 @@ declare module "number/isIntegerAboveOrEqual" {
 declare module "array/join" {
     interface joinOptions {
         delim?: string;
+        dedupe?: boolean;
         trim?: boolean;
         innertrim?: boolean;
         valtrim?: boolean;
@@ -151,6 +152,27 @@ declare module "date/endOfUTC" {
     function endOfUTC(val: Date | string, key?: EndOfUTCKey): Date;
     export { endOfUTC, endOfUTC as default };
 }
+declare module "number/isIntegerAbove" {
+    function isIntegerAbove(val: unknown, ref: number): val is number;
+    export { isIntegerAbove, isIntegerAbove as default };
+}
+declare module "caching/LRU" {
+    export type LRUCacheOptions = {
+        max_size?: number;
+    };
+    class LRUCache<K, 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;
+        clear(): void;
+    }
+    export { LRUCache, LRUCache as default };
+}
 declare module "date/format" {
     const WEEK_STARTS: {
         readonly mon: "mon";
@@ -253,10 +275,6 @@ declare module "function/is" {
     function isFunction(val: unknown): val is (...args: unknown[]) => unknown;
     export { isFunction, isFunction as default };
 }
-declare module "number/isIntegerAbove" {
-    function isIntegerAbove(val: unknown, ref: number): val is number;
-    export { isIntegerAbove, isIntegerAbove as default };
-}
 declare module "function/debounce" {
     function debounce<T extends (...args: any[]) => any>(fn: T, wait: number): T & {
         cancel: () => void;
@@ -549,12 +567,13 @@ declare module "is" {
     export { Is, Is as default };
 }
 declare module "caching/memoize" {
-    function memoize<T extends (...args: any[]) => unknown>(fn: T, resolver?: (...args: Parameters<T>) => any, memoize_for?: number | false): T;
+    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 };
 }
 declare module "caching/index" {
+    import { LRUCache } from "caching/LRU";
     import { memoize } from "caching/memoize";
-    export { memoize };
+    export { LRUCache, LRUCache as LRU, memoize };
 }
 declare module "deep/freeze" {
     type deepInput = {

package/package.json

@@ -1 +1 @@
-{ "name": "@valkyriestudios/utils", "version": "12.27.1", "description": "A collection of single-function utilities for common tasks", "author": { "name": "Peter Vermeulen", "url": "https://www.linkedin.com/in/petervermeulen1/" }, "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.28.0", "description": "A collection of single-function utilities for common tasks", "author": { "name": "Peter Vermeulen", "url": "https://www.linkedin.com/in/petervermeulen1/" }, "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" }