@boristype/bt-cli 0.1.0-alpha.0

package/build/transformers/templateLiterals.js

@@ -0,0 +1,104 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.templateLiteralsTransformer = templateLiteralsTransformer;
+const typescript_1 = __importDefault(require("typescript"));
+/**
+ * Трансформер для преобразования шаблонных строк в конкатенацию.
+ * Использует режим "loose" — все части приводятся к строкам через конкатенацию с "".
+ *
+ * @example
+ * // Вход:
+ * const msg = `Hello, ${name}!`;
+ * const multi = `a${b}c${d}e`;
+ *
+ * // Выход:
+ * const msg = "Hello, " + name + "!";
+ * const multi = "a" + b + "c" + d + "e";
+ *
+ * @returns TypeScript transformer factory
+ */
+function templateLiteralsTransformer() {
+    return (context) => {
+        return (sourceFile) => {
+            const visitor = (node) => {
+                // Обрабатываем шаблонные литералы (template literals)
+                if (typescript_1.default.isTemplateExpression(node)) {
+                    return transformTemplateExpression(node, context);
+                }
+                // Обрабатываем tagged template expressions (например: tag`hello`)
+                if (typescript_1.default.isTaggedTemplateExpression(node)) {
+                    // Tagged templates требуют особой обработки, пока пропускаем
+                    // TODO: поддержка tagged templates если нужно
+                    return typescript_1.default.visitEachChild(node, visitor, context);
+                }
+                // Обрабатываем простые шаблонные строки без выражений (`hello`)
+                if (typescript_1.default.isNoSubstitutionTemplateLiteral(node)) {
+                    // Просто превращаем в обычную строку
+                    return typescript_1.default.factory.createStringLiteral(node.text);
+                }
+                return typescript_1.default.visitEachChild(node, visitor, context);
+            };
+            return typescript_1.default.visitNode(sourceFile, visitor);
+        };
+    };
+}
+/**
+ * Преобразует TemplateExpression в конкатенацию строк.
+ *
+ * @param node - узел TemplateExpression
+ * @param context - контекст трансформации
+ * @returns выражение конкатенации строк
+ */
+function transformTemplateExpression(node, context) {
+    const parts = [];
+    // Добавляем начальную часть (head)
+    if (node.head.text.length > 0) {
+        parts.push(typescript_1.default.factory.createStringLiteral(node.head.text));
+    }
+    // Обрабатываем каждый span (выражение + следующий текст)
+    for (const span of node.templateSpans) {
+        // Добавляем выражение (рекурсивно обрабатываем на случай вложенных шаблонов)
+        const visitedExpression = typescript_1.default.visitNode(span.expression, (n) => {
+            if (typescript_1.default.isTemplateExpression(n)) {
+                return transformTemplateExpression(n, context);
+            }
+            if (typescript_1.default.isNoSubstitutionTemplateLiteral(n)) {
+                return typescript_1.default.factory.createStringLiteral(n.text);
+            }
+            return n;
+        });
+        parts.push(visitedExpression);
+        // Добавляем текстовую часть после выражения
+        const literal = span.literal;
+        if (literal.text.length > 0) {
+            parts.push(typescript_1.default.factory.createStringLiteral(literal.text));
+        }
+    }
+    // Если нет частей, возвращаем пустую строку
+    if (parts.length === 0) {
+        return typescript_1.default.factory.createStringLiteral('');
+    }
+    // Если только одна часть — возвращаем её
+    if (parts.length === 1) {
+        // Если это не строка, нужно привести к строке через конкатенацию с ""
+        const part = parts[0];
+        if (typescript_1.default.isStringLiteral(part)) {
+            return part;
+        }
+        // "" + expr для приведения к строке
+        return typescript_1.default.factory.createBinaryExpression(typescript_1.default.factory.createStringLiteral(''), typescript_1.default.SyntaxKind.PlusToken, part);
+    }
+    // Строим цепочку конкатенации слева направо
+    let result = parts[0];
+    // Если первая часть не строка, начинаем с "" + для приведения к строке
+    if (!typescript_1.default.isStringLiteral(result)) {
+        result = typescript_1.default.factory.createBinaryExpression(typescript_1.default.factory.createStringLiteral(''), typescript_1.default.SyntaxKind.PlusToken, result);
+    }
+    for (let i = 1; i < parts.length; i++) {
+        result = typescript_1.default.factory.createBinaryExpression(result, typescript_1.default.SyntaxKind.PlusToken, parts[i]);
+    }
+    return result;
+}

package/build/transformers/tocodelibrary.js

@@ -0,0 +1,178 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tocodelibraryTransformer = tocodelibraryTransformer;
+const typescript_1 = __importDefault(require("typescript"));
+const utils_1 = require("./utils");
+function tocodelibraryTransformer() {
+    return (context) => {
+        return (sourceFile) => {
+            if (sourceFile.fileName.endsWith(".test.ts")) {
+                return sourceFile;
+            }
+            // Пропускаем трансформацию для executable objects
+            if ((0, utils_1.isExecutableObject)(sourceFile)) {
+                return sourceFile;
+            }
+            const hoistedFunctions = [];
+            let functionCounter = 0;
+            const functionNameMap = new Map();
+            const nameToHoistedName = new Map(); // Маппинг имени -> hoisted имя
+            const functionDepthMap = new Map(); // Маппинг функции -> уровень вложенности
+            let currentDepth = 0;
+            // Генерация уникального имени для функции
+            function generateUniqueName(originalName, node, depth) {
+                const baseName = originalName || "anonymous";
+                // Top-level функции (depth === 0) сохраняют оригинальное имя
+                let uniqueName;
+                if (depth === 0 && originalName) {
+                    uniqueName = originalName;
+                }
+                else {
+                    // Вложенные функции получают префикс __hoisted_
+                    uniqueName = `__hoisted_${baseName}_${functionCounter++}`;
+                }
+                functionNameMap.set(node, uniqueName);
+                functionDepthMap.set(node, depth);
+                if (originalName) {
+                    // Маппинг для всех функций (и top-level и вложенных)
+                    nameToHoistedName.set(originalName, uniqueName);
+                }
+                return uniqueName;
+            }
+            // Генерация пути к __codelibrary через цепочку __parent
+            function generateCodelibaryPath(depth) {
+                if (depth === 0) {
+                    return context.factory.createPropertyAccessExpression((0, utils_1.markUntouchable)(context.factory.createIdentifier("__module_env")), "__codelibrary");
+                }
+                let expr = context.factory.createIdentifier("__env");
+                for (let i = 0; i < depth; i++) {
+                    expr = context.factory.createPropertyAccessExpression(expr, "__parent");
+                }
+                return context.factory.createPropertyAccessExpression((0, utils_1.markUntouchable)(expr), "__codelibrary");
+            }
+            // Первый проход: собираем все функции и даем им уникальные имена
+            function collectFunctions(node) {
+                if (typescript_1.default.isFunctionDeclaration(node)) {
+                    const originalName = node.name?.text;
+                    const uniqueName = generateUniqueName(originalName, node, currentDepth);
+                    const hoistedFunction = context.factory.createFunctionDeclaration(node.modifiers, node.asteriskToken, context.factory.createIdentifier(uniqueName), node.typeParameters, node.parameters, node.type, node.body);
+                    hoistedFunctions.push(hoistedFunction);
+                    // Увеличиваем глубину для вложенных функций
+                    currentDepth++;
+                    typescript_1.default.forEachChild(node, collectFunctions);
+                    currentDepth--;
+                    return;
+                }
+                typescript_1.default.forEachChild(node, collectFunctions);
+            }
+            // Второй проход: заменяем объявления функций и callable на ref, добавляем lib
+            function visitor(node, depth = 0) {
+                if (typescript_1.default.isFunctionDeclaration(node)) {
+                    const originalName = node.name?.text;
+                    const uniqueName = functionNameMap.get(node);
+                    if (!uniqueName) {
+                        return node;
+                    }
+                    // Увеличиваем глубину для обработки тела функции
+                    const newDepth = depth + 1;
+                    // Обрабатываем тело функции для замены вложенных функций
+                    const transformedBody = node.body
+                        ? typescript_1.default.visitNode(node.body, (n) => visitor(n, newDepth))
+                        : undefined;
+                    // Обновляем hoisted функцию с трансформированным телом
+                    const hoistedIndex = hoistedFunctions.findIndex(f => f.name?.text === uniqueName);
+                    if (hoistedIndex !== -1 && transformedBody) {
+                        hoistedFunctions[hoistedIndex] = context.factory.createFunctionDeclaration(hoistedFunctions[hoistedIndex].modifiers, hoistedFunctions[hoistedIndex].asteriskToken, hoistedFunctions[hoistedIndex].name, hoistedFunctions[hoistedIndex].typeParameters, hoistedFunctions[hoistedIndex].parameters, hoistedFunctions[hoistedIndex].type, transformedBody);
+                    }
+                    // Удаляем объявление функции из кода
+                    return [];
+                }
+                // Обрабатываем дескрипторы функций
+                if (typescript_1.default.isObjectLiteralExpression(node)) {
+                    const hasDescriptor = node.properties.some(prop => typescript_1.default.isPropertyAssignment(prop) &&
+                        ((typescript_1.default.isIdentifier(prop.name) && prop.name.text === "@descriptor") ||
+                            (typescript_1.default.isStringLiteral(prop.name) && prop.name.text === "@descriptor")));
+                    if (hasDescriptor) {
+                        // Это дескриптор, добавляем свойство lib
+                        const codelibPath = generateCodelibaryPath(depth);
+                        const newProperties = node.properties.map(prop => {
+                            // Заменяем callable на ref
+                            if (typescript_1.default.isPropertyAssignment(prop)) {
+                                const propertyName = typescript_1.default.isIdentifier(prop.name)
+                                    ? prop.name.text
+                                    : typescript_1.default.isStringLiteral(prop.name)
+                                        ? prop.name.text
+                                        : undefined;
+                                if (propertyName === "callable") {
+                                    if (typescript_1.default.isIdentifier(prop.initializer)) {
+                                        const functionName = prop.initializer.text;
+                                        const hoistedName = nameToHoistedName.get(functionName);
+                                        if (hoistedName) {
+                                            return context.factory.createPropertyAssignment(context.factory.createStringLiteral("ref"), context.factory.createStringLiteral(hoistedName));
+                                        }
+                                    }
+                                    return context.factory.createPropertyAssignment(context.factory.createStringLiteral("ref"), typescript_1.default.visitNode(prop.initializer, (n) => visitor(n, depth)));
+                                }
+                            }
+                            return prop;
+                        });
+                        // Добавляем свойство lib
+                        const propertiesWithLib = [
+                            ...newProperties,
+                            context.factory.createPropertyAssignment(context.factory.createStringLiteral("lib"), codelibPath)
+                        ];
+                        return context.factory.updateObjectLiteralExpression(node, propertiesWithLib);
+                    }
+                }
+                return typescript_1.default.visitEachChild(node, (n) => visitor(n, depth), context);
+            }
+            // Собираем все функции
+            collectFunctions(sourceFile);
+            // Трансформируем исходный файл
+            const transformedStatements = sourceFile.statements.map(statement => typescript_1.default.visitNode(statement, visitor)).flat().filter((s) => s !== undefined);
+            // Разделяем statements на export декларации и остальной код
+            const exportStatements = [];
+            const initStatements = [];
+            transformedStatements.forEach(statement => {
+                // Проверяем, содержит ли statement модификатор export или является export декларацией
+                const hasExportModifier = typescript_1.default.canHaveModifiers(statement) &&
+                    typescript_1.default.getModifiers(statement)?.some((m) => m.kind === typescript_1.default.SyntaxKind.ExportKeyword);
+                const isExportDeclaration = typescript_1.default.isExportDeclaration(statement) || typescript_1.default.isExportAssignment(statement);
+                // Все что содержит export остается на top-level
+                // Это включает: export type, export interface, export {}, export default, export function, export const и т.д.
+                if (hasExportModifier || isExportDeclaration) {
+                    exportStatements.push(statement);
+                }
+                else {
+                    initStatements.push(statement);
+                }
+            });
+            // Ищем var __module_env = {} и добавляем __codelibrary
+            const statementsWithCodelibrary = initStatements.flatMap(statement => {
+                // Проверяем, является ли это var __module_env = {}
+                if (typescript_1.default.isVariableStatement(statement)) {
+                    const decl = statement.declarationList.declarations[0];
+                    if (decl && typescript_1.default.isIdentifier(decl.name) && decl.name.text === "__module_env") {
+                        // Нашли __module_env, добавляем после него __module_env.__codelibrary = __codelibrary
+                        const codelibAssignment = context.factory.createExpressionStatement(context.factory.createBinaryExpression(context.factory.createPropertyAccessExpression((0, utils_1.markUntouchable)(context.factory.createIdentifier("__module_env")), "__codelibrary"), typescript_1.default.SyntaxKind.EqualsToken, context.factory.createIdentifier("__codelibrary")));
+                        return [statement, codelibAssignment];
+                    }
+                }
+                return [statement];
+            });
+            // Создаем функцию __init с оставшимися statements (без export деклараций)
+            const initFunction = context.factory.createFunctionDeclaration(undefined, undefined, context.factory.createIdentifier("__init"), undefined, [
+                context.factory.createParameterDeclaration(undefined, undefined, context.factory.createIdentifier("__codelibrary")),
+                context.factory.createParameterDeclaration(undefined, undefined, context.factory.createIdentifier("__module"))
+            ], undefined, context.factory.createBlock(statementsWithCodelibrary, true));
+            // Объединяем: hoisted функции, __init, и export декларации в конце
+            const newStatements = [...hoistedFunctions, initFunction, ...exportStatements];
+            newStatements.forEach(stmt => (0, utils_1.setParentNodes)(stmt, sourceFile));
+            // Возвращаем новый файл с hoisted функциями, __init и export декларациями
+            return context.factory.updateSourceFile(sourceFile, newStatements);
+        };
+    };
+}

package/build/transformers/utils.js

@@ -0,0 +1,202 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.printAstNode = printAstNode;
+exports.markUntouchable = markUntouchable;
+exports.isUntouchable = isUntouchable;
+exports.markExecutableObject = markExecutableObject;
+exports.isExecutableObject = isExecutableObject;
+exports.setExecutableObjectKey = setExecutableObjectKey;
+exports.getExecutableObjectKey = getExecutableObjectKey;
+exports.preserveSymbolsFrom = preserveSymbolsFrom;
+exports.setParentNodes = setParentNodes;
+exports.visitNodeWithParents = visitNodeWithParents;
+exports.visitEachChildWithParents = visitEachChildWithParents;
+const ts = __importStar(require("typescript"));
+/**
+ * Utility functions for TypeScript AST transformers.
+ *
+ * Эти функции обеспечивают корректную работу последовательных трансформеров,
+ * устанавливая parent ссылки для узлов, созданных через factory методы.
+ *
+ * Проблема: Когда трансформер создает новые узлы через ts.factory.create*(),
+ * у этих узлов нет parent ссылок. Последующие трансформеры, которые полагаются
+ * на node.parent для определения контекста, не могут корректно обработать такие узлы.
+ *
+ * Решение: Использовать setParentNodes() после создания новых узлов.
+ *
+ * @example
+ * // Создание новых узлов без parent:
+ * const newNode = ts.factory.createObjectLiteralExpression(properties, true);
+ * return setParentNodes(newNode); // Устанавливаем parent для всех детей
+ *
+ * @example
+ * // Замена узла в visitor с сохранением parent из оригинальной ноды:
+ * if (ts.isArrowFunction(node)) {
+ *   const newFunc = ts.factory.createFunctionExpression(...);
+ *   return setParentNodes(newFunc, node.parent); // Parent от оригинального узла
+ * }
+ *
+ * @example
+ * // Использование wrapper для visitNode:
+ * const transformed = visitNodeWithParents(node, visitor); // Автоматически сохраняет parent
+ */
+function printAstNode(node, sourceCode) {
+    const printer = ts.createPrinter({
+        newLine: ts.NewLineKind.LineFeed,
+    });
+    let sourceFile;
+    if (sourceCode) {
+        // Используем существующий исходный код
+        sourceFile = ts.createSourceFile('temp.ts', sourceCode, ts.ScriptTarget.Latest, true);
+    }
+    else {
+        // Создаем минимальный sourceFile для контекста
+        sourceFile = ts.createSourceFile('temp.ts', '', ts.ScriptTarget.Latest);
+    }
+    const result = printer.printNode(ts.EmitHint.Unspecified, node, sourceFile);
+    // console.log(result);
+    return result;
+}
+const untouchable = Symbol('untouchable');
+function markUntouchable(obj) {
+    obj[untouchable] = true;
+    return obj;
+}
+function isUntouchable(obj) {
+    return obj && obj[untouchable] === true;
+}
+const executableObject = Symbol('executableObject');
+function markExecutableObject(obj) {
+    obj[executableObject] = true;
+    return obj;
+}
+function isExecutableObject(obj) {
+    return obj && obj[executableObject] === true;
+}
+const executableObjectKey = Symbol('executableObjectKey');
+function setExecutableObjectKey(obj, key) {
+    obj[executableObjectKey] = key;
+    return obj;
+}
+function getExecutableObjectKey(obj) {
+    return obj && obj[executableObjectKey];
+}
+function preserveSymbolsFrom(target, source) {
+    if (isUntouchable(source)) {
+        markUntouchable(target);
+    }
+    if (isExecutableObject(source)) {
+        markExecutableObject(target);
+    }
+    if (getExecutableObjectKey(source) !== undefined) {
+        setExecutableObjectKey(target, getExecutableObjectKey(source));
+    }
+    return target;
+}
+/**
+ * Устанавливает parent ссылки для всех дочерних узлов в AST.
+ * Используется после создания новых узлов через factory методы,
+ * чтобы последующие трансформеры могли корректно работать с node.parent.
+ *
+ * @param node - Корневой узел, для которого нужно установить parent ссылки
+ * @param parentNode - Опциональный parent для корневого узла (полезно при замене узлов в visitor)
+ * @returns Тот же узел с установленными parent ссылками
+ *
+ * @example
+ * // Замена узла в visitor с сохранением parent:
+ * if (ts.isArrowFunction(node)) {
+ *   const newNode = ts.factory.createFunctionExpression(...);
+ *   return setParentNodes(newNode, node.parent); // Сохраняем parent из оригинальной ноды
+ * }
+ */
+function setParentNodes(node, parentNode) {
+    function visit(currentNode, parent) {
+        // Устанавливаем parent для текущего узла
+        if (parent && currentNode !== parent && currentNode.kind !== 308) {
+            currentNode.parent = parent;
+        }
+        // Рекурсивно обходим всех детей
+        ts.forEachChild(currentNode, child => {
+            visit(child, currentNode);
+        });
+    }
+    if (!node)
+        return node;
+    // Устанавливаем parent для корневого узла, если указан
+    if (parentNode && node !== parentNode && node.kind !== 308) {
+        node.parent = parentNode;
+    }
+    // Обходим детей корневого узла
+    ts.forEachChild(node, child => {
+        visit(child, node);
+    });
+    return node;
+}
+/**
+ * Wrapper для ts.visitNode, который автоматически устанавливает parent ссылки
+ * для результата трансформации.
+ *
+ * @param node - Узел для трансформации
+ * @param visitor - Visitor функция
+ * @param preserveParent - Если true, сохраняет parent из оригинального узла
+ * @returns Трансформированный узел с установленными parent ссылками
+ */
+function visitNodeWithParents(node, visitor, preserveParent = true) {
+    if (!node)
+        return undefined;
+    const originalParent = node.parent;
+    const result = ts.visitNode(node, visitor);
+    if (result) {
+        setParentNodes(result, preserveParent ? originalParent : undefined);
+    }
+    return result;
+}
+/**
+ * Wrapper для ts.visitEachChild, который автоматически устанавливает parent ссылки
+ * для результата трансформации.
+ *
+ * @param node - Узел для трансформации
+ * @param visitor - Visitor функция
+ * @param context - Контекст трансформации
+ * @param preserveParent - Если true, сохраняет parent из оригинального узла
+ * @returns Трансформированный узел с установленными parent ссылками
+ */
+function visitEachChildWithParents(node, visitor, context, preserveParent = true) {
+    const originalParent = node.parent;
+    const result = ts.visitEachChild(node, visitor, context);
+    setParentNodes(result, preserveParent ? originalParent : undefined);
+    return result;
+}