@boristype/bt-cli 0.1.0-alpha.0

package/build/transformers/enumsToObjects.js

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.enumsToObjectsTransformer = enumsToObjectsTransformer;
+const typescript_1 = __importDefault(require("typescript"));
+function enumsToObjectsTransformer() {
+    return (context) => (sourceFile) => {
+        function visit(node) {
+            if (typescript_1.default.isEnumDeclaration(node)) {
+                const members = node.members.map((member, index) => {
+                    const name = member.name;
+                    const initializer = member.initializer || typescript_1.default.factory.createNumericLiteral(index);
+                    return typescript_1.default.factory.createPropertyAssignment(name, initializer);
+                });
+                return typescript_1.default.factory.createVariableStatement([], [
+                    typescript_1.default.factory.createVariableDeclaration(node.name, undefined, undefined, typescript_1.default.factory.createObjectLiteralExpression(members, true))
+                ]);
+            }
+            return typescript_1.default.visitEachChild(node, visit, context);
+        }
+        return typescript_1.default.visitNode(sourceFile, visit);
+    };
+}

package/build/transformers/execObj.js

@@ -0,0 +1,220 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.execObjTransformer = execObjTransformer;
+const typescript_1 = __importDefault(require("typescript"));
+const utils_1 = require("./utils");
+const node_path_1 = __importDefault(require("node:path"));
+const node_fs_1 = __importDefault(require("node:fs"));
+// Специальные объекты из @boristype/types
+const EXECUTABLE_OBJECTS = new Set([
+    'remoteAction',
+    'remoteCollection',
+    'systemEventHandler',
+    'serverAgent',
+    'codeLibrary',
+    'statisticRec'
+]);
+// Маппинг типов TypeScript на функции преобразования
+const TYPE_CONVERTERS = {
+    'string': 'String',
+    'number': 'OptInt',
+    'boolean': 'tools_web.is_true'
+};
+function getCurrentPackageFile(program) {
+    let projectRoot = program.getCurrentDirectory();
+    let packageJsonPath = node_path_1.default.join(projectRoot, 'package.json');
+    // Если не нашли, идем вверх по директориям
+    while (!node_fs_1.default.existsSync(packageJsonPath) && projectRoot !== node_path_1.default.dirname(projectRoot)) {
+        projectRoot = node_path_1.default.dirname(projectRoot);
+        packageJsonPath = node_path_1.default.join(projectRoot, 'package.json');
+    }
+    if (node_fs_1.default.existsSync(packageJsonPath)) {
+        const packageJson = JSON.parse(node_fs_1.default.readFileSync(packageJsonPath, 'utf-8'));
+        return packageJson;
+    }
+    return null;
+}
+function execObjTransformer(program, executables) {
+    const packageJson = getCurrentPackageFile(program);
+    // console.log('ExecObj Transformer initialized');
+    // console.log(`Output directory: ${getOutputDirectory(program)}`);
+    // console.log(`Package: ${packageJson.name} ${packageJson.version}`);
+    // const executables: ExecutableObjectSourceFileInfo[] = [];
+    // '<package.name>+<package.version>+/src/agents/myAgent.ts': 
+    return (context) => (sourceFile) => {
+        // console.log(`Processing file: ${sourceFile.fileName}`);
+        const factory = context.factory;
+        let hasExecutableObjects = false;
+        const importedObjects = new Set();
+        // Первый проход: проверяем наличие импортов executable objects
+        function checkImports(node) {
+            if (typescript_1.default.isImportDeclaration(node)) {
+                const moduleSpecifier = node.moduleSpecifier;
+                if (typescript_1.default.isStringLiteral(moduleSpecifier) && moduleSpecifier.text.startsWith('@boristype/types')) {
+                    if (node.importClause?.namedBindings && typescript_1.default.isNamedImports(node.importClause.namedBindings)) {
+                        for (const element of node.importClause.namedBindings.elements) {
+                            const importName = element.name.text;
+                            if (EXECUTABLE_OBJECTS.has(importName)) {
+                                importedObjects.add(importName);
+                                hasExecutableObjects = true;
+                            }
+                        }
+                    }
+                }
+            }
+            typescript_1.default.forEachChild(node, checkImports);
+        }
+        checkImports(sourceFile);
+        // Если нет executable objects, пропускаем файл
+        if (!hasExecutableObjects) {
+            return sourceFile;
+        }
+        executables.push({
+            packageName: packageJson.name,
+            packageVersion: packageJson.version,
+            filePath: sourceFile.fileName,
+        });
+        // Помечаем sourceFile как executable
+        (0, utils_1.markExecutableObject)(sourceFile);
+        (0, utils_1.setExecutableObjectKey)(sourceFile, `${packageJson.name}+${packageJson.version}+${sourceFile.fileName}`);
+        // Счетчик для уникальных имен переменных
+        let tempVarCounter = 0;
+        // Второй проход: трансформируем код
+        function visit(node) {
+            // Удаляем импорты executable objects из @boristype/types
+            if (typescript_1.default.isImportDeclaration(node)) {
+                const moduleSpecifier = node.moduleSpecifier;
+                if (typescript_1.default.isStringLiteral(moduleSpecifier) && moduleSpecifier.text.startsWith('@boristype/types')) {
+                    if (node.importClause?.namedBindings && typescript_1.default.isNamedImports(node.importClause.namedBindings)) {
+                        // Фильтруем импорты, оставляя только те, которые не являются executable objects
+                        const filteredElements = node.importClause.namedBindings.elements.filter(element => !EXECUTABLE_OBJECTS.has(element.name.text));
+                        // Если все импорты были executable objects, удаляем весь import statement
+                        if (filteredElements.length === 0) {
+                            return [];
+                        }
+                        // Если остались другие импорты, создаем новый import statement без executable objects
+                        if (filteredElements.length < node.importClause.namedBindings.elements.length) {
+                            return factory.updateImportDeclaration(node, node.modifiers, factory.updateImportClause(node.importClause, node.importClause.isTypeOnly, node.importClause.name, factory.updateNamedImports(node.importClause.namedBindings, filteredElements)), node.moduleSpecifier, node.assertClause);
+                        }
+                    }
+                }
+            }
+            // Удаляем вызовы .use() на EXECUTABLE_OBJECTS (например, serverAgent.use())
+            if (typescript_1.default.isExpressionStatement(node)) {
+                const expr = node.expression;
+                if (typescript_1.default.isCallExpression(expr) && typescript_1.default.isPropertyAccessExpression(expr.expression)) {
+                    const propAccess = expr.expression;
+                    if (typescript_1.default.isIdentifier(propAccess.expression) &&
+                        importedObjects.has(propAccess.expression.text) &&
+                        typescript_1.default.isIdentifier(propAccess.name) &&
+                        propAccess.name.text === 'use') {
+                        // Удаляем этот statement
+                        return [];
+                    }
+                }
+            }
+            // Обрабатываем variable statement с serverAgent.getVar
+            if (typescript_1.default.isVariableStatement(node)) {
+                const extraStatements = [];
+                const declarations = [];
+                for (const decl of node.declarationList.declarations) {
+                    if (decl.initializer && typescript_1.default.isCallExpression(decl.initializer)) {
+                        const callExpr = decl.initializer;
+                        // Проверяем serverAgent.getVar<T>(...)
+                        if (typescript_1.default.isPropertyAccessExpression(callExpr.expression)) {
+                            const propAccess = callExpr.expression;
+                            if (typescript_1.default.isIdentifier(propAccess.expression) &&
+                                importedObjects.has(propAccess.expression.text) &&
+                                typescript_1.default.isIdentifier(propAccess.name)) {
+                                const objectName = propAccess.expression.text;
+                                const methodName = propAccess.name.text;
+                                // Обрабатываем serverAgent.getVar
+                                if (objectName === 'serverAgent' && methodName === 'getVar') {
+                                    const transformed = transformServerAgentGetVar(decl, callExpr);
+                                    if (transformed) {
+                                        extraStatements.push(...transformed.statements);
+                                        declarations.push(transformed.declaration);
+                                        continue;
+                                    }
+                                }
+                            }
+                        }
+                    }
+                    // Если не трансформировали, оставляем как есть
+                    declarations.push(decl);
+                }
+                const result = [];
+                // Добавляем extra statements
+                if (extraStatements.length > 0) {
+                    result.push(...extraStatements);
+                }
+                // Создаем variable statement с оставшимися декларациями
+                if (declarations.length > 0) {
+                    result.push(factory.createVariableStatement(node.modifiers, factory.createVariableDeclarationList(declarations, node.declarationList.flags)));
+                }
+                return result.length > 0 ? result : node;
+            }
+            return typescript_1.default.visitEachChild(node, visit, context);
+        }
+        // Трансформирует serverAgent.getVar<T>(name, errorMessage)
+        function transformServerAgentGetVar(originalDecl, callExpr) {
+            if (!typescript_1.default.isIdentifier(originalDecl.name)) {
+                return null;
+            }
+            const varName = originalDecl.name.text;
+            const args = callExpr.arguments;
+            if (args.length === 0 || !typescript_1.default.isStringLiteral(args[0])) {
+                return null;
+            }
+            const parameterName = args[0].text;
+            const errorMessage = args.length > 1 && typescript_1.default.isStringLiteral(args[1])
+                ? args[1].text
+                : `${parameterName} parameter is required`;
+            // Определяем тип из type arguments
+            let typeConverter = 'String'; // default
+            if (callExpr.typeArguments && callExpr.typeArguments.length > 0) {
+                const typeArg = callExpr.typeArguments[0];
+                if (typescript_1.default.isTypeReferenceNode(typeArg) && typescript_1.default.isIdentifier(typeArg.typeName)) {
+                    const typeName = typeArg.typeName.text;
+                    typeConverter = TYPE_CONVERTERS[typeName] || 'String';
+                }
+                else if (typeArg.kind === typescript_1.default.SyntaxKind.StringKeyword) {
+                    typeConverter = 'String';
+                }
+                else if (typeArg.kind === typescript_1.default.SyntaxKind.NumberKeyword) {
+                    typeConverter = 'OptInt';
+                }
+                else if (typeArg.kind === typescript_1.default.SyntaxKind.BooleanKeyword) {
+                    typeConverter = 'tools_web.is_true';
+                }
+            }
+            const tempVarName = `serverAgentParam_${parameterName.replace(/[^a-zA-Z0-9_]/g, '_')}`;
+            const statements = [];
+            // var serverAgentParam_personId = undefined;
+            statements.push(factory.createVariableStatement(undefined, factory.createVariableDeclarationList([factory.createVariableDeclaration(tempVarName, undefined, undefined, factory.createIdentifier('undefined'))], typescript_1.default.NodeFlags.None)));
+            // serverAgentParam_personId = OptInt(Param.GetOptProperty("person_id"));
+            statements.push(factory.createExpressionStatement(factory.createAssignment(factory.createIdentifier(tempVarName), factory.createCallExpression(factory.createIdentifier(typeConverter), undefined, [
+                (0, utils_1.markUntouchable)(factory.createCallExpression(factory.createPropertyAccessExpression(factory.createIdentifier('Param'), 'GetOptProperty'), undefined, [factory.createStringLiteral(parameterName)]))
+            ]))));
+            // if (serverAgentParam_personId === undefined) { throw "error message"; }
+            statements.push(factory.createIfStatement(factory.createBinaryExpression(factory.createIdentifier(tempVarName), factory.createToken(typescript_1.default.SyntaxKind.EqualsEqualsEqualsToken), factory.createIdentifier('undefined')), factory.createBlock([
+                factory.createThrowStatement(factory.createStringLiteral(errorMessage))
+            ], true)));
+            // const varName = tempVarName;
+            const newDeclaration = factory.createVariableDeclaration(originalDecl.name, originalDecl.exclamationToken, originalDecl.type, factory.createIdentifier(tempVarName));
+            return {
+                statements,
+                declaration: newDeclaration
+            };
+        }
+        const transformed = (0, utils_1.setParentNodes)(typescript_1.default.visitNode(sourceFile, visit), sourceFile);
+        // Если это массив statements, нужно создать новый sourceFile
+        if (Array.isArray(transformed)) {
+            return (0, utils_1.preserveSymbolsFrom)(factory.updateSourceFile(sourceFile, transformed), sourceFile);
+        }
+        return (0, utils_1.preserveSymbolsFrom)(transformed, sourceFile);
+    };
+}

package/build/transformers/forOfToForIn.js

@@ -0,0 +1,45 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forOfToForInTransformer = forOfToForInTransformer;
+const typescript_1 = __importDefault(require("typescript"));
+/**
+ * Трансформер для преобразования циклов for-of в for-in.
+ *
+ * В BorisScript нет for-of, но for-in работает по индексам массива,
+ * что эквивалентно поведению for-of для массивов.
+ *
+ * @example
+ * // Вход:
+ * for (const item of items) {
+ *   console.log(item);
+ * }
+ *
+ * // Выход:
+ * for (const item in items) {
+ *   console.log(item);
+ * }
+ *
+ * @returns TypeScript transformer factory
+ */
+function forOfToForInTransformer() {
+    return (context) => {
+        return (sourceFile) => {
+            const visitor = (node) => {
+                // Обрабатываем for-of циклы
+                if (typescript_1.default.isForOfStatement(node)) {
+                    // Рекурсивно обрабатываем дочерние узлы
+                    const visitedInitializer = typescript_1.default.visitNode(node.initializer, visitor);
+                    const visitedExpression = typescript_1.default.visitNode(node.expression, visitor);
+                    const visitedStatement = typescript_1.default.visitNode(node.statement, visitor);
+                    // Создаём for-in вместо for-of
+                    return typescript_1.default.factory.createForInStatement(visitedInitializer, visitedExpression, visitedStatement);
+                }
+                return typescript_1.default.visitEachChild(node, visitor, context);
+            };
+            return typescript_1.default.visitNode(sourceFile, visitor);
+        };
+    };
+}

package/build/transformers/funcSemantic.js

@@ -0,0 +1,113 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.funcSemanticTransformer = funcSemanticTransformer;
+const typescript_1 = __importDefault(require("typescript"));
+const utils_1 = require("./utils");
+// Helper function to create argument restoration statements
+function createArgumentRestorationStatements(parameters) {
+    const statements = [];
+    let normalParamIndex = 0;
+    parameters.forEach((param, index) => {
+        const paramName = param.name.text;
+        if (param.dotDotDotToken) {
+            // Rest parameter: use bt.array_rest(arguments, startIndex)
+            const restCall = typescript_1.default.factory.createCallExpression((0, utils_1.markUntouchable)(typescript_1.default.factory.createPropertyAccessExpression(typescript_1.default.factory.createIdentifier('bt'), typescript_1.default.factory.createIdentifier('array_rest'))), undefined, [
+                typescript_1.default.factory.createIdentifier('__arguments'),
+                typescript_1.default.factory.createNumericLiteral(normalParamIndex)
+            ]);
+            statements.push(typescript_1.default.factory.createVariableStatement(undefined, typescript_1.default.factory.createVariableDeclarationList([typescript_1.default.factory.createVariableDeclaration(typescript_1.default.factory.createIdentifier(paramName), undefined, undefined, restCall)], typescript_1.default.NodeFlags.Let)));
+        }
+        else {
+            // Normal parameter: restore from arguments[index] or undefined
+            // __arguments.length > index ? __arguments[index] : undefined
+            statements.push(typescript_1.default.factory.createVariableStatement(undefined, typescript_1.default.factory.createVariableDeclarationList([typescript_1.default.factory.createVariableDeclaration(typescript_1.default.factory.createIdentifier(paramName), undefined, undefined, typescript_1.default.factory.createConditionalExpression(typescript_1.default.factory.createBinaryExpression(typescript_1.default.factory.createPropertyAccessExpression((0, utils_1.markUntouchable)(typescript_1.default.factory.createIdentifier('__arguments')), typescript_1.default.factory.createIdentifier('length')), typescript_1.default.factory.createToken(typescript_1.default.SyntaxKind.GreaterThanToken), typescript_1.default.factory.createNumericLiteral(normalParamIndex)), typescript_1.default.factory.createToken(typescript_1.default.SyntaxKind.QuestionToken), typescript_1.default.factory.createElementAccessExpression(typescript_1.default.factory.createIdentifier('__arguments'), typescript_1.default.factory.createNumericLiteral(normalParamIndex)), typescript_1.default.factory.createToken(typescript_1.default.SyntaxKind.ColonToken), typescript_1.default.factory.createIdentifier('undefined')))], typescript_1.default.NodeFlags.Let)));
+            normalParamIndex++;
+        }
+    });
+    return statements;
+}
+// Helper function to transform function body with argument restoration
+function transformFunctionBody(body, parameters) {
+    if (!body || parameters.length === 0) {
+        return body;
+    }
+    const argRestoration = createArgumentRestorationStatements(parameters);
+    return typescript_1.default.factory.createBlock([...argRestoration, ...body.statements], true);
+}
+// Helper function to create function parameters (__env, __this, __arguments)
+function createFunctionParameters() {
+    return [
+        typescript_1.default.factory.createParameterDeclaration(undefined, undefined, typescript_1.default.factory.createIdentifier('__env'), undefined, undefined, undefined),
+        typescript_1.default.factory.createParameterDeclaration(undefined, undefined, typescript_1.default.factory.createIdentifier('__this'), undefined, undefined, undefined),
+        typescript_1.default.factory.createParameterDeclaration(undefined, undefined, typescript_1.default.factory.createIdentifier('__arguments'), undefined, undefined, undefined)
+    ];
+}
+function funcSemanticTransformer() {
+    return (context) => {
+        return (sourceFile) => {
+            const visitor = (node) => {
+                // Transform function declarations
+                if (typescript_1.default.isFunctionDeclaration(node)) {
+                    const visitedBody = typescript_1.default.visitEachChild(node.body, visitor, context);
+                    const newBody = transformFunctionBody(visitedBody, node.parameters);
+                    return typescript_1.default.factory.updateFunctionDeclaration(node, node.modifiers, node.asteriskToken, node.name, node.typeParameters, createFunctionParameters(), node.type, newBody);
+                }
+                // // Transform function expressions
+                // if (ts.isFunctionExpression(node)) {
+                //   const newBody = transformFunctionBody(node.body, node.parameters);
+                //   return ts.factory.updateFunctionExpression(
+                //     node,
+                //     node.modifiers,
+                //     node.asteriskToken,
+                //     node.name,
+                //     node.typeParameters,
+                //     createFunctionParameters(),
+                //     node.type,
+                //     newBody!
+                //   );
+                // }
+                // // Transform arrow functions
+                // if (ts.isArrowFunction(node)) {
+                //   let functionBody: ts.Block;
+                //   if (ts.isBlock(node.body)) {
+                //     functionBody = node.body;
+                //   } else {
+                //     functionBody = ts.factory.createBlock([
+                //       ts.factory.createReturnStatement(node.body as ts.Expression)
+                //     ]);
+                //   }
+                //   const newBody = transformFunctionBody(functionBody, node.parameters)!;
+                //   return ts.factory.updateArrowFunction(
+                //     node,
+                //     node.modifiers,
+                //     node.typeParameters,
+                //     createFunctionParameters(),
+                //     node.type,
+                //     node.equalsGreaterThanToken,
+                //     newBody
+                //   );
+                // }
+                // // Transform method declarations
+                // if (ts.isMethodDeclaration(node)) {
+                //   const newBody = transformFunctionBody(node.body, node.parameters);
+                //   return ts.factory.updateMethodDeclaration(
+                //     node,
+                //     node.modifiers,
+                //     node.asteriskToken,
+                //     node.name,
+                //     node.questionToken,
+                //     node.typeParameters,
+                //     createFunctionParameters(),
+                //     node.type,
+                //     newBody
+                //   );
+                // }
+                return typescript_1.default.visitEachChild(node, visitor, context);
+            };
+            return (0, utils_1.preserveSymbolsFrom)((0, utils_1.setParentNodes)(typescript_1.default.visitNode(sourceFile, visitor), sourceFile), sourceFile);
+        };
+    };
+}