userface
Version:
Universal Data-Driven UI Engine with live data, validation, and multi-platform support
224 lines (223 loc) • 8.53 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.Engine = void 0;
const lifecycle_manager_1 = require("./lifecycle-manager");
const event_bus_1 = require("./event-bus");
class Engine {
constructor(componentStore, dataService, pluginManager, validator, errorHandler, testRunner, logger) {
Object.defineProperty(this, "componentStore", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "dataService", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "pluginManager", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "validator", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "errorHandler", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "testRunner", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
Object.defineProperty(this, "logger", {
enumerable: true,
configurable: true,
writable: true,
value: void 0
});
this.componentStore = componentStore;
this.dataService = dataService;
this.pluginManager = pluginManager;
this.validator = validator;
this.errorHandler = errorHandler;
this.testRunner = testRunner;
this.logger = logger;
this.logger.info('Engine initialized');
}
// === КОМПОНЕНТЫ ===
async registerComponent(name, component, schema) {
try {
await lifecycle_manager_1.lifecycleManager.executeLifecycle('beforeRegister', { name, component, schema });
this.componentStore.registerComponent(name, component, schema);
await lifecycle_manager_1.lifecycleManager.executeLifecycle('afterRegister', { name, component, schema });
this.logger.info(`Component registered: ${name}`);
}
catch (error) {
await this.handleError(error, { operation: 'registerComponent', name });
}
}
getComponent(name) {
return this.componentStore.getComponent(name);
}
getComponentSchema(name) {
return this.componentStore.getComponentSchema(name);
}
// === РЕНДЕРИНГ ===
async render(userFace, adapterId) {
try {
await lifecycle_manager_1.lifecycleManager.executeLifecycle('beforeRender', { userFace, adapterId });
// Валидация (временно отключена)
// const schema = this.componentRegistry.getComponentSchema(userFace.component);
// if (schema) {
// const validation = this.validationEngine.validateUserFace(userFace, schema);
// if (!validation.isValid) {
// throw new Error(`Validation failed: ${validation.errors.map((e: any) => e.message).join(', ')}`);
// }
// }
// Простой рендеринг - возвращаем компонент с данными
const component = this.componentStore.getComponent(userFace.component);
if (!component) {
throw new Error(`Component not found: ${userFace.component}`);
}
// Обрабатываем data свойства в UserFace
if (userFace.data) {
for (const [key, dataConfig] of Object.entries(userFace.data)) {
const data = await this.dataService.getData(dataConfig.source, dataConfig.config);
userFace[key] = data;
}
}
const result = {
component: component,
props: userFace,
adapterId,
timestamp: Date.now()
};
await lifecycle_manager_1.lifecycleManager.executeLifecycle('afterRender', { userFace, adapterId, result });
return result;
}
catch (error) {
return await this.handleError(error, { operation: 'render', userFace, adapterId });
}
}
// === DATA SERVICE ===
registerDataSource(path, config) {
this.dataService.registerDataSource(path, config);
}
async getData(path, options) {
return this.dataService.getData(path, options);
}
subscribeToData(path, callback) {
return this.dataService.subscribe(path, callback);
}
getDataState(path) {
return this.dataService.getState(path);
}
// === АДАПТЕРЫ ===
registerAdapter(adapter) {
// Простая реализация - сохраняем адаптер в componentStore
this.componentStore.registerAdapter?.(adapter);
this.logger.info(`Adapter registered: ${adapter.id || adapter.name}`);
}
getAdapter(adapterId) {
return this.componentStore.getAdapter?.(adapterId);
}
getAllAdapters() {
return this.componentStore.getAllAdapters?.() || [];
}
// === ПЛАГИНЫ ===
async registerPlugin(plugin, config) {
await this.pluginManager.registerPlugin(plugin, config);
}
async installPlugin(pluginId) {
await this.pluginManager.installPlugin(pluginId);
}
async uninstallPlugin(pluginId) {
await this.pluginManager.uninstallPlugin(pluginId);
}
getActivePlugins() {
return this.pluginManager.getActivePlugins();
}
getInstalledPlugins() {
return this.pluginManager.getInstalledPlugins();
}
getEnabledPlugins() {
return this.pluginManager.getEnabledPlugins();
}
getPlugin(pluginId) {
return this.pluginManager.getPlugin(pluginId);
}
getAllPlugins() {
return this.pluginManager.getAllPlugins();
}
// === ТЕСТИРОВАНИЕ ===
async runAllTests() {
return this.testRunner.runAllTests();
}
createMockComponent(name, schema, render) {
return this.testRunner.createMockComponent(name, schema, render);
}
// === СОЗДАНИЕ КОМПОНЕНТОВ ===
// УБИРАЕМ createComponentFromCode - это костыль!
// Компоненты должны создаваться на сервере, а движок только их регистрирует
// === ЖИЗНЕННЫЙ ЦИКЛ ===
onBeforeRegister(callback) {
lifecycle_manager_1.lifecycleManager.onBeforeRegister(callback);
}
onAfterRegister(callback) {
lifecycle_manager_1.lifecycleManager.onAfterRegister(callback);
}
onBeforeRender(callback) {
lifecycle_manager_1.lifecycleManager.onBeforeRender(callback);
}
onAfterRender(callback) {
lifecycle_manager_1.lifecycleManager.onAfterRender(callback);
}
onError(callback) {
lifecycle_manager_1.lifecycleManager.onError(callback);
}
// === СОБЫТИЯ ===
on(event, callback) {
event_bus_1.eventBus.on(event, callback);
}
off(event, callback) {
event_bus_1.eventBus.off(event, callback);
}
emit(event, data) {
event_bus_1.eventBus.emit(event, data);
}
// === ПРИВАТНЫЕ МЕТОДЫ ===
async handleError(error, context) {
this.logger.error(`Engine error: ${error.message}`, context);
try {
// Простая обработка ошибки без recovery
console.error('Engine error:', error.message, context);
}
catch (recoveryError) {
this.logger.error('Error handling failed:', recoveryError);
}
throw error;
}
// === СТАТИСТИКА ===
getStats() {
return {
components: this.componentStore.getAllComponents().size,
plugins: this.pluginManager.getAllPlugins().length,
activePlugins: this.pluginManager.getActivePlugins().length,
dataSources: this.dataService.getDataStats().totalSources,
testResults: this.testRunner.getTestResults().length
};
}
}
exports.Engine = Engine;