@fjell/cache 4.6.5 → 4.6.7

package/dist/Cache.cjs.js

@@ -8,6 +8,45 @@ const logger$1 = require('./logger.cjs.js');
 const httpApi = require('@fjell/http-api');
 
 const logger = logger$1.default.get('Cache');
+// Normalize a key value to string for consistent comparison
+const normalizeKeyValue = (value)=>{
+    return String(value);
+};
+// Normalized key comparison function that handles string/number differences
+const isItemKeyEqualNormalized = (a, b)=>{
+    // For now, just normalize the keys to strings and use the original comparison
+    const normalizedA = normalizeKey(a);
+    const normalizedB = normalizeKey(b);
+    return core.isItemKeyEqual(normalizedA, normalizedB);
+};
+// Helper function to normalize a key
+const normalizeKey = (key)=>{
+    if (typeof key === 'object' && key !== null) {
+        const normalizedKey = JSON.parse(JSON.stringify(key));
+        // Normalize pk values
+        if ('pk' in normalizedKey && normalizedKey.pk !== null) {
+            normalizedKey.pk = normalizeKeyValue(normalizedKey.pk);
+        }
+        // Normalize lk values
+        if ('lk' in normalizedKey && normalizedKey.lk !== null) {
+            normalizedKey.lk = normalizeKeyValue(normalizedKey.lk);
+        }
+        // Normalize loc array lk values
+        if ('loc' in normalizedKey && Array.isArray(normalizedKey.loc)) {
+            normalizedKey.loc = normalizedKey.loc.map((locItem)=>{
+                if (locItem && 'lk' in locItem && locItem.lk !== null) {
+                    return {
+                        ...locItem,
+                        lk: normalizeKeyValue(locItem.lk)
+                    };
+                }
+                return locItem;
+            });
+        }
+        return normalizedKey;
+    }
+    return key;
+};
 const createCache = async (api, pkType, parentCache)=>{
     let pkTypes = [
         pkType
@@ -284,7 +323,7 @@ const createCache = async (api, pkType, parentCache)=>{
         }
         // TODO: This could be merged with the isValidItemKey check, later.
         core.validatePK(v, pkType);
-        if (!core.isItemKeyEqual(key, v.key)) {
+        if (!isItemKeyEqualNormalized(key, v.key)) {
             logger.error('Key does not match item key: %j != %j', key, v.key);
             throw new Error('Key does not match item key');
         }
@@ -316,4 +355,4 @@ const createCache = async (api, pkType, parentCache)=>{
 };
 
 exports.createCache = createCache;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGUuY2pzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGUuY2pzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/Cache.es.js

@@ -4,6 +4,45 @@ import LibLogger from './logger.es.js';
 import { NotFoundError } from '@fjell/http-api';
 
 const logger = LibLogger.get('Cache');
+// Normalize a key value to string for consistent comparison
+const normalizeKeyValue = (value)=>{
+    return String(value);
+};
+// Normalized key comparison function that handles string/number differences
+const isItemKeyEqualNormalized = (a, b)=>{
+    // For now, just normalize the keys to strings and use the original comparison
+    const normalizedA = normalizeKey(a);
+    const normalizedB = normalizeKey(b);
+    return isItemKeyEqual(normalizedA, normalizedB);
+};
+// Helper function to normalize a key
+const normalizeKey = (key)=>{
+    if (typeof key === 'object' && key !== null) {
+        const normalizedKey = JSON.parse(JSON.stringify(key));
+        // Normalize pk values
+        if ('pk' in normalizedKey && normalizedKey.pk !== null) {
+            normalizedKey.pk = normalizeKeyValue(normalizedKey.pk);
+        }
+        // Normalize lk values
+        if ('lk' in normalizedKey && normalizedKey.lk !== null) {
+            normalizedKey.lk = normalizeKeyValue(normalizedKey.lk);
+        }
+        // Normalize loc array lk values
+        if ('loc' in normalizedKey && Array.isArray(normalizedKey.loc)) {
+            normalizedKey.loc = normalizedKey.loc.map((locItem)=>{
+                if (locItem && 'lk' in locItem && locItem.lk !== null) {
+                    return {
+                        ...locItem,
+                        lk: normalizeKeyValue(locItem.lk)
+                    };
+                }
+                return locItem;
+            });
+        }
+        return normalizedKey;
+    }
+    return key;
+};
 const createCache = async (api, pkType, parentCache)=>{
     let pkTypes = [
         pkType
@@ -280,7 +319,7 @@ const createCache = async (api, pkType, parentCache)=>{
         }
         // TODO: This could be merged with the isValidItemKey check, later.
         validatePK(v, pkType);
-        if (!isItemKeyEqual(key, v.key)) {
+        if (!isItemKeyEqualNormalized(key, v.key)) {
             logger.error('Key does not match item key: %j != %j', key, v.key);
             throw new Error('Key does not match item key');
         }
@@ -312,4 +351,4 @@ const createCache = async (api, pkType, parentCache)=>{
 };
 
 export { createCache };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGUuZXMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGUuZXMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/CacheMap.cjs.js

@@ -19,6 +19,68 @@ function _define_property(obj, key, value) {
     return obj;
 }
 const logger = logger$1.default.get("CacheMap");
+// Normalize a key value to string for consistent comparison and hashing
+const normalizeKeyValue = (value)=>{
+    return String(value);
+};
+// Normalized hash function for Dictionary that converts pk/lk values to strings
+const createNormalizedHashFunction = ()=>{
+    return (key)=>{
+        if (typeof key === 'object' && key !== null) {
+            // Create a normalized version of the key with string values
+            const normalizedKey = JSON.parse(JSON.stringify(key));
+            // Normalize pk values
+            if ('pk' in normalizedKey && normalizedKey.pk !== null) {
+                normalizedKey.pk = normalizeKeyValue(normalizedKey.pk);
+            }
+            // Normalize lk values
+            if ('lk' in normalizedKey && normalizedKey.lk !== null) {
+                normalizedKey.lk = normalizeKeyValue(normalizedKey.lk);
+            }
+            // Normalize loc array lk values
+            if ('loc' in normalizedKey && Array.isArray(normalizedKey.loc)) {
+                normalizedKey.loc = normalizedKey.loc.map((locItem)=>{
+                    if (locItem && 'lk' in locItem && locItem.lk !== null) {
+                        return {
+                            ...locItem,
+                            lk: normalizeKeyValue(locItem.lk)
+                        };
+                    }
+                    return locItem;
+                });
+            }
+            return JSON.stringify(normalizedKey);
+        }
+        return JSON.stringify(key);
+    };
+};
+// Helper function to normalize and compare location key arrays
+const isLocKeyArrayEqual = (a, b)=>{
+    if (a.length !== b.length) {
+        return false;
+    }
+    for(let i = 0; i < a.length; i++){
+        const normalizedA = normalizeLocKeyItem(a[i]);
+        const normalizedB = normalizeLocKeyItem(b[i]);
+        if (JSON.stringify(normalizedA) !== JSON.stringify(normalizedB)) {
+            return false;
+        }
+    }
+    return true;
+};
+// Helper function to normalize a location key item
+const normalizeLocKeyItem = (item)=>{
+    if (typeof item === 'object' && item !== null) {
+        const normalized = {
+            ...item
+        };
+        if ('lk' in normalized && normalized.lk !== null) {
+            normalized.lk = normalizeKeyValue(normalized.lk);
+        }
+        return normalized;
+    }
+    return item;
+};
 // const isObj = (x: any) => typeof x === "object" && x !== null;
 // const intersection = (a: object, b: object): object => {
 //   const result: { [key: string]: any } = {}
@@ -73,7 +135,7 @@ class CacheMap extends core.Dictionary {
                     locKeys,
                     ComKey
                 });
-                return JSON.stringify(locKeys) === JSON.stringify(ComKey.loc);
+                return isLocKeyArrayEqual(locKeys, ComKey.loc);
             }).map((key)=>this.get(key));
         }
     }
@@ -99,10 +161,10 @@ class CacheMap extends core.Dictionary {
         return clone;
     }
     constructor(types, map){
-        super(map), _define_property(this, "types", void 0);
+        super(map, createNormalizedHashFunction()), _define_property(this, "types", void 0);
         this.types = types;
     }
 }
 
 exports.CacheMap = CacheMap;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGVNYXAuY2pzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGVNYXAuY2pzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/CacheMap.es.js

@@ -15,6 +15,68 @@ function _define_property(obj, key, value) {
     return obj;
 }
 const logger = LibLogger.get("CacheMap");
+// Normalize a key value to string for consistent comparison and hashing
+const normalizeKeyValue = (value)=>{
+    return String(value);
+};
+// Normalized hash function for Dictionary that converts pk/lk values to strings
+const createNormalizedHashFunction = ()=>{
+    return (key)=>{
+        if (typeof key === 'object' && key !== null) {
+            // Create a normalized version of the key with string values
+            const normalizedKey = JSON.parse(JSON.stringify(key));
+            // Normalize pk values
+            if ('pk' in normalizedKey && normalizedKey.pk !== null) {
+                normalizedKey.pk = normalizeKeyValue(normalizedKey.pk);
+            }
+            // Normalize lk values
+            if ('lk' in normalizedKey && normalizedKey.lk !== null) {
+                normalizedKey.lk = normalizeKeyValue(normalizedKey.lk);
+            }
+            // Normalize loc array lk values
+            if ('loc' in normalizedKey && Array.isArray(normalizedKey.loc)) {
+                normalizedKey.loc = normalizedKey.loc.map((locItem)=>{
+                    if (locItem && 'lk' in locItem && locItem.lk !== null) {
+                        return {
+                            ...locItem,
+                            lk: normalizeKeyValue(locItem.lk)
+                        };
+                    }
+                    return locItem;
+                });
+            }
+            return JSON.stringify(normalizedKey);
+        }
+        return JSON.stringify(key);
+    };
+};
+// Helper function to normalize and compare location key arrays
+const isLocKeyArrayEqual = (a, b)=>{
+    if (a.length !== b.length) {
+        return false;
+    }
+    for(let i = 0; i < a.length; i++){
+        const normalizedA = normalizeLocKeyItem(a[i]);
+        const normalizedB = normalizeLocKeyItem(b[i]);
+        if (JSON.stringify(normalizedA) !== JSON.stringify(normalizedB)) {
+            return false;
+        }
+    }
+    return true;
+};
+// Helper function to normalize a location key item
+const normalizeLocKeyItem = (item)=>{
+    if (typeof item === 'object' && item !== null) {
+        const normalized = {
+            ...item
+        };
+        if ('lk' in normalized && normalized.lk !== null) {
+            normalized.lk = normalizeKeyValue(normalized.lk);
+        }
+        return normalized;
+    }
+    return item;
+};
 // const isObj = (x: any) => typeof x === "object" && x !== null;
 // const intersection = (a: object, b: object): object => {
 //   const result: { [key: string]: any } = {}
@@ -69,7 +131,7 @@ class CacheMap extends Dictionary {
                     locKeys,
                     ComKey
                 });
-                return JSON.stringify(locKeys) === JSON.stringify(ComKey.loc);
+                return isLocKeyArrayEqual(locKeys, ComKey.loc);
             }).map((key)=>this.get(key));
         }
     }
@@ -95,10 +157,10 @@ class CacheMap extends Dictionary {
         return clone;
     }
     constructor(types, map){
-        super(map), _define_property(this, "types", void 0);
+        super(map, createNormalizedHashFunction()), _define_property(this, "types", void 0);
         this.types = types;
     }
 }
 
 export { CacheMap };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGVNYXAuZXMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiQ2FjaGVNYXAuZXMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/index.cjs

@@ -329,6 +329,68 @@ function _define_property$1(obj, key, value) {
     return obj;
 }
 const logger$2 = LibLogger.get("CacheMap");
+// Normalize a key value to string for consistent comparison and hashing
+const normalizeKeyValue$1 = (value)=>{
+    return String(value);
+};
+// Normalized hash function for Dictionary that converts pk/lk values to strings
+const createNormalizedHashFunction = ()=>{
+    return (key)=>{
+        if (typeof key === 'object' && key !== null) {
+            // Create a normalized version of the key with string values
+            const normalizedKey = JSON.parse(JSON.stringify(key));
+            // Normalize pk values
+            if ('pk' in normalizedKey && normalizedKey.pk !== null) {
+                normalizedKey.pk = normalizeKeyValue$1(normalizedKey.pk);
+            }
+            // Normalize lk values
+            if ('lk' in normalizedKey && normalizedKey.lk !== null) {
+                normalizedKey.lk = normalizeKeyValue$1(normalizedKey.lk);
+            }
+            // Normalize loc array lk values
+            if ('loc' in normalizedKey && Array.isArray(normalizedKey.loc)) {
+                normalizedKey.loc = normalizedKey.loc.map((locItem)=>{
+                    if (locItem && 'lk' in locItem && locItem.lk !== null) {
+                        return {
+                            ...locItem,
+                            lk: normalizeKeyValue$1(locItem.lk)
+                        };
+                    }
+                    return locItem;
+                });
+            }
+            return JSON.stringify(normalizedKey);
+        }
+        return JSON.stringify(key);
+    };
+};
+// Helper function to normalize and compare location key arrays
+const isLocKeyArrayEqual = (a, b)=>{
+    if (a.length !== b.length) {
+        return false;
+    }
+    for(let i = 0; i < a.length; i++){
+        const normalizedA = normalizeLocKeyItem(a[i]);
+        const normalizedB = normalizeLocKeyItem(b[i]);
+        if (JSON.stringify(normalizedA) !== JSON.stringify(normalizedB)) {
+            return false;
+        }
+    }
+    return true;
+};
+// Helper function to normalize a location key item
+const normalizeLocKeyItem = (item)=>{
+    if (typeof item === 'object' && item !== null) {
+        const normalized = {
+            ...item
+        };
+        if ('lk' in normalized && normalized.lk !== null) {
+            normalized.lk = normalizeKeyValue$1(normalized.lk);
+        }
+        return normalized;
+    }
+    return item;
+};
 // const isObj = (x: any) => typeof x === "object" && x !== null;
 // const intersection = (a: object, b: object): object => {
 //   const result: { [key: string]: any } = {}
@@ -383,7 +445,7 @@ class CacheMap extends core.Dictionary {
                     locKeys,
                     ComKey
                 });
-                return JSON.stringify(locKeys) === JSON.stringify(ComKey.loc);
+                return isLocKeyArrayEqual(locKeys, ComKey.loc);
             }).map((key)=>this.get(key));
         }
     }
@@ -409,12 +471,51 @@ class CacheMap extends core.Dictionary {
         return clone;
     }
     constructor(types, map){
-        super(map), _define_property$1(this, "types", void 0);
+        super(map, createNormalizedHashFunction()), _define_property$1(this, "types", void 0);
         this.types = types;
     }
 }
 
 const logger$1 = LibLogger.get('Cache');
+// Normalize a key value to string for consistent comparison
+const normalizeKeyValue = (value)=>{
+    return String(value);
+};
+// Normalized key comparison function that handles string/number differences
+const isItemKeyEqualNormalized = (a, b)=>{
+    // For now, just normalize the keys to strings and use the original comparison
+    const normalizedA = normalizeKey(a);
+    const normalizedB = normalizeKey(b);
+    return core.isItemKeyEqual(normalizedA, normalizedB);
+};
+// Helper function to normalize a key
+const normalizeKey = (key)=>{
+    if (typeof key === 'object' && key !== null) {
+        const normalizedKey = JSON.parse(JSON.stringify(key));
+        // Normalize pk values
+        if ('pk' in normalizedKey && normalizedKey.pk !== null) {
+            normalizedKey.pk = normalizeKeyValue(normalizedKey.pk);
+        }
+        // Normalize lk values
+        if ('lk' in normalizedKey && normalizedKey.lk !== null) {
+            normalizedKey.lk = normalizeKeyValue(normalizedKey.lk);
+        }
+        // Normalize loc array lk values
+        if ('loc' in normalizedKey && Array.isArray(normalizedKey.loc)) {
+            normalizedKey.loc = normalizedKey.loc.map((locItem)=>{
+                if (locItem && 'lk' in locItem && locItem.lk !== null) {
+                    return {
+                        ...locItem,
+                        lk: normalizeKeyValue(locItem.lk)
+                    };
+                }
+                return locItem;
+            });
+        }
+        return normalizedKey;
+    }
+    return key;
+};
 const createCache = async (api, pkType, parentCache)=>{
     let pkTypes = [
         pkType
@@ -691,7 +792,7 @@ const createCache = async (api, pkType, parentCache)=>{
         }
         // TODO: This could be merged with the isValidItemKey check, later.
         core.validatePK(v, pkType);
-        if (!core.isItemKeyEqual(key, v.key)) {
+        if (!isItemKeyEqualNormalized(key, v.key)) {
             logger$1.error('Key does not match item key: %j != %j', key, v.key);
             throw new Error('Key does not match item key');
         }

package/dist/index.cjs.map

@@ -1 +1 @@
-{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}
+{"version":3,"file":"index.cjs","sources":[],"sourcesContent":[],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@fjell/cache",
   "description": "Cache for Fjell",
-  "version": "4.6.5",
+  "version": "4.6.7",
   "keywords": [
     "cache",
     "fjell"
@@ -19,30 +19,30 @@
     }
   },
   "dependencies": {
-    "@fjell/client-api": "^4.4.5",
-    "@fjell/core": "^4.4.6",
-    "@fjell/http-api": "^4.4.4",
-    "@fjell/logging": "^4.4.6"
+    "@fjell/client-api": "^4.4.6",
+    "@fjell/core": "^4.4.7",
+    "@fjell/http-api": "^4.4.5",
+    "@fjell/logging": "^4.4.7"
   },
   "devDependencies": {
     "@eslint/eslintrc": "^3.3.1",
-    "@eslint/js": "^9.30.1",
-    "@swc/core": "^1.12.11",
+    "@eslint/js": "^9.31.0",
+    "@swc/core": "^1.12.14",
     "@tsconfig/recommended": "^1.0.10",
     "@types/multer": "^2.0.0",
-    "@types/node": "^24.0.12",
-    "@typescript-eslint/eslint-plugin": "^8.36.0",
-    "@typescript-eslint/parser": "^8.36.0",
+    "@types/node": "^24.0.13",
+    "@typescript-eslint/eslint-plugin": "^8.37.0",
+    "@typescript-eslint/parser": "^8.37.0",
     "@vitest/coverage-v8": "^3.2.4",
     "@vitest/ui": "^3.2.4",
     "concurrently": "^9.2.0",
-    "eslint": "^9.30.1",
+    "eslint": "^9.31.0",
     "nodemon": "^3.1.10",
     "rimraf": "^6.0.1",
     "ts-node": "^10.9.2",
     "tsc-alias": "^1.8.16",
     "typescript": "^5.8.3",
-    "vite": "^7.0.3",
+    "vite": "^7.0.4",
     "vite-plugin-dts": "^4.5.4",
     "vite-plugin-node": "^7.0.0",
     "vitest": "^3.2.4"