@valkyriestudios/utils 12.42.0 → 12.43.0

package/README.md

@@ -239,7 +239,7 @@ const group = groupBy([
 **Take note**: any object without the key will be added to a fallback group called '_'
 
 
-### array/dedupe(val:Array, opts?:{filter_fn})
+### array/dedupe(val:Array, opts?:{key:string; filter_fn})
 Remove all duplicates from an array, behind the scenes it uses the fnv 1A hash algorithm to performantly do comparisons.
 ```typescript
 import dedupe from '@valkyriestudios/utils/array/dedupe';
@@ -251,6 +251,22 @@ dedupe(['hello', 'hello', 'world']); // ['hello', 'world']
 dedupe(['hello', 'hello', 'world', false, 'world'], {filter_fn: el => isNotEmptyString(el)}); // ['hello', 'world']
 ```
 
+Also supports deduping according to a specific `key`:
+```typescript
+import dedupe from '@valkyriestudios/utils/array/dedupe';
+
+const users = [
+  { id: 1, name: 'Alice' },
+  { id: 2, name: 'Bob' },
+  { id: 1, name: 'Alicia' }, // duplicate id
+];
+
+// Deduplicate by `id`
+const uniqueUsers = dedupe(users, { key: 'id' });
+console.log(uniqueUsers);
+// => [ { id: 1, name: "Alice" }, { id: 2, name: "Bob" } ]
+```
+
 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,dedupe:false})
@@ -978,15 +994,18 @@ import guid from '@valkyriestudios/utils/hash/guid';
 guid(); // 245caf1a-86af-11e7-bb31-be2e44b06b34
 ```
 
+### hash/djb2(val:unknown)
+Generate a djb2 hash from an object/array/primitive/...
+```typescript
+import djb2 from '@valkyriestudios/utils/hash/djb2';
+djb2('hello world');
+```
+
 ### hash/fnv1A(val:unknown)
-Generate a fnv1A hash from an object, using a 32-bit prime/offset
+Generate a fnv1A hash from an object/array/primitive/...
 ```typescript
 import fnv1A from '@valkyriestudios/utils/hash/fnv1A';
-fnv1A('hello world'); // -2023343616
-fnv1A({a:1,b:2}); // 361168128
-fnv1A(4); // 1630425728
-fnv1A(new RegExp(/ab+c/, 'i')); // 2131692544
-fnv1A(new Date('2012-02-02')); // 1655579136
+fnv1A('hello world');
 ```
 
 ### Is

package/array/dedupe.d.ts

@@ -1,14 +1,16 @@
-type DedupeOptions<T> = {
+type DedupeOptionsBase<T> = {
     /**
      * Pass a custom filter function which will be run in O(n) while deduping is going on
      */
     filter_fn?: (el: T) => boolean;
 };
-/**
- * Dedupes the provided array
- *
- * @param {Array} val - Array to dedupe
- * @param {DedupeOptions?} opts - Dedupe options
- */
-declare function dedupe<T>(val: T[], opts?: DedupeOptions<T>): T[];
+type DedupeOptionsWithKey<T extends Record<string, unknown>> = DedupeOptionsBase<T> & {
+    /**
+     * Deduplicate based on a single property key of T
+     */
+    key: keyof T;
+};
+type DedupeOptionsNoKey<T> = DedupeOptionsBase<T>;
+declare function dedupe<T extends Record<string, unknown>>(val: T[], opts: DedupeOptionsWithKey<T>): T[];
+declare function dedupe<T>(val: T[], opts?: DedupeOptionsNoKey<T>): T[];
 export { dedupe, dedupe as default };

package/array/is.d.ts

@@ -3,5 +3,5 @@
  *
  * @param {unknown} val - Value to verify
  */
-declare function isArray(val: unknown): val is unknown[];
+declare function isArray<T = unknown>(val: unknown): val is T[];
 export { isArray, isArray as default };

package/array/isNotEmpty.d.ts

@@ -3,5 +3,5 @@
  *
  * @param {unknown} val - Value to verify
  */
-declare function isNotEmptyArray(val: unknown): val is unknown[];
+declare function isNotEmptyArray<T = unknown>(val: unknown): val is T[];
 export { isNotEmptyArray, isNotEmptyArray as default };

package/caching/memoize.d.ts

@@ -2,7 +2,7 @@
  * Turn a function into a memoized function. An optional resolver function can be passed which allows custom cache key generation.
  *
  * Example:
- *  const memoized_function = memoize((a) => fnv1A(a));
+ *  const memoized_function = memoize((a) => djb2(a));
  *
  * @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

package/cjs/array/dedupe.js

@@ -2,53 +2,41 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dedupe = dedupe;
 exports.default = dedupe;
-const REPL_NAN = 'nan';
-const REPL_TRUE = 'true';
-const REPL_FALSE = 'false';
-const REPL_UNDEF = 'undefined';
-const REPL_NULL = 'null';
-function getTypeString(el) {
-    switch (typeof el) {
-        case 'string':
-            return el;
-        case 'number':
-            return Number.isNaN(el) || !Number.isFinite(el) ? REPL_NAN : String(el);
-        case 'boolean':
-            return el ? REPL_TRUE : REPL_FALSE;
-        case 'undefined':
-            return REPL_UNDEF;
-        case 'object':
-            if (el === null) {
-                return REPL_NULL;
-            }
-            else if (Array.isArray(el) || el.toString() === '[object Object]') {
-                return JSON.stringify(el);
-            }
-            else if (el instanceof RegExp) {
-                return el.toString();
-            }
-            else if (el instanceof Date) {
-                return String(el.getTime());
-            }
-    }
-    return '';
-}
+const utils_1 = require("../hash/utils");
 function dedupe(val, opts) {
     if (!Array.isArray(val))
         return [];
     const FILTER_FN = opts?.filter_fn;
+    const KEY = opts?.key;
     const set = new Set();
     const acc = [];
     let hash;
     const len = val.length;
-    for (let i = 0; i < len; i++) {
-        const el = val[i];
-        if (FILTER_FN && !FILTER_FN(el))
-            continue;
-        hash = getTypeString(el);
-        if (!set.has(hash)) {
-            set.add(hash);
-            acc.push(el);
+    if (KEY) {
+        const CUSTOM_FILTER_FN = typeof FILTER_FN === 'function'
+            ? (el) => el && Object.prototype.toString.call(el) === '[object Object]' && FILTER_FN(el)
+            : (el) => el && Object.prototype.toString.call(el) === '[object Object]';
+        for (let i = 0; i < len; i++) {
+            const el = val[i];
+            if (!CUSTOM_FILTER_FN(el))
+                continue;
+            hash = (0, utils_1.toString)(el[KEY]);
+            if (!set.has(hash)) {
+                set.add(hash);
+                acc.push(el);
+            }
+        }
+    }
+    else {
+        for (let i = 0; i < len; i++) {
+            const el = val[i];
+            if (FILTER_FN && !FILTER_FN(el))
+                continue;
+            hash = (0, utils_1.toString)(el);
+            if (!set.has(hash)) {
+                set.add(hash);
+                acc.push(el);
+            }
         }
     }
     return acc;

package/cjs/caching/memoize.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.memoize = memoize;
 exports.default = memoize;
 const isAsync_1 = __importDefault(require("../function/isAsync"));
-const fnv1A_1 = __importDefault(require("../hash/fnv1A"));
+const djb2_1 = __importDefault(require("../hash/djb2"));
 const isIntegerAbove_1 = __importDefault(require("../number/isIntegerAbove"));
 const LRU_1 = __importDefault(require("./LRU"));
 function memoize(fn, resolver, cache_duration_ms = false, cache_max_size = 100) {
@@ -16,7 +16,7 @@ function memoize(fn, resolver, cache_duration_ms = false, cache_max_size = 100)
     const memoized = (0, isAsync_1.default)(fn)
         ? async function (...args) {
             let key = isResolverFn ? resolver(...args) : args[0];
-            key = typeof key === 'string' ? key : Number.isFinite(key) ? String(key) : String((0, fnv1A_1.default)(key));
+            key = typeof key === 'string' ? key : Number.isFinite(key) ? String(key) : (0, djb2_1.default)(key);
             const cached_val = cache.get(key);
             const now = Date.now();
             if (cached_val !== undefined && (cache_duration === false || (now - cached_val.ts) < cache_duration)) {
@@ -28,7 +28,7 @@ function memoize(fn, resolver, cache_duration_ms = false, cache_max_size = 100)
         }
         : function (...args) {
             let key = isResolverFn ? resolver(...args) : args[0];
-            key = typeof key === 'string' ? key : Number.isFinite(key) ? String(key) : String((0, fnv1A_1.default)(key));
+            key = typeof key === 'string' ? key : Number.isFinite(key) ? String(key) : (0, djb2_1.default)(key);
             const cached_val = cache.get(key);
             const now = Date.now();
             if (cached_val !== undefined && (cache_duration === false || (now - cached_val.ts) < cache_duration)) {

package/cjs/hash/djb2.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.djb2 = djb2;
+exports.default = djb2;
+const utils_1 = require("./utils");
+function djb2(data) {
+    let hash = 5381;
+    const normalized = (0, utils_1.toString)(data);
+    const len = normalized.length;
+    for (let i = 0; i < len; i++) {
+        hash = ((hash << 5) + hash) ^ normalized.charCodeAt(i);
+    }
+    return String(hash >>> 0);
+}

package/cjs/hash/fnv1A.js

@@ -3,52 +3,15 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FNV_64 = exports.FNV_32 = void 0;
 exports.fnv1A = fnv1A;
 exports.default = fnv1A;
+const utils_1 = require("./utils");
 exports.FNV_32 = 2166136261;
-exports.FNV_64 = 1099511628211;
-const REPL_NAN = 'nan';
-const REPL_TRUE = 'true';
-const REPL_FALSE = 'false';
-const REPL_UNDEF = 'undefined';
-const REPL_NULL = 'null';
+exports.FNV_64 = 1099511628211n;
 function fnv1A(data, offset = exports.FNV_32) {
     let hash = offset;
-    let sanitized;
-    switch (typeof data) {
-        case 'string':
-            sanitized = data;
-            break;
-        case 'number':
-            sanitized = Number.isNaN(data) || !Number.isFinite(data) ? REPL_NAN : String(data);
-            break;
-        case 'boolean':
-            sanitized = data ? REPL_TRUE : REPL_FALSE;
-            break;
-        case 'undefined':
-            sanitized = REPL_UNDEF;
-            break;
-        case 'object':
-            if (data === null) {
-                sanitized = REPL_NULL;
-            }
-            else if (Array.isArray(data) || Object.prototype.toString.call(data) === '[object Object]') {
-                sanitized = JSON.stringify(data);
-            }
-            else if (data instanceof RegExp) {
-                sanitized = String(data);
-            }
-            else if (data instanceof Date) {
-                sanitized = String(data.getTime());
-            }
-            else {
-                throw new TypeError('An FNV1A Hash could not be calculated for this datatype');
-            }
-            break;
-        default:
-            throw new TypeError('An FNV1A Hash could not be calculated for this datatype');
-    }
-    const len = sanitized.length;
+    const normalized = (0, utils_1.toString)(data);
+    const len = normalized.length;
     for (let i = 0; i < len; i++) {
-        hash ^= sanitized.charCodeAt(i);
+        hash ^= normalized.charCodeAt(i);
         hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
     }
     return hash >>> 0;

package/cjs/hash/utils.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toString = toString;
+function toString(raw) {
+    switch (typeof raw) {
+        case 'string':
+            return raw;
+        case 'number':
+            return Number.isFinite(raw) ? String(raw) : 'nan';
+        case 'bigint':
+            return raw.toString();
+        case 'boolean':
+            return raw ? 'true' : 'false';
+        case 'undefined':
+            return 'undefined';
+        case 'object':
+            if (raw === null) {
+                return 'null';
+            }
+            else if (Array.isArray(raw) || Object.prototype.toString.call(raw) === '[object Object]') {
+                return JSON.stringify(raw);
+            }
+            else if (raw instanceof RegExp) {
+                return String(raw);
+            }
+            else if (raw instanceof Date) {
+                return String(raw.getTime());
+            }
+            else if (raw instanceof Error) {
+                return raw.name + '|' + raw.message;
+            }
+            else {
+                throw new TypeError('A Hash could not be calculated for this datatype');
+            }
+        case 'symbol':
+            return String(raw);
+        default:
+            throw new TypeError('A Hash could not be calculated for this datatype');
+    }
+}

package/esm/array/dedupe.js

@@ -1,50 +1,38 @@
-const REPL_NAN = 'nan';
-const REPL_TRUE = 'true';
-const REPL_FALSE = 'false';
-const REPL_UNDEF = 'undefined';
-const REPL_NULL = 'null';
-function getTypeString(el) {
-    switch (typeof el) {
-        case 'string':
-            return el;
-        case 'number':
-            return Number.isNaN(el) || !Number.isFinite(el) ? REPL_NAN : String(el);
-        case 'boolean':
-            return el ? REPL_TRUE : REPL_FALSE;
-        case 'undefined':
-            return REPL_UNDEF;
-        case 'object':
-            if (el === null) {
-                return REPL_NULL;
-            }
-            else if (Array.isArray(el) || el.toString() === '[object Object]') {
-                return JSON.stringify(el);
-            }
-            else if (el instanceof RegExp) {
-                return el.toString();
-            }
-            else if (el instanceof Date) {
-                return String(el.getTime());
-            }
-    }
-    return '';
-}
+import { toString } from '../hash/utils';
 function dedupe(val, opts) {
     if (!Array.isArray(val))
         return [];
     const FILTER_FN = opts?.filter_fn;
+    const KEY = opts?.key;
     const set = new Set();
     const acc = [];
     let hash;
     const len = val.length;
-    for (let i = 0; i < len; i++) {
-        const el = val[i];
-        if (FILTER_FN && !FILTER_FN(el))
-            continue;
-        hash = getTypeString(el);
-        if (!set.has(hash)) {
-            set.add(hash);
-            acc.push(el);
+    if (KEY) {
+        const CUSTOM_FILTER_FN = typeof FILTER_FN === 'function'
+            ? (el) => el && Object.prototype.toString.call(el) === '[object Object]' && FILTER_FN(el)
+            : (el) => el && Object.prototype.toString.call(el) === '[object Object]';
+        for (let i = 0; i < len; i++) {
+            const el = val[i];
+            if (!CUSTOM_FILTER_FN(el))
+                continue;
+            hash = toString(el[KEY]);
+            if (!set.has(hash)) {
+                set.add(hash);
+                acc.push(el);
+            }
+        }
+    }
+    else {
+        for (let i = 0; i < len; i++) {
+            const el = val[i];
+            if (FILTER_FN && !FILTER_FN(el))
+                continue;
+            hash = toString(el);
+            if (!set.has(hash)) {
+                set.add(hash);
+                acc.push(el);
+            }
         }
     }
     return acc;

package/esm/caching/memoize.js

@@ -1,5 +1,5 @@
 import isAsyncFunction from '../function/isAsync';
-import fnv1A from '../hash/fnv1A';
+import djb2 from '../hash/djb2';
 import isIntegerGt from '../number/isIntegerAbove';
 import LRU from './LRU';
 function memoize(fn, resolver, cache_duration_ms = false, cache_max_size = 100) {
@@ -9,7 +9,7 @@ function memoize(fn, resolver, cache_duration_ms = false, cache_max_size = 100)
     const memoized = isAsyncFunction(fn)
         ? async function (...args) {
             let key = isResolverFn ? resolver(...args) : args[0];
-            key = typeof key === 'string' ? key : Number.isFinite(key) ? String(key) : String(fnv1A(key));
+            key = typeof key === 'string' ? key : Number.isFinite(key) ? String(key) : djb2(key);
             const cached_val = cache.get(key);
             const now = Date.now();
             if (cached_val !== undefined && (cache_duration === false || (now - cached_val.ts) < cache_duration)) {
@@ -21,7 +21,7 @@ function memoize(fn, resolver, cache_duration_ms = false, cache_max_size = 100)
         }
         : function (...args) {
             let key = isResolverFn ? resolver(...args) : args[0];
-            key = typeof key === 'string' ? key : Number.isFinite(key) ? String(key) : String(fnv1A(key));
+            key = typeof key === 'string' ? key : Number.isFinite(key) ? String(key) : djb2(key);
             const cached_val = cache.get(key);
             const now = Date.now();
             if (cached_val !== undefined && (cache_duration === false || (now - cached_val.ts) < cache_duration)) {

package/esm/hash/djb2.js

@@ -0,0 +1,11 @@
+import { toString } from './utils';
+function djb2(data) {
+    let hash = 5381;
+    const normalized = toString(data);
+    const len = normalized.length;
+    for (let i = 0; i < len; i++) {
+        hash = ((hash << 5) + hash) ^ normalized.charCodeAt(i);
+    }
+    return String(hash >>> 0);
+}
+export { djb2, djb2 as default };

package/esm/hash/fnv1A.js

@@ -1,49 +1,12 @@
+import { toString } from './utils';
 export const FNV_32 = 2166136261;
-export const FNV_64 = 1099511628211;
-const REPL_NAN = 'nan';
-const REPL_TRUE = 'true';
-const REPL_FALSE = 'false';
-const REPL_UNDEF = 'undefined';
-const REPL_NULL = 'null';
+export const FNV_64 = 1099511628211n;
 function fnv1A(data, offset = FNV_32) {
     let hash = offset;
-    let sanitized;
-    switch (typeof data) {
-        case 'string':
-            sanitized = data;
-            break;
-        case 'number':
-            sanitized = Number.isNaN(data) || !Number.isFinite(data) ? REPL_NAN : String(data);
-            break;
-        case 'boolean':
-            sanitized = data ? REPL_TRUE : REPL_FALSE;
-            break;
-        case 'undefined':
-            sanitized = REPL_UNDEF;
-            break;
-        case 'object':
-            if (data === null) {
-                sanitized = REPL_NULL;
-            }
-            else if (Array.isArray(data) || Object.prototype.toString.call(data) === '[object Object]') {
-                sanitized = JSON.stringify(data);
-            }
-            else if (data instanceof RegExp) {
-                sanitized = String(data);
-            }
-            else if (data instanceof Date) {
-                sanitized = String(data.getTime());
-            }
-            else {
-                throw new TypeError('An FNV1A Hash could not be calculated for this datatype');
-            }
-            break;
-        default:
-            throw new TypeError('An FNV1A Hash could not be calculated for this datatype');
-    }
-    const len = sanitized.length;
+    const normalized = toString(data);
+    const len = normalized.length;
     for (let i = 0; i < len; i++) {
-        hash ^= sanitized.charCodeAt(i);
+        hash ^= normalized.charCodeAt(i);
         hash += (hash << 1) + (hash << 4) + (hash << 7) + (hash << 8) + (hash << 24);
     }
     return hash >>> 0;

package/esm/hash/utils.js

@@ -0,0 +1,37 @@
+export function toString(raw) {
+    switch (typeof raw) {
+        case 'string':
+            return raw;
+        case 'number':
+            return Number.isFinite(raw) ? String(raw) : 'nan';
+        case 'bigint':
+            return raw.toString();
+        case 'boolean':
+            return raw ? 'true' : 'false';
+        case 'undefined':
+            return 'undefined';
+        case 'object':
+            if (raw === null) {
+                return 'null';
+            }
+            else if (Array.isArray(raw) || Object.prototype.toString.call(raw) === '[object Object]') {
+                return JSON.stringify(raw);
+            }
+            else if (raw instanceof RegExp) {
+                return String(raw);
+            }
+            else if (raw instanceof Date) {
+                return String(raw.getTime());
+            }
+            else if (raw instanceof Error) {
+                return raw.name + '|' + raw.message;
+            }
+            else {
+                throw new TypeError('A Hash could not be calculated for this datatype');
+            }
+        case 'symbol':
+            return String(raw);
+        default:
+            throw new TypeError('A Hash could not be calculated for this datatype');
+    }
+}

package/hash/djb2.d.ts

@@ -0,0 +1,7 @@
+/**
+ * DJB2 Hash implementation
+ *
+ * @param {unknown} data - Value to hash
+ */
+declare function djb2(data: unknown): string;
+export { djb2, djb2 as default };

package/hash/fnv1A.d.ts

@@ -1,5 +1,5 @@
 export declare const FNV_32 = 2166136261;
-export declare const FNV_64 = 1099511628211;
+export declare const FNV_64 = 1099511628211n;
 /**
  * Convert a provided value into a Fowler-Noll-Vo 1A hash
  * For more info: https://tools.ietf.org/html/draft-eastlake-fnv-03

package/hash/utils.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Convert data to a format that is hashable
+ *
+ * @param {unknown} raw - Value to be converted
+ */
+export declare function toString(raw: unknown): string;

package/index.d.ts

@@ -2,11 +2,19 @@ declare module "equal" {
     function equal(a: any, b: any): boolean;
     export { equal, equal as default };
 }
+declare module "hash/utils" {
+    export function toString(raw: unknown): string;
+}
 declare module "array/dedupe" {
-    type DedupeOptions<T> = {
+    type DedupeOptionsBase<T> = {
         filter_fn?: (el: T) => boolean;
     };
-    function dedupe<T>(val: T[], opts?: DedupeOptions<T>): T[];
+    type DedupeOptionsWithKey<T extends Record<string, unknown>> = DedupeOptionsBase<T> & {
+        key: keyof T;
+    };
+    type DedupeOptionsNoKey<T> = DedupeOptionsBase<T>;
+    function dedupe<T extends Record<string, unknown>>(val: T[], opts: DedupeOptionsWithKey<T>): T[];
+    function dedupe<T>(val: T[], opts?: DedupeOptionsNoKey<T>): T[];
     export { dedupe, dedupe as default };
 }
 declare module "number/round" {
@@ -91,7 +99,7 @@ declare module "array/mapPrimitive" {
     export { mapPrimitive, mapPrimitive as default };
 }
 declare module "object/isNotEmpty" {
-    function isNotEmptyObject<T extends Record<string, any>>(val: T | unknown): val is T;
+    function isNotEmptyObject<T extends Record<string, unknown> = Record<string, unknown>>(val: T | unknown): val is T;
     export { isNotEmptyObject, isNotEmptyObject as default };
 }
 declare module "array/groupBy" {
@@ -111,7 +119,7 @@ declare module "array/split" {
     export { split, split as default };
 }
 declare module "object/is" {
-    function isObject<T extends Record<string, any>>(val: T | unknown): val is T;
+    function isObject<T extends Record<string, unknown> = Record<string, unknown>>(val: T | unknown): val is T;
     export { isObject, isObject as default };
 }
 declare module "array/sort" {
@@ -127,11 +135,11 @@ declare module "array/sort" {
     export { sort, sort as default };
 }
 declare module "array/is" {
-    function isArray(val: unknown): val is unknown[];
+    function isArray<T = unknown>(val: unknown): val is T[];
     export { isArray, isArray as default };
 }
 declare module "array/isNotEmpty" {
-    function isNotEmptyArray(val: unknown): val is unknown[];
+    function isNotEmptyArray<T = unknown>(val: unknown): val is T[];
     export { isNotEmptyArray, isNotEmptyArray as default };
 }
 declare module "array/index" {
@@ -635,11 +643,9 @@ 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 "hash/djb2" {
+    function djb2(data: unknown): string;
+    export { djb2, djb2 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;
@@ -692,6 +698,12 @@ 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 = 1099511628211n;
+    function fnv1A(data: unknown, offset?: number): number;
+    export { fnv1A, fnv1A as default };
+}
 declare module "hash/guid" {
     function guid(): string;
     export { guid, guid as default };

package/object/is.d.ts

@@ -3,5 +3,5 @@
  *
  * @param {unknown} val - Value to verify
  */
-declare function isObject<T extends Record<string, any>>(val: T | unknown): val is T;
+declare function isObject<T extends Record<string, unknown> = Record<string, unknown>>(val: T | unknown): val is T;
 export { isObject, isObject as default };

package/object/isNotEmpty.d.ts

@@ -3,5 +3,5 @@
  *
  * @param {unknown} val - Value to verify
  */
-declare function isNotEmptyObject<T extends Record<string, any>>(val: T | unknown): val is T;
+declare function isNotEmptyObject<T extends Record<string, unknown> = Record<string, unknown>>(val: T | unknown): val is T;
 export { isNotEmptyObject, isNotEmptyObject as default };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@valkyriestudios/utils",
-    "version": "12.42.0",
+    "version": "12.43.0",
     "description": "A collection of single-function utilities for common tasks",
     "author": {
         "name": "Peter Vermeulen",
@@ -514,12 +514,12 @@
         }
     },
     "devDependencies": {
-        "@types/node": "^22.15.31",
-        "@vitest/coverage-v8": "^3.2.3",
+        "@types/node": "^22.18.0",
+        "@vitest/coverage-v8": "^3.2.4",
         "esbuild-register": "^3.6.0",
-        "eslint": "^9.29.0",
-        "typescript": "^5.8.3",
-        "typescript-eslint": "^8.34.0",
-        "vitest": "^3.2.3"
+        "eslint": "^9.34.0",
+        "typescript": "^5.9.2",
+        "typescript-eslint": "^8.41.0",
+        "vitest": "^3.2.4"
     }
 }