@fjell/registry 4.4.5 → 4.4.7

package/dist/errors/RegistryHubError.d.ts

@@ -0,0 +1,39 @@
+import { RegistryError } from './RegistryError';
+/**
+ * Base class for registry hub-related errors
+ */
+export declare abstract class RegistryHubError extends RegistryError {
+    readonly hubType?: string;
+    constructor(message: string, hubType?: string, context?: Record<string, any>);
+}
+/**
+ * Thrown when attempting to register a registry with a type that already exists
+ */
+export declare class DuplicateRegistryTypeError extends RegistryHubError {
+    readonly duplicateType: string;
+    constructor(type: string, context?: Record<string, any>);
+}
+/**
+ * Thrown when attempting to access a registry type that doesn't exist
+ */
+export declare class RegistryTypeNotFoundError extends RegistryHubError {
+    readonly requestedType: string;
+    readonly availableTypes: string[];
+    constructor(requestedType: string, availableTypes?: string[], context?: Record<string, any>);
+}
+/**
+ * Thrown when a registry factory function fails to create a valid registry
+ */
+export declare class RegistryFactoryError extends RegistryHubError {
+    readonly factoryError: Error;
+    readonly attemptedType: string;
+    constructor(type: string, factoryError: Error, context?: Record<string, any>);
+}
+/**
+ * Thrown when a factory returns an invalid registry object
+ */
+export declare class InvalidRegistryFactoryResultError extends RegistryHubError {
+    readonly factoryResult: any;
+    readonly attemptedType: string;
+    constructor(type: string, factoryResult: any, context?: Record<string, any>);
+}

package/dist/errors/RegistryHubError.js

@@ -0,0 +1,84 @@
+import { RegistryError } from './RegistryError.js';
+
+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;
+}
+/**
+ * Base class for registry hub-related errors
+ */ class RegistryHubError extends RegistryError {
+    constructor(message, hubType, context){
+        const enrichedContext = hubType ? {
+            ...context,
+            hubType
+        } : context;
+        super(message, '', enrichedContext), _define_property(this, "hubType", void 0);
+        this.hubType = hubType;
+    }
+}
+/**
+ * Thrown when attempting to register a registry with a type that already exists
+ */ class DuplicateRegistryTypeError extends RegistryHubError {
+    constructor(type, context){
+        super(`Registry already registered under type: ${type}. ` + `Each registry type must be unique within a registry hub.`, '', {
+            ...context,
+            duplicateType: type
+        }), _define_property(this, "duplicateType", void 0);
+        this.duplicateType = type;
+    }
+}
+/**
+ * Thrown when attempting to access a registry type that doesn't exist
+ */ class RegistryTypeNotFoundError extends RegistryHubError {
+    constructor(requestedType, availableTypes = [], context){
+        let message = `No registry registered under type: ${requestedType}`;
+        if (availableTypes.length > 0) {
+            message += `. Available types: [${availableTypes.join(', ')}]`;
+        }
+        super(message, '', {
+            ...context,
+            requestedType,
+            availableTypes
+        }), _define_property(this, "requestedType", void 0), _define_property(this, "availableTypes", void 0);
+        this.requestedType = requestedType;
+        this.availableTypes = availableTypes;
+    }
+}
+/**
+ * Thrown when a registry factory function fails to create a valid registry
+ */ class RegistryFactoryError extends RegistryHubError {
+    constructor(type, factoryError, context){
+        super(`Registry factory failed to create registry of type '${type}': ${factoryError.message}`, '', {
+            ...context,
+            attemptedType: type,
+            originalError: factoryError.message
+        }), _define_property(this, "factoryError", void 0), _define_property(this, "attemptedType", void 0);
+        this.factoryError = factoryError;
+        this.attemptedType = type;
+    }
+}
+/**
+ * Thrown when a factory returns an invalid registry object
+ */ class InvalidRegistryFactoryResultError extends RegistryHubError {
+    constructor(type, factoryResult, context){
+        super(`Registry factory returned invalid registry for type '${type}'. ` + `Expected registry with 'type', 'get', 'register', and 'createInstance' properties, ` + `got: ${typeof factoryResult}`, '', {
+            ...context,
+            attemptedType: type,
+            factoryResult: typeof factoryResult
+        }), _define_property(this, "factoryResult", void 0), _define_property(this, "attemptedType", void 0);
+        this.factoryResult = factoryResult;
+        this.attemptedType = type;
+    }
+}
+
+export { DuplicateRegistryTypeError, InvalidRegistryFactoryResultError, RegistryFactoryError, RegistryHubError, RegistryTypeNotFoundError };
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiUmVnaXN0cnlIdWJFcnJvci5qcyIsInNvdXJjZXMiOltdLCJzb3VyY2VzQ29udGVudCI6W10sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OzsifQ==

package/dist/errors/index.d.ts

@@ -0,0 +1,4 @@
+export * from './RegistryError';
+export * from './InstanceError';
+export * from './CoordinateError';
+export * from './RegistryHubError';