@boristype/bt-cli 0.1.0-alpha.0

package/build/core/building/files.js

@@ -0,0 +1,290 @@
+"use strict";
+/**
+ * Работа с файлами для сборки
+ *
+ * Отвечает за:
+ * - Сбор non-TypeScript файлов из проекта
+ * - Копирование non-TypeScript файлов в output директорию
+ * - Watch mode для non-TypeScript файлов
+ *
+ * @module build/files
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectNonTypescriptFiles = collectNonTypescriptFiles;
+exports.copyNonTypescriptFiles = copyNonTypescriptFiles;
+exports.watchNonTypescriptFiles = watchNonTypescriptFiles;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = require("node:path");
+const chokidar_1 = __importDefault(require("chokidar"));
+const logger_js_1 = require("../logger.js");
+/**
+ * Расширения TypeScript файлов (исключаются из копирования)
+ */
+const TS_EXTENSIONS = ['.ts', '.tsx'];
+/**
+ * Проверяет, является ли путь вложенным в другой путь
+ */
+function isSubpath(parent, child) {
+    const normalizedParent = (0, node_path_1.normalize)(parent).replace(/\\/g, '/');
+    const normalizedChild = (0, node_path_1.normalize)(child).replace(/\\/g, '/');
+    return normalizedChild.startsWith(normalizedParent + '/');
+}
+/**
+ * Определяет rootDir из конфигурации
+ *
+ * Если rootDir не указан явно, пытается вычислить из include паттернов
+ * или использует директорию tsconfig.
+ */
+function inferRootDir(configuration, configDir) {
+    // Явно указанный rootDir
+    if (configuration.options.rootDir) {
+        return (0, node_path_1.resolve)(configDir, configuration.options.rootDir);
+    }
+    // Пытаемся извлечь общий prefix из include паттернов
+    const { include } = configuration.raw || {};
+    if (include && include.length > 0) {
+        // Берём первый паттерн и извлекаем базовую директорию
+        const firstPattern = include[0];
+        const baseDir = firstPattern.split('*')[0].replace(/\/+$/, '') || '.';
+        return (0, node_path_1.resolve)(configDir, baseDir);
+    }
+    // Fallback: директория tsconfig
+    return configDir;
+}
+/**
+ * Собирает список non-TypeScript файлов из rootDir
+ *
+ * Сканирует все файлы в rootDir, исключая:
+ * - TypeScript файлы (.ts, .tsx)
+ * - Файлы из exclude паттернов tsconfig
+ * - outDir (если находится внутри rootDir)
+ * - node_modules
+ *
+ * @param configuration - ParsedCommandLine от TypeScript
+ * @param configDir - Директория где находится tsconfig (для resolve путей)
+ * @returns Список абсолютных путей к non-TypeScript файлам
+ */
+function collectNonTypescriptFiles(configuration, configDir = process.cwd()) {
+    const { outDir } = configuration.options;
+    if (outDir === undefined) {
+        throw new Error('The outDir option is not set in the tsconfig.json file.');
+    }
+    // fs.globSync доступен только в Node.js 22+
+    if (parseInt(process.versions.node.split('.')[0]) < 22) {
+        throw new Error('Non-TypeScript files processing requires Node.js v22 or later');
+    }
+    const rootDir = inferRootDir(configuration, configDir);
+    const absoluteOutDir = (0, node_path_1.resolve)(configDir, outDir);
+    // Базовые исключения
+    const ignore = [
+        '**/node_modules/**',
+    ];
+    // Добавляем exclude из tsconfig
+    const { exclude } = configuration.raw || {};
+    if (exclude) {
+        for (const pattern of exclude) {
+            ignore.push(pattern);
+        }
+    }
+    // Исключаем outDir если он внутри rootDir
+    if (isSubpath(rootDir, absoluteOutDir)) {
+        const relativeOutDir = (0, node_path_1.relative)(rootDir, absoluteOutDir);
+        ignore.push(`${relativeOutDir}/**`);
+    }
+    // Сканируем rootDir
+    const pattern = (0, node_path_1.join)(rootDir, '**', '*').replace(/\\/g, '/');
+    // Node.js fs.globSync возвращает string[], фильтруем вручную
+    return node_fs_1.default.globSync(pattern, {
+        exclude: (fileName) => {
+            // Проверяем ignore паттерны
+            const relativePath = (0, node_path_1.relative)(rootDir, fileName).replace(/\\/g, '/');
+            // Если путь выходит за пределы rootDir, пропускаем проверку
+            // (fs.globSync может вызывать exclude для родительских директорий)
+            if (relativePath.startsWith('..')) {
+                return false;
+            }
+            return ignore.some(p => {
+                if (typeof p === 'string') {
+                    // Простая проверка glob паттернов
+                    if (p.includes('**')) {
+                        // Для паттернов типа "**/node_modules/**" проверяем вхождение
+                        const innerPattern = p.replace(/\*\*/g, '').replace(/^\/+|\/+$/g, '');
+                        if (innerPattern) {
+                            return relativePath.includes(innerPattern);
+                        }
+                        return false; // Паттерн только из ** - игнорируем
+                    }
+                    return relativePath === p || relativePath.startsWith(p + '/');
+                }
+                return false;
+            });
+        },
+    })
+        // Фильтруем директории
+        .filter(f => node_fs_1.default.statSync(f).isFile())
+        // Фильтруем TypeScript файлы
+        .filter(f => !TS_EXTENSIONS.some(ext => f.endsWith(ext)));
+}
+/**
+ * Фильтрует файлы по заданному списку
+ */
+function selectFiles(allFiles, filterFiles) {
+    if (filterFiles.length === 0) {
+        return allFiles;
+    }
+    return allFiles.filter(x => filterFiles.includes(x));
+}
+/**
+ * Копирует non-TypeScript файлы в output директорию
+ *
+ * Сохраняет структуру директорий относительно rootDir.
+ *
+ * @param context - Контекст сборки
+ */
+function copyNonTypescriptFiles(context) {
+    const { tsConfig, options, files, cwd } = context;
+    const configDir = cwd || process.cwd();
+    logger_js_1.logger.warning('📁 Copying non-TypeScript files...');
+    if (options.includeNonTsFiles === false) {
+        logger_js_1.logger.warning('Non-TypeScript files copy is disabled');
+        return;
+    }
+    const { outDir } = tsConfig.options;
+    if (!outDir) {
+        logger_js_1.logger.warning('outDir not set, skipping non-TypeScript files copy');
+        return;
+    }
+    const rootDir = inferRootDir(tsConfig, configDir);
+    const absoluteOutDir = (0, node_path_1.resolve)(configDir, outDir);
+    const entries = collectNonTypescriptFiles(tsConfig, configDir);
+    const selectedFiles = selectFiles(entries, files);
+    logger_js_1.logger.warning(`📁 Found ${entries.length} non-TypeScript files, copying ${selectedFiles.length} files...`);
+    for (const filePath of selectedFiles) {
+        const relativePath = (0, node_path_1.relative)(rootDir, filePath);
+        const outputFilePath = (0, node_path_1.resolve)(absoluteOutDir, relativePath);
+        node_fs_1.default.mkdirSync((0, node_path_1.dirname)(outputFilePath), { recursive: true });
+        node_fs_1.default.writeFileSync(outputFilePath, node_fs_1.default.readFileSync((0, node_path_1.resolve)(filePath), 'utf-8'));
+    }
+}
+/**
+ * Создаёт watcher для non-TypeScript файлов
+ *
+ * Использует chokidar для отслеживания изменений в non-ts файлах
+ * и копирует их в output директорию при изменении.
+ * Использует ту же логику определения rootDir, что и collectNonTypescriptFiles.
+ *
+ * @param context - Контекст сборки
+ * @param onChange - Callback при изменении файла (опционально)
+ * @returns Контроллер для остановки watch
+ */
+function watchNonTypescriptFiles(context, onChange) {
+    const { tsConfig, options, cwd } = context;
+    if (options.includeNonTsFiles === false) {
+        // Возвращаем пустой контроллер если non-ts файлы отключены
+        return { close: () => { } };
+    }
+    const { outDir } = tsConfig.options;
+    const configDir = cwd || process.cwd();
+    if (!outDir) {
+        logger_js_1.logger.warning('outDir not set, skipping non-TypeScript files watch');
+        return { close: () => { } };
+    }
+    // Используем ту же логику что и collectNonTypescriptFiles
+    const rootDir = inferRootDir(tsConfig, configDir);
+    const absoluteOutDir = (0, node_path_1.resolve)(configDir, outDir);
+    // Формируем ignored паттерны
+    const { exclude } = tsConfig.raw || {};
+    const ignoredPatterns = [
+        /node_modules/,
+        // Игнорируем TypeScript файлы
+        (filePath) => TS_EXTENSIONS.some(ext => filePath.endsWith(ext)),
+    ];
+    // Добавляем exclude из tsconfig
+    if (exclude) {
+        for (const pattern of exclude) {
+            ignoredPatterns.push((0, node_path_1.resolve)(configDir, pattern).replace(/\\/g, '/'));
+        }
+    }
+    // Исключаем outDir
+    if (isSubpath(rootDir, absoluteOutDir)) {
+        ignoredPatterns.push((filePath) => isSubpath(absoluteOutDir, filePath) || filePath === absoluteOutDir);
+    }
+    logger_js_1.logger.info(`📁 Watching non-TS files in: ${rootDir}`);
+    // Создаём watcher на rootDir
+    const watcher = chokidar_1.default.watch(rootDir, {
+        ignored: ignoredPatterns,
+        ignoreInitial: true,
+        persistent: true,
+    });
+    // Debug events
+    watcher.on('ready', () => {
+        logger_js_1.logger.info('📁 Non-TS watcher ready');
+    });
+    watcher.on('error', (error) => {
+        logger_js_1.logger.error(`📁 Non-TS watcher error: ${error}`);
+    });
+    /**
+     * Проверяет, является ли файл non-TS файлом для копирования
+     * (дополнительная проверка, т.к. chokidar ignored может пропустить)
+     */
+    const isNonTsFile = (filePath) => {
+        return !TS_EXTENSIONS.some(ext => filePath.endsWith(ext));
+    };
+    /**
+     * Копирует файл в output директорию
+     */
+    const copyFile = (filePath) => {
+        // Фильтруем TypeScript файлы
+        if (!isNonTsFile(filePath)) {
+            return;
+        }
+        try {
+            const relativePath = (0, node_path_1.relative)(rootDir, filePath);
+            const outputFilePath = (0, node_path_1.resolve)(absoluteOutDir, relativePath);
+            node_fs_1.default.mkdirSync((0, node_path_1.dirname)(outputFilePath), { recursive: true });
+            node_fs_1.default.copyFileSync(filePath, outputFilePath);
+            logger_js_1.logger.info(`📄 Copied: ${relativePath}`);
+            if (onChange) {
+                onChange(filePath);
+            }
+        }
+        catch (error) {
+            logger_js_1.logger.error(`Failed to copy ${filePath}: ${error}`);
+        }
+    };
+    /**
+     * Удаляет файл из output директории
+     */
+    const deleteFile = (filePath) => {
+        // Фильтруем TypeScript файлы
+        if (!isNonTsFile(filePath)) {
+            return;
+        }
+        try {
+            const relativePath = (0, node_path_1.relative)(rootDir, filePath);
+            const outputFilePath = (0, node_path_1.resolve)(absoluteOutDir, relativePath);
+            if (node_fs_1.default.existsSync(outputFilePath)) {
+                node_fs_1.default.unlinkSync(outputFilePath);
+                logger_js_1.logger.info(`🗑️ Deleted: ${relativePath}`);
+                if (onChange) {
+                    onChange(filePath);
+                }
+            }
+        }
+        catch (error) {
+            logger_js_1.logger.error(`Failed to delete ${filePath}: ${error}`);
+        }
+    };
+    // Обработчики событий
+    watcher.on('add', copyFile);
+    watcher.on('change', copyFile);
+    watcher.on('unlink', deleteFile);
+    return {
+        close: () => {
+            watcher.close();
+        },
+    };
+}

package/build/core/building/index.js

@@ -0,0 +1,102 @@
+"use strict";
+/**
+ * Build Pipeline
+ *
+ * Основной модуль сборки TypeScript в BorisScript.
+ * Предоставляет unified API для single и watch режимов.
+ *
+ * @example
+ * ```typescript
+ * // Single build
+ * const result = BuildPipeline.run({
+ *   tsConfig: parsedConfig,
+ *   options: btcOptions,
+ * });
+ *
+ * // Watch mode (будущее)
+ * const watcher = BuildPipeline.watch(config, {
+ *   onRebuild: (result) => console.log('Rebuilt!', result.success),
+ * });
+ * watcher.close();
+ * ```
+ *
+ * @module build
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = exports.BuildPipeline = exports.copyNonTypescriptFiles = exports.collectNonTypescriptFiles = exports.compile = exports.decodeUnicodeEscapes = exports.indentString = exports.stripControlChars = exports.transformOutput = exports.createBuildContext = void 0;
+const logger_js_1 = require("../logger.js");
+const types_js_1 = require("./types.js");
+const compiler_js_1 = require("./compiler.js");
+const files_js_1 = require("./files.js");
+// Re-exports
+var types_js_2 = require("./types.js");
+Object.defineProperty(exports, "createBuildContext", { enumerable: true, get: function () { return types_js_2.createBuildContext; } });
+var output_js_1 = require("./output.js");
+Object.defineProperty(exports, "transformOutput", { enumerable: true, get: function () { return output_js_1.transformOutput; } });
+Object.defineProperty(exports, "stripControlChars", { enumerable: true, get: function () { return output_js_1.stripControlChars; } });
+Object.defineProperty(exports, "indentString", { enumerable: true, get: function () { return output_js_1.indentString; } });
+Object.defineProperty(exports, "decodeUnicodeEscapes", { enumerable: true, get: function () { return output_js_1.decodeUnicodeEscapes; } });
+var compiler_js_2 = require("./compiler.js");
+Object.defineProperty(exports, "compile", { enumerable: true, get: function () { return compiler_js_2.compile; } });
+var files_js_2 = require("./files.js");
+Object.defineProperty(exports, "collectNonTypescriptFiles", { enumerable: true, get: function () { return files_js_2.collectNonTypescriptFiles; } });
+Object.defineProperty(exports, "copyNonTypescriptFiles", { enumerable: true, get: function () { return files_js_2.copyNonTypescriptFiles; } });
+/**
+ * Build Pipeline - единая точка входа для сборки
+ */
+exports.BuildPipeline = {
+    /**
+     * Выполняет однократную сборку проекта
+     *
+     * @param contextOrOptions - Контекст сборки или опции для его создания
+     * @returns Результат сборки
+     */
+    run(contextOrOptions) {
+        const context = 'mode' in contextOrOptions && contextOrOptions.mode !== undefined
+            ? contextOrOptions
+            : (0, types_js_1.createBuildContext)(contextOrOptions);
+        logger_js_1.logger.info(`🔨 ${new Date().toLocaleTimeString()} Build started`);
+        // Компилируем TypeScript
+        const result = (0, compiler_js_1.compile)(context);
+        // Копируем non-TypeScript файлы
+        (0, files_js_1.copyNonTypescriptFiles)(context);
+        if (result.success) {
+            logger_js_1.logger.info(`✅ ${new Date().toLocaleTimeString()} Build finished (${result.duration}ms)`);
+        }
+        else {
+            logger_js_1.logger.error(`❌ ${new Date().toLocaleTimeString()} Build failed with errors`);
+        }
+        return result;
+    },
+    /**
+     * Запускает watch режим для инкрементальной сборки
+     *
+     * @param contextOrOptions - Контекст сборки или опции для его создания
+     * @param watchOptions - Опции watch режима
+     * @returns Контроллер для остановки watch
+     */
+    watch(contextOrOptions, watchOptions) {
+        const context = 'mode' in contextOrOptions && contextOrOptions.mode !== undefined
+            ? contextOrOptions
+            : (0, types_js_1.createBuildContext)({ ...contextOrOptions, mode: 'watch' });
+        logger_js_1.logger.info(`👀 ${new Date().toLocaleTimeString()} Watch mode started`);
+        // Копируем non-TS файлы один раз при старте watch
+        // (при пересборке копирование не нужно - только watcher отслеживает изменения)
+        (0, files_js_1.copyNonTypescriptFiles)(context);
+        // Запускаем TypeScript watch для инкрементальной компиляции
+        const tsWatcher = (0, compiler_js_1.createWatchProgram)(context, (result) => {
+            logger_js_1.logger.warning(`🔄 ${new Date().toLocaleTimeString()} Rebuild completed. Success: ${result.success}`);
+            // Вызываем пользовательский callback
+            watchOptions?.onRebuild?.(result);
+        });
+        // Запускаем chokidar watcher для non-TypeScript файлов
+        const nonTsWatcher = (0, files_js_1.watchNonTypescriptFiles)(context, watchOptions?.onNonTsFileChange);
+        return {
+            close: () => {
+                tsWatcher.close();
+                nonTsWatcher.close();
+            },
+        };
+    },
+};
+exports.default = exports.BuildPipeline;

package/build/core/building/output.js

@@ -0,0 +1,92 @@
+"use strict";
+/**
+ * Пост-обработка выходных файлов
+ *
+ * Отвечает за:
+ * - Трансформацию JS в XML/HTML форматы
+ * - Декодирование Unicode escape последовательностей
+ * - Добавление BOM
+ *
+ * @module build/output
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transformOutput = transformOutput;
+exports.decodeUnicodeEscapes = decodeUnicodeEscapes;
+exports.stripControlChars = stripControlChars;
+exports.indentString = indentString;
+const xml_js_1 = require("../utils/xml.js");
+/**
+ * Трансформирует выходной файл
+ *
+ * Применяет пост-обработку к сгенерированному JS коду:
+ * - Конвертация в XML для файлов с `/// @xml-init`
+ * - Конвертация в HTML для файлов с `/// @html`
+ * - Декодирование Unicode escape sequences
+ * - Добавление BOM (Byte Order Mark)
+ *
+ * @param fileName - Имя выходного файла
+ * @param code - Сгенерированный код
+ * @param options - Опции компиляции
+ */
+function transformOutput(fileName, code, options) {
+    let resultFileName = fileName;
+    let resultCode = code;
+    // Конвертация в SPXML формат
+    // TODO: заменить на import стиль
+    if (resultCode.indexOf('/// @xml-init') !== -1) {
+        // Убираем запрещённые управляющие символы (кроме \t, \n, \r)
+        resultCode = stripControlChars(resultCode);
+        resultCode = indentString(resultCode, '\t\t');
+        const xmlObj = {
+            '?xml': { '@_version': '1.0', '@_encoding': 'UTF-8' },
+            'SPXML-INLINE-FORM': {
+                'OnInit': {
+                    '@_PROPERTY': '1',
+                    '@_EXPR': '\n' + resultCode + '\n\t',
+                },
+            },
+        };
+        resultCode = xml_js_1.xmlBuilder.build(xmlObj);
+        resultFileName = resultFileName.replace('.js', '.xml');
+    }
+    // Конвертация в ASP.NET HTML формат
+    // TODO: заменить на import стиль
+    if (resultCode.indexOf('/// @html') !== -1) {
+        resultCode = `<%\n${resultCode}\n%>`;
+        resultFileName = resultFileName.replace('.js', '.html');
+    }
+    // Декодирование Unicode escape последовательностей
+    if (options.retainNonAsciiCharacters !== true) {
+        resultCode = decodeUnicodeEscapes(resultCode);
+    }
+    // Добавление BOM для корректной кодировки
+    resultCode = '\uFEFF' + resultCode;
+    return {
+        fileName: resultFileName,
+        content: resultCode,
+    };
+}
+/**
+ * Декодирует Unicode escape последовательности в строке
+ *
+ * @example
+ * decodeUnicodeEscapes('\\u0041') // 'A'
+ */
+function decodeUnicodeEscapes(code) {
+    return code.replace(/\\u[\dA-Fa-f]{4}/g, (match) => {
+        return String.fromCharCode(parseInt(match.substr(2), 16));
+    });
+}
+/**
+ * Удаляет запрещённые управляющие символы из строки.
+ * Сохраняет tab (\\t), newline (\\n), carriage return (\\r).
+ */
+function stripControlChars(value) {
+    return value.replace(/[\x00-\x08\x0B\x0C\x0E-\x1F\x7F]/g, '');
+}
+/**
+ * Добавляет отступ к каждой строке
+ */
+function indentString(value, indent) {
+    return value.split('\n').map(line => indent + line).join('\n');
+}

package/build/core/building/transformers.js

@@ -0,0 +1,110 @@
+"use strict";
+/**
+ * Реестр TypeScript трансформеров
+ *
+ * Единый источник трансформеров для single и watch режимов.
+ * Трансформеры разделены на before (до emit) и after (после emit).
+ *
+ * @module build/transformers
+ */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBeforeTransformers = createBeforeTransformers;
+exports.createAfterTransformers = createAfterTransformers;
+exports.createTransformers = createTransformers;
+// Before-трансформеры (работают с AST до генерации JS)
+const namespaces_js_1 = require("../../transformers/namespaces.js");
+const enumsToObjects_js_1 = require("../../transformers/enumsToObjects.js");
+const arrayFunctional_js_1 = __importDefault(require("../../transformers/arrayFunctional.js"));
+const arrayGeneral_js_1 = __importDefault(require("../../transformers/arrayGeneral.js"));
+const remodule_js_1 = require("../../transformers/remodule.js");
+const functions_js_1 = require("../../transformers/functions.js");
+const string_js_1 = __importDefault(require("../../transformers/string.js"));
+const math_js_1 = require("../../transformers/math.js");
+const propSemantic_js_1 = __importDefault(require("../../transformers/propSemantic.js"));
+const tocodelibrary_js_1 = require("../../transformers/tocodelibrary.js");
+const funcSemantic_js_1 = require("../../transformers/funcSemantic.js");
+const execObj_js_1 = require("../../transformers/execObj.js");
+const dirname_js_1 = require("../../transformers/dirname.js");
+const objectProperties_js_1 = require("../../transformers/objectProperties.js");
+const globalCache_js_1 = require("../../transformers/globalCache.js");
+const numericSeparator_js_1 = require("../../transformers/numericSeparator.js");
+// After-трансформеры (замена Babel плагинов, работают после генерации JS)
+const templateLiterals_js_1 = require("../../transformers/templateLiterals.js");
+const shorthandProperties_js_1 = require("../../transformers/shorthandProperties.js");
+const forOfToForIn_js_1 = require("../../transformers/forOfToForIn.js");
+const spreadArray_js_1 = require("../../transformers/spreadArray.js");
+const spreadObject_js_1 = require("../../transformers/spreadObject.js");
+const destructuring_js_1 = require("../../transformers/destructuring.js");
+const replaceDollar_js_1 = require("../../transformers/replaceDollar.js");
+const blockScoping_js_1 = require("../../transformers/blockScoping.js");
+const loopHoistVariables_js_1 = require("../../transformers/loopHoistVariables.js");
+const precedence_js_1 = require("../../transformers/precedence.js");
+const removeImportExport_js_1 = require("../../transformers/removeImportExport.js");
+/**
+ * Создаёт набор before-трансформеров
+ *
+ * @param program - TypeScript program для type-aware трансформеров
+ * @param options - Опции компиляции btc
+ * @param executables - Массив для сбора информации об исполняемых объектах
+ */
+function createBeforeTransformers(program, options, executables) {
+    const transformers = [];
+    // numericSeparator должен быть в before, т.к. printer сохраняет исходный текст литералов
+    transformers.push((0, numericSeparator_js_1.numericSeparatorTransformer)()); // 1_000_000 -> 1000000
+    // Базовые трансформации синтаксиса
+    transformers.push((0, enumsToObjects_js_1.enumsToObjectsTransformer)());
+    transformers.push((0, namespaces_js_1.namespacesTransformer)());
+    // Polyfill трансформации (опционально)
+    if (options.usePolyfill) {
+        transformers.push((0, arrayFunctional_js_1.default)(program), (0, arrayGeneral_js_1.default)(program), (0, string_js_1.default)(program), (0, math_js_1.mathTransformer)(), (0, globalCache_js_1.globalCacheTransformer)(program));
+    }
+    // Трансформации функций и объектов
+    transformers.push((0, functions_js_1.functionsTransformer)());
+    transformers.push((0, objectProperties_js_1.objectPropertiesTransformer)());
+    // Сбор информации об исполняемых объектах
+    transformers.push((0, execObj_js_1.execObjTransformer)(program, executables));
+    // Remodule трансформации (опционально)
+    if (options.useRemodule) {
+        transformers.push((0, dirname_js_1.dirnameTransformer)(), (0, funcSemantic_js_1.funcSemanticTransformer)(), (0, remodule_js_1.remoduleTransformer)(program), (0, tocodelibrary_js_1.tocodelibraryTransformer)(), (0, propSemantic_js_1.default)(program));
+    }
+    return transformers;
+}
+/**
+ * Создаёт набор after-трансформеров
+ *
+ * After-трансформеры выполняются после генерации JS кода.
+ * Заменяют функциональность Babel плагинов для понижения синтаксиса.
+ */
+function createAfterTransformers() {
+    return [
+        (0, templateLiterals_js_1.templateLiteralsTransformer)(), // `hello ${x}` -> "hello " + x
+        (0, shorthandProperties_js_1.shorthandPropertiesTransformer)(), // { x } -> { x: x }
+        (0, forOfToForIn_js_1.forOfToForInTransformer)(), // for-of -> for-in
+        (0, spreadArray_js_1.spreadArrayTransformer)(), // [...arr] -> ArrayUnion(arr)
+        (0, spreadObject_js_1.spreadObjectTransformer)(), // {...obj} -> ObjectUnion({}, obj)
+        (0, destructuring_js_1.destructuringTransformer)(), // const { a } = obj -> const a = obj.a
+        (0, blockScoping_js_1.blockScopingTransformer)(), // let/const -> var (с shadowing)
+        (0, loopHoistVariables_js_1.loopHoistVariablesTransformer)(), // hoist loop vars before loop
+        (0, precedence_js_1.precedenceTransformer)(), // добавляет скобки для приоритета операций
+        (0, replaceDollar_js_1.replaceDollarTransformer)(), // $name -> _24_name
+        (0, removeImportExport_js_1.removeImportExportTransformer)(), // удаляет import/export
+    ];
+}
+/**
+ * Создаёт полный набор трансформеров для компиляции
+ *
+ * @param program - TypeScript program
+ * @param options - Опции компиляции btc
+ * @returns Объект с before, after трансформерами и массивом executables
+ */
+function createTransformers(program, options) {
+    const executables = [];
+    return {
+        before: createBeforeTransformers(program, options, executables),
+        after: createAfterTransformers(),
+        executables,
+    };
+}

package/build/core/building/types.js

@@ -0,0 +1,19 @@
+"use strict";
+/**
+ * Типы для Build Pipeline
+ * @module build/types
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createBuildContext = createBuildContext;
+/**
+ * Создаёт контекст сборки
+ */
+function createBuildContext(opts) {
+    return {
+        mode: opts.mode ?? 'single',
+        tsConfig: opts.tsConfig,
+        options: opts.options,
+        files: opts.files ?? [],
+        cwd: opts.cwd ?? process.cwd(),
+    };
+}