@wildo-ai/saas-frontend-lib 1.0.1

package/dist/esm/core/errors/error-management.frontend.service.js

@@ -0,0 +1,746 @@
+/**
+ * Unified Error Management Service
+ *
+ * Centralized error management service consolidating:
+ * - Error classification (static methods)
+ * - HTTP error behavior (static methods)
+ * - Global error handlers (static methods)
+ * - Error deduplication (instance methods)
+ * - Error handling orchestration (instance methods)
+ * - HTTP error handling (instance methods)
+ *
+ * This service replaces multiple separate services and utility functions
+ * to provide a single, cohesive error management system.
+ */
+import { ErrorType, ErrorCustomMessageReference, ERROR_DEFINITIONS, ResourceOperationRiskLevel, ErrorActionFrontend, ErrorSeverity, } from '@wildo-ai/saas-models';
+import { frontendEventBus } from '../../core/events/event-bus.frontend.service.js';
+import { FrontendEvents } from '../../core/events/events.frontend.schemas.js';
+import { LoggerFrontendService } from '../../core/monitoring/logger.frontend.service.js';
+import { sharedErrorBuilder } from './errors-builder.frontend.services.js';
+import { ERROR_DEDUPLICATION_WINDOW_MS, ERROR_MAX_DUPLICATES, } from './errors.frontend.schemas.js';
+import { HTTP_ERROR_BEHAVIOR_MATRIX } from './http-error-behavior.frontend.schemas.js';
+const logger = LoggerFrontendService.getLogger();
+const logDebug = logger.debugByType('ErrorManagement');
+logger.setDebugTypeLogging('ErrorManagement', false);
+/**
+ * Default behavior for unknown HTTP status codes
+ */
+const DEFAULT_HTTP_ERROR_BEHAVIOR = {
+    errorType: ErrorType.UNKNOWN,
+    severity: ErrorSeverity.HIGH,
+    frontendActions: [ErrorActionFrontend.NOTIFY],
+    showToUser: true,
+    emitEvent: true,
+    shouldRetry: false,
+    description: 'Unknown HTTP error',
+};
+/**
+ * Network error behavior (no HTTP status code)
+ */
+const NETWORK_ERROR_BEHAVIOR = {
+    errorType: ErrorType.NETWORK,
+    severity: ErrorSeverity.HIGH,
+    frontendActions: [ErrorActionFrontend.NOTIFY],
+    showToUser: true,
+    emitEvent: true,
+    shouldRetry: true,
+    maxRetries: 3,
+    description: 'Network connectivity issue',
+};
+/**
+ * Unified Error Management Service
+ *
+ * Provides all error management functionality in a single, cohesive service.
+ */
+class ErrorManagementService {
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Instance State (for stateful operations)
+    // ─────────────────────────────────────────────────────────────────────────────
+    /** Tracked errors for deduplication */
+    trackedErrors = new Map();
+    /** Runtime overrides for HTTP error behavior */
+    static runtimeOverrides = new Map();
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Static Methods: Error Classification
+    // ─────────────────────────────────────────────────────────────────────────────
+    /**
+     * Classify an error and determine its ErrorType
+     *
+     * Classification priority:
+     * 1. Error name (most specific)
+     * 2. Error message content (pattern matching)
+     * 3. Default fallback (UNKNOWN or UNCAUGHT_EXCEPTION)
+     */
+    static classifyError(error) {
+        // Handle non-Error objects
+        if (!(error instanceof Error)) {
+            return ErrorType.UNKNOWN;
+        }
+        const message = error.message.toLowerCase();
+        const errorName = error.name;
+        // Check error name first (most specific classification)
+        if (errorName === 'ValidationError' || errorName === 'ZodError') {
+            return ErrorType.VALIDATION;
+        }
+        if (errorName === 'JsonWebTokenError' || errorName === 'TokenExpiredError') {
+            return ErrorType.AUTHENTICATION;
+        }
+        // Check message content for pattern matching
+        if (message.includes('validation') || message.includes('invalid')) {
+            return ErrorType.VALIDATION;
+        }
+        if (message.includes('not found')) {
+            return ErrorType.NOT_FOUND;
+        }
+        if (message.includes('unauthorized')) {
+            return ErrorType.AUTHENTICATION;
+        }
+        if (message.includes('forbidden') || message.includes('permission')) {
+            return ErrorType.AUTHORIZATION;
+        }
+        if (message.includes('conflict') || message.includes('already exists')) {
+            return ErrorType.CONFLICT;
+        }
+        if (message.includes('network')) {
+            return ErrorType.NETWORK;
+        }
+        if (message.includes('rate limit') || message.includes('too many requests')) {
+            return ErrorType.RATE_LIMIT;
+        }
+        if (message.includes('business rule') || message.includes('constraint')) {
+            return ErrorType.BUSINESS_RULE;
+        }
+        // Default fallback
+        return ErrorType.UNCAUGHT_EXCEPTION;
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Static Methods: HTTP Error Behavior
+    // ─────────────────────────────────────────────────────────────────────────────
+    /**
+     * Merge base behavior with risk-level specific overrides
+     */
+    static mergeBehaviorWithRiskOverride(base, riskOverride) {
+        if (!riskOverride) {
+            return base;
+        }
+        return {
+            ...base,
+            ...riskOverride,
+            // Merge frontendActions if provided, otherwise keep base
+            frontendActions: riskOverride.frontendActions !== undefined
+                ? riskOverride.frontendActions
+                : base.frontendActions,
+        };
+    }
+    /**
+     * Get the error behavior for a specific HTTP status code and risk level
+     *
+     * Resolution order:
+     * 1. Runtime overrides (if any)
+     * 2. Base matrix with risk-level overrides
+     * 3. Fallback based on status code range
+     * 4. Default behavior
+     */
+    static getHttpErrorBehavior(statusCode, riskLevel = ResourceOperationRiskLevel.MEDIUM) {
+        // 1. Check runtime overrides first
+        const runtimeOverride = ErrorManagementService.runtimeOverrides.get(statusCode);
+        if (runtimeOverride) {
+            const riskOverride = runtimeOverride.riskOverrides?.[riskLevel];
+            return ErrorManagementService.mergeBehaviorWithRiskOverride(runtimeOverride.base, riskOverride);
+        }
+        // 2. Check base matrix
+        const matrixEntry = HTTP_ERROR_BEHAVIOR_MATRIX[statusCode];
+        if (matrixEntry) {
+            const riskOverride = matrixEntry.riskOverrides?.[riskLevel];
+            return ErrorManagementService.mergeBehaviorWithRiskOverride(matrixEntry.base, riskOverride);
+        }
+        // 3. Fallback based on status code range
+        if (statusCode >= 400 && statusCode < 500) {
+            return {
+                errorType: ErrorType.VALIDATION,
+                severity: ErrorSeverity.LOW,
+                frontendActions: [ErrorActionFrontend.NOTIFY],
+                showToUser: true,
+                emitEvent: true,
+                shouldRetry: false,
+                description: `Client error (${statusCode})`,
+            };
+        }
+        if (statusCode >= 500 && statusCode < 600) {
+            return {
+                errorType: ErrorType.INTERNAL,
+                severity: ErrorSeverity.HIGH,
+                frontendActions: [ErrorActionFrontend.NOTIFY],
+                showToUser: true,
+                emitEvent: true,
+                shouldRetry: true,
+                maxRetries: 2,
+                description: `Server error (${statusCode})`,
+            };
+        }
+        // 4. Default behavior
+        return DEFAULT_HTTP_ERROR_BEHAVIOR;
+    }
+    /**
+     * Check if an HTTP status code should trigger logout for a given risk level
+     */
+    static shouldTriggerLogout(statusCode, riskLevel = ResourceOperationRiskLevel.MEDIUM) {
+        const behavior = ErrorManagementService.getHttpErrorBehavior(statusCode, riskLevel);
+        return behavior.triggerLogout === true;
+    }
+    /**
+     * Check if an HTTP status code should be retried
+     */
+    static shouldRetryHttpError(statusCode, riskLevel = ResourceOperationRiskLevel.MEDIUM) {
+        const behavior = ErrorManagementService.getHttpErrorBehavior(statusCode, riskLevel);
+        return behavior.shouldRetry === true;
+    }
+    /**
+     * Check if an error should emit an event (can be overridden by silent mode)
+     */
+    static shouldEmitErrorEvent(statusCode, riskLevel = ResourceOperationRiskLevel.MEDIUM, silent = false) {
+        if (silent) {
+            return false;
+        }
+        const behavior = ErrorManagementService.getHttpErrorBehavior(statusCode, riskLevel);
+        return behavior.emitEvent !== false;
+    }
+    /**
+     * Set a runtime override for a specific HTTP status code
+     */
+    static setHttpErrorBehaviorOverride(statusCode, behavior) {
+        ErrorManagementService.runtimeOverrides.set(statusCode, behavior);
+    }
+    /**
+     * Clear a runtime override for a specific HTTP status code
+     */
+    static clearHttpErrorBehaviorOverride(statusCode) {
+        ErrorManagementService.runtimeOverrides.delete(statusCode);
+    }
+    /**
+     * Clear all runtime overrides
+     */
+    static clearAllHttpErrorBehaviorOverrides() {
+        ErrorManagementService.runtimeOverrides.clear();
+    }
+    /**
+     * Get network error behavior
+     */
+    static getNetworkErrorBehavior() {
+        return NETWORK_ERROR_BEHAVIOR;
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Static Methods: Global Error Handlers
+    // ─────────────────────────────────────────────────────────────────────────────
+    /**
+     * Initialize global error handlers
+     * Should be called once during application startup
+     */
+    static initializeGlobalErrorHandlers() {
+        // Get singleton instance for event handlers
+        const errorManagement = ErrorManagementService.getInstance();
+        // Handle unhandled promise rejections
+        window.addEventListener('unhandledrejection', (event) => {
+            logDebug('Unhandled promise rejection caught', {
+                reason: event.reason,
+                promise: event.promise,
+            });
+            // Prevent default browser console error
+            event.preventDefault();
+            // Process through error management service
+            errorManagement.handleError(event.reason, {
+                source: 'promise',
+                additionalContext: {
+                    unhandledRejection: true,
+                    promise: String(event.promise),
+                },
+            });
+        });
+        // Handle general errors (fallback for errors not caught by ErrorBoundary)
+        window.addEventListener('error', (event) => {
+            // Only handle if not already handled by ErrorBoundary
+            if (!event.error || !event.error.__handledByErrorBoundary) {
+                logDebug('Global error event caught', {
+                    message: event.message,
+                    filename: event.filename,
+                    lineno: event.lineno,
+                    colno: event.colno,
+                    error: event.error,
+                });
+                errorManagement.handleError(event.error || new Error(event.message), {
+                    source: 'manual',
+                    additionalContext: {
+                        filename: event.filename,
+                        lineno: event.lineno,
+                        colno: event.colno,
+                    },
+                });
+            }
+        });
+        logDebug('Global error handlers initialized');
+    }
+    /**
+     * Cleanup global error handlers (for testing)
+     */
+    static cleanupGlobalErrorHandlers() {
+        // Note: In a real app, you might want to store handlers to remove them
+        // For now, we'll leave them active for the app lifetime
+        logDebug('Global error handlers cleanup called (handlers remain active)');
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Instance Methods: Error Deduplication
+    // ─────────────────────────────────────────────────────────────────────────────
+    /**
+     * Check if error should be suppressed (is duplicate)
+     */
+    shouldSuppress(wildoError) {
+        const fingerprint = this.createFingerprint(wildoError);
+        const fingerprintKey = this.getFingerprintKey(fingerprint);
+        const now = Date.now();
+        const tracked = this.trackedErrors.get(fingerprintKey);
+        if (!tracked) {
+            // First occurrence - track it
+            this.trackedErrors.set(fingerprintKey, {
+                fingerprint,
+                timestamp: now,
+                count: 1,
+            });
+            // Cleanup old entries
+            this.cleanup(now);
+            return false; // Don't suppress
+        }
+        // Check if within deduplication window
+        const age = now - tracked.timestamp;
+        if (age > ERROR_DEDUPLICATION_WINDOW_MS) {
+            // Outside window - reset tracking
+            tracked.timestamp = now;
+            tracked.count = 1;
+            return false; // Don't suppress
+        }
+        // Within window - increment count
+        tracked.count++;
+        // Allow through if too many duplicates (might indicate real issue)
+        if (tracked.count > ERROR_MAX_DUPLICATES) {
+            logDebug('Allowing duplicate error through (max duplicates exceeded)', {
+                fingerprint,
+                count: tracked.count,
+            });
+            tracked.count = 1; // Reset count
+            return false; // Don't suppress
+        }
+        // Suppress duplicate
+        logDebug('Suppressing duplicate error', {
+            fingerprint,
+            count: tracked.count,
+            age,
+        });
+        return true; // Suppress
+    }
+    /**
+     * Create error fingerprint for deduplication
+     */
+    createFingerprint(wildoError) {
+        const context = wildoError.context || {};
+        return {
+            type: wildoError.type,
+            customMessageReference: wildoError.customMessageReference,
+            url: context.url,
+            resourceType: context.resourceType,
+            operationIdentifier: context.operationIdentifier,
+        };
+    }
+    /**
+     * Get fingerprint key for Map lookup
+     */
+    getFingerprintKey(fingerprint) {
+        return JSON.stringify(fingerprint);
+    }
+    /**
+     * Cleanup old tracked errors
+     */
+    cleanup(now) {
+        for (const [key, tracked] of this.trackedErrors.entries()) {
+            if (now - tracked.timestamp > ERROR_DEDUPLICATION_WINDOW_MS * 2) {
+                this.trackedErrors.delete(key);
+            }
+        }
+    }
+    /**
+     * Clear all tracked errors (for testing)
+     */
+    clearDeduplication() {
+        this.trackedErrors.clear();
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Instance Methods: Error Handling Orchestration
+    // ─────────────────────────────────────────────────────────────────────────────
+    /**
+     * Handle any error - unified entry point
+     *
+     * @param error - Error object, string, or any error value
+     * @param context - Error context for routing and processing
+     */
+    handleError(error, context = {}) {
+        try {
+            logDebug('ErrorManagement.handleError called', {
+                error: error instanceof Error ? error.message : String(error),
+                source: context.source,
+                riskLevel: context.riskLevel,
+            });
+            // Route to appropriate handler based on source
+            switch (context.source) {
+                case 'http':
+                    // Convert ErrorManagerContext to HttpErrorContext
+                    const httpContext = {
+                        url: context.additionalContext?.url,
+                        method: context.additionalContext?.method,
+                        riskLevel: context.riskLevel,
+                        resourceType: context.resourceType,
+                        operationIdentifier: context.operationIdentifier,
+                        silent: context.silent,
+                        additionalContext: context.additionalContext,
+                    };
+                    this.handleHttpError(error, httpContext);
+                    break;
+                case 'react':
+                    this.handleReactError(error, context);
+                    break;
+                case 'router':
+                    this.handleRouterError(error, context);
+                    break;
+                case 'websocket':
+                    this.handleWebSocketError(error, context);
+                    break;
+                case 'promise':
+                    this.handlePromiseError(error, context);
+                    break;
+                case 'manual':
+                default:
+                    this.handleGenericError(error, context);
+                    break;
+            }
+        }
+        catch (handlerError) {
+            // Fallback if error handling itself fails
+            logger.error('ErrorManagement.handleError failed', {
+                originalError: error,
+                handlerError: handlerError instanceof Error ? handlerError.message : String(handlerError),
+            });
+        }
+    }
+    /**
+     * Handle React component errors
+     */
+    handleReactError(error, context) {
+        // Note: For full React errors with component stack, use ErrorBoundary which calls buildReactError()
+        const wildoError = sharedErrorBuilder.buildWildoError_Frontend(ErrorType.UNCAUGHT_EXCEPTION, {
+            context: {
+                source: 'react',
+                errorName: error.name,
+                errorMessage: error.message,
+                errorStack: error.stack,
+                ...(context.additionalContext || {}),
+            },
+        });
+        this.emitError(wildoError, context.silent);
+    }
+    /**
+     * Handle router errors
+     */
+    handleRouterError(error, context) {
+        // Use helper method for consistent router error building
+        const status = context.additionalContext?.status;
+        const wildoError = sharedErrorBuilder.buildRouterError(error, status, {
+            source: 'router',
+            ...(context.additionalContext || {}),
+        });
+        this.emitError(wildoError, context.silent);
+    }
+    /**
+     * Handle WebSocket errors
+     */
+    handleWebSocketError(error, context) {
+        // Use helper method for consistent WebSocket error building
+        const wildoError = sharedErrorBuilder.buildWebSocketError(error, {
+            ...(context.additionalContext || {}),
+        });
+        this.emitError(wildoError, context.silent);
+    }
+    /**
+     * Handle promise rejection errors
+     */
+    handlePromiseError(error, context) {
+        // Use helper method for consistent promise error building
+        const wildoError = sharedErrorBuilder.buildPromiseError(error, {
+            ...(context.additionalContext || {}),
+        });
+        this.emitError(wildoError, context.silent);
+    }
+    /**
+     * Handle generic/manual errors
+     */
+    handleGenericError(error, context) {
+        // Use centralized error classification
+        const errorType = ErrorManagementService.classifyError(error);
+        const wildoError = sharedErrorBuilder.buildWildoError_Frontend(errorType, {
+            context: {
+                source: context.source || 'manual',
+                errorMessage: error instanceof Error ? error.message : String(error),
+                errorStack: error instanceof Error ? error.stack : undefined,
+                ...(context.additionalContext || {}),
+            },
+        });
+        this.emitError(wildoError, context.silent);
+    }
+    /**
+     * Emit error via EventBus
+     */
+    emitError(wildoError, silent) {
+        if (silent) {
+            logDebug('Error suppressed (silent mode)', {
+                errorType: wildoError.type,
+                customMessageReference: wildoError.customMessageReference,
+            });
+            return;
+        }
+        try {
+            frontendEventBus.emit(FrontendEvents.ERROR_OCCURED, {
+                error: wildoError,
+            });
+        }
+        catch (emitError) {
+            logger.error('Failed to emit error event', { error: emitError });
+        }
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Instance Methods: HTTP Error Handling
+    // ─────────────────────────────────────────────────────────────────────────────
+    /**
+     * Handle an HTTP error
+     *
+     * @param error - The axios error or any error object
+     * @param context - Additional context for error handling
+     * @returns HttpErrorResult with error details and behavior
+     */
+    handleHttpError(error, context = {}) {
+        const httpStatus = error?.response?.status;
+        const responseData = error?.response?.data;
+        const riskLevel = context.riskLevel || ResourceOperationRiskLevel.MEDIUM;
+        logDebug('Handling HTTP error', {
+            status: httpStatus,
+            url: context.url || error?.config?.url,
+            method: context.method || error?.config?.method,
+            riskLevel,
+            hasResponseData: !!responseData,
+        });
+        // Determine behavior based on status code AND risk level
+        const behavior = httpStatus
+            ? ErrorManagementService.getHttpErrorBehavior(httpStatus, riskLevel)
+            : ErrorManagementService.getNetworkErrorBehavior();
+        // Extract error details from response if available
+        const errorDetails = this.extractErrorDetails(responseData);
+        // Build the WildoError_Frontend
+        const wildoError = this.buildWildoError(error, behavior, errorDetails, context);
+        // Emit event if configured and not silent
+        let eventEmitted = false;
+        const shouldEmit = httpStatus
+            ? ErrorManagementService.shouldEmitErrorEvent(httpStatus, riskLevel, context.silent)
+            : !context.silent; // For network errors, only check silent flag
+        logDebug('Error event emission check', {
+            httpStatus,
+            riskLevel,
+            silent: context.silent,
+            shouldEmit,
+            triggerLogout: behavior.triggerLogout,
+            errorType: wildoError.type,
+            emitEvent: behavior.emitEvent,
+        });
+        if (shouldEmit) {
+            this.emitErrorEvent(wildoError);
+            eventEmitted = true;
+        }
+        else {
+            logDebug('Error event NOT emitted', {
+                reason: context.silent ? 'silent mode' : 'emitEvent=false',
+                errorType: wildoError.type,
+                httpStatus,
+            });
+        }
+        // Log the error
+        this.logError(wildoError, behavior, context);
+        return {
+            wildoError,
+            behavior,
+            eventEmitted,
+            shouldLogout: behavior.triggerLogout === true,
+        };
+    }
+    /**
+     * Extract error details from response data
+     */
+    extractErrorDetails(responseData) {
+        if (!responseData) {
+            return {};
+        }
+        // Handle Wildo error format
+        if (responseData.error) {
+            const backendError = responseData.error;
+            return {
+                customMessageReference: backendError.code || backendError.customMessageReference,
+                message: backendError.message,
+                errorContext: backendError.context,
+                backendErrorType: backendError.type,
+            };
+        }
+        // Handle simple error format
+        return {
+            customMessageReference: responseData.code,
+            message: responseData.message,
+        };
+    }
+    /**
+     * Build WildoError_Frontend from error and behavior
+     */
+    buildWildoError(error, behavior, errorDetails, context) {
+        // Use backend error type if provided, otherwise use behavior-derived type
+        const errorType = errorDetails.backendErrorType || behavior.errorType;
+        const errorDefinition = ERROR_DEFINITIONS[errorType];
+        // Determine custom message reference
+        const customMessageReference = errorDetails.customMessageReference
+            || errorDefinition?.defaultCustomMessageReference
+            || ErrorCustomMessageReference.UNKNOWN;
+        // Build error context
+        const errorContext = {
+            httpStatus: error?.response?.status,
+            url: context.url || error?.config?.url,
+            method: context.method || error?.config?.method,
+            ...(errorDetails.errorContext || {}),
+            ...(context.additionalContext || {}),
+        };
+        if (context.resourceType) {
+            errorContext.resourceType = context.resourceType;
+        }
+        if (context.operationIdentifier) {
+            errorContext.operationIdentifier = context.operationIdentifier;
+        }
+        if (context.operationPathKey) {
+            errorContext.operationPathKey = context.operationPathKey;
+        }
+        if (errorDetails.message) {
+            errorContext.originalMessage = errorDetails.message;
+        }
+        // Build the WildoError_Frontend
+        const wildoError = sharedErrorBuilder.buildWildoError_Frontend(errorType, {
+            customMessageReference: customMessageReference,
+            operationPathKey: context.operationPathKey,
+            context: errorContext,
+        });
+        // Override some properties from behavior
+        wildoError.showToUser = behavior.showToUser;
+        wildoError.frontendActions = behavior.frontendActions;
+        if (behavior.redirectPolicy) {
+            wildoError.redirectPolicy = behavior.redirectPolicy;
+        }
+        // Attach triggerLogout flag for authentication error handling
+        wildoError.triggerLogout = behavior.triggerLogout === true;
+        // Phase 1b: Extract and attach userGuidance from backend error response
+        const guidance = error?.response?.data?.error?.userGuidance;
+        if (guidance) {
+            // Follow existing pattern: patch via cast (same as other dynamic fields in buildWildoError)
+            wildoError.userGuidance = guidance;
+        }
+        return wildoError;
+    }
+    /**
+     * Emit ERROR_OCCURED event
+     */
+    emitErrorEvent(wildoError) {
+        try {
+            frontendEventBus.emit(FrontendEvents.ERROR_OCCURED, {
+                error: wildoError,
+            });
+            logDebug('Emitted ERROR_OCCURED event', {
+                errorType: wildoError.type,
+                customMessageReference: wildoError.customMessageReference,
+            });
+        }
+        catch (emitError) {
+            logger.warn('Failed to emit ERROR_OCCURED event', { error: emitError });
+        }
+    }
+    /**
+     * Log the error with appropriate level
+     */
+    logError(wildoError, behavior, context) {
+        const logContext = {
+            errorType: wildoError.type,
+            customMessageReference: wildoError.customMessageReference,
+            severity: behavior.severity,
+            url: context.url,
+            resourceType: context.resourceType,
+            operationIdentifier: context.operationIdentifier,
+        };
+        // Log based on severity
+        switch (behavior.severity) {
+            case 'critical':
+            case 'high':
+                logger.error(behavior.description, logContext);
+                break;
+            case 'medium':
+                logger.warn(behavior.description, logContext);
+                break;
+            case 'low':
+            default:
+                logDebug(behavior.description, logContext);
+                break;
+        }
+    }
+    /**
+     * Check if an error is an authentication error
+     */
+    isAuthenticationError(error) {
+        const httpStatus = error?.response?.status;
+        if (httpStatus === 401) {
+            return true;
+        }
+        // Check response data for auth error types
+        const responseData = error?.response?.data;
+        if (responseData?.error?.type === ErrorType.AUTHENTICATION) {
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Check if an error is an authorization error
+     */
+    isAuthorizationError(error) {
+        const httpStatus = error?.response?.status;
+        if (httpStatus === 403) {
+            return true;
+        }
+        // Check response data for auth error types
+        const responseData = error?.response?.data;
+        if (responseData?.error?.type === ErrorType.AUTHORIZATION) {
+            return true;
+        }
+        return false;
+    }
+    // ─────────────────────────────────────────────────────────────────────────────
+    // Singleton Pattern
+    // ─────────────────────────────────────────────────────────────────────────────
+    static instance = null;
+    /**
+     * Get singleton instance
+     */
+    static getInstance() {
+        if (!ErrorManagementService.instance) {
+            ErrorManagementService.instance = new ErrorManagementService();
+        }
+        return ErrorManagementService.instance;
+    }
+}
+// Export singleton instance
+export const errorManagement = ErrorManagementService.getInstance();
+// Export class for static method access
+export { ErrorManagementService };
+//# sourceMappingURL=error-management.frontend.service.js.map