vladx 1.0.0

package/src/runtime/advanced-type-system.js

@@ -0,0 +1,209 @@
+/**
+ * AdvancedTypeSystem — Расширенная система типов
+ */
+
+import { TypeSystem } from './type-system.js';
+
+export class AdvancedTypeSystem extends TypeSystem {
+    constructor() {
+        super();
+        this.typeAliases = new Map();
+        this.unionTypes = new Map();
+        this.intersectionTypes = new Map();
+        this.genericTypes = new Map();
+        this.initializeAdvancedTypes();
+    }
+
+    /**
+     * Инициализация расширенных типов
+     */
+    initializeAdvancedTypes() {
+        // Union types
+        this.types.set('числоилистрока', {
+            name: 'числоилистрока',
+            check: (value) => {
+                if (value && typeof value === 'object' && 'value' in value) {
+                    return value.type === 'number' || value.type === 'string';
+                }
+                return typeof value === 'number' || typeof value === 'string';
+            },
+            defaultValue: 0
+        });
+
+        // Tuple types (массивы фиксированной длины)
+        this.types.set('пара', {
+            name: 'пара',
+            check: (value) => Array.isArray(value) && value.length === 2,
+            defaultValue: [null, null]
+        });
+
+        this.types.set('тройка', {
+            name: 'тройка',
+            check: (value) => Array.isArray(value) && value.length === 3,
+            defaultValue: [null, null, null]
+        });
+    }
+
+    /**
+     * Создать union type
+     */
+    createUnionType(name, ...typeNames) {
+        const typeCheckers = typeNames.map(tn => {
+            const typeDef = this.types.get(tn);
+            return typeDef ? typeDef.check : (() => false);
+        });
+
+        this.unionTypes.set(name, typeNames);
+        this.types.set(name, {
+            name,
+            check: (value) => typeCheckers.some(checker => checker(value)),
+            defaultValue: this.types.get(typeNames[0])?.defaultValue || null
+        });
+
+        return this;
+    }
+
+    /**
+     * Создать intersection type
+     */
+    createIntersectionType(name, ...typeNames) {
+        const typeCheckers = typeNames.map(tn => {
+            const typeDef = this.types.get(tn);
+            return typeDef ? typeDef.check : (() => true);
+        });
+
+        this.intersectionTypes.set(name, typeNames);
+        this.types.set(name, {
+            name,
+            check: (value) => typeCheckers.every(checker => checker(value)),
+            defaultValue: null
+        });
+
+        return this;
+    }
+
+    /**
+     * Создать generic type
+     */
+    createGenericType(name, baseTypeName) {
+        const baseType = this.types.get(baseTypeName);
+        if (!baseType) {
+            throw new Error(`Базовый тип не найден: ${baseTypeName}`);
+        }
+
+        this.genericTypes.set(name, {
+            baseType: baseTypeName,
+            typeParameters: []
+        });
+
+        this.types.set(name, {
+            name,
+            check: baseType.check,
+            defaultValue: baseType.defaultValue
+        });
+
+        return this;
+    }
+
+    /**
+     * Создать alias для типа
+     */
+    createTypeAlias(aliasName, originalTypeName) {
+        const originalType = this.types.get(originalTypeName);
+        if (!originalType) {
+            throw new Error(`Тип не найден: ${originalTypeName}`);
+        }
+
+        this.typeAliases.set(aliasName, originalTypeName);
+        this.types.set(aliasName, originalType);
+
+        return this;
+    }
+
+    /**
+     * Инференс типа с поддержкой union и intersection
+     */
+    inferType(value) {
+        if (value === null || value === undefined) return 'ничто';
+
+        // Если это VladXObject
+        if (value && typeof value === 'object' && 'type' in value) {
+            switch (value.type) {
+                case 'number': return 'число';
+                case 'string': return 'строка';
+                case 'boolean': return 'логический';
+                case 'array':
+                    // Проверка на tuple types
+                    if (Array.isArray(value.value)) {
+                        if (value.value.length === 2) return 'пара';
+                        if (value.value.length === 3) return 'тройка';
+                    }
+                    return 'массив';
+                case 'object': return 'объект';
+                case 'function':
+                case 'closure': return 'функция';
+                case 'null': return 'ничто';
+                default: return 'любой';
+            }
+        }
+
+        if (typeof value === 'number') return 'число';
+        if (typeof value === 'string') return 'строка';
+        if (typeof value === 'boolean') return 'логический';
+        if (Array.isArray(value)) {
+            if (value.length === 2) return 'пара';
+            if (value.length === 3) return 'тройка';
+            return 'массив';
+        }
+        if (typeof value === 'function') return 'функция';
+        if (typeof value === 'object') return 'объект';
+        return 'любой';
+    }
+
+    /**
+     * Проверить совместимость типов
+     */
+    isTypeCompatible(type1, type2) {
+        if (type1 === type2) return true;
+        if (type1 === 'любой' || type2 === 'любой') return true;
+
+        // Проверка union types
+        if (this.unionTypes.has(type1)) {
+            const types = this.unionTypes.get(type1);
+            return types.includes(type2);
+        }
+
+        if (this.unionTypes.has(type2)) {
+            const types = this.unionTypes.get(type2);
+            return types.includes(type1);
+        }
+
+        // Проверка type aliases
+        if (this.typeAliases.has(type1)) {
+            const original = this.typeAliases.get(type1);
+            return this.isTypeCompatible(original, type2);
+        }
+
+        if (this.typeAliases.has(type2)) {
+            const original = this.typeAliases.get(type2);
+            return this.isTypeCompatible(type1, original);
+        }
+
+        return false;
+    }
+
+    /**
+     * Получить все типы
+     */
+    getAllTypes() {
+        return {
+            basic: Array.from(this.types.keys()),
+            unions: Array.from(this.unionTypes.keys()),
+            intersections: Array.from(this.intersectionTypes.keys()),
+            generics: Array.from(this.genericTypes.keys()),
+            aliases: Array.from(this.typeAliases.keys())
+        };
+    }
+}
+
+export default AdvancedTypeSystem;

package/src/runtime/async-manager.js

@@ -0,0 +1,252 @@
+/**
+ * AsyncManager — Управление асинхронными операциями
+ */
+
+import { VladXObject } from './vladx-object.js';
+
+export class AsyncManager {
+    constructor(options = {}) {
+        this.maxConcurrent = options.maxConcurrent || 10;
+        this.timeout = options.timeout || 30000;
+        this.activePromises = new Set();
+        this.queue = [];
+        this.stats = {
+            total: 0,
+            completed: 0,
+            failed: 0,
+            timeout: 0
+        };
+    }
+
+    /**
+     * Параллельное выполнение
+     */
+    async parallel(tasks, options = {}) {
+        const maxConcurrency = options.maxConcurrency || this.maxConcurrent;
+        const timeout = options.timeout || this.timeout;
+
+        if (tasks.length === 0) {
+            return VladXObject.array([]);
+        }
+
+        const results = [];
+        const executing = new Set();
+
+        const processTask = async (task, index) => {
+            try {
+                const result = await Promise.race([
+                    task(),
+                    new Promise((_, reject) =>
+                        setTimeout(() => reject(new Error('Timeout')), timeout)
+                    )
+                ]);
+                results[index] = result;
+                this.stats.completed++;
+            } catch (error) {
+                results[index] = { error: error.message };
+                this.stats.failed++;
+            } finally {
+                executing.delete(processTask);
+
+                if (this.queue.length > 0) {
+                    const next = this.queue.shift();
+                    executing.add(next);
+                    next();
+                }
+            }
+        };
+
+        for (let i = 0; i < tasks.length; i++) {
+            if (executing.size >= maxConcurrency) {
+                await new Promise(resolve => {
+                    const taskWrapper = () => {
+                        processTask(tasks[i], i).then(resolve);
+                    };
+                    this.queue.push(taskWrapper);
+                });
+            } else {
+                const promise = processTask(tasks[i], i);
+                executing.add(promise);
+            }
+        }
+
+        await Promise.all(executing);
+        this.stats.total += tasks.length;
+
+        return VladXObject.array(results);
+    }
+
+    /**
+     * Sequential выполнение
+     */
+    async sequential(tasks) {
+        const results = [];
+
+        for (const task of tasks) {
+            try {
+                const result = await Promise.race([
+                    task(),
+                    new Promise((_, reject) =>
+                        setTimeout(() => reject(new Error('Timeout')), this.timeout)
+                    )
+                ]);
+                results.push(result);
+                this.stats.completed++;
+            } catch (error) {
+                results.push({ error: error.message });
+                this.stats.failed++;
+            }
+        }
+
+        this.stats.total += tasks.length;
+        return VladXObject.array(results);
+    }
+
+    /**
+     * Race - первый завершившийся промис
+     */
+    async race(tasks) {
+        if (tasks.length === 0) {
+            return VladXObject.null();
+        }
+
+        try {
+            const result = await Promise.race([
+                Promise.race(tasks.map(t => t())),
+                new Promise((_, reject) =>
+                    setTimeout(() => reject(new Error('Timeout')), this.timeout)
+                )
+            ]);
+            return VladXObject.fromJS(result);
+        } catch (error) {
+            this.stats.failed++;
+            throw error;
+        }
+    }
+
+    /**
+     * AllSettled - все промисы завершены (включая rejected)
+     */
+    async allSettled(tasks) {
+        if (tasks.length === 0) {
+            return VladXObject.array([]);
+        }
+
+        const results = await Promise.allSettled(
+            tasks.map(task =>
+                Promise.race([
+                    task(),
+                    new Promise((_, reject) =>
+                        setTimeout(() => reject(new Error('Timeout')), this.timeout)
+                    )
+                ])
+            )
+        );
+
+        this.stats.total += tasks.length;
+        return VladXObject.array(
+            results.map(result => ({
+                status: result.status,
+                value: result.status === 'fulfilled' ? result.value : result.reason
+            }))
+        );
+    }
+
+    /**
+     * Any - первый успешно завершившийся
+     */
+    async any(tasks) {
+        if (tasks.length === 0) {
+            throw new Error('Нет задач для выполнения');
+        }
+
+        try {
+            const result = await Promise.any(
+                tasks.map(task =>
+                    Promise.race([
+                        task(),
+                        new Promise((_, reject) =>
+                            setTimeout(() => reject(new Error('Timeout')), this.timeout)
+                        )
+                    ])
+                )
+            );
+            return VladXObject.fromJS(result);
+        } catch (error) {
+            this.stats.failed++;
+            throw error;
+        }
+    }
+
+    /**
+     * Debounce - задержка выполнения
+     */
+    debounce(func, delay) {
+        let timeoutId;
+
+        return (...args) => {
+            clearTimeout(timeoutId);
+            return new Promise((resolve) => {
+                timeoutId = setTimeout(() => {
+                    resolve(func(...args));
+                }, delay);
+            });
+        };
+    }
+
+    /**
+     * Throttle - ограничение частоты выполнения
+     */
+    throttle(func, limit) {
+        let inThrottle;
+
+        return (...args) => {
+            if (!inThrottle) {
+                func(...args);
+                inThrottle = true;
+                setTimeout(() => inThrottle = false, limit);
+            }
+        };
+    }
+
+    /**
+     * Retry - повторная попытка при ошибке
+     */
+    async retry(func, maxAttempts = 3, delay = 1000) {
+        let lastError;
+
+        for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+            try {
+                return await func();
+            } catch (error) {
+                lastError = error;
+                if (attempt < maxAttempts) {
+                    await new Promise(resolve => setTimeout(resolve, delay * attempt));
+                }
+            }
+        }
+
+        throw lastError;
+    }
+
+    /**
+     * Очистка активных промисов
+     */
+    clear() {
+        this.activePromises.clear();
+        this.queue = [];
+    }
+
+    /**
+     * Получить статистику
+     */
+    getStats() {
+        return {
+            ...this.stats,
+            active: this.activePromises.size,
+            queued: this.queue.length
+        };
+    }
+}
+
+export default AsyncManager;

package/src/runtime/builtins.js

@@ -0,0 +1,143 @@
+/**
+ * VladX Builtins — Встроенные модули и функции
+ */
+
+import { VladXObject } from './vladx-object.js';
+
+export class Builtins {
+    constructor(interpreter) {
+        this.interpreter = interpreter;
+        this.modules = new Map();
+        this.registerCoreModules();
+    }
+
+    /**
+     * Регистрация основных модулей
+     */
+    registerCoreModules() {
+        // Модуль для работы с консолью
+        this.modules.set('консоль', {
+            печать: (...args) => {
+                console.log(...args.map(arg => 
+                    typeof arg === 'object' ? JSON.stringify(arg, null, 2) : String(arg)
+                ));
+                return VladXObject.null();
+            },
+            вывод: (...args) => {
+                process.stdout.write(args.join(' '));
+                return VladXObject.null();
+            },
+            ошибка: (...args) => {
+                console.error(...args);
+                return VladXObject.null();
+            },
+            время: () => {
+    const now = new Date();
+    return VladXObject.object({
+        миллисекунды: now.getTime(),
+        год: now.getFullYear(),
+        месяц: now.getMonth() + 1,
+        день: now.getDate(),
+        час: now.getHours(),
+        минута: now.getMinutes(),
+        секунда: now.getSeconds()
+    });
+}
+
+        });
+
+        // Модуль для работы с файловой системой
+        this.modules.set('файловаяСистема', {
+            существует: async (path) => {
+                const fs = await import('fs');
+                return VladXObject.boolean(fs.existsSync(path));
+            },
+            читать: async (path) => {
+                const fs = await import('fs');
+                try {
+                    return VladXObject.string(fs.readFileSync(path, 'utf-8'));
+                } catch (e) {
+                    throw new Error(`Не удалось прочитать файл: ${e.message}`);
+                }
+            },
+            писать: async (path, content) => {
+                const fs = await import('fs');
+                try {
+                    fs.writeFileSync(path, content, 'utf-8');
+                    return VladXObject.boolean(true);
+                } catch (e) {
+                    throw new Error(`Не удалось записать файл: ${e.message}`);
+                }
+            }
+        });
+
+        // Модуль для работы с JSON
+        this.modules.set('json', {
+            сериализовать: (obj) => {
+                try {
+                    return VladXObject.string(JSON.stringify(obj));
+                } catch (e) {
+                    throw new Error(`Ошибка сериализации: ${e.message}`);
+                }
+            },
+            десериализовать: (str) => {
+                try {
+                    return VladXObject.object(JSON.parse(str));
+                } catch (e) {
+                    throw new Error(`Ошибка десериализации: ${e.message}`);
+                }
+            }
+        });
+
+        // Модуль для работы с датой и временем
+        this.modules.set('дата', {
+            сейчас: () => {
+                return VladXObject.object({
+                    год: new Date().getFullYear(),
+                    месяц: new Date().getMonth() + 1,
+                    день: new Date().getDate(),
+                    час: new Date().getHours(),
+                    минута: new Date().getMinutes(),
+                    секунда: new Date().getSeconds()
+                });
+            },
+            миллисекунды: () => {
+                return VladXObject.number(Date.now());
+            }
+        });
+    }
+
+    /**
+     * Загрузка модуля
+     */
+    async loadModule(moduleName) {
+        if (this.modules.has(moduleName)) {
+            return this.modules.get(moduleName);
+        }
+
+        // Внешние модули должны загружаться через module-system
+        throw new Error(`Встроенный модуль "${moduleName}" не найден. Используйте import для внешних модулей.`);
+    }
+
+    /**
+     * Импорт модуля
+     */
+    async importModule(moduleName, options = {}) {
+        const module = await this.loadModule(moduleName);
+
+        // Создание объекта модуля
+        const moduleObj = VladXObject.object({});
+
+        for (const [key, value] of Object.entries(module)) {
+            if (typeof value === 'function') {
+                moduleObj.value[key] = VladXObject.function(value, key);
+            } else {
+                moduleObj.value[key] = VladXObject.object(value);
+            }
+        }
+
+        return moduleObj;
+    }
+}
+
+export default Builtins;