@boristype/bt-cli 0.1.0-alpha.0

package/build/transformers/arrayGeneral.js

@@ -0,0 +1,222 @@
+"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.default = arrayGeneralTransformer;
+const ts = __importStar(require("typescript"));
+const utils_1 = require("./utils");
+function makeArrayPolyfillExpression(functionName) {
+    return (0, utils_1.markUntouchable)(ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('bt'), ts.factory.createIdentifier('polyfill')), ts.factory.createIdentifier('Array')), ts.factory.createIdentifier(functionName)));
+}
+function collectArgs(expression, node, count, restAsArray = false, visitor = undefined) {
+    const args = [expression];
+    if (count !== undefined) {
+        const positionalEnd = restAsArray ? count - 2 : count - 1;
+        for (let i = 0; i < positionalEnd; i++) {
+            args.push(node.arguments[i] || ts.factory.createIdentifier('undefined'));
+        }
+        if (restAsArray) {
+            const restArgs = node.arguments.slice(positionalEnd);
+            args.push(ts.factory.createArrayLiteralExpression(restArgs));
+        }
+    }
+    else {
+        args.push(...node.arguments);
+    }
+    if (visitor !== undefined) {
+        for (let i = 0; i < args.length; i++) {
+            args[i] = ts.visitNode(args[i], visitor);
+        }
+    }
+    return args;
+}
+function arrayGeneralTransformer(program) {
+    return (context) => (file) => {
+        const typeChecker = program.getTypeChecker();
+        function visit(node) {
+            // Check for method calls on arrays
+            if (ts.isCallExpression(node) && ts.isPropertyAccessExpression(node.expression)) {
+                const expression = node.expression.expression;
+                const type = typeChecker.getTypeAtLocation(expression);
+                // Check if the type is an array or array-like
+                const isArrayType = typeChecker.typeToString(type).includes('[]') ||
+                    ((type.flags & ts.TypeFlags.Object) !== 0 && typeChecker.getIndexTypeOfType(type, ts.IndexKind.Number) !== undefined);
+                if (isArrayType) {
+                    if (node.expression.name.text === 'at') {
+                        const args = collectArgs(expression, node, 2, false, visit);
+                        return ts.factory.createCallExpression(makeArrayPolyfillExpression('at'), undefined, args);
+                    }
+                    if (node.expression.name.text === 'concat') {
+                        const args = collectArgs(expression, node, undefined, false, visit);
+                        return ts.factory.createCallExpression(ts.factory.createIdentifier('ArrayUnion'), undefined, args);
+                    }
+                    if (node.expression.name.text === 'copyWithin') {
+                        const args = collectArgs(expression, node, 4, false, visit);
+                        return ts.factory.createCallExpression(makeArrayPolyfillExpression('copyWithin'), undefined, args);
+                    }
+                    if (node.expression.name.text === 'entries') {
+                        const args = collectArgs(expression, node, 1, false, visit);
+                        return ts.factory.createCallExpression(makeArrayPolyfillExpression('entries'), undefined, args);
+                    }
+                    if (node.expression.name.text === 'fill') {
+                        const args = collectArgs(expression, node, 4, false, visit);
+                        return ts.factory.createCallExpression(makeArrayPolyfillExpression('fill'), undefined, args);
+                    }
+                    if (node.expression.name.text === 'flat') {
+                        const args = collectArgs(expression, node, 2, false, visit);
+                        return ts.factory.createCallExpression(makeArrayPolyfillExpression('flat'), undefined, args);
+                    }
+                    if (node.expression.name.text === 'includes') {
+                        const args = collectArgs(expression, node, 3, false, visit);
+                        return ts.factory.createCallExpression(makeArrayPolyfillExpression('includes'), undefined, args);
+                    }
+                    if (node.expression.name.text === 'indexOf') {
+                        const args = collectArgs(expression, node, 3, false, visit);
+                        return ts.factory.createCallExpression(makeArrayPolyfillExpression('indexOf'), undefined, args);
+                    }
+                    if (node.expression.name.text === 'join') {
+                        const args = collectArgs(expression, node, 2, false, visit);
+                        return ts.factory.createCallExpression(makeArrayPolyfillExpression('join'), undefined, args);
+                    }
+                    if (node.expression.name.text === 'keys') {
+                        const args = collectArgs(expression, node, 1, false, visit);
+                        return ts.factory.createCallExpression(makeArrayPolyfillExpression('keys'), undefined, args);
+                    }
+                    if (node.expression.name.text === 'lastIndexOf') {
+                        const args = collectArgs(expression, node, 3, false, visit);
+                        return ts.factory.createCallExpression(makeArrayPolyfillExpression('lastIndexOf'), undefined, args);
+                    }
+                    if (node.expression.name.text === 'pop') {
+                        const args = collectArgs(expression, node, 1, false, visit);
+                        return ts.factory.createCallExpression(makeArrayPolyfillExpression('pop'), undefined, args);
+                    }
+                    // if (node.expression.name.text === 'push') {
+                    //   const args = collectArgs(expression, node, 1);
+                    //   return ts.factory.createCallExpression(
+                    //     makeArrayPolyfillExpression('push'),
+                    //     undefined,
+                    //     args
+                    //   );
+                    // }
+                    if (node.expression.name.text === 'reverse') {
+                        const args = collectArgs(expression, node, 1, false, visit);
+                        return ts.factory.createCallExpression(makeArrayPolyfillExpression('reverse'), undefined, args);
+                    }
+                    if (node.expression.name.text === 'shift') {
+                        const args = collectArgs(expression, node, 1, false, visit);
+                        return ts.factory.createCallExpression(makeArrayPolyfillExpression('shift'), undefined, args);
+                    }
+                    if (node.expression.name.text === 'slice') {
+                        const args = collectArgs(expression, node, 3, false, visit);
+                        return ts.factory.createCallExpression(makeArrayPolyfillExpression('slice'), undefined, args);
+                    }
+                    if (node.expression.name.text === 'splice') {
+                        const args = collectArgs(expression, node, 4, true, visit);
+                        return ts.factory.createCallExpression(makeArrayPolyfillExpression('splice'), undefined, args);
+                    }
+                    // if (node.expression.name.text === 'sort') {
+                    //   const args = collectArgs(expression, node, 3);
+                    //   return ts.factory.createCallExpression(
+                    //     makeArrayPolyfillExpression('sort'),
+                    //     undefined,
+                    //     args
+                    //   );
+                    // }
+                    if (node.expression.name.text === 'toReversed') {
+                        const args = collectArgs(expression, node, 1, false, visit);
+                        return ts.factory.createCallExpression(makeArrayPolyfillExpression('toReversed'), undefined, args);
+                    }
+                    // if (node.expression.name.text === 'toSorted') {
+                    //   const args = collectArgs(expression, node, 3);
+                    //   return ts.factory.createCallExpression(
+                    //     makeArrayPolyfillExpression('toSorted'),
+                    //     undefined,
+                    //     args
+                    //   );
+                    // }
+                    if (node.expression.name.text === 'toSpliced') {
+                        const args = collectArgs(expression, node, 4, true, visit);
+                        return ts.factory.createCallExpression(makeArrayPolyfillExpression('toSpliced'), undefined, args);
+                    }
+                    if (node.expression.name.text === 'unshift') {
+                        const args = collectArgs(expression, node, 2, true, visit);
+                        return ts.factory.createCallExpression(makeArrayPolyfillExpression('unshift'), undefined, args);
+                    }
+                    if (node.expression.name.text === 'values') {
+                        const args = collectArgs(expression, node, 1, false, visit);
+                        return ts.factory.createCallExpression(makeArrayPolyfillExpression('values'), undefined, args);
+                    }
+                    if (node.expression.name.text === 'with') {
+                        const args = collectArgs(expression, node, 3, false, visit);
+                        return ts.factory.createCallExpression(makeArrayPolyfillExpression('_with'), undefined, args);
+                    }
+                }
+            }
+            // Check for .length property access
+            if (ts.isPropertyAccessExpression(node) && node.name.text === 'length') {
+                const expression = node.expression;
+                const type = typeChecker.getTypeAtLocation(expression);
+                // Check if the type is an array or array-like
+                const isArrayType = typeChecker.typeToString(type).includes('[]') ||
+                    ((type.flags & ts.TypeFlags.Object) !== 0 && typeChecker.getIndexTypeOfType(type, ts.IndexKind.Number) !== undefined);
+                if (isArrayType) {
+                    // Replace arr.length with ArrayCount(arr)
+                    return ts.factory.createCallExpression(ts.factory.createIdentifier('ArrayCount'), undefined, [expression]);
+                }
+            }
+            // Check for Array.isArray and Array.from calls
+            if (ts.isCallExpression(node)) {
+                const expression = node.expression;
+                if (ts.isPropertyAccessExpression(expression) &&
+                    expression.name.text === 'isArray' &&
+                    ts.isIdentifier(expression.expression) &&
+                    expression.expression.text === 'Array') {
+                    // Replace Array.isArray(value) with IsArray(value)
+                    return ts.factory.createCallExpression(ts.factory.createIdentifier('IsArray'), undefined, node.arguments);
+                }
+                if (ts.isPropertyAccessExpression(expression) &&
+                    expression.name.text === 'from' &&
+                    ts.isIdentifier(expression.expression) &&
+                    expression.expression.text === 'Array') {
+                    // Replace Array.from(value) with ArraySelectAll(value)
+                    return ts.factory.createCallExpression(ts.factory.createIdentifier('ArraySelectAll'), undefined, node.arguments);
+                }
+            }
+            // Recursively visit child nodes
+            return ts.visitEachChild(node, visit, context);
+        }
+        const transformedFile = ts.visitNode(file, visit);
+        return ts.factory.updateSourceFile(transformedFile, transformedFile.statements);
+    };
+}

package/build/transformers/blockScoping.js

@@ -0,0 +1,212 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.blockScopingTransformer = blockScopingTransformer;
+const typescript_1 = __importDefault(require("typescript"));
+/**
+ * Трансформер для преобразования let/const в var.
+ *
+ * Обрабатывает:
+ * 1. Простая замена let/const → var
+ * 2. Shadowing detection — переименование при конфликтах имён
+ *
+ * НЕ обрабатывает (MVP):
+ * - Замыкания в циклах (IIFE wrapper)
+ * - TDZ (Temporal Dead Zone) — TypeScript проверяет
+ * - Const violations — TypeScript проверяет
+ *
+ * @example
+ * // Вход:
+ * let x = 1;
+ * const y = 2;
+ * {
+ *   let x = 3;  // shadowing
+ * }
+ *
+ * // Выход:
+ * var x = 1;
+ * var y = 2;
+ * {
+ *   var x_1 = 3;  // переименовано
+ * }
+ *
+ * @returns TypeScript transformer factory
+ */
+function blockScopingTransformer() {
+    return (context) => {
+        return (sourceFile) => {
+            // Счётчик для генерации уникальных имён
+            let uidCounter = 0;
+            const generateUid = (name) => `${name}_${++uidCounter}`;
+            const scopeStack = [];
+            // Текущие переименования для данного scope
+            const pushScope = () => scopeStack.push(new Map());
+            const popScope = () => scopeStack.pop();
+            /**
+             * Получить текущее имя переменной с учётом переименований
+             */
+            const resolveName = (name) => {
+                // Ищем снизу вверх (от внутреннего scope к внешнему)
+                for (let i = scopeStack.length - 1; i >= 0; i--) {
+                    const renamed = scopeStack[i].get(name);
+                    if (renamed !== undefined) {
+                        return renamed;
+                    }
+                }
+                return name;
+            };
+            /**
+             * Проверить, есть ли переменная в родительских scopes (для shadowing detection)
+             */
+            const hasInParentScopes = (name) => {
+                for (let i = scopeStack.length - 2; i >= 0; i--) {
+                    if (scopeStack[i].has(name)) {
+                        return true;
+                    }
+                }
+                return false;
+            };
+            /**
+             * Зарегистрировать переменную в текущем scope
+             * Возвращает новое имя если было переименование, иначе оригинальное
+             */
+            const registerVariable = (name) => {
+                const currentScope = scopeStack[scopeStack.length - 1];
+                if (!currentScope)
+                    return name;
+                // Проверяем shadowing
+                if (hasInParentScopes(name)) {
+                    const newName = generateUid(name);
+                    currentScope.set(name, newName);
+                    return newName;
+                }
+                // Нет shadowing — регистрируем с оригинальным именем
+                currentScope.set(name, name);
+                return name;
+            };
+            /**
+             * Проверяем, является ли узел началом нового block scope
+             */
+            const isBlockScopeNode = (node) => {
+                return typescript_1.default.isBlock(node) ||
+                    typescript_1.default.isForStatement(node) ||
+                    typescript_1.default.isForInStatement(node) ||
+                    typescript_1.default.isForOfStatement(node) ||
+                    typescript_1.default.isCaseClause(node) ||
+                    typescript_1.default.isDefaultClause(node);
+            };
+            /**
+             * Проверяем, является ли узел function scope (var hoisting boundary)
+             */
+            const isFunctionScopeNode = (node) => {
+                return typescript_1.default.isFunctionDeclaration(node) ||
+                    typescript_1.default.isFunctionExpression(node) ||
+                    typescript_1.default.isArrowFunction(node) ||
+                    typescript_1.default.isMethodDeclaration(node) ||
+                    typescript_1.default.isSourceFile(node);
+            };
+            /**
+             * Обрабатываем VariableDeclarationList
+             */
+            const transformVariableDeclarationList = (node) => {
+                const isLet = (node.flags & typescript_1.default.NodeFlags.Let) !== 0;
+                const isConst = (node.flags & typescript_1.default.NodeFlags.Const) !== 0;
+                if (!isLet && !isConst) {
+                    // Уже var — просто обходим дочерние узлы
+                    return typescript_1.default.factory.updateVariableDeclarationList(node, node.declarations.map(decl => typescript_1.default.visitNode(decl, visitor)));
+                }
+                // Преобразуем let/const → var
+                const newDeclarations = node.declarations.map(decl => {
+                    if (typescript_1.default.isIdentifier(decl.name)) {
+                        const originalName = decl.name.text;
+                        const newName = registerVariable(originalName);
+                        // Рекурсивно обрабатываем initializer
+                        const newInitializer = decl.initializer
+                            ? typescript_1.default.visitNode(decl.initializer, visitor)
+                            : undefined;
+                        if (newName !== originalName) {
+                            // Переименовываем
+                            return typescript_1.default.factory.createVariableDeclaration(typescript_1.default.factory.createIdentifier(newName), undefined, undefined, newInitializer);
+                        }
+                        else {
+                            return typescript_1.default.factory.createVariableDeclaration(decl.name, undefined, undefined, newInitializer);
+                        }
+                    }
+                    // TODO: BindingPattern (деструктуризация) — пока просто обходим
+                    return typescript_1.default.visitNode(decl, visitor);
+                });
+                // Создаём var declaration
+                return typescript_1.default.factory.createVariableDeclarationList(newDeclarations, typescript_1.default.NodeFlags.None // var
+                );
+            };
+            /**
+             * Основной visitor
+             */
+            const visitor = (node) => {
+                // Начало function scope — полностью новый контекст для var
+                if (isFunctionScopeNode(node) && !typescript_1.default.isSourceFile(node)) {
+                    pushScope();
+                    const result = typescript_1.default.visitEachChild(node, visitor, context);
+                    popScope();
+                    return result;
+                }
+                // Начало block scope
+                if (isBlockScopeNode(node)) {
+                    pushScope();
+                    const result = typescript_1.default.visitEachChild(node, visitor, context);
+                    popScope();
+                    return result;
+                }
+                // Обрабатываем VariableDeclarationList
+                if (typescript_1.default.isVariableDeclarationList(node)) {
+                    return transformVariableDeclarationList(node);
+                }
+                // Переименовываем использования переменных
+                if (typescript_1.default.isIdentifier(node)) {
+                    const parent = node.parent;
+                    // Пропускаем случаи где identifier — не ссылка на переменную:
+                    // - объявления (обрабатываются в transformVariableDeclarationList)
+                    // - property access: obj.prop
+                    // - property name в объектном литерале: { prop: value }
+                    // - parameter names (обрабатываются отдельно)
+                    if (parent) {
+                        // obj.prop — prop не переменная
+                        if (typescript_1.default.isPropertyAccessExpression(parent) && parent.name === node) {
+                            return node;
+                        }
+                        // { prop: value } — prop не переменная
+                        if (typescript_1.default.isPropertyAssignment(parent) && parent.name === node) {
+                            return node;
+                        }
+                        // function foo() — foo обрабатывается отдельно
+                        if (typescript_1.default.isFunctionDeclaration(parent) && parent.name === node) {
+                            return node;
+                        }
+                        // let x = ... — x обрабатывается в transformVariableDeclarationList
+                        if (typescript_1.default.isVariableDeclaration(parent) && parent.name === node) {
+                            return node;
+                        }
+                        // (param) => ... — param не let/const
+                        if (typescript_1.default.isParameter(parent) && parent.name === node) {
+                            return node;
+                        }
+                    }
+                    // Проверяем, нужно ли переименовать
+                    const originalName = node.text;
+                    const resolvedName = resolveName(originalName);
+                    if (resolvedName !== originalName) {
+                        return typescript_1.default.factory.createIdentifier(resolvedName);
+                    }
+                }
+                return typescript_1.default.visitEachChild(node, visitor, context);
+            };
+            // Инициализируем глобальный scope
+            pushScope();
+            const result = typescript_1.default.visitNode(sourceFile, visitor);
+            popScope();
+            return result;
+        };
+    };
+}

package/build/transformers/destructuring.js

@@ -0,0 +1,133 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.destructuringTransformer = destructuringTransformer;
+const typescript_1 = __importDefault(require("typescript"));
+/**
+ * Трансформер для преобразования деструктуризации объектов и массивов.
+ *
+ * @example
+ * // Вход (объект):
+ * const { a, b, ...rest } = obj;
+ *
+ * // Выход:
+ * const a = obj.a;
+ * const b = obj.b;
+ * const rest = bt.object_rest(obj, ["a", "b"]);
+ *
+ * @example
+ * // Вход (массив):
+ * const [x, y, ...rest] = arr;
+ *
+ * // Выход:
+ * const _arr = ArrayDirect(arr);
+ * const x = _arr[0];
+ * const y = _arr[1];
+ * const rest = bt.array_rest(_arr, 2);
+ *
+ * @returns TypeScript transformer factory
+ */
+function destructuringTransformer() {
+    return (context) => {
+        let uidCounter = 0;
+        /**
+         * Генерирует уникальный идентификатор
+         */
+        const generateUid = (prefix) => {
+            return typescript_1.default.factory.createIdentifier(`_${prefix}${uidCounter++}`);
+        };
+        return (sourceFile) => {
+            const visitor = (node) => {
+                // Обрабатываем объявления переменных
+                if (typescript_1.default.isVariableStatement(node)) {
+                    const declarations = node.declarationList.declarations;
+                    const newStatements = [];
+                    let hasDestructuring = false;
+                    for (const declarator of declarations) {
+                        // Обрабатываем деструктуризацию объекта
+                        if (typescript_1.default.isObjectBindingPattern(declarator.name) && declarator.initializer) {
+                            hasDestructuring = true;
+                            const init = typescript_1.default.visitNode(declarator.initializer, visitor);
+                            const excludedKeys = [];
+                            for (const element of declarator.name.elements) {
+                                if (typescript_1.default.isBindingElement(element)) {
+                                    if (element.dotDotDotToken) {
+                                        // Rest element: ...rest
+                                        const restName = element.name;
+                                        const restCall = typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createPropertyAccessExpression(typescript_1.default.factory.createIdentifier('bt'), 'object_rest'), undefined, [
+                                            init,
+                                            typescript_1.default.factory.createArrayLiteralExpression(excludedKeys.map(k => typescript_1.default.factory.createStringLiteral(k)))
+                                        ]);
+                                        newStatements.push(createVarStatement(restName.text, restCall));
+                                    }
+                                    else {
+                                        // Regular property: { a } or { a: b }
+                                        const propertyName = element.propertyName
+                                            ? element.propertyName.text
+                                            : element.name.text;
+                                        const variableName = element.name.text;
+                                        excludedKeys.push(propertyName);
+                                        const memberAccess = typescript_1.default.factory.createPropertyAccessExpression(init, propertyName);
+                                        newStatements.push(createVarStatement(variableName, memberAccess));
+                                    }
+                                }
+                            }
+                        }
+                        // Обрабатываем деструктуризацию массива
+                        else if (typescript_1.default.isArrayBindingPattern(declarator.name) && declarator.initializer) {
+                            hasDestructuring = true;
+                            const init = typescript_1.default.visitNode(declarator.initializer, visitor);
+                            // Создаём вспомогательную переменную: var _arr = ArrayDirect(init)
+                            const auxVar = generateUid('arr');
+                            const auxCall = typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier('ArrayDirect'), undefined, [init]);
+                            newStatements.push(createVarStatement(auxVar.text, auxCall));
+                            // Обрабатываем элементы массива
+                            let index = 0;
+                            for (const element of declarator.name.elements) {
+                                if (typescript_1.default.isOmittedExpression(element)) {
+                                    // Пропущенный элемент [, , x]
+                                    index++;
+                                    continue;
+                                }
+                                if (typescript_1.default.isBindingElement(element)) {
+                                    if (element.dotDotDotToken) {
+                                        // Rest element: ...rest
+                                        const restName = element.name;
+                                        const restCall = typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createPropertyAccessExpression(typescript_1.default.factory.createIdentifier('bt'), 'array_rest'), undefined, [auxVar, typescript_1.default.factory.createNumericLiteral(index)]);
+                                        newStatements.push(createVarStatement(restName.text, restCall));
+                                    }
+                                    else {
+                                        // Regular element: [a, b]
+                                        const variableName = element.name.text;
+                                        const elementAccess = typescript_1.default.factory.createElementAccessExpression(auxVar, typescript_1.default.factory.createNumericLiteral(index));
+                                        newStatements.push(createVarStatement(variableName, elementAccess));
+                                        index++;
+                                    }
+                                }
+                            }
+                        }
+                        // Обычные объявления - оставляем как есть
+                        else {
+                            const visitedDeclarator = typescript_1.default.visitNode(declarator, visitor);
+                            newStatements.push(typescript_1.default.factory.createVariableStatement(undefined, typescript_1.default.factory.createVariableDeclarationList([visitedDeclarator], typescript_1.default.NodeFlags.None)));
+                        }
+                    }
+                    if (hasDestructuring) {
+                        return newStatements;
+                    }
+                }
+                return typescript_1.default.visitEachChild(node, visitor, context);
+            };
+            return typescript_1.default.visitNode(sourceFile, visitor);
+        };
+    };
+}
+/**
+ * Создаёт var statement: var name = initializer;
+ */
+function createVarStatement(name, initializer) {
+    return typescript_1.default.factory.createVariableStatement(undefined, typescript_1.default.factory.createVariableDeclarationList([typescript_1.default.factory.createVariableDeclaration(name, undefined, undefined, initializer)], typescript_1.default.NodeFlags.None // var
+    ));
+}

package/build/transformers/dirname.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dirnameTransformer = dirnameTransformer;
+const typescript_1 = __importDefault(require("typescript"));
+const utils_1 = require("./utils");
+function dirnameTransformer() {
+    return (context) => (sourceFile) => {
+        const factory = context.factory;
+        const isExecObj = (0, utils_1.isExecutableObject)(sourceFile);
+        const execObjKey = isExecObj ? (0, utils_1.getExecutableObjectKey)(sourceFile) : undefined;
+        // console.log(`dirnameTransformer: isExecObj=${isExecObj}, execObjKey=${execObjKey}`);
+        let hasAbsoluteUrlCalls = true;
+        // Рекурсивная функция для обхода и трансформации дерева
+        const visitor = (node) => {
+            // Проверяем, является ли узел вызовом функции AbsoluteUrl
+            if (typescript_1.default.isCallExpression(node) &&
+                typescript_1.default.isIdentifier(node.expression) &&
+                node.expression.text === 'AbsoluteUrl') {
+                hasAbsoluteUrlCalls = true;
+                // Заменяем на __AbsoluteUrl
+                const args = node.arguments;
+                const newArgs = [];
+                if (args.length >= 1) {
+                    newArgs.push(args[0]); // url
+                }
+                if (args.length >= 2) {
+                    newArgs.push(args[1]); // baseUrl
+                }
+                else {
+                    // Если baseUrl не указан, добавляем undefined
+                    newArgs.push(factory.createIdentifier('undefined'));
+                }
+                return factory.updateCallExpression(node, factory.createIdentifier('__AbsoluteUrl'), node.typeArguments, newArgs);
+            }
+            return typescript_1.default.visitEachChild(node, visitor, context);
+        };
+        // Обходим файл
+        const transformedSourceFile = typescript_1.default.visitNode(sourceFile, visitor);
+        // Если были вызовы AbsoluteUrl, добавляем функцию __AbsoluteUrl
+        if (hasAbsoluteUrlCalls) {
+            let functionBody;
+            if (isExecObj && execObjKey !== undefined) {
+                // Для executable object: если baseUrl === undefined, используем UrlAppendPath(UrlParent(bt.getFileUrl(KEY)), url)
+                functionBody = factory.createReturnStatement(factory.createConditionalExpression(factory.createBinaryExpression(factory.createIdentifier('baseUrl'), factory.createToken(typescript_1.default.SyntaxKind.EqualsEqualsEqualsToken), factory.createIdentifier('undefined')), factory.createToken(typescript_1.default.SyntaxKind.QuestionToken), factory.createCallExpression(factory.createIdentifier('UrlAppendPath'), undefined, [
+                    factory.createCallExpression(factory.createIdentifier('UrlParent'), undefined, [
+                        (0, utils_1.markUntouchable)(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('bt'), 'getFileUrl'), undefined, [factory.createStringLiteral(execObjKey)]))
+                    ]),
+                    factory.createIdentifier('url')
+                ]), factory.createToken(typescript_1.default.SyntaxKind.ColonToken), factory.createCallExpression(factory.createIdentifier('AbsoluteUrl'), undefined, [
+                    factory.createIdentifier('url'),
+                    factory.createIdentifier('baseUrl')
+                ])));
+            }
+            else {
+                // Для обычных файлов
+                functionBody = factory.createReturnStatement(factory.createConditionalExpression(factory.createBinaryExpression(factory.createIdentifier('baseUrl'), factory.createToken(typescript_1.default.SyntaxKind.EqualsEqualsEqualsToken), factory.createIdentifier('undefined')), factory.createToken(typescript_1.default.SyntaxKind.QuestionToken), factory.createCallExpression(factory.createIdentifier('AbsoluteUrl'), undefined, [factory.createIdentifier('url')]), factory.createToken(typescript_1.default.SyntaxKind.ColonToken), factory.createCallExpression(factory.createIdentifier('AbsoluteUrl'), undefined, [
+                    factory.createIdentifier('url'),
+                    factory.createIdentifier('baseUrl')
+                ])));
+            }
+            // Создаем функцию __AbsoluteUrl
+            const absoluteUrlFunction = factory.createFunctionDeclaration(undefined, // modifiers
+            undefined, // asteriskToken
+            '__AbsoluteUrl', undefined, // typeParameters
+            [
+                factory.createParameterDeclaration(undefined, undefined, 'url', undefined, undefined, undefined),
+                factory.createParameterDeclaration(undefined, undefined, 'baseUrl', factory.createToken(typescript_1.default.SyntaxKind.QuestionToken), undefined, undefined)
+            ], undefined, // type
+            factory.createBlock([functionBody], true));
+            // Добавляем функцию в начало файла
+            const statements = [absoluteUrlFunction, ...transformedSourceFile.statements];
+            return (0, utils_1.preserveSymbolsFrom)(factory.updateSourceFile(transformedSourceFile, statements), sourceFile);
+        }
+        return (0, utils_1.preserveSymbolsFrom)(transformedSourceFile, sourceFile);
+    };
+}