vladx 1.0.0

package/src/runtime/debugger.js

@@ -0,0 +1,260 @@
+/**
+ * Debugger — Отладчик для пошагового выполнения
+ */
+
+export class Debugger {
+    constructor(interpreter) {
+        this.interpreter = interpreter;
+        this.breakpoints = new Set();
+        this.stepMode = false;
+        this.stepDepth = 0;
+        this.currentFrame = null;
+        this.callStack = [];
+        this.watchExpressions = [];
+        this.paused = false;
+        this.onNextBreakpoint = null;
+        this.sourceMaps = new Map();
+    }
+
+    /**
+     * Установить breakpoint
+     */
+    setBreakpoint(filename, line) {
+        const key = `${filename}:${line}`;
+        this.breakpoints.add(key);
+    }
+
+    /**
+     * Удалить breakpoint
+     */
+    removeBreakpoint(filename, line) {
+        const key = `${filename}:${line}`;
+        this.breakpoints.delete(key);
+    }
+
+    /**
+     * Проверить breakpoint
+     */
+    shouldBreak(filename, line) {
+        const key = `${filename}:${line}`;
+        return this.breakpoints.has(key);
+    }
+
+    /**
+     * Включить пошаговый режим
+     */
+    stepInto() {
+        this.stepMode = 'into';
+        this.stepDepth = this.callStack.length;
+        this.paused = false;
+    }
+
+    /**
+     * Шагнуть (перепрыгнуть через функцию)
+     */
+    stepOver() {
+        this.stepMode = 'over';
+        this.stepDepth = this.callStack.length;
+        this.paused = false;
+    }
+
+    /**
+     * Шагнуть из функции
+     */
+    stepOut() {
+        this.stepMode = 'out';
+        this.stepDepth = this.callStack.length;
+        this.paused = false;
+    }
+
+    /**
+     * Продолжить выполнение
+     */
+    continue() {
+        this.stepMode = false;
+        this.paused = false;
+        if (this.onNextBreakpoint) {
+            this.onNextBreakpoint();
+            this.onNextBreakpoint = null;
+        }
+    }
+
+    /**
+     * Проверить, нужно ли паузу
+     */
+    checkBreak(filename, line) {
+        if (this.stepMode) {
+            switch (this.stepMode) {
+                case 'into':
+                    return true;
+                case 'over':
+                    return this.callStack.length <= this.stepDepth;
+                case 'out':
+                    return this.callStack.length < this.stepDepth;
+            }
+        }
+
+        return this.shouldBreak(filename, line);
+    }
+
+    /**
+     * Добавить watch expression
+     */
+    addWatch(expression) {
+        this.watchExpressions.push(expression);
+    }
+
+    /**
+     * Удалить watch expression
+     */
+    removeWatch(expression) {
+        const index = this.watchExpressions.indexOf(expression);
+        if (index !== -1) {
+            this.watchExpressions.splice(index, 1);
+        }
+    }
+
+    /**
+     * Оценить watch expressions
+     */
+    async evaluateWatches() {
+        const results = {};
+
+        for (const expr of this.watchExpressions) {
+            try {
+                results[expr] = await this.interpreter.evaluateExpression(expr);
+            } catch (e) {
+                results[expr] = { error: e.message };
+            }
+        }
+
+        return results;
+    }
+
+    /**
+     * Получить стек вызовов
+     */
+    getCallStack() {
+        return this.callStack.map(frame => ({
+            filename: frame.filename,
+            line: frame.line,
+            function: frame.functionName,
+            locals: this.getLocals(frame)
+        }));
+    }
+
+    /**
+     * Получить локальные переменные
+     */
+    getLocals(frame) {
+        if (!frame || !frame.environment) {
+            return {};
+        }
+
+        const locals = {};
+        for (const [key, value] of frame.environment.variables) {
+            locals[key] = value;
+        }
+
+        return locals;
+    }
+
+    /**
+     * Получить значение переменной
+     */
+    getVariable(name) {
+        if (!this.currentFrame || !this.currentFrame.environment) {
+            return undefined;
+        }
+
+        try {
+            return this.currentFrame.environment.get(name);
+        } catch (e) {
+            return undefined;
+        }
+    }
+
+    /**
+     * Установить значение переменной
+     */
+    setVariable(name, value) {
+        if (!this.currentFrame || !this.currentFrame.environment) {
+            return false;
+        }
+
+        try {
+            this.currentFrame.environment.assign(name, value);
+            return true;
+        } catch (e) {
+            return false;
+        }
+    }
+
+    /**
+     * Добавить фрейм в стек вызовов
+     */
+    pushFrame(frame) {
+        this.callStack.push(frame);
+        this.currentFrame = frame;
+    }
+
+    /**
+     * Удалить фрейм из стека вызовов
+     */
+    popFrame() {
+        this.callStack.pop();
+        this.currentFrame = this.callStack[this.callStack.length - 1];
+    }
+
+    /**
+     * Получить текущее состояние
+     */
+    getState() {
+        return {
+            paused: this.paused,
+            breakpoints: Array.from(this.breakpoints),
+            watchExpressions: [...this.watchExpressions],
+            callStack: this.getCallStack(),
+            currentFrame: this.currentFrame ? {
+                filename: this.currentFrame.filename,
+                line: this.currentFrame.line,
+                function: this.currentFrame.functionName
+            } : null
+        };
+    }
+
+    /**
+     * Добавить source map
+     */
+    addSourceMap(filename, map) {
+        this.sourceMaps.set(filename, map);
+    }
+
+    /**
+     * Конвертировать позицию в исходный код
+     */
+    mapPosition(filename, line, column) {
+        const map = this.sourceMaps.get(filename);
+        if (!map) {
+            return { line, column };
+        }
+
+        // Simplified source map lookup
+        // В реальной реализации нужно парсить source map JSON
+        return { line, column };
+    }
+
+    /**
+     * Очистить состояние
+     */
+    clear() {
+        this.breakpoints.clear();
+        this.stepMode = false;
+        this.callStack = [];
+        this.watchExpressions = [];
+        this.currentFrame = null;
+        this.paused = false;
+    }
+}
+
+export default Debugger;

package/src/runtime/enhanced-module-system.js

@@ -0,0 +1,196 @@
+/**
+ * EnhancedModuleSystem — Улучшенная система модулей
+ */
+
+import { ModuleSystem } from './module-system.js';
+
+export class EnhancedModuleSystem extends ModuleSystem {
+    constructor(interpreter) {
+        super(interpreter);
+        this.circularDependencies = new Map();
+        this.dependencyGraph = new Map();
+        this.importStack = [];
+        this.dynamicImports = new Map();
+    }
+
+    /**
+     * Проверка на циклические зависимости
+     */
+    checkCircularDependencies(modulePath) {
+        if (this.importStack.includes(modulePath)) {
+            const cycle = [...this.importStack, modulePath];
+            throw new Error(`Циклическая зависимость: ${cycle.join(' -> ')}`);
+        }
+
+        this.importStack.push(modulePath);
+
+        const dependencies = this.dependencyGraph.get(modulePath) || [];
+
+        for (const dep of dependencies) {
+            this.checkCircularDependencies(dep);
+        }
+
+        this.importStack.pop();
+    }
+
+    /**
+     * Добавить зависимость в граф
+     */
+    addDependency(from, to) {
+        if (!this.dependencyGraph.has(from)) {
+            this.dependencyGraph.set(from, []);
+        }
+        this.dependencyGraph.get(from).push(to);
+    }
+
+    /**
+     * Динамический импорт
+     */
+    async dynamicImport(modulePath, currentPath) {
+        const cacheKey = `${currentPath}:${modulePath}`;
+
+        if (this.dynamicImports.has(cacheKey)) {
+            return this.dynamicImports.get(cacheKey);
+        }
+
+        const promise = this.loadModule(modulePath, currentPath);
+        this.dynamicImports.set(cacheKey, promise);
+
+        try {
+            return await promise;
+        } catch (error) {
+            this.dynamicImports.delete(cacheKey);
+            throw error;
+        }
+    }
+
+    /**
+     * Переэкспорт
+     */
+    async reExport(fromModule, exports, currentPath) {
+        const module = await this.loadModule(fromModule, currentPath);
+
+        if (Array.isArray(exports)) {
+            // Именованный реэкспорт
+            const result = {};
+            for (const name of exports) {
+                if (name in module) {
+                    result[name] = module[name];
+                }
+            }
+            return result;
+        } else if (typeof exports === 'string') {
+            // Реэкспорт по умолчанию
+            return module[exports] || module;
+        } else {
+            // Реэкспорт всего
+            return module;
+        }
+    }
+
+    /**
+     * Conditional экспорт
+     */
+    async conditionalExport(modulePath, conditions, currentPath) {
+        const module = await this.loadModule(modulePath, currentPath);
+
+        for (const [condition, value] of Object.entries(conditions)) {
+            if (this.checkCondition(condition)) {
+                return value;
+            }
+        }
+
+        return module;
+    }
+
+    /**
+     * Проверка условия экспорта
+     */
+    checkCondition(condition) {
+        switch (condition) {
+            case 'production':
+                return process.env.NODE_ENV === 'production';
+            case 'development':
+                return process.env.NODE_ENV === 'development';
+            case 'test':
+                return process.env.NODE_ENV === 'test';
+            case 'node':
+                return typeof process !== 'undefined';
+            case 'browser':
+                return typeof window !== 'undefined';
+            default:
+                return false;
+        }
+    }
+
+    /**
+     * Получить граф зависимостей
+     */
+    getDependencyGraph() {
+        return {
+            graph: Object.fromEntries(this.dependencyGraph),
+            circular: Array.from(this.circularDependencies.entries())
+        };
+    }
+
+    /**
+     * Очистить граф зависимостей
+     */
+    clearDependencyGraph() {
+        this.dependencyGraph.clear();
+        this.circularDependencies.clear();
+        this.importStack = [];
+    }
+
+    /**
+     * Топологическая сортировка зависимостей
+     */
+    topologicalSort() {
+        const visited = new Set();
+        const result = [];
+        const graph = Object.fromEntries(this.dependencyGraph);
+
+        const visit = (node) => {
+            if (visited.has(node)) return;
+            visited.add(node);
+
+            const dependencies = graph[node] || [];
+            for (const dep of dependencies) {
+                visit(dep);
+            }
+
+            result.push(node);
+        };
+
+        for (const node of Object.keys(graph)) {
+            visit(node);
+        }
+
+        return result;
+    }
+
+    /**
+     * Проверить модуль на наличие зависимостей
+     */
+    hasDependencies(modulePath) {
+        const deps = this.dependencyGraph.get(modulePath);
+        return deps && deps.length > 0;
+    }
+
+    /**
+     * Получить все модули, которые зависят от данного
+     */
+    getDependents(modulePath) {
+        const dependents = [];
+
+        for (const [from, tos] of this.dependencyGraph.entries()) {
+            if (tos.includes(modulePath)) {
+                dependents.push(from);
+            }
+        }
+
+        return dependents;
+    }
+}
+
+export default EnhancedModuleSystem;

package/src/runtime/environment-enhanced.js

@@ -0,0 +1,272 @@
+/**
+ * Environment — Улучшенное управление окружением
+ */
+
+import { CacheManager } from './cache-manager.js';
+import { SecurityManager } from './security-manager.js';
+
+export class EnvironmentEnhanced {
+    constructor(options = {}) {
+        this.name = options.name || process.env.NODE_ENV || 'development';
+        this.isDevelopment = this.name === 'development';
+        this.isProduction = this.name === 'production';
+        this.isTest = this.name === 'test';
+
+        this.cache = new CacheManager({
+            maxSize: options.cacheSize || 1000,
+            ttl: options.cacheTTL || 300000
+        });
+
+        this.security = new SecurityManager({
+            enabled: options.securityEnabled !== false,
+            allowedPaths: options.allowedPaths || [],
+            maxFileSize: options.maxFileSize || 10 * 1024 * 1024
+        });
+
+        this.config = options.config || {};
+        this.variables = options.variables || {};
+        this.plugins = new Map();
+        this.middleware = [];
+        this.hooks = new Map();
+    }
+
+    /**
+     * Получить переменную окружения
+     */
+    get(key, defaultValue) {
+        if (key in this.variables) {
+            return this.variables[key];
+        }
+
+        if (key in process.env) {
+            return process.env[key];
+        }
+
+        return defaultValue;
+    }
+
+    /**
+     * Установить переменную окружения
+     */
+    set(key, value) {
+        this.variables[key] = value;
+        return this;
+    }
+
+    /**
+     * Получить конфигурацию
+     */
+    getConfig(key, defaultValue) {
+        return this.getNestedValue(this.config, key, defaultValue);
+    }
+
+    /**
+     * Получить вложенное значение
+     */
+    getNestedValue(obj, path, defaultValue) {
+        const keys = path.split('.');
+        let result = obj;
+
+        for (const key of keys) {
+            if (result && typeof result === 'object' && key in result) {
+                result = result[key];
+            } else {
+                return defaultValue;
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Добавить плагин
+     */
+    use(plugin) {
+        const name = plugin.name || `plugin_${this.plugins.size}`;
+        this.plugins.set(name, plugin);
+
+        if (plugin.install) {
+            plugin.install(this);
+        }
+
+        return this;
+    }
+
+    /**
+     * Добавить middleware
+     */
+    add(middleware) {
+        this.middleware.push(middleware);
+        return this;
+    }
+
+    /**
+     * Выполнить middleware
+     */
+    async executeMiddleware(context) {
+        for (const middleware of this.middleware) {
+            const result = await middleware(context, this);
+
+            if (result === false) {
+                break;
+            }
+        }
+
+        return context;
+    }
+
+    /**
+     * Добавить hook
+     */
+    on(event, callback) {
+        if (!this.hooks.has(event)) {
+            this.hooks.set(event, []);
+        }
+
+        this.hooks.get(event).push(callback);
+        return this;
+    }
+
+    /**
+     * Удалить hook
+     */
+    off(event, callback) {
+        const hooks = this.hooks.get(event);
+        if (hooks) {
+            const index = hooks.indexOf(callback);
+            if (index !== -1) {
+                hooks.splice(index, 1);
+            }
+        }
+        return this;
+    }
+
+    /**
+     * Запустить hook
+     */
+    async emit(event, ...args) {
+        const hooks = this.hooks.get(event);
+        if (hooks) {
+            for (const callback of hooks) {
+                await callback(...args);
+            }
+        }
+        return this;
+    }
+
+    /**
+     * Проверить функцию
+     */
+    hasFeature(feature) {
+        return this.getConfig(`features.${feature}`, false);
+    }
+
+    /**
+     * Получить режим работы
+     */
+    getMode() {
+        return this.name;
+    }
+
+    /**
+     * Получить информацию о системе
+     */
+    getSystemInfo() {
+        return {
+            platform: process.platform,
+            arch: process.arch,
+            nodeVersion: process.version,
+            cpus: process.cpuUsage(),
+            memory: process.memoryUsage(),
+            uptime: process.uptime(),
+            env: process.env.NODE_ENV
+        };
+    }
+
+    /**
+     * Логирование
+     */
+    log(level, ...args) {
+        const timestamp = new Date().toISOString();
+        const message = args.map(arg =>
+            typeof arg === 'object' ? JSON.stringify(arg) : String(arg)
+        ).join(' ');
+
+        console.log(`[${timestamp}] [${level.toUpperCase()}] ${message}`);
+
+        this.emit('log', { level, message, timestamp });
+    }
+
+    info(...args) {
+        this.log('info', ...args);
+    }
+
+    warn(...args) {
+        this.log('warn', ...args);
+    }
+
+    error(...args) {
+        this.log('error', ...args);
+    }
+
+    debug(...args) {
+        if (this.isDevelopment) {
+            this.log('debug', ...args);
+        }
+    }
+
+    /**
+     * Измерение времени
+     */
+    time(label) {
+        this.timers = this.timers || {};
+        this.timers[label] = Date.now();
+    }
+
+    timeEnd(label) {
+        if (!this.timers || !(label in this.timers)) {
+            return 0;
+        }
+
+        const duration = Date.now() - this.timers[label];
+        delete this.timers[label];
+
+        this.info(`${label}: ${duration}ms`);
+        return duration;
+    }
+
+    /**
+     * Очистить ресурсы
+     */
+    async cleanup() {
+        this.cache.clear();
+
+        for (const [name, plugin] of this.plugins) {
+            if (plugin.uninstall) {
+                await plugin.uninstall(this);
+            }
+        }
+
+        this.plugins.clear();
+        this.middleware = [];
+        this.hooks.clear();
+    }
+
+    /**
+     * Получить статистику окружения
+     */
+    getStats() {
+        return {
+            name: this.name,
+            cache: this.cache.getStats(),
+            plugins: Array.from(this.plugins.keys()),
+            middleware: this.middleware.length,
+            hooks: Object.fromEntries(
+                Array.from(this.hooks.entries()).map(([k, v]) => [k, v.length])
+            ),
+            system: this.getSystemInfo()
+        };
+    }
+}
+
+export default EnvironmentEnhanced;