userface/build/engine/plugin-system.js

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

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.pluginSystem = exports.PluginSystem = void 0;
exports.initializePluginSystem = initializePluginSystem;
const logger_1 = require("./logger");
class PluginSystem {
    constructor(registry) {
        Object.defineProperty(this, "registry", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: registry
        });
        Object.defineProperty(this, "plugins", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: new Map()
        });
        Object.defineProperty(this, "configs", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: new Map()
        });
        Object.defineProperty(this, "statuses", {
            enumerable: true,
            configurable: true,
            writable: true,
            value: new Map()
        });
    }
    async registerPlugin(plugin, config) {
        logger_1.logger.info(`Plugin "${plugin.name}" registered (id: ${plugin.id}, type: ${plugin.type})`);
        this.plugins.set(plugin.id, plugin);
        this.configs.set(plugin.id, {
            enabled: false,
            priority: 0,
            settings: {},
            ...config
        });
        this.statuses.set(plugin.id, {
            id: plugin.id,
            installed: false,
            enabled: false,
            version: plugin.version
        });
    }
    async installPlugin(pluginId) {
        const plugin = this.plugins.get(pluginId);
        if (!plugin)
            throw new Error(`Plugin not found: ${pluginId}`);
        if (plugin.install) {
            await plugin.install();
        }
        const status = this.statuses.get(pluginId);
        if (status) {
            status.installed = true;
        }
        logger_1.logger.info(`Plugin "${plugin.name}" installed (id: ${pluginId})`);
    }
    async uninstallPlugin(pluginId) {
        const plugin = this.plugins.get(pluginId);
        if (!plugin)
            throw new Error(`Plugin not found: ${pluginId}`);
        if (plugin.uninstall) {
            await plugin.uninstall();
        }
        const status = this.statuses.get(pluginId);
        if (status) {
            status.installed = false;
            status.enabled = false;
        }
        logger_1.logger.info(`Plugin "${plugin.name}" uninstalled (id: ${pluginId})`);
    }
    async enablePlugin(pluginId) {
        const plugin = this.plugins.get(pluginId);
        if (!plugin)
            throw new Error(`Plugin not found: ${pluginId}`);
        if (plugin.enable) {
            await plugin.enable();
        }
        const status = this.statuses.get(pluginId);
        if (status) {
            status.enabled = true;
        }
        const config = this.configs.get(pluginId);
        if (config) {
            config.enabled = true;
        }
        logger_1.logger.info(`Plugin "${plugin.name}" enabled (id: ${pluginId})`);
    }
    async disablePlugin(pluginId) {
        const plugin = this.plugins.get(pluginId);
        if (!plugin)
            throw new Error(`Plugin not found: ${pluginId}`);
        if (plugin.disable) {
            await plugin.disable();
        }
        const status = this.statuses.get(pluginId);
        if (status) {
            status.enabled = false;
        }
        const config = this.configs.get(pluginId);
        if (config) {
            config.enabled = false;
        }
        logger_1.logger.info(`Plugin "${plugin.name}" disabled (id: ${pluginId})`);
    }
    getPlugin(pluginId) {
        return this.plugins.get(pluginId);
    }
    getAllPlugins() {
        return Array.from(this.plugins.values());
    }
    getPluginsByType(type) {
        return Array.from(this.plugins.values()).filter(p => p.type === type);
    }
    getActivePlugins() {
        return Array.from(this.plugins.values()).filter(p => {
            const status = this.statuses.get(p.id);
            return status?.installed;
        });
    }
    getInstalledPlugins() {
        return Array.from(this.plugins.values()).filter(p => {
            const status = this.statuses.get(p.id);
            return status?.installed;
        });
    }
    getEnabledPlugins() {
        return Array.from(this.plugins.values()).filter(p => {
            const status = this.statuses.get(p.id);
            return status?.enabled;
        });
    }
    getPluginStatus(pluginId) {
        return this.statuses.get(pluginId);
    }
    getAllStatuses() {
        return Array.from(this.statuses.values());
    }
    updatePluginConfig(pluginId, config) {
        const existingConfig = this.configs.get(pluginId);
        if (existingConfig) {
            Object.assign(existingConfig, config);
        }
    }
    async removePlugin(pluginId) {
        await this.uninstallPlugin(pluginId);
        this.plugins.delete(pluginId);
        this.configs.delete(pluginId);
        this.statuses.delete(pluginId);
        logger_1.logger.info(`Plugin removed (id: ${pluginId})`);
    }
    async clear() {
        for (const pluginId of this.plugins.keys()) {
            await this.removePlugin(pluginId);
        }
    }
}
exports.PluginSystem = PluginSystem;
function initializePluginSystem(registry) {
    exports.pluginSystem = new PluginSystem(registry);
    return exports.pluginSystem;
}