@fjell/cache 4.6.7 → 4.6.10

package/dist/index.cjs

@@ -5,10 +5,11 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const Logging = require('@fjell/logging');
 const core = require('@fjell/core');
 const httpApi = require('@fjell/http-api');
+const registry = require('@fjell/registry');
 
 const LibLogger = Logging.getLogger('@fjell/cache');
 
-const logger$3 = LibLogger.get('ItemAggregator');
+const logger$5 = LibLogger.get('ItemAggregator');
 const toCacheConfig = (config)=>{
     let cacheConfig;
     if (config.optional === undefined) {
@@ -23,7 +24,7 @@ const toCacheConfig = (config)=>{
 };
 const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
     const populate = async (item)=>{
-        logger$3.default('populate', {
+        logger$5.default('populate', {
             item
         });
         for(const key in aggregates){
@@ -32,19 +33,19 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         for(const key in events){
             await populateEvent(key, item);
         }
-        logger$3.default('populate done', {
+        logger$5.default('populate done', {
             item
         });
         return item;
     };
     const populateAggregate = async (key, item)=>{
-        logger$3.default('populate aggregate key', {
+        logger$5.default('populate aggregate key', {
             key
         });
         const cacheConfig = toCacheConfig(aggregates[key]);
         if (item.refs === undefined) {
             if (cacheConfig.optional === false) {
-                logger$3.error('Item does not have refs an is not optional ' + JSON.stringify(item));
+                logger$5.error('Item does not have refs an is not optional ' + JSON.stringify(item));
                 throw new Error('Item does not have refs an is not optional ' + JSON.stringify(item));
             } else {
                 if (item.events && Object.prototype.hasOwnProperty.call(item.events, key)) {
@@ -53,7 +54,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
             }
         } else if (item.refs[key] === undefined) {
             if (cacheConfig.optional === false) {
-                logger$3.error('Item does not have mandatory ref with key, not optional ' + key + ' ' + JSON.stringify(item));
+                logger$5.error('Item does not have mandatory ref with key, not optional ' + key + ' ' + JSON.stringify(item));
                 throw new Error('Item does not have mandatory ref with key, not optional ' + key + ' ' + JSON.stringify(item));
             } else {
                 if (item.events && Object.prototype.hasOwnProperty.call(item.events, key)) {
@@ -62,7 +63,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
             }
         } else {
             const ref = item.refs[key];
-            logger$3.default('AGG Retrieving Item in Populate', {
+            logger$5.default('AGG Retrieving Item in Populate', {
                 key: ref
             });
             const [, newItem] = await cacheConfig.cache.retrieve(ref);
@@ -79,7 +80,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
     };
     // TODO: I'm not a big fan that this just "automatically" assumes that the "by" key in event is a ref.
     const populateEvent = async (key, item)=>{
-        logger$3.default('populate event key', {
+        logger$5.default('populate event key', {
             key
         });
         const cacheConfig = toCacheConfig(events[key]);
@@ -87,13 +88,13 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
             throw new Error('Item does not have events ' + JSON.stringify(item));
         } else if (item.events[key] === undefined) {
             if (cacheConfig.optional === false) {
-                logger$3.error('Item does not have mandatory event with key ' + key + ' ' + JSON.stringify(item));
+                logger$5.error('Item does not have mandatory event with key ' + key + ' ' + JSON.stringify(item));
                 throw new Error('Item does not have mandatory event with key ' + key + ' ' + JSON.stringify(item));
             }
         } else {
             const event = item.events[key];
             if (event.by === undefined) {
-                logger$3.error('populateEvent with an Event that does not have by', {
+                logger$5.error('populateEvent with an Event that does not have by', {
                     event,
                     ik: item.key,
                     eventKey: key
@@ -103,7 +104,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
                     event
                 }));
             }
-            logger$3.default('EVENT Retrieving Item in Populate', {
+            logger$5.default('EVENT Retrieving Item in Populate', {
                 key: event.by
             });
             const [, newItem] = await cacheConfig.cache.retrieve(event.by);
@@ -113,7 +114,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         }
     };
     const all = async (query = {}, locations = [])=>{
-        logger$3.default('all', {
+        logger$5.default('all', {
             query,
             locations
         });
@@ -125,7 +126,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         ];
     };
     const one = async (query = {}, locations = [])=>{
-        logger$3.default('one', {
+        logger$5.default('one', {
             query,
             locations
         });
@@ -140,7 +141,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         ];
     };
     const action = async (key, action, body = {})=>{
-        logger$3.default('action', {
+        logger$5.default('action', {
             key,
             action,
             body
@@ -153,7 +154,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         ];
     };
     const allAction = async (action, body = {}, locations = [])=>{
-        logger$3.default('action', {
+        logger$5.default('action', {
             action,
             body,
             locations
@@ -166,7 +167,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         ];
     };
     const allFacet = async (facet, params = {}, locations = [])=>{
-        logger$3.default('allFacet', {
+        logger$5.default('allFacet', {
             facet,
             params,
             locations
@@ -178,7 +179,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         ];
     };
     const create = async (v, locations = [])=>{
-        logger$3.default('create', {
+        logger$5.default('create', {
             v,
             locations
         });
@@ -190,7 +191,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         ];
     };
     const get = async (key)=>{
-        logger$3.default('get', {
+        logger$5.default('get', {
             key
         });
         const [cacheMap, item] = await cache.get(key);
@@ -204,7 +205,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         ];
     };
     const retrieve = async (key)=>{
-        logger$3.default('retrieve', {
+        logger$5.default('retrieve', {
             key
         });
         const [cacheMap, item] = await cache.retrieve(key);
@@ -218,14 +219,14 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         ];
     };
     const remove = async (key)=>{
-        logger$3.default('remove', {
+        logger$5.default('remove', {
             key
         });
         const cacheMap = await cache.remove(key);
         return cacheMap;
     };
     const update = async (key, v)=>{
-        logger$3.default('update', {
+        logger$5.default('update', {
             key,
             v
         });
@@ -238,7 +239,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
     };
     // Facets are a pass-thru for aggregators
     const facet = async (key, facet)=>{
-        logger$3.default('facet', {
+        logger$5.default('facet', {
             key,
             facet
         });
@@ -249,7 +250,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         ];
     };
     const find = async (finder, finderParams = {}, locations = [])=>{
-        logger$3.default('find', {
+        logger$5.default('find', {
             finder,
             finderParams,
             locations
@@ -262,7 +263,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         ];
     };
     const findOne = async (finder, finderParams = {}, locations = [])=>{
-        logger$3.default('find', {
+        logger$5.default('find', {
             finder,
             finderParams,
             locations
@@ -275,7 +276,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
         ];
     };
     const set = async (key, v)=>{
-        logger$3.default('set', {
+        logger$5.default('set', {
             key,
             v
         });
@@ -315,7 +316,7 @@ const createAggregator = async (cache, { aggregates = {}, events = {} })=>{
     };
 };
 
-function _define_property$1(obj, key, value) {
+function _define_property(obj, key, value) {
     if (key in obj) {
         Object.defineProperty(obj, key, {
             value: value,
@@ -328,7 +329,7 @@ function _define_property$1(obj, key, value) {
     }
     return obj;
 }
-const logger$2 = LibLogger.get("CacheMap");
+const logger$4 = LibLogger.get("CacheMap");
 // Normalize a key value to string for consistent comparison and hashing
 const normalizeKeyValue$1 = (value)=>{
     return String(value);
@@ -431,17 +432,17 @@ class CacheMap extends core.Dictionary {
     }
     allIn(locations) {
         if (locations.length === 0) {
-            logger$2.debug('Returning all items, LocKeys is empty');
+            logger$4.debug('Returning all items, LocKeys is empty');
             return this.values();
         } else {
             const locKeys = locations;
-            logger$2.debug('allIn', {
+            logger$4.debug('allIn', {
                 locKeys,
                 keys: this.keys().length
             });
             return this.keys().filter((key)=>key && core.isComKey(key)).filter((key)=>{
                 const ComKey = key;
-                logger$2.debug('Comparing Location Keys', {
+                logger$4.debug('Comparing Location Keys', {
                     locKeys,
                     ComKey
                 });
@@ -451,7 +452,7 @@ class CacheMap extends core.Dictionary {
     }
     // TODO: Can we do case insensitive matching?
     contains(query, locations) {
-        logger$2.debug('contains', {
+        logger$4.debug('contains', {
             query,
             locations
         });
@@ -459,7 +460,7 @@ class CacheMap extends core.Dictionary {
         return items.some((item)=>core.isQueryMatch(item, query));
     }
     queryIn(query, locations = []) {
-        logger$2.debug('queryIn', {
+        logger$4.debug('queryIn', {
             query,
             locations
         });
@@ -471,12 +472,12 @@ class CacheMap extends core.Dictionary {
         return clone;
     }
     constructor(types, map){
-        super(map, createNormalizedHashFunction()), _define_property$1(this, "types", void 0);
+        super(map, createNormalizedHashFunction()), _define_property(this, "types", void 0);
         this.types = types;
     }
 }
 
-const logger$1 = LibLogger.get('Cache');
+const logger$3 = LibLogger.get('Cache');
 // Normalize a key value to string for consistent comparison
 const normalizeKeyValue = (value)=>{
     return String(value);
@@ -525,7 +526,7 @@ const createCache = async (api, pkType, parentCache)=>{
     }
     let cacheMap = new CacheMap(pkTypes);
     const all = async (query = {}, locations = [])=>{
-        logger$1.default('all', {
+        logger$3.default('all', {
             query,
             locations
         });
@@ -546,7 +547,7 @@ const createCache = async (api, pkType, parentCache)=>{
         ];
     };
     const one = async (query = {}, locations = [])=>{
-        logger$1.default('one', {
+        logger$3.default('one', {
             query,
             locations
         });
@@ -567,7 +568,7 @@ const createCache = async (api, pkType, parentCache)=>{
         ];
     };
     const action = async (key, action, body = {})=>{
-        logger$1.default('action', {
+        logger$3.default('action', {
             key,
             action,
             body
@@ -575,7 +576,7 @@ const createCache = async (api, pkType, parentCache)=>{
         // TODO: This is validating the key, but it doesn't have knowledge of the pkType
         // This should be looking at the parentCaches and calculating an array of pkTypes
         if (!core.isValidItemKey(key)) {
-            logger$1.error('Key for Action is not a valid ItemKey: %j', key);
+            logger$3.error('Key for Action is not a valid ItemKey: %j', key);
             throw new Error('Key for Action is not a valid ItemKey');
         }
         const updated = await api.action(key, action, body);
@@ -586,7 +587,7 @@ const createCache = async (api, pkType, parentCache)=>{
         ];
     };
     const allAction = async (action, body = {}, locations = [])=>{
-        logger$1.default('allAction', {
+        logger$3.default('allAction', {
             action,
             body,
             locations
@@ -609,7 +610,7 @@ const createCache = async (api, pkType, parentCache)=>{
         ];
     };
     const allFacet = async (facet, params = {}, locations = [])=>{
-        logger$1.default('allFacet', {
+        logger$3.default('allFacet', {
             facet,
             params,
             locations
@@ -621,7 +622,7 @@ const createCache = async (api, pkType, parentCache)=>{
         ];
     };
     const create = async (v, locations = [])=>{
-        logger$1.default('create', {
+        logger$3.default('create', {
             v,
             locations
         });
@@ -633,13 +634,13 @@ const createCache = async (api, pkType, parentCache)=>{
         ];
     };
     const get = async (key)=>{
-        logger$1.default('get', {
+        logger$3.default('get', {
             key
         });
         // TODO: This is validating the key, but it doesn't have knowledge of the pkType
         // This should be looking at the parentCaches and calculating an array of pkTypes
         if (!core.isValidItemKey(key)) {
-            logger$1.error('Key for Get is not a valid ItemKey: %j', key);
+            logger$3.error('Key for Get is not a valid ItemKey: %j', key);
             throw new Error('Key for Get is not a valid ItemKey');
         }
         let ret;
@@ -649,7 +650,7 @@ const createCache = async (api, pkType, parentCache)=>{
                 cacheMap.set(ret.key, ret);
             }
         } catch (e) {
-            logger$1.error("Error getting item for key", {
+            logger$3.error("Error getting item for key", {
                 key,
                 message: e.message,
                 stack: e.stack
@@ -662,20 +663,20 @@ const createCache = async (api, pkType, parentCache)=>{
         ];
     };
     const retrieve = async (key)=>{
-        logger$1.default('retrieve', {
+        logger$3.default('retrieve', {
             key
         });
         if (!core.isValidItemKey(key)) {
-            logger$1.error('Key for Retrieve is not a valid ItemKey: %j', key);
+            logger$3.error('Key for Retrieve is not a valid ItemKey: %j', key);
             throw new Error('Key for Retrieve is not a valid ItemKey');
         }
         const containsItemKey = cacheMap.includesKey(key);
         let retrieved;
         if (containsItemKey) {
-            logger$1.default('Looking for Object in Cache', key);
+            logger$3.default('Looking for Object in Cache', key);
             retrieved = cacheMap.get(key);
         } else {
-            logger$1.default('Object Not Found in Cache, Retrieving from Server API', {
+            logger$3.default('Object Not Found in Cache, Retrieving from Server API', {
                 key
             });
             [, retrieved] = await get(key);
@@ -688,20 +689,20 @@ const createCache = async (api, pkType, parentCache)=>{
         return retValue;
     };
     const remove = async (key)=>{
-        logger$1.default('remove', {
+        logger$3.default('remove', {
             key
         });
         // TODO: This is validating the key, but it doesn't have knowledge of the pkType
         // This should be looking at the parentCaches and calculating an array of pkTypes
         if (!core.isValidItemKey(key)) {
-            logger$1.error('Key for Remove is not a valid ItemKey: %j', key);
+            logger$3.error('Key for Remove is not a valid ItemKey: %j', key);
             throw new Error('Key for Remove is not a valid ItemKey');
         }
         try {
             await api.remove(key);
             cacheMap.delete(key);
         } catch (e) {
-            logger$1.error("Error deleting item", {
+            logger$3.error("Error deleting item", {
                 error: e
             });
             throw e;
@@ -709,14 +710,14 @@ const createCache = async (api, pkType, parentCache)=>{
         return cacheMap;
     };
     const update = async (key, v)=>{
-        logger$1.default('update', {
+        logger$3.default('update', {
             key,
             v
         });
         // TODO: This is validating the key, but it doesn't have knowledge of the pkType
         // This should be looking at the parentCaches and calculating an array of pkTypes
         if (!core.isValidItemKey(key)) {
-            logger$1.error('Key for Update is not a valid ItemKey: %j', key);
+            logger$3.error('Key for Update is not a valid ItemKey: %j', key);
             throw new Error('Key for Update is not a valid ItemKey');
         }
         try {
@@ -727,7 +728,7 @@ const createCache = async (api, pkType, parentCache)=>{
                 core.validatePK(updated, pkType)
             ];
         } catch (e) {
-            logger$1.error("Error updating chat", {
+            logger$3.error("Error updating chat", {
                 error: e
             });
             throw e;
@@ -735,7 +736,7 @@ const createCache = async (api, pkType, parentCache)=>{
     };
     // Facets are a pass-thru for caches
     const facet = async (key, facet, params = {})=>{
-        logger$1.default('facet', {
+        logger$3.default('facet', {
             key,
             facet
         });
@@ -746,7 +747,7 @@ const createCache = async (api, pkType, parentCache)=>{
         ];
     };
     const find = async (finder, params = {}, locations = [])=>{
-        logger$1.default('find', {
+        logger$3.default('find', {
             finder,
             params,
             locations
@@ -761,7 +762,7 @@ const createCache = async (api, pkType, parentCache)=>{
         ];
     };
     const findOne = async (finder, finderParams = {}, locations = [])=>{
-        logger$1.default('findOne', {
+        logger$3.default('findOne', {
             finder,
             finderParams,
             locations
@@ -780,20 +781,20 @@ const createCache = async (api, pkType, parentCache)=>{
         ];
     };
     const set = async (key, v)=>{
-        logger$1.default('set', {
+        logger$3.default('set', {
             key,
             v
         });
         // TODO: This is validating the key, but it doesn't have knowledge of the pkType
         // This should be looking at the parentCaches and calculating an array of pkTypes
         if (!core.isValidItemKey(key)) {
-            logger$1.error('Key for Update is not a valid ItemKey: %j', key);
+            logger$3.error('Key for Update is not a valid ItemKey: %j', key);
             throw new Error('Key for Update is not a valid ItemKey');
         }
         // TODO: This could be merged with the isValidItemKey check, later.
         core.validatePK(v, pkType);
         if (!isItemKeyEqualNormalized(key, v.key)) {
-            logger$1.error('Key does not match item key: %j != %j', key, v.key);
+            logger$3.error('Key does not match item key: %j != %j', key, v.key);
             throw new Error('Key does not match item key');
         }
         cacheMap.set(key, v);
@@ -823,67 +824,70 @@ const createCache = async (api, pkType, parentCache)=>{
     };
 };
 
-function _define_property(obj, key, value) {
-    if (key in obj) {
-        Object.defineProperty(obj, key, {
-            value: value,
-            enumerable: true,
-            configurable: true,
-            writable: true
-        });
-    } else {
-        obj[key] = value;
-    }
-    return obj;
-}
-const logger = LibLogger.get('CacheRegistry');
-class CacheRegistry {
-    constructor(){
-        // TODO: My use of Generics has Boxed me into a corner where I can't reference AbstractCache without the types
-        _define_property(this, "cacheMap", {});
-        _define_property(this, "registerCache", async (cache)=>{
-            try {
-                logger.debug('Attempting to register cache with pkTypes:', cache.pkTypes);
-                const key = JSON.stringify(cache.pkTypes);
-                if (this.cacheMap[key]) {
-                    logger.debug(`Cache with pkTypes ${key} already exists, will be overwritten`);
-                }
-                this.cacheMap[key] = cache;
-                logger.debug('Cache registered successfully with key:', key);
-            } catch (error) {
-                logger.error('Failed to register cache:', error);
-                throw error;
-            }
-        });
-        _define_property(this, "getCache", (kts)=>{
-            logger.debug('Attempting to get cache for key types:', kts);
-            const key = JSON.stringify(kts);
-            logger.debug('Looking up cache with key:', key);
-            const cache = this.cacheMap[key];
-            if (!cache) {
-                logger.warning(`No cache found for key types: ${key}`);
-            }
-            return cache;
-        });
-        _define_property(this, "printRegisteredCaches", ()=>{
-            logger.debug('Printing all registered caches:');
-            const cacheCount = Object.keys(this.cacheMap).length;
-            logger.debug(`Total number of registered caches: ${cacheCount}`);
-            if (cacheCount === 0) {
-                logger.debug('No caches are currently registered');
-            }
-            Object.entries(this.cacheMap).forEach(([keyTypes])=>{
-                logger.debug(`Cache with key types: ${keyTypes}`);
-            });
+const logger$2 = LibLogger.get("Instance");
+const createInstance = (registry$1, coordinate, cache)=>{
+    logger$2.debug("createInstance", {
+        coordinate,
+        cache,
+        registry: registry$1
+    });
+    const baseInstance = registry.createInstance(registry$1, coordinate);
+    return {
+        ...baseInstance,
+        cache
+    };
+};
+const isInstance = (instance)=>{
+    return instance !== null && instance !== undefined && instance.coordinate !== undefined && instance.cache !== undefined && instance.registry !== undefined;
+};
+
+const logger$1 = LibLogger.get("InstanceFactory");
+/**
+ * Factory function for creating cache instances
+ */ const createInstanceFactory = (cache)=>{
+    return (coordinate, context)=>{
+        logger$1.debug("Creating cache instance", {
+            coordinate,
+            registry: context.registry,
+            cache
+        });
+        return createInstance(context.registry, coordinate, cache);
+    };
+};
+
+const logger = LibLogger.get("Registry");
+/**
+ * Factory function for creating cache registries
+ */ const createRegistryFactory = ()=>{
+    return (type, registryHub)=>{
+        if (type !== 'cache') {
+            throw new Error(`Cache registry factory can only create 'cache' type registries, got: ${type}`);
+        }
+        logger.debug("Creating cache registry", {
+            type,
+            registryHub
         });
-        logger.debug('CacheRegistry instance created');
-    }
-}
-_define_property(CacheRegistry, "instance", void 0);
+        const baseRegistry = registry.createRegistry(type, registryHub);
+        // Cast to Registry for type safety
+        return baseRegistry;
+    };
+};
+/**
+ * Creates a new cache registry instance
+ */ const createRegistry = (registryHub)=>{
+    const baseRegistry = registry.createRegistry('cache', registryHub);
+    return {
+        ...baseRegistry
+    };
+};
 
 exports.CacheMap = CacheMap;
-exports.CacheRegistry = CacheRegistry;
 exports.createAggregator = createAggregator;
 exports.createCache = createCache;
+exports.createInstance = createInstance;
+exports.createInstanceFactory = createInstanceFactory;
+exports.createRegistry = createRegistry;
+exports.createRegistryFactory = createRegistryFactory;
+exports.isInstance = isInstance;
 exports.toCacheConfig = toCacheConfig;
 //# sourceMappingURL=index.cjs.map

package/dist/index.cjs.js

@@ -5,7 +5,9 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 const Aggregator = require('./Aggregator.cjs.js');
 const Cache = require('./Cache.cjs.js');
 const CacheMap = require('./CacheMap.cjs.js');
-const CacheRegistry = require('./CacheRegistry.cjs.js');
+const Instance = require('./Instance.cjs.js');
+const InstanceFactory = require('./InstanceFactory.cjs.js');
+const Registry = require('./Registry.cjs.js');
 
 
 
@@ -13,5 +15,9 @@ exports.createAggregator = Aggregator.createAggregator;
 exports.toCacheConfig = Aggregator.toCacheConfig;
 exports.createCache = Cache.createCache;
 exports.CacheMap = CacheMap.CacheMap;
-exports.CacheRegistry = CacheRegistry.CacheRegistry;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguY2pzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7OyJ9
+exports.createInstance = Instance.createInstance;
+exports.isInstance = Instance.isInstance;
+exports.createInstanceFactory = InstanceFactory.createInstanceFactory;
+exports.createRegistry = Registry.createRegistry;
+exports.createRegistryFactory = Registry.createRegistryFactory;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguY2pzLmpzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

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/dist/index.d.ts

@@ -1,4 +1,6 @@
 export * from './Aggregator';
 export * from './Cache';
 export * from './CacheMap';
-export * from './CacheRegistry';
+export * from './Instance';
+export * from './InstanceFactory';
+export * from './Registry';

package/dist/index.es.js

@@ -1,5 +1,7 @@
 export { createAggregator, toCacheConfig } from './Aggregator.es.js';
 export { createCache } from './Cache.es.js';
 export { CacheMap } from './CacheMap.es.js';
-export { CacheRegistry } from './CacheRegistry.es.js';
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZXMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7In0=
+export { createInstance, isInstance } from './Instance.es.js';
+export { createInstanceFactory } from './InstanceFactory.es.js';
+export { createRegistry, createRegistryFactory } from './Registry.es.js';
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguZXMuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7OzsifQ==