userface/build/engine/error-recovery.js

Universal Data-Driven UI Engine with live data, validation, and multi-platform support

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.errorRecovery = exports.ErrorRecovery = void 0;
const logger_1 = require("./logger");
class ErrorRecovery {
    constructor() {
        Object.defineProperty(this, "defaultFallback", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: 'div'
        });
    }
    handleComponentError(error, spec, config) {
        const recoveryConfig = config || this.getDefaultConfig();
        logger_1.logger.warn(`Component error occurred: ${spec.component} - ${error.message} (strategy: ${recoveryConfig.strategy})`);
        switch (recoveryConfig.strategy) {
            case 'fallback':
                return this.createFallbackComponent(error, spec, recoveryConfig.fallbackComponent);
            case 'retry':
                return this.retryComponent(spec, recoveryConfig);
            case 'ignore':
                return this.createSilentFallback(spec);
            case 'throw':
            default:
                throw error;
        }
    }
    createFallbackComponent(error, spec, fallbackComponent) {
        const component = fallbackComponent || this.defaultFallback;
        return {
            component,
            props: {
                style: {
                    padding: '10px',
                    border: '1px solid #ff6b6b',
                    backgroundColor: '#ffe6e6',
                    color: '#d63031',
                    borderRadius: '4px',
                    fontSize: '14px'
                },
                children: this.formatErrorMessage(error, spec)
            },
            error,
            originalSpec: spec
        };
    }
    createSilentFallback(spec) {
        return {
            component: this.defaultFallback,
            props: {
                style: { display: 'none' },
                children: null
            },
            originalSpec: spec
        };
    }
    retryComponent(spec, config) {
        const maxRetries = config.maxRetries || 3;
        // В реальной реализации здесь была бы логика повторных попыток
        // Пока возвращаем fallback
        logger_1.logger.info(`Retrying component: ${spec.component} (max retries: ${maxRetries})`);
        return this.createFallbackComponent(new Error(`Component failed after ${maxRetries} retries`), spec, config.fallbackComponent);
    }
    formatErrorMessage(error, spec) {
        return `Error rendering component '${spec.component}': ${error.message}`;
    }
    canRecover(error) {
        // Определяем, можно ли восстановиться от ошибки
        const nonRecoverableErrors = [
            'Component not found',
            'Invalid component definition',
            'Critical system error'
        ];
        return !nonRecoverableErrors.some(msg => error.message.includes(msg));
    }
    getRecommendedStrategy(error) {
        if (!this.canRecover(error)) {
            return 'throw';
        }
        if (error.message.includes('Network') || error.message.includes('Timeout')) {
            return 'retry';
        }
        return 'fallback';
    }
    getDefaultConfig() {
        return {
            strategy: 'fallback',
            maxRetries: 3,
            fallbackComponent: this.defaultFallback,
            logErrors: true
        };
    }
}
exports.ErrorRecovery = ErrorRecovery;
exports.errorRecovery = new ErrorRecovery();