@fjell/registry 4.4.4 → 4.4.6

package/dist/Instance.js

@@ -1,18 +1,18 @@
 import LibLogger from './logger.js';
 
 const logger = LibLogger.get("Instance");
-const createInstance = (definition, registry)=>{
+const createInstance = (registry, coordinate)=>{
     logger.debug("createInstance", {
-        definition,
+        coordinate,
         registry
     });
     return {
-        definition,
+        coordinate,
         registry
     };
 };
 const isInstance = (instance)=>{
-    return instance !== null && instance !== undefined && instance.definition !== undefined && instance.registry !== undefined;
+    return instance !== null && instance !== undefined && instance.coordinate !== undefined && instance.registry !== undefined;
 };
 
 export { createInstance, isInstance };

package/dist/Registry.cjs

@@ -4,118 +4,127 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
 
 const logger$1 = require('./logger.cjs');
 const Instance = require('./Instance.cjs');
+const Coordinate = require('./Coordinate.cjs');
 
 const logger = logger$1.default.get("Registry");
-const isScopedInstance = (instance)=>{
-    // eslint-disable-next-line no-undefined
-    return instance.instance !== undefined;
-};
-const retrieveScopedInstance = (scopedInstanceArray, scopes)=>{
-    let instance;
-    if (scopes) {
-        var _scopedInstanceArray_find;
-        instance = (_scopedInstanceArray_find = scopedInstanceArray.find((sl)=>{
-            return sl.scopes && scopes && scopes.every((scope)=>sl.scopes && sl.scopes.includes(scope));
-        })) === null || _scopedInstanceArray_find === void 0 ? void 0 : _scopedInstanceArray_find.instance;
-    } else {
-        var _scopedInstanceArray_;
-        instance = (_scopedInstanceArray_ = scopedInstanceArray[0]) === null || _scopedInstanceArray_ === void 0 ? void 0 : _scopedInstanceArray_.instance;
+const findScopedInstance = (scopedInstances, requestedScopes)=>{
+    if (!requestedScopes || requestedScopes.length === 0) {
+        var _scopedInstances_;
+        // Return first instance if no scopes specified
+        const firstInstance = (_scopedInstances_ = scopedInstances[0]) === null || _scopedInstances_ === void 0 ? void 0 : _scopedInstances_.instance;
+        if (!firstInstance) {
+            throw new Error('No instances available');
+        }
+        return firstInstance;
     }
-    if (!instance) {
-        throw new Error(`No Scoped Instance for ${scopes === null || scopes === void 0 ? void 0 : scopes.join(', ')}`);
+    // Find instance that matches all requested scopes
+    const matchingInstance = scopedInstances.find((scopedInstance)=>{
+        if (!scopedInstance.scopes) return false;
+        return requestedScopes.every((scope)=>scopedInstance.scopes && scopedInstance.scopes.includes(scope));
+    });
+    if (!matchingInstance) {
+        throw new Error(`No instance found matching scopes: ${requestedScopes.join(', ')}`);
     }
-    return instance;
+    return matchingInstance.instance;
 };
-const createRegistry = ()=>{
-    // TODO: My use of Generics has Boxes be into a corner where I can't reference AbstractLib without the types
-    const libTree = {};
-    const register = (kta, instance, options)=>{
-        const ktaArray = [
+const createRegistry = (type, registryHub)=>{
+    const instanceTree = {};
+    const createInstance = (kta, scopes, factory)=>{
+        logger.debug(`Creating and registering instance for key path and scopes`, kta, scopes, `in registry type: ${type}`);
+        // Create coordinate for the instance
+        const coordinate = Coordinate.createCoordinate(kta, scopes);
+        // Use factory to create the instance with the new context parameter
+        const instance = factory(coordinate, {
+            registry,
+            registryHub
+        });
+        // Validate the created instance
+        if (!Instance.isInstance(instance)) {
+            throw new Error(`Factory did not return a valid instance for: ${kta.join('.')}`);
+        }
+        // Register the instance
+        registerInternal(kta, instance, {
+            scopes
+        });
+        return instance;
+    };
+    const registerInternal = (kta, instance, options)=>{
+        const keyPath = [
             ...kta
-        ];
-        let currentTree = libTree;
-        logger.debug(`Registering lib for KTA and scopes`, ktaArray, options === null || options === void 0 ? void 0 : options.scopes);
+        ].reverse(); // Work from most specific to least specific
+        let currentLevel = instanceTree;
+        logger.debug(`Registering instance for key path and scopes`, keyPath, options === null || options === void 0 ? void 0 : options.scopes, `in registry type: ${type}`);
         if (!Instance.isInstance(instance)) {
-            throw new Error(`Attempting to register a non-instance as an instance: ${ktaArray.join('.')}`);
+            throw new Error(`Attempting to register a non-instance: ${kta.join('.')}`);
         }
-        while(ktaArray.length > 0){
-            const kt = ktaArray.pop();
-            if (kt) {
-                if (ktaArray.length === 0) {
-                    if (!currentTree[kt]) {
-                        currentTree[kt] = [
-                            [],
-                            null
-                        ];
-                    }
-                    currentTree[kt][0].push({
-                        scopes: options === null || options === void 0 ? void 0 : options.scopes,
-                        instance
-                    });
-                } else {
-                    if (!currentTree[kt]) {
-                        const newTree = {};
-                        currentTree[kt] = [
-                            [],
-                            newTree
-                        ];
-                        currentTree = newTree;
-                    } else if (!currentTree[kt][1]) {
-                        const newTree = {};
-                        currentTree[kt][1] = newTree;
-                        currentTree = newTree;
-                    } else {
-                        currentTree = currentTree[kt][1];
-                    }
-                }
+        // Navigate to the correct location in the tree
+        for(let i = 0; i < keyPath.length; i++){
+            const keyType = keyPath[i];
+            const isLeaf = i === keyPath.length - 1;
+            if (!currentLevel[keyType]) {
+                currentLevel[keyType] = {
+                    instances: [],
+                    children: isLeaf ? null : {}
+                };
+            }
+            if (isLeaf) {
+                // Add instance to the leaf node
+                currentLevel[keyType].instances.push({
+                    scopes: options === null || options === void 0 ? void 0 : options.scopes,
+                    instance
+                });
             } else {
-                throw new Error(`Invalid KTA containing an empty false or undefined kt: ${ktaArray.join('.')}`);
+                // Navigate deeper into the tree
+                if (!currentLevel[keyType].children) {
+                    currentLevel[keyType].children = {};
+                }
+                currentLevel = currentLevel[keyType].children;
             }
         }
     };
+    const register = (kta, instance, options)=>{
+        logger.debug('Using deprecated register method. Consider using createInstance instead.');
+        registerInternal(kta, instance, options);
+    };
     const get = (kta, options)=>{
-        const ktaArray = [
+        const keyPath = [
             ...kta
-        ];
-        let currentTree = libTree;
-        let instance = null;
-        // logger.debug(`Getting lib for KTA and scopes`, ktaArray, options?.scopes);
-        while(ktaArray.length > 0){
-            const kt = ktaArray.pop();
-            if (kt) {
-                if (ktaArray.length === 0 && currentTree[kt]) {
-                    const element = currentTree[kt];
-                    const scopedInstanceArray = element[0];
-                    if (scopedInstanceArray.length > 0 && isScopedInstance(scopedInstanceArray[0])) {
-                        instance = retrieveScopedInstance(scopedInstanceArray, options === null || options === void 0 ? void 0 : options.scopes);
-                        // eslint-disable-next-line max-depth
-                        if (!instance) {
-                            var _options_scopes;
-                            throw new Error(`No Instance not found for kta: ${JSON.stringify(ktaArray)}, Scopes: ${options === null || options === void 0 ? void 0 : (_options_scopes = options.scopes) === null || _options_scopes === void 0 ? void 0 : _options_scopes.join(', ')}`);
-                        }
-                    } else {
-                        throw new Error(`No Instance not found for kta: ${JSON.stringify(ktaArray)}, Last Key not a instance: ${kt}`);
-                    }
-                } else {
-                    if (!currentTree[kt]) {
-                        throw new Error(`Lib not found for kta: ${JSON.stringify(ktaArray)}, Subtree Not Found: ${kt}`);
-                    } else {
-                        currentTree = currentTree[kt][1];
-                    }
+        ].reverse();
+        let currentLevel = instanceTree;
+        // Navigate to the target node
+        for(let i = 0; i < keyPath.length; i++){
+            const keyType = keyPath[i];
+            const isLeaf = i === keyPath.length - 1;
+            if (!currentLevel[keyType]) {
+                throw new Error(`Instance not found for key path: ${kta.join('.')}, Missing key: ${keyType}`);
+            }
+            if (isLeaf) {
+                // Found the target node, extract instance
+                const scopedInstances = currentLevel[keyType].instances;
+                if (scopedInstances.length === 0) {
+                    throw new Error(`No instances registered for key path: ${kta.join('.')}`);
                 }
+                return findScopedInstance(scopedInstances, options === null || options === void 0 ? void 0 : options.scopes);
             } else {
-                throw new Error(`Invalid KTA containing an empty false or undefined kt: ${JSON.stringify(ktaArray)}`);
+                // Continue navigation
+                if (!currentLevel[keyType].children) {
+                    throw new Error(`Instance not found for key path: ${kta.join('.')}, No children for: ${keyType}`);
+                }
+                currentLevel = currentLevel[keyType].children;
             }
         }
-        return instance;
+        return null;
     };
-    return {
+    const registry = {
+        type,
+        registryHub,
+        createInstance,
         register,
         get,
-        // TODO: Remove this once we have a better way to test
-        libTree
+        instanceTree
     };
+    return registry;
 };
 
 exports.createRegistry = createRegistry;
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVnaXN0cnkuY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVnaXN0cnkuY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/Registry.d.ts

@@ -1,42 +1,3 @@
-import { Instance } from './Instance';
-/**
- * The Registry interface provides a central registry for managing and accessing instances of services.
- * It serves as a dependency injection container that allows libraries to reference and access
- * other library instances they depend on.
- *
- * The registry maintains a tree structure of library instances and provides methods to:
- * 1. Register new library instances with their key types and optional scopes
- * 2. Retrieve library instances by their key types and optional scopes
- * 3. Access the library tree structure for dependency resolution
- */
-export interface Registry {
-    /**
-     * Registers a new library instance in the registry.
-     * @param kta - Array of key types that identify this library instance
-     * @param instance - The library instance to register
-     * @param options - Optional configuration including scopes for the instance
-     */
-    register: (kta: string[], instance: Instance<any, any | never, any | never, any | never, any | never, any | never>, options?: {
-        scopes?: string[];
-    }) => void;
-    /**
-     * Retrieves a library instance from the registry.
-     * @param kta - Array of key types to identify the library instance
-     * @param options - Optional configuration including scopes to search in
-     * @returns The found library instance or null if not found
-     */
-    get: (kta: string[], options?: {
-        scopes?: string[];
-    }) => Instance<any, any | never, any | never, any | never, any | never, any | never> | null;
-    /** The tree structure representing the hierarchy of library instances */
-    libTree: LibTree;
-}
-interface ScopedInstance {
-    scopes?: string[];
-    instance: Instance<any, any | never, any | never, any | never, any | never, any | never>;
-}
-interface LibTree {
-    [kt: string]: [ScopedInstance[], LibTree | null];
-}
-export declare const createRegistry: () => Registry;
-export {};
+import { Registry, RegistryHub } from './types';
+export type { Registry, RegistryHub, InstanceFactory, RegistryFactory } from './types';
+export declare const createRegistry: (type: string, registryHub?: RegistryHub) => Registry;

package/dist/Registry.js

@@ -1,117 +1,126 @@
 import LibLogger from './logger.js';
 import { isInstance } from './Instance.js';
+import { createCoordinate } from './Coordinate.js';
 
 const logger = LibLogger.get("Registry");
-const isScopedInstance = (instance)=>{
-    // eslint-disable-next-line no-undefined
-    return instance.instance !== undefined;
-};
-const retrieveScopedInstance = (scopedInstanceArray, scopes)=>{
-    let instance;
-    if (scopes) {
-        var _scopedInstanceArray_find;
-        instance = (_scopedInstanceArray_find = scopedInstanceArray.find((sl)=>{
-            return sl.scopes && scopes && scopes.every((scope)=>sl.scopes && sl.scopes.includes(scope));
-        })) === null || _scopedInstanceArray_find === void 0 ? void 0 : _scopedInstanceArray_find.instance;
-    } else {
-        var _scopedInstanceArray_;
-        instance = (_scopedInstanceArray_ = scopedInstanceArray[0]) === null || _scopedInstanceArray_ === void 0 ? void 0 : _scopedInstanceArray_.instance;
+const findScopedInstance = (scopedInstances, requestedScopes)=>{
+    if (!requestedScopes || requestedScopes.length === 0) {
+        var _scopedInstances_;
+        // Return first instance if no scopes specified
+        const firstInstance = (_scopedInstances_ = scopedInstances[0]) === null || _scopedInstances_ === void 0 ? void 0 : _scopedInstances_.instance;
+        if (!firstInstance) {
+            throw new Error('No instances available');
+        }
+        return firstInstance;
     }
-    if (!instance) {
-        throw new Error(`No Scoped Instance for ${scopes === null || scopes === void 0 ? void 0 : scopes.join(', ')}`);
+    // Find instance that matches all requested scopes
+    const matchingInstance = scopedInstances.find((scopedInstance)=>{
+        if (!scopedInstance.scopes) return false;
+        return requestedScopes.every((scope)=>scopedInstance.scopes && scopedInstance.scopes.includes(scope));
+    });
+    if (!matchingInstance) {
+        throw new Error(`No instance found matching scopes: ${requestedScopes.join(', ')}`);
     }
-    return instance;
+    return matchingInstance.instance;
 };
-const createRegistry = ()=>{
-    // TODO: My use of Generics has Boxes be into a corner where I can't reference AbstractLib without the types
-    const libTree = {};
-    const register = (kta, instance, options)=>{
-        const ktaArray = [
+const createRegistry = (type, registryHub)=>{
+    const instanceTree = {};
+    const createInstance = (kta, scopes, factory)=>{
+        logger.debug(`Creating and registering instance for key path and scopes`, kta, scopes, `in registry type: ${type}`);
+        // Create coordinate for the instance
+        const coordinate = createCoordinate(kta, scopes);
+        // Use factory to create the instance with the new context parameter
+        const instance = factory(coordinate, {
+            registry,
+            registryHub
+        });
+        // Validate the created instance
+        if (!isInstance(instance)) {
+            throw new Error(`Factory did not return a valid instance for: ${kta.join('.')}`);
+        }
+        // Register the instance
+        registerInternal(kta, instance, {
+            scopes
+        });
+        return instance;
+    };
+    const registerInternal = (kta, instance, options)=>{
+        const keyPath = [
             ...kta
-        ];
-        let currentTree = libTree;
-        logger.debug(`Registering lib for KTA and scopes`, ktaArray, options === null || options === void 0 ? void 0 : options.scopes);
+        ].reverse(); // Work from most specific to least specific
+        let currentLevel = instanceTree;
+        logger.debug(`Registering instance for key path and scopes`, keyPath, options === null || options === void 0 ? void 0 : options.scopes, `in registry type: ${type}`);
         if (!isInstance(instance)) {
-            throw new Error(`Attempting to register a non-instance as an instance: ${ktaArray.join('.')}`);
+            throw new Error(`Attempting to register a non-instance: ${kta.join('.')}`);
         }
-        while(ktaArray.length > 0){
-            const kt = ktaArray.pop();
-            if (kt) {
-                if (ktaArray.length === 0) {
-                    if (!currentTree[kt]) {
-                        currentTree[kt] = [
-                            [],
-                            null
-                        ];
-                    }
-                    currentTree[kt][0].push({
-                        scopes: options === null || options === void 0 ? void 0 : options.scopes,
-                        instance
-                    });
-                } else {
-                    if (!currentTree[kt]) {
-                        const newTree = {};
-                        currentTree[kt] = [
-                            [],
-                            newTree
-                        ];
-                        currentTree = newTree;
-                    } else if (!currentTree[kt][1]) {
-                        const newTree = {};
-                        currentTree[kt][1] = newTree;
-                        currentTree = newTree;
-                    } else {
-                        currentTree = currentTree[kt][1];
-                    }
-                }
+        // Navigate to the correct location in the tree
+        for(let i = 0; i < keyPath.length; i++){
+            const keyType = keyPath[i];
+            const isLeaf = i === keyPath.length - 1;
+            if (!currentLevel[keyType]) {
+                currentLevel[keyType] = {
+                    instances: [],
+                    children: isLeaf ? null : {}
+                };
+            }
+            if (isLeaf) {
+                // Add instance to the leaf node
+                currentLevel[keyType].instances.push({
+                    scopes: options === null || options === void 0 ? void 0 : options.scopes,
+                    instance
+                });
             } else {
-                throw new Error(`Invalid KTA containing an empty false or undefined kt: ${ktaArray.join('.')}`);
+                // Navigate deeper into the tree
+                if (!currentLevel[keyType].children) {
+                    currentLevel[keyType].children = {};
+                }
+                currentLevel = currentLevel[keyType].children;
             }
         }
     };
+    const register = (kta, instance, options)=>{
+        logger.debug('Using deprecated register method. Consider using createInstance instead.');
+        registerInternal(kta, instance, options);
+    };
     const get = (kta, options)=>{
-        const ktaArray = [
+        const keyPath = [
             ...kta
-        ];
-        let currentTree = libTree;
-        let instance = null;
-        // logger.debug(`Getting lib for KTA and scopes`, ktaArray, options?.scopes);
-        while(ktaArray.length > 0){
-            const kt = ktaArray.pop();
-            if (kt) {
-                if (ktaArray.length === 0 && currentTree[kt]) {
-                    const element = currentTree[kt];
-                    const scopedInstanceArray = element[0];
-                    if (scopedInstanceArray.length > 0 && isScopedInstance(scopedInstanceArray[0])) {
-                        instance = retrieveScopedInstance(scopedInstanceArray, options === null || options === void 0 ? void 0 : options.scopes);
-                        // eslint-disable-next-line max-depth
-                        if (!instance) {
-                            var _options_scopes;
-                            throw new Error(`No Instance not found for kta: ${JSON.stringify(ktaArray)}, Scopes: ${options === null || options === void 0 ? void 0 : (_options_scopes = options.scopes) === null || _options_scopes === void 0 ? void 0 : _options_scopes.join(', ')}`);
-                        }
-                    } else {
-                        throw new Error(`No Instance not found for kta: ${JSON.stringify(ktaArray)}, Last Key not a instance: ${kt}`);
-                    }
-                } else {
-                    if (!currentTree[kt]) {
-                        throw new Error(`Lib not found for kta: ${JSON.stringify(ktaArray)}, Subtree Not Found: ${kt}`);
-                    } else {
-                        currentTree = currentTree[kt][1];
-                    }
+        ].reverse();
+        let currentLevel = instanceTree;
+        // Navigate to the target node
+        for(let i = 0; i < keyPath.length; i++){
+            const keyType = keyPath[i];
+            const isLeaf = i === keyPath.length - 1;
+            if (!currentLevel[keyType]) {
+                throw new Error(`Instance not found for key path: ${kta.join('.')}, Missing key: ${keyType}`);
+            }
+            if (isLeaf) {
+                // Found the target node, extract instance
+                const scopedInstances = currentLevel[keyType].instances;
+                if (scopedInstances.length === 0) {
+                    throw new Error(`No instances registered for key path: ${kta.join('.')}`);
                 }
+                return findScopedInstance(scopedInstances, options === null || options === void 0 ? void 0 : options.scopes);
             } else {
-                throw new Error(`Invalid KTA containing an empty false or undefined kt: ${JSON.stringify(ktaArray)}`);
+                // Continue navigation
+                if (!currentLevel[keyType].children) {
+                    throw new Error(`Instance not found for key path: ${kta.join('.')}, No children for: ${keyType}`);
+                }
+                currentLevel = currentLevel[keyType].children;
             }
         }
-        return instance;
+        return null;
     };
-    return {
+    const registry = {
+        type,
+        registryHub,
+        createInstance,
         register,
         get,
-        // TODO: Remove this once we have a better way to test
-        libTree
+        instanceTree
     };
+    return registry;
 };
 
 export { createRegistry };
-//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVnaXN0cnkuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVnaXN0cnkuanMiLCJzb3VyY2VzIjpbXSwic291cmNlc0NvbnRlbnQiOltdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7In0=

package/dist/RegistryHub.cjs

@@ -0,0 +1,78 @@
+'use strict';
+
+Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+
+const logger$1 = require('./logger.cjs');
+const RegistryHubError = require('./errors/RegistryHubError.cjs');
+
+const logger = logger$1.default.get("RegistryHub");
+const createRegistryHub = ()=>{
+    const registries = {};
+    const createRegistry = (type, factory)=>{
+        logger.debug(`Creating new registry with type: ${type}`);
+        if (registries[type]) {
+            throw new RegistryHubError.DuplicateRegistryTypeError(type);
+        }
+        // Create the registry with a reference to this hub
+        const registry = factory(type, hub);
+        // Ensure the created registry has a reference to this hub if not already set
+        if (!('registryHub' in registry) || registry.registryHub !== hub) {
+            // @ts-expect-error: registryHub is optional and may be readonly, but we want to set it for hub awareness
+            registry.registryHub = hub;
+        }
+        // Register the created registry
+        registries[type] = registry;
+        logger.debug(`Successfully created and registered new registry with type: ${type}`);
+        return registry;
+    };
+    const registerRegistry = (registry)=>{
+        const type = registry.type;
+        logger.debug(`Registering registry with type: ${type}`);
+        if (registries[type]) {
+            throw new RegistryHubError.DuplicateRegistryTypeError(type);
+        }
+        registries[type] = registry;
+        // Ensure the created registry has a reference to this hub if not already set
+        if (!('registryHub' in registry) || registry.registryHub !== hub) {
+            // @ts-expect-error: registryHub is optional and may be readonly, but we want to set it for hub awareness
+            registry.registryHub = hub;
+        }
+        logger.debug(`Successfully registered registry with type: ${type}`);
+    };
+    const get = (type, kta, options)=>{
+        var _options_scopes;
+        logger.debug(`Looking up instance for type: ${type}, kta: ${kta.join('.')}, scopes: ${(options === null || options === void 0 ? void 0 : (_options_scopes = options.scopes) === null || _options_scopes === void 0 ? void 0 : _options_scopes.join(',')) || 'none'}`);
+        const registry = registries[type];
+        if (!registry) {
+            const availableTypes = Object.keys(registries);
+            throw new RegistryHubError.RegistryTypeNotFoundError(type, availableTypes);
+        }
+        return registry.get(kta, options);
+    };
+    const getRegistry = (type)=>{
+        return registries[type] || null;
+    };
+    const getRegisteredTypes = ()=>{
+        return Object.keys(registries);
+    };
+    const unregisterRegistry = (type)=>{
+        if (registries[type]) {
+            delete registries[type];
+            logger.debug(`Unregistered registry under type: ${type}`);
+            return true;
+        }
+        return false;
+    };
+    const hub = {
+        createRegistry,
+        registerRegistry,
+        get,
+        getRegistry,
+        getRegisteredTypes,
+        unregisterRegistry
+    };
+    return hub;
+};
+
+exports.createRegistryHub = createRegistryHub;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVnaXN0cnlIdWIuY2pzIiwic291cmNlcyI6W10sInNvdXJjZXNDb250ZW50IjpbXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OyJ9

package/dist/RegistryHub.d.ts

@@ -0,0 +1,3 @@
+import { RegistryHub } from './types';
+export type { RegistryHub } from './types';
+export declare const createRegistryHub: () => RegistryHub;