@boristype/bt-cli 0.1.0-alpha.0

package/build/plugins/precedence.js

@@ -0,0 +1,172 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = precedencePlugin;
+const core_1 = require("@babel/core");
+// Таблица приоритетов операторов согласно MDN
+// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_precedence
+const PRECEDENCE = {
+    // 13: Exponentiation (right-to-left)
+    '**': 13,
+    // 12: Multiplicative operators (left-to-right)
+    '*': 12,
+    '/': 12,
+    '%': 12,
+    // 11: Additive operators (left-to-right)
+    '+': 11,
+    '-': 11,
+    // 10: Bitwise shift (left-to-right)
+    '<<': 10,
+    '>>': 10,
+    '>>>': 10,
+    // 9: Relational operators (left-to-right)
+    '<': 9,
+    '<=': 9,
+    '>': 9,
+    '>=': 9,
+    'in': 9,
+    'instanceof': 9,
+    // 8: Equality operators (left-to-right)
+    '==': 8,
+    '!=': 8,
+    '===': 8,
+    '!==': 8,
+    // 7: Bitwise AND (left-to-right)
+    '&': 7,
+    // 6: Bitwise XOR (left-to-right)
+    '^': 6,
+    // 5: Bitwise OR (left-to-right)
+    '|': 5,
+    // 4: Logical AND (left-to-right)
+    '&&': 4,
+    // 3: Logical OR, Nullish coalescing (left-to-right)
+    '||': 3,
+    '??': 3,
+    // 2: Assignment operators (right-to-left)
+    '=': 2,
+    '+=': 2,
+    '-=': 2,
+    '*=': 2,
+    '**=': 2,
+    '/=': 2,
+    '%=': 2,
+    '<<=': 2,
+    '>>=': 2,
+    '>>>=': 2,
+    '&=': 2,
+    '^=': 2,
+    '|=': 2,
+    '&&=': 2,
+    '||=': 2,
+    '??=': 2,
+    // 1: Comma operator (left-to-right)
+    ',': 1,
+};
+// Операторы с правоассоциативностью (вычисляются справа налево)
+const RIGHT_ASSOCIATIVE = new Set([
+    '**',
+    '=', '+=', '-=', '*=', '**=', '/=', '%=',
+    '<<=', '>>=', '>>>=',
+    '&=', '^=', '|=',
+    '&&=', '||=', '??=',
+]);
+function getPrecedence(operator) {
+    return PRECEDENCE[operator] ?? 999; // Высокий приоритет для неизвестных операторов
+}
+function isRightAssociative(operator) {
+    return RIGHT_ASSOCIATIVE.has(operator);
+}
+function needsParentheses(parentOp, childOp, isLeft) {
+    const parentPrec = getPrecedence(parentOp);
+    const childPrec = getPrecedence(childOp);
+    // Если приоритет разный, всегда нужны скобки
+    if (childPrec !== parentPrec) {
+        return true;
+    }
+    // Если приоритет одинаковый, ВСЕГДА нужны скобки, чтобы явно показать порядок
+    // Для left-to-right: 10 / 2 * 5 → (10 / 2) * 5 - оборачиваем левый
+    // Для right-to-left: 2 ** 3 ** 4 → 2 ** (3 ** 4) - оборачиваем правый
+    if (isRightAssociative(parentOp)) {
+        // Для right-to-left оборачиваем правый операнд
+        return !isLeft;
+    }
+    else {
+        // Для left-to-right оборачиваем левый операнд
+        return isLeft;
+    }
+}
+function precedencePlugin() {
+    return {
+        name: 'precedence-enforcer',
+        visitor: {
+            BinaryExpression(path) {
+                const node = path.node;
+                // Проверяем левый операнд
+                if (core_1.types.isBinaryExpression(node.left)) {
+                    if (needsParentheses(node.operator, node.left.operator, true)) {
+                        path.get('left').replaceWith(core_1.types.parenthesizedExpression(node.left));
+                    }
+                }
+                // Проверяем правый операнд
+                if (core_1.types.isBinaryExpression(node.right)) {
+                    if (needsParentheses(node.operator, node.right.operator, false)) {
+                        path.get('right').replaceWith(core_1.types.parenthesizedExpression(node.right));
+                    }
+                }
+            },
+            LogicalExpression(path) {
+                const node = path.node;
+                // Проверяем левый операнд
+                if (core_1.types.isLogicalExpression(node.left) || core_1.types.isBinaryExpression(node.left)) {
+                    const leftOp = node.left.operator;
+                    if (needsParentheses(node.operator, leftOp, true)) {
+                        path.get('left').replaceWith(core_1.types.parenthesizedExpression(node.left));
+                    }
+                }
+                // Проверяем правый операнд
+                if (core_1.types.isLogicalExpression(node.right) || core_1.types.isBinaryExpression(node.right)) {
+                    const rightOp = node.right.operator;
+                    if (needsParentheses(node.operator, rightOp, false)) {
+                        path.get('right').replaceWith(core_1.types.parenthesizedExpression(node.right));
+                    }
+                }
+            },
+            ConditionalExpression(path) {
+                const node = path.node;
+                // Условие: оборачиваем бинарные/логические выражения с приоритетом <= 2
+                if (core_1.types.isBinaryExpression(node.test) || core_1.types.isLogicalExpression(node.test)) {
+                    const testOp = node.test.operator;
+                    const testPrec = getPrecedence(testOp);
+                    if (testPrec <= 2) {
+                        path.get('test').replaceWith(core_1.types.parenthesizedExpression(node.test));
+                    }
+                }
+                // consequent: оборачиваем запятую и присваивания
+                if (core_1.types.isBinaryExpression(node.consequent) || core_1.types.isLogicalExpression(node.consequent)) {
+                    const trueOp = node.consequent.operator;
+                    const truePrec = getPrecedence(trueOp);
+                    if (truePrec <= 2) {
+                        path.get('consequent').replaceWith(core_1.types.parenthesizedExpression(node.consequent));
+                    }
+                }
+                // alternate: оборачиваем запятую и присваивания
+                if (core_1.types.isBinaryExpression(node.alternate) || core_1.types.isLogicalExpression(node.alternate)) {
+                    const falseOp = node.alternate.operator;
+                    const falsePrec = getPrecedence(falseOp);
+                    if (falsePrec <= 2) {
+                        path.get('alternate').replaceWith(core_1.types.parenthesizedExpression(node.alternate));
+                    }
+                }
+            },
+            AssignmentExpression(path) {
+                const node = path.node;
+                // Проверяем правый операнд
+                if (core_1.types.isAssignmentExpression(node.right) || core_1.types.isBinaryExpression(node.right) || core_1.types.isLogicalExpression(node.right)) {
+                    const rightOp = node.right.operator;
+                    if (needsParentheses(node.operator, rightOp, false)) {
+                        path.get('right').replaceWith(core_1.types.parenthesizedExpression(node.right));
+                    }
+                }
+            },
+        },
+    };
+}

package/build/plugins/removeImportExport.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = removeImportExportPlugin;
+function removeImportExportPlugin() {
+    return {
+        name: 'remove-import-export',
+        visitor: {
+            // Handle import declarations
+            ImportDeclaration(path) {
+                path.remove();
+            },
+            // Remove dummy export variables (marked with @__dummy_export comment)
+            VariableDeclaration(path) {
+                const leadingComments = path.node.leadingComments;
+                if (leadingComments?.some(comment => comment.value.includes('@__dummy_export'))) {
+                    path.remove();
+                }
+            },
+            // Handle export declarations (named and default)
+            ExportNamedDeclaration(path) {
+                if (!path.node.declaration) {
+                    // console.log('Warning: Export named declaration without declaration found.');
+                    path.remove();
+                    return;
+                }
+                // console.log('Transforming export named declaration:', path.node.declaration.type);
+                // path.remove();
+                path.replaceWith(path.node.declaration);
+            },
+            ExportDefaultDeclaration(path) {
+                // export default может быть без declaration (например export default выражение)
+                // В Babel это представлено через ExportDefaultDeclaration где declaration это само выражение
+                // Мы просто удаляем весь export default
+                path.remove();
+            },
+            // Handle export all declarations
+            ExportAllDeclaration(path) {
+                path.remove();
+            },
+        },
+    };
+}

package/build/plugins/replaceDollar.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = replaceDollarPlugin;
+function replaceDollarPlugin() {
+    return {
+        name: 'replace-dollar',
+        visitor: {
+            Identifier(path) {
+                if (path.node.name.includes('$')) {
+                    const newName = path.node.name.replace(/\$/g, '_24_');
+                    path.node.name = newName;
+                }
+            },
+        },
+    };
+}

package/build/plugins/spreadArray.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = transformArraySpreadToArrayUnionPlugin;
+const core_1 = require("@babel/core");
+function transformArraySpreadToArrayUnionPlugin() {
+    return {
+        name: 'transform-array-spread-to-array-union',
+        visitor: {
+            ArrayExpression(path) {
+                // Проверяем наличие spread-элементов в массиве
+                const hasSpread = path.node.elements.some(element => element && core_1.types.isSpreadElement(element));
+                if (!hasSpread) {
+                    return; // Пропускаем массивы без spread-элементов
+                }
+                const args = [];
+                let currentLiteralArray = [];
+                // Обрабатываем элементы массива
+                path.node.elements.forEach(element => {
+                    if (element && core_1.types.isSpreadElement(element)) {
+                        // Если есть накопленные литералы, добавляем их как массив
+                        if (currentLiteralArray.length > 0) {
+                            args.push(core_1.types.arrayExpression(currentLiteralArray));
+                            currentLiteralArray = [];
+                        }
+                        // Добавляем аргумент spread-элемента
+                        args.push(element.argument);
+                    }
+                    else {
+                        // Собираем не-spread элементы (t.Expression | null)
+                        currentLiteralArray.push(element);
+                    }
+                });
+                // Добавляем оставшиеся литералы как массив
+                if (currentLiteralArray.length > 0) {
+                    args.push(core_1.types.arrayExpression(currentLiteralArray));
+                }
+                // Заменяем выражение массива вызовом ArrayUnion
+                path.replaceWith(core_1.types.callExpression(core_1.types.identifier('ArrayUnion'), args));
+            }
+        }
+    };
+}

package/build/plugins/spreadObject.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = transformObjectSpreadToObjectUnionPlugin;
+const core_1 = require("@babel/core");
+function transformObjectSpreadToObjectUnionPlugin() {
+    return {
+        name: 'transform-object-spread-to-object-union',
+        pre() {
+            this.needsObjectUnion = false;
+        },
+        visitor: {
+            Program: {
+                exit(path, state) {
+                    if (state.needsObjectUnion) {
+                        // Вставляем определение функции ObjectUnion в начало программы
+                        const functionDecl = core_1.types.functionDeclaration(core_1.types.identifier('ObjectUnion'), [core_1.types.identifier('obj1'), core_1.types.identifier('obj2')], core_1.types.blockStatement([
+                            core_1.types.variableDeclaration('var', [
+                                core_1.types.variableDeclarator(core_1.types.identifier('newObject'), core_1.types.objectExpression([]))
+                            ]),
+                            core_1.types.variableDeclaration('var', [
+                                core_1.types.variableDeclarator(core_1.types.identifier('key'))
+                            ]),
+                            core_1.types.forInStatement(core_1.types.identifier('key'), core_1.types.identifier('obj1'), core_1.types.blockStatement([
+                                core_1.types.expressionStatement(core_1.types.callExpression(core_1.types.memberExpression(core_1.types.identifier('newObject'), core_1.types.identifier('SetProperty')), [
+                                    core_1.types.identifier('key'),
+                                    core_1.types.callExpression(core_1.types.memberExpression(core_1.types.identifier('obj1'), core_1.types.identifier('GetProperty')), [core_1.types.identifier('key')])
+                                ]))
+                            ])),
+                            core_1.types.forInStatement(core_1.types.identifier('key'), core_1.types.identifier('obj2'), core_1.types.blockStatement([
+                                core_1.types.expressionStatement(core_1.types.callExpression(core_1.types.memberExpression(core_1.types.identifier('newObject'), core_1.types.identifier('SetProperty')), [
+                                    core_1.types.identifier('key'),
+                                    core_1.types.callExpression(core_1.types.memberExpression(core_1.types.identifier('obj2'), core_1.types.identifier('GetProperty')), [core_1.types.identifier('key')])
+                                ]))
+                            ])),
+                            core_1.types.returnStatement(core_1.types.identifier('newObject'))
+                        ]));
+                        path.unshiftContainer('body', functionDecl);
+                    }
+                }
+            },
+            ObjectExpression(path, state) {
+                // Проверяем наличие spread-элементов в объекте
+                const hasSpread = path.node.properties.some(property => core_1.types.isSpreadElement(property));
+                if (!hasSpread) {
+                    return; // Пропускаем объекты без spread-элементов
+                }
+                state.needsObjectUnion = true;
+                const parts = [];
+                let currentLiteralProperties = [];
+                // Обрабатываем свойства объекта
+                path.node.properties.forEach(property => {
+                    if (core_1.types.isSpreadElement(property)) {
+                        // Если есть накопленные свойства, добавляем их как объект
+                        if (currentLiteralProperties.length > 0) {
+                            parts.push(core_1.types.objectExpression(currentLiteralProperties));
+                            currentLiteralProperties = [];
+                        }
+                        // Добавляем аргумент spread-элемента
+                        parts.push(property.argument);
+                    }
+                    else {
+                        // Собираем не-spread свойства (с кастом к t.ObjectMember)
+                        currentLiteralProperties.push(property);
+                    }
+                });
+                // Добавляем оставшиеся свойства как объект
+                if (currentLiteralProperties.length > 0) {
+                    parts.push(core_1.types.objectExpression(currentLiteralProperties));
+                }
+                // Если частей нет, возвращаем пустой объект
+                if (parts.length === 0) {
+                    path.replaceWith(core_1.types.objectExpression([]));
+                    return;
+                }
+                // Если только одна часть, заменяем на нее
+                if (parts.length === 1) {
+                    // path.replaceWith(parts[0]);
+                    path.replaceWith(core_1.types.callExpression(core_1.types.identifier('ObjectUnion'), [core_1.types.objectExpression([]), parts[0]]));
+                    return;
+                }
+                // Строим вложенные вызовы ObjectUnion попарно (left-associative)
+                let expression = parts[0];
+                for (let i = 1; i < parts.length; i++) {
+                    expression = core_1.types.callExpression(core_1.types.identifier('ObjectUnion'), [expression, parts[i]]);
+                }
+                // Заменяем выражение объекта вложенными вызовами ObjectUnion
+                path.replaceWith(expression);
+            }
+        }
+    };
+}