@boristype/bt-cli 0.1.0-alpha.0

package/build/transformers/loopHoistVariables.js

@@ -0,0 +1,352 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loopHoistVariablesTransformer = loopHoistVariablesTransformer;
+const typescript_1 = __importDefault(require("typescript"));
+/**
+ * Трансформер для поднятия переменных из циклов.
+ *
+ * Переменные, объявленные внутри циклов, поднимаются перед циклом
+ * и переименовываются с суффиксом _loopN для избежания конфликтов.
+ * Объявления внутри цикла заменяются на присваивания.
+ *
+ * @example
+ * // Вход:
+ * for (var i in arr) {
+ *   var x = i * 2;
+ *   console.log(x);
+ * }
+ *
+ * // Выход:
+ * var i_loop1 = undefined;
+ * var x_loop1 = undefined;
+ * for (i_loop1 in arr) {
+ *   x_loop1 = i_loop1 * 2;
+ *   console.log(x_loop1);
+ * }
+ *
+ * @returns TypeScript transformer factory
+ */
+function loopHoistVariablesTransformer() {
+    return (context) => {
+        return (sourceFile) => {
+            let loopCounter = 0;
+            /**
+             * Проверяет, является ли узел циклом
+             */
+            const isLoop = (node) => {
+                return typescript_1.default.isForStatement(node) ||
+                    typescript_1.default.isForInStatement(node) ||
+                    typescript_1.default.isForOfStatement(node) ||
+                    typescript_1.default.isWhileStatement(node) ||
+                    typescript_1.default.isDoStatement(node);
+            };
+            /**
+             * Собирает все переменные из тела цикла, включая заголовки вложенных циклов
+             */
+            const collectLoopVariables = (loopBody, loopNum, variables) => {
+                const visit = (node) => {
+                    // Не заходим во вложенные функции
+                    if (typescript_1.default.isFunctionDeclaration(node) || typescript_1.default.isFunctionExpression(node) || typescript_1.default.isArrowFunction(node)) {
+                        return;
+                    }
+                    // Собираем переменные из VariableStatement
+                    if (typescript_1.default.isVariableStatement(node)) {
+                        for (const decl of node.declarationList.declarations) {
+                            if (typescript_1.default.isIdentifier(decl.name)) {
+                                const originalName = decl.name.text;
+                                const newName = `${originalName}_loop${loopNum}`;
+                                variables.push({ originalName, newName });
+                            }
+                            // TODO: BindingPattern (деструктуризация) — пока пропускаем
+                        }
+                    }
+                    // Собираем переменные из заголовков вложенных циклов for-in/for-of
+                    if (typescript_1.default.isForInStatement(node) || typescript_1.default.isForOfStatement(node)) {
+                        if (typescript_1.default.isVariableDeclarationList(node.initializer)) {
+                            const decl = node.initializer.declarations[0];
+                            if (decl && typescript_1.default.isIdentifier(decl.name)) {
+                                const originalName = decl.name.text;
+                                const newName = `${originalName}_loop${loopNum}`;
+                                variables.push({ originalName, newName });
+                            }
+                        }
+                    }
+                    // Собираем переменные из заголовков вложенных циклов for
+                    if (typescript_1.default.isForStatement(node) && node.initializer && typescript_1.default.isVariableDeclarationList(node.initializer)) {
+                        for (const decl of node.initializer.declarations) {
+                            if (typescript_1.default.isIdentifier(decl.name)) {
+                                const originalName = decl.name.text;
+                                const newName = `${originalName}_loop${loopNum}`;
+                                variables.push({ originalName, newName });
+                            }
+                        }
+                    }
+                    typescript_1.default.forEachChild(node, visit);
+                };
+                visit(loopBody);
+            };
+            /**
+             * Трансформирует тело цикла: заменяет объявления на присваивания
+             * и переименовывает использования переменных
+             */
+            const transformLoopBody = (body, variables) => {
+                const renameMap = new Map(variables.map(v => [v.originalName, v.newName]));
+                const visitor = (node) => {
+                    // Заменяем VariableStatement на присваивания
+                    if (typescript_1.default.isVariableStatement(node)) {
+                        const assignments = [];
+                        for (const decl of node.declarationList.declarations) {
+                            if (typescript_1.default.isIdentifier(decl.name)) {
+                                const originalName = decl.name.text;
+                                const newName = renameMap.get(originalName);
+                                if (newName) {
+                                    // Создаём присваивание: newName = init || undefined
+                                    const init = decl.initializer
+                                        ? typescript_1.default.visitNode(decl.initializer, visitor)
+                                        : typescript_1.default.factory.createIdentifier('undefined');
+                                    assignments.push(typescript_1.default.factory.createExpressionStatement(typescript_1.default.factory.createAssignment(typescript_1.default.factory.createIdentifier(newName), init)));
+                                }
+                            }
+                        }
+                        if (assignments.length === 1) {
+                            return assignments[0];
+                        }
+                        else if (assignments.length > 1) {
+                            // Возвращаем блок с несколькими присваиваниями
+                            // Но это проблема — нужно вернуть несколько statements
+                            // Пока возвращаем первое (TODO: обработать множественные)
+                            return assignments[0];
+                        }
+                    }
+                    // Трансформируем заголовки вложенных циклов for-in/for-of
+                    if (typescript_1.default.isForInStatement(node) || typescript_1.default.isForOfStatement(node)) {
+                        let newInitializer = node.initializer;
+                        if (typescript_1.default.isVariableDeclarationList(node.initializer)) {
+                            const decl = node.initializer.declarations[0];
+                            if (decl && typescript_1.default.isIdentifier(decl.name)) {
+                                const newName = renameMap.get(decl.name.text);
+                                if (newName) {
+                                    // Заменяем var x на просто x_loopN
+                                    newInitializer = typescript_1.default.factory.createIdentifier(newName);
+                                }
+                            }
+                        }
+                        const transformedBody = typescript_1.default.visitNode(node.statement, visitor);
+                        const transformedExpression = typescript_1.default.visitNode(node.expression, visitor);
+                        if (typescript_1.default.isForInStatement(node)) {
+                            return typescript_1.default.factory.createForInStatement(newInitializer, transformedExpression, transformedBody);
+                        }
+                        else {
+                            return typescript_1.default.factory.createForOfStatement(node.awaitModifier, newInitializer, transformedExpression, transformedBody);
+                        }
+                    }
+                    // Трансформируем заголовки вложенных циклов for
+                    if (typescript_1.default.isForStatement(node)) {
+                        let newInitializer = node.initializer;
+                        if (node.initializer && typescript_1.default.isVariableDeclarationList(node.initializer)) {
+                            const assignments = [];
+                            for (const decl of node.initializer.declarations) {
+                                if (typescript_1.default.isIdentifier(decl.name)) {
+                                    const newName = renameMap.get(decl.name.text);
+                                    if (newName && decl.initializer) {
+                                        assignments.push(typescript_1.default.factory.createAssignment(typescript_1.default.factory.createIdentifier(newName), typescript_1.default.visitNode(decl.initializer, visitor)));
+                                    }
+                                }
+                            }
+                            if (assignments.length === 1) {
+                                newInitializer = assignments[0];
+                            }
+                            else if (assignments.length > 1) {
+                                newInitializer = typescript_1.default.factory.createCommaListExpression(assignments);
+                            }
+                            else {
+                                newInitializer = undefined;
+                            }
+                        }
+                        return typescript_1.default.factory.createForStatement(newInitializer, node.condition ? typescript_1.default.visitNode(node.condition, visitor) : undefined, node.incrementor ? typescript_1.default.visitNode(node.incrementor, visitor) : undefined, typescript_1.default.visitNode(node.statement, visitor));
+                    }
+                    // Переименовываем идентификаторы
+                    if (typescript_1.default.isIdentifier(node)) {
+                        const parent = node.parent;
+                        // Пропускаем property access и property assignment
+                        if (parent && typescript_1.default.isPropertyAccessExpression(parent) && parent.name === node) {
+                            return node;
+                        }
+                        if (parent && typescript_1.default.isPropertyAssignment(parent) && parent.name === node) {
+                            return node;
+                        }
+                        const newName = renameMap.get(node.text);
+                        if (newName) {
+                            return typescript_1.default.factory.createIdentifier(newName);
+                        }
+                    }
+                    return typescript_1.default.visitEachChild(node, visitor, context);
+                };
+                return typescript_1.default.visitNode(body, visitor);
+            };
+            /**
+             * Создаёт объявления переменных для вставки перед циклом
+             */
+            const createHoistedDeclarations = (variables) => {
+                return variables.map(v => typescript_1.default.factory.createVariableStatement(undefined, typescript_1.default.factory.createVariableDeclarationList([typescript_1.default.factory.createVariableDeclaration(v.newName, undefined, undefined, typescript_1.default.factory.createIdentifier('undefined'))], typescript_1.default.NodeFlags.None // var
+                )));
+            };
+            /**
+             * Обрабатывает for-in цикл
+             */
+            const transformForInStatement = (node) => {
+                loopCounter++;
+                const loopNum = loopCounter;
+                const variables = [];
+                // Собираем переменную из заголовка цикла (for var x in ...)
+                let newInitializer = node.initializer;
+                if (typescript_1.default.isVariableDeclarationList(node.initializer)) {
+                    const decl = node.initializer.declarations[0];
+                    if (decl && typescript_1.default.isIdentifier(decl.name)) {
+                        const originalName = decl.name.text;
+                        const newName = `${originalName}_loop${loopNum}`;
+                        variables.push({ originalName, newName });
+                        // Заменяем объявление на просто идентификатор
+                        newInitializer = typescript_1.default.factory.createIdentifier(newName);
+                    }
+                }
+                // Собираем переменные из тела цикла
+                collectLoopVariables(node.statement, loopNum, variables);
+                // Трансформируем тело
+                const transformedBody = transformLoopBody(node.statement, variables);
+                // Создаём новый for-in
+                const newForIn = typescript_1.default.factory.createForInStatement(newInitializer, typescript_1.default.visitNode(node.expression, mainVisitor), transformedBody);
+                // Возвращаем объявления + цикл
+                const hoisted = createHoistedDeclarations(variables);
+                return [...hoisted, newForIn];
+            };
+            /**
+             * Обрабатывает for-of цикл (хотя он должен быть уже преобразован в for-in)
+             */
+            const transformForOfStatement = (node) => {
+                loopCounter++;
+                const loopNum = loopCounter;
+                const variables = [];
+                let newInitializer = node.initializer;
+                if (typescript_1.default.isVariableDeclarationList(node.initializer)) {
+                    const decl = node.initializer.declarations[0];
+                    if (decl && typescript_1.default.isIdentifier(decl.name)) {
+                        const originalName = decl.name.text;
+                        const newName = `${originalName}_loop${loopNum}`;
+                        variables.push({ originalName, newName });
+                        newInitializer = typescript_1.default.factory.createIdentifier(newName);
+                    }
+                }
+                collectLoopVariables(node.statement, loopNum, variables);
+                const transformedBody = transformLoopBody(node.statement, variables);
+                const newForOf = typescript_1.default.factory.createForOfStatement(node.awaitModifier, newInitializer, typescript_1.default.visitNode(node.expression, mainVisitor), transformedBody);
+                const hoisted = createHoistedDeclarations(variables);
+                return [...hoisted, newForOf];
+            };
+            /**
+             * Обрабатывает for цикл
+             */
+            const transformForStatement = (node) => {
+                loopCounter++;
+                const loopNum = loopCounter;
+                const variables = [];
+                // Собираем переменные из инициализатора (for (var i = 0; ...))
+                let newInitializer = node.initializer;
+                if (node.initializer && typescript_1.default.isVariableDeclarationList(node.initializer)) {
+                    const assignments = [];
+                    for (const decl of node.initializer.declarations) {
+                        if (typescript_1.default.isIdentifier(decl.name)) {
+                            const originalName = decl.name.text;
+                            const newName = `${originalName}_loop${loopNum}`;
+                            variables.push({ originalName, newName });
+                            if (decl.initializer) {
+                                assignments.push(typescript_1.default.factory.createAssignment(typescript_1.default.factory.createIdentifier(newName), decl.initializer));
+                            }
+                        }
+                    }
+                    if (assignments.length === 1) {
+                        newInitializer = assignments[0];
+                    }
+                    else if (assignments.length > 1) {
+                        newInitializer = typescript_1.default.factory.createCommaListExpression(assignments);
+                    }
+                    else {
+                        newInitializer = undefined;
+                    }
+                }
+                // Собираем переменные из тела
+                collectLoopVariables(node.statement, loopNum, variables);
+                // Трансформируем тело и условия
+                const renameMap = new Map(variables.map(v => [v.originalName, v.newName]));
+                const renameVisitor = (n) => {
+                    if (typescript_1.default.isIdentifier(n)) {
+                        const parent = n.parent;
+                        if (parent && typescript_1.default.isPropertyAccessExpression(parent) && parent.name === n)
+                            return n;
+                        if (parent && typescript_1.default.isPropertyAssignment(parent) && parent.name === n)
+                            return n;
+                        const newName = renameMap.get(n.text);
+                        if (newName)
+                            return typescript_1.default.factory.createIdentifier(newName);
+                    }
+                    return typescript_1.default.visitEachChild(n, renameVisitor, context);
+                };
+                const transformedBody = transformLoopBody(node.statement, variables);
+                const transformedCondition = node.condition
+                    ? typescript_1.default.visitNode(node.condition, renameVisitor)
+                    : undefined;
+                const transformedIncrementor = node.incrementor
+                    ? typescript_1.default.visitNode(node.incrementor, renameVisitor)
+                    : undefined;
+                const newFor = typescript_1.default.factory.createForStatement(newInitializer, transformedCondition, transformedIncrementor, transformedBody);
+                const hoisted = createHoistedDeclarations(variables);
+                return [...hoisted, newFor];
+            };
+            /**
+             * Обрабатывает while/do-while циклы
+             */
+            const transformWhileStatement = (node) => {
+                loopCounter++;
+                const loopNum = loopCounter;
+                const variables = [];
+                collectLoopVariables(node.statement, loopNum, variables);
+                if (variables.length === 0) {
+                    // Нет переменных — просто обходим детей
+                    return [typescript_1.default.visitEachChild(node, mainVisitor, context)];
+                }
+                const transformedBody = transformLoopBody(node.statement, variables);
+                let newLoop;
+                if (typescript_1.default.isWhileStatement(node)) {
+                    newLoop = typescript_1.default.factory.createWhileStatement(typescript_1.default.visitNode(node.expression, mainVisitor), transformedBody);
+                }
+                else {
+                    newLoop = typescript_1.default.factory.createDoStatement(transformedBody, typescript_1.default.visitNode(node.expression, mainVisitor));
+                }
+                const hoisted = createHoistedDeclarations(variables);
+                return [...hoisted, newLoop];
+            };
+            /**
+             * Основной visitor
+             */
+            const mainVisitor = (node) => {
+                if (typescript_1.default.isForInStatement(node)) {
+                    return transformForInStatement(node);
+                }
+                if (typescript_1.default.isForOfStatement(node)) {
+                    return transformForOfStatement(node);
+                }
+                if (typescript_1.default.isForStatement(node)) {
+                    return transformForStatement(node);
+                }
+                if (typescript_1.default.isWhileStatement(node) || typescript_1.default.isDoStatement(node)) {
+                    return transformWhileStatement(node);
+                }
+                return typescript_1.default.visitEachChild(node, mainVisitor, context);
+            };
+            return typescript_1.default.visitNode(sourceFile, mainVisitor);
+        };
+    };
+}

package/build/transformers/math.js

@@ -0,0 +1,39 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mathTransformer = mathTransformer;
+const typescript_1 = __importDefault(require("typescript"));
+function makeMathPolyfillExpression(functionName) {
+    return typescript_1.default.factory.createPropertyAccessExpression(typescript_1.default.factory.createPropertyAccessExpression(typescript_1.default.factory.createPropertyAccessExpression(typescript_1.default.factory.createIdentifier('bt'), typescript_1.default.factory.createIdentifier('polyfill')), typescript_1.default.factory.createIdentifier('Math')), typescript_1.default.factory.createIdentifier(functionName));
+}
+function mathTransformer() {
+    return (context) => (sourceFile) => {
+        const REPLACE_METHODS = ['ceil', 'floor', 'trunc', 'random'];
+        const MAX_METHOD = 'max';
+        const MIN_METHOD = 'min';
+        function visit(node) {
+            node = typescript_1.default.visitEachChild(node, visit, context);
+            if (typescript_1.default.isCallExpression(node)) {
+                if (typescript_1.default.isPropertyAccessExpression(node.expression)) {
+                    const prop = node.expression;
+                    if (typescript_1.default.isIdentifier(prop.expression) && prop.expression.text === 'Math') {
+                        const methodName = prop.name.text;
+                        if (REPLACE_METHODS.includes(methodName)) {
+                            return typescript_1.default.factory.createCallExpression(makeMathPolyfillExpression(methodName), undefined, node.arguments);
+                        }
+                        else if (methodName === MAX_METHOD) {
+                            return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(`Max`), undefined, node.arguments);
+                        }
+                        else if (methodName === MIN_METHOD) {
+                            return typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier(`Min`), undefined, node.arguments);
+                        }
+                    }
+                }
+            }
+            return node;
+        }
+        return typescript_1.default.visitNode(sourceFile, visit);
+    };
+}

package/build/transformers/namespaces.js

@@ -0,0 +1,22 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.namespacesTransformer = namespacesTransformer;
+const typescript_1 = __importDefault(require("typescript"));
+function namespacesTransformer() {
+    return (context) => (sourceFile) => {
+        function visit(node) {
+            if (typescript_1.default.isModuleDeclaration(node) && (node.flags & typescript_1.default.NodeFlags.Namespace)) {
+                if (node.body && typescript_1.default.isModuleBlock(node.body)) {
+                    const statements = node.body.statements.map((statement) => typescript_1.default.visitNode(statement, visit));
+                    const customString = typescript_1.default.factory.createExpressionStatement(typescript_1.default.factory.createStringLiteral(`META:NAMESPACE:${node.name.text}`));
+                    node = [customString, ...statements];
+                }
+            }
+            return typescript_1.default.visitEachChild(node, visit, context);
+        }
+        return typescript_1.default.visitNode(sourceFile, visit);
+    };
+}

package/build/transformers/numericSeparator.js

@@ -0,0 +1,46 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.numericSeparatorTransformer = numericSeparatorTransformer;
+const typescript_1 = __importDefault(require("typescript"));
+/**
+ * Трансформер для удаления числовых разделителей из литералов.
+ * Преобразует числа вида 1_000_000 в 1000000.
+ *
+ * ВАЖНО: Этот трансформер должен работать в секции `before`,
+ * т.к. TypeScript printer сохраняет исходный текст литералов.
+ *
+ * @example
+ * // Вход:
+ * const x = 1_000_000;
+ * const y = 0xFF_FF;
+ *
+ * // Выход:
+ * const x = 1000000;
+ * const y = 0xFFFF;
+ *
+ * @returns TypeScript transformer factory
+ */
+function numericSeparatorTransformer() {
+    return (context) => {
+        return (sourceFile) => {
+            const visitor = (node) => {
+                // Обрабатываем числовые литералы
+                if (typescript_1.default.isNumericLiteral(node)) {
+                    // Получаем исходный текст из source file
+                    const text = node.getText(sourceFile);
+                    // Проверяем, содержит ли литерал разделители
+                    if (text.includes('_')) {
+                        // Удаляем все подчёркивания и создаём новый литерал
+                        const cleanedText = text.replace(/_/g, '');
+                        return typescript_1.default.factory.createNumericLiteral(cleanedText);
+                    }
+                }
+                return typescript_1.default.visitEachChild(node, visitor, context);
+            };
+            return typescript_1.default.visitNode(sourceFile, visitor);
+        };
+    };
+}

package/build/transformers/objectProperties.js

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.objectPropertiesTransformer = objectPropertiesTransformer;
+const typescript_1 = __importDefault(require("typescript"));
+const utils_1 = require("./utils");
+function objectPropertiesTransformer() {
+    return (context) => (sourceFile) => {
+        function visit(node) {
+            // Обрабатываем объектные литералы
+            if (typescript_1.default.isObjectLiteralExpression(node)) {
+                const newProperties = node.properties.map(prop => {
+                    // Обрабатываем shorthand properties (например, {x} -> {x: x})
+                    if (typescript_1.default.isShorthandPropertyAssignment(prop)) {
+                        // Создаем полное свойство с ключом в кавычках
+                        const keyName = prop.name.text;
+                        return typescript_1.default.factory.createPropertyAssignment(typescript_1.default.factory.createStringLiteral(keyName), prop.name);
+                    }
+                    // Обрабатываем обычные свойства
+                    if (typescript_1.default.isPropertyAssignment(prop)) {
+                        let keyNode;
+                        // Если ключ - идентификатор или число, оборачиваем в строковый литерал
+                        if (typescript_1.default.isIdentifier(prop.name)) {
+                            keyNode = typescript_1.default.factory.createStringLiteral(prop.name.text);
+                        }
+                        else if (typescript_1.default.isNumericLiteral(prop.name)) {
+                            keyNode = typescript_1.default.factory.createStringLiteral(prop.name.text);
+                        }
+                        else if (typescript_1.default.isComputedPropertyName(prop.name)) {
+                            // Computed properties оставляем как есть
+                            keyNode = prop.name;
+                        }
+                        else {
+                            // Уже строковый литерал - оставляем как есть
+                            keyNode = prop.name;
+                        }
+                        // Рекурсивно обрабатываем значение
+                        const visitedValue = typescript_1.default.visitNode(prop.initializer, visit);
+                        return typescript_1.default.factory.createPropertyAssignment(keyNode, visitedValue);
+                    }
+                    // Методы и другие типы свойств оставляем как есть, но обрабатываем рекурсивно
+                    return typescript_1.default.visitEachChild(prop, visit, context);
+                });
+                return typescript_1.default.factory.createObjectLiteralExpression(newProperties, true);
+            }
+            return typescript_1.default.visitEachChild(node, visit, context);
+        }
+        const transformedSourceFile = typescript_1.default.visitNode(sourceFile, visit);
+        (0, utils_1.setParentNodes)(transformedSourceFile, sourceFile);
+        return transformedSourceFile;
+    };
+}