@boristype/bt-cli 0.1.0-alpha.0

package/build/transformers/functions.js

@@ -0,0 +1,270 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.functionsTransformer = functionsTransformer;
+const typescript_1 = __importDefault(require("typescript"));
+const utils_1 = require("./utils");
+// Helper function to extract lambda functions from a node tree
+function extractLambdaFunctions(node) {
+    const lambdas = [];
+    function visit(n) {
+        if (n.__lambdaFunctions) {
+            lambdas.push(...n.__lambdaFunctions);
+            delete n.__lambdaFunctions;
+        }
+        typescript_1.default.forEachChild(n, visit);
+    }
+    visit(node);
+    return lambdas;
+}
+// Helper function to extract method functions from object literals
+function extractMethodFunctions(node) {
+    const methods = [];
+    function visit(n) {
+        if (n.__methodFunctions) {
+            methods.push(...n.__methodFunctions);
+            delete n.__methodFunctions;
+        }
+        typescript_1.default.forEachChild(n, visit);
+    }
+    visit(node);
+    return methods;
+}
+function functionsTransformer() {
+    return (context) => {
+        return (sourceFile) => {
+            let lambdaCounter = 0;
+            // First pass: transform nodes and collect hoisted functions
+            const transformedStatements = [];
+            sourceFile.statements.forEach((statement) => {
+                const hoistedFunctions = [];
+                // lambdaCounter = 0; // Reset counter for each statement
+                const visitor = (node, isInsideFunction = false) => {
+                    // Transform arrow functions assigned to const/let/var
+                    if (typescript_1.default.isVariableStatement(node)) {
+                        const declaration = node.declarationList.declarations[0];
+                        if (declaration &&
+                            declaration.initializer &&
+                            typescript_1.default.isArrowFunction(declaration.initializer)) {
+                            const arrowFunc = declaration.initializer;
+                            const funcName = declaration.name.text;
+                            // Create a regular function declaration
+                            const functionDecl = typescript_1.default.factory.createFunctionDeclaration(undefined, undefined, funcName, undefined, arrowFunc.parameters, arrowFunc.type, arrowFunc.body && typescript_1.default.isBlock(arrowFunc.body)
+                                ? arrowFunc.body
+                                : typescript_1.default.factory.createBlock([
+                                    typescript_1.default.factory.createReturnStatement(arrowFunc.body)
+                                ]));
+                            return functionDecl;
+                        }
+                    }
+                    // Transform methods in object literals
+                    if (typescript_1.default.isObjectLiteralExpression(node)) {
+                        const objectLiteral = node;
+                        const newProperties = [];
+                        // Find the variable name of this object (if any)
+                        let objectName = 'unknown';
+                        if (typescript_1.default.isVariableDeclaration(node.parent)) {
+                            objectName = node.parent.name.text;
+                        }
+                        objectLiteral.properties.forEach((prop) => {
+                            if (typescript_1.default.isMethodDeclaration(prop)) {
+                                const methodName = prop.name.text;
+                                const hoistedFuncName = `${methodName}__method_of__${objectName}`;
+                                // Create hoisted function
+                                const hoistedFunc = typescript_1.default.factory.createFunctionDeclaration(undefined, undefined, hoistedFuncName, undefined, prop.parameters, prop.type, prop.body);
+                                hoistedFunctions.push(hoistedFunc);
+                                // Replace method with property assignment
+                                const propertyAssignment = typescript_1.default.factory.createPropertyAssignment(prop.name, typescript_1.default.factory.createIdentifier(hoistedFuncName));
+                                newProperties.push(propertyAssignment);
+                            }
+                            else {
+                                newProperties.push(prop);
+                            }
+                        });
+                        const objLiteral = typescript_1.default.factory.createObjectLiteralExpression(newProperties, true);
+                        return (0, utils_1.setParentNodes)(objLiteral);
+                    }
+                    // Transform arrow functions used as arguments (lambdas)
+                    if (typescript_1.default.isCallExpression(node)) {
+                        const newArgs = node.arguments.map((arg) => {
+                            if (typescript_1.default.isArrowFunction(arg)) {
+                                const lambdaName = `lambda_${lambdaCounter++}`;
+                                // Create hoisted function
+                                const hoistedFunc = typescript_1.default.factory.createFunctionDeclaration(undefined, undefined, lambdaName, undefined, arg.parameters, arg.type, arg.body && typescript_1.default.isBlock(arg.body)
+                                    ? arg.body
+                                    : typescript_1.default.factory.createBlock([
+                                        typescript_1.default.factory.createReturnStatement(arg.body)
+                                    ]));
+                                // Only hoist if NOT inside a function
+                                if (!isInsideFunction) {
+                                    hoistedFunctions.push(hoistedFunc);
+                                }
+                                return typescript_1.default.factory.createIdentifier(lambdaName);
+                            }
+                            return typescript_1.default.visitNode(arg, (n) => visitor(n, isInsideFunction));
+                        });
+                        return typescript_1.default.factory.updateCallExpression(node, typescript_1.default.visitNode(node.expression, (n) => visitor(n, isInsideFunction)), node.typeArguments, typescript_1.default.factory.createNodeArray(newArgs));
+                    }
+                    // Handle function declarations - mark that we're inside a function
+                    if (typescript_1.default.isFunctionDeclaration(node) || typescript_1.default.isFunctionExpression(node) || typescript_1.default.isArrowFunction(node)) {
+                        // Process function body with isInsideFunction = true
+                        if (node.body && typescript_1.default.isBlock(node.body)) {
+                            const functionBodyVisitor = (innerNode) => {
+                                // Transform arrow functions assigned to const/let/var inside function body
+                                if (typescript_1.default.isVariableStatement(innerNode)) {
+                                    const declaration = innerNode.declarationList.declarations[0];
+                                    if (declaration &&
+                                        declaration.initializer &&
+                                        typescript_1.default.isArrowFunction(declaration.initializer)) {
+                                        const arrowFunc = declaration.initializer;
+                                        const funcName = declaration.name.text;
+                                        // Create a regular function declaration
+                                        const functionDecl = typescript_1.default.factory.createFunctionDeclaration(undefined, undefined, funcName, undefined, arrowFunc.parameters, arrowFunc.type, arrowFunc.body && typescript_1.default.isBlock(arrowFunc.body)
+                                            ? arrowFunc.body
+                                            : typescript_1.default.factory.createBlock([
+                                                typescript_1.default.factory.createReturnStatement(arrowFunc.body)
+                                            ]));
+                                        return functionDecl;
+                                    }
+                                }
+                                // Transform object literal methods inside functions
+                                if (typescript_1.default.isObjectLiteralExpression(innerNode)) {
+                                    const objectLiteral = innerNode;
+                                    const newProperties = [];
+                                    const methodFunctions = [];
+                                    // Find the function name where this object is defined
+                                    let contextName = 'unknown';
+                                    if (typescript_1.default.isFunctionDeclaration(node)) {
+                                        contextName = node.name?.text || 'anonymous';
+                                    }
+                                    objectLiteral.properties.forEach((prop) => {
+                                        if (typescript_1.default.isMethodDeclaration(prop)) {
+                                            const methodName = prop.name.text;
+                                            const hoistedFuncName = `${methodName}__method_of__${contextName}`;
+                                            // Create hoisted function
+                                            const hoistedFunc = typescript_1.default.factory.createFunctionDeclaration(undefined, undefined, hoistedFuncName, undefined, prop.parameters, prop.type, prop.body);
+                                            methodFunctions.push(hoistedFunc);
+                                            // Replace method with property assignment
+                                            const propertyAssignment = typescript_1.default.factory.createPropertyAssignment(prop.name, typescript_1.default.factory.createIdentifier(hoistedFuncName));
+                                            newProperties.push(propertyAssignment);
+                                        }
+                                        else {
+                                            newProperties.push(prop);
+                                        }
+                                    });
+                                    // Store method functions to be added to the function body
+                                    if (methodFunctions.length > 0) {
+                                        const newObj = typescript_1.default.factory.createObjectLiteralExpression(newProperties, true);
+                                        newObj.__methodFunctions = methodFunctions;
+                                        return (0, utils_1.setParentNodes)(newObj);
+                                    }
+                                    const objLiteral = typescript_1.default.factory.createObjectLiteralExpression(newProperties, true);
+                                    return (0, utils_1.setParentNodes)(objLiteral, objectLiteral.parent);
+                                }
+                                return typescript_1.default.visitEachChild(innerNode, functionBodyVisitor, context);
+                            };
+                            // Transform expressions and collect lambda functions
+                            const transformExpression = (expr, lambdas) => {
+                                if (typescript_1.default.isCallExpression(expr)) {
+                                    // First, recursively transform nested call expressions
+                                    const transformedExpression = transformExpression(expr.expression, lambdas);
+                                    const newArgs = expr.arguments.map((arg) => {
+                                        if (typescript_1.default.isArrowFunction(arg)) {
+                                            const lambdaName = `lambda_${lambdaCounter++}`;
+                                            const hoistedFunc = typescript_1.default.factory.createFunctionDeclaration(undefined, undefined, lambdaName, undefined, arg.parameters, arg.type, arg.body && typescript_1.default.isBlock(arg.body)
+                                                ? arg.body
+                                                : typescript_1.default.factory.createBlock([
+                                                    typescript_1.default.factory.createReturnStatement(arg.body)
+                                                ]));
+                                            lambdas.push(hoistedFunc);
+                                            return typescript_1.default.factory.createIdentifier(lambdaName);
+                                        }
+                                        else if (typescript_1.default.isCallExpression(arg)) {
+                                            // Recursively handle nested calls
+                                            return transformExpression(arg, lambdas);
+                                        }
+                                        return arg;
+                                    });
+                                    return typescript_1.default.factory.updateCallExpression(expr, transformedExpression, expr.typeArguments, typescript_1.default.factory.createNodeArray(newArgs));
+                                }
+                                return expr;
+                            };
+                            // Transform body statements and inject lambda functions before their usage
+                            const transformedStatements = [];
+                            node.body.statements.forEach((stmt) => {
+                                // First transform variable statements and function declarations
+                                const basicTransformed = typescript_1.default.visitNode(stmt, functionBodyVisitor);
+                                // Extract method functions from object literals
+                                const methodFunctions = extractMethodFunctions(basicTransformed);
+                                if (methodFunctions.length > 0) {
+                                    methodFunctions.forEach((func) => transformedStatements.push(func));
+                                }
+                                // Check if this is a return statement with call expressions
+                                if (typescript_1.default.isReturnStatement(basicTransformed) && basicTransformed.expression) {
+                                    const lambdas = [];
+                                    const transformedExpression = transformExpression(basicTransformed.expression, lambdas);
+                                    if (lambdas.length > 0) {
+                                        // Add lambda functions before the return statement
+                                        lambdas.forEach((func) => transformedStatements.push(func));
+                                    }
+                                    transformedStatements.push(typescript_1.default.factory.updateReturnStatement(basicTransformed, transformedExpression));
+                                }
+                                else if (typescript_1.default.isExpressionStatement(basicTransformed)) {
+                                    // Handle expression statements with call expressions
+                                    const lambdas = [];
+                                    const transformedExpression = transformExpression(basicTransformed.expression, lambdas);
+                                    if (lambdas.length > 0) {
+                                        lambdas.forEach((func) => transformedStatements.push(func));
+                                    }
+                                    transformedStatements.push(typescript_1.default.factory.updateExpressionStatement(basicTransformed, transformedExpression));
+                                }
+                                else {
+                                    transformedStatements.push(basicTransformed);
+                                }
+                            });
+                            // Handle default parameters
+                            const defaultParamChecks = [];
+                            const newParameters = [];
+                            if (typescript_1.default.isFunctionDeclaration(node)) {
+                                node.parameters.forEach((param) => {
+                                    if (param.initializer) {
+                                        // Create parameter without default value
+                                        const newParam = typescript_1.default.factory.createParameterDeclaration(param.modifiers, param.dotDotDotToken, param.name, param.questionToken, param.type, undefined // Remove initializer
+                                        );
+                                        newParameters.push(newParam);
+                                        // Create if statement to check for undefined
+                                        const paramName = param.name;
+                                        const ifStatement = typescript_1.default.factory.createIfStatement(typescript_1.default.factory.createBinaryExpression(typescript_1.default.factory.createIdentifier(paramName.text), typescript_1.default.factory.createToken(typescript_1.default.SyntaxKind.EqualsEqualsEqualsToken), typescript_1.default.factory.createIdentifier('undefined')), typescript_1.default.factory.createBlock([
+                                            typescript_1.default.factory.createExpressionStatement(typescript_1.default.factory.createBinaryExpression(typescript_1.default.factory.createIdentifier(paramName.text), typescript_1.default.factory.createToken(typescript_1.default.SyntaxKind.EqualsToken), param.initializer))
+                                        ], true));
+                                        defaultParamChecks.push(ifStatement);
+                                    }
+                                    else {
+                                        newParameters.push(param);
+                                    }
+                                });
+                            }
+                            // Combine default param checks with transformed statements
+                            const finalStatements = [...defaultParamChecks, ...transformedStatements];
+                            const newBody = typescript_1.default.factory.createBlock(finalStatements, true);
+                            if (typescript_1.default.isFunctionDeclaration(node)) {
+                                return typescript_1.default.factory.updateFunctionDeclaration(node, node.modifiers, node.asteriskToken, node.name, node.typeParameters, newParameters.length > 0 ? newParameters : node.parameters, node.type, newBody);
+                            }
+                        }
+                        return node;
+                    }
+                    return typescript_1.default.visitEachChild(node, (n) => visitor(n, isInsideFunction), context);
+                };
+                const transformedStatement = typescript_1.default.visitNode(statement, visitor);
+                // Add hoisted functions before the transformed statement
+                if (hoistedFunctions.length > 0) {
+                    hoistedFunctions.forEach(func => transformedStatements.push(func));
+                }
+                transformedStatements.push(transformedStatement);
+            });
+            return typescript_1.default.factory.updateSourceFile(sourceFile, transformedStatements);
+        };
+    };
+}

package/build/transformers/globalCache.js

@@ -0,0 +1,34 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.globalCacheTransformer = globalCacheTransformer;
+const typescript_1 = __importDefault(require("typescript"));
+const utils_1 = require("./utils");
+function globalCacheTransformer(program) {
+    const typeChecker = program.getTypeChecker();
+    return (context) => (sourceFile) => {
+        const factory = context.factory;
+        function visit(node) {
+            // Проверяем, является ли узел вызовом метода (globalCache.set(), globalCache.get(), globalCache.has())
+            if (typescript_1.default.isCallExpression(node) && typescript_1.default.isPropertyAccessExpression(node.expression)) {
+                const propertyAccess = node.expression;
+                const objectExpression = propertyAccess.expression;
+                const methodName = propertyAccess.name.text;
+                // Проверяем тип объекта
+                const type = typeChecker.getTypeAtLocation(objectExpression);
+                const typeString = typeChecker.typeToString(type);
+                // Проверяем, что это тип GlobalCache и метод один из: set, get, has
+                if (typeString === 'GlobalCache' && ['set', 'get', 'has'].includes(methodName)) {
+                    // Создаем bt.cache.method(...)
+                    const btCache = factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(factory.createIdentifier('bt'), factory.createIdentifier('cache')), factory.createIdentifier(methodName));
+                    // Создаем новый вызов с теми же аргументами
+                    return factory.createCallExpression((0, utils_1.markUntouchable)(btCache), node.typeArguments, node.arguments);
+                }
+            }
+            return typescript_1.default.visitEachChild(node, visit, context);
+        }
+        return (0, utils_1.setParentNodes)(typescript_1.default.visitNode(sourceFile, visit), sourceFile);
+    };
+}