Improved rotateStringArray option WIP

2026-08-09 12:42:29 +00:00 · 2020-12-27 14:14:50 +03:00
parent 2546b27c09
commit efac711ce4
24 changed files with 36811 additions and 272 deletions
@@ -137,6 +137,23 @@ export class NodeFactory {
        };
    }

+    /**
+     * @param {Pattern | null} param
+     * @param {BlockStatement} body
+     * @returns {CatchClause}
+     */
+    public static catchClauseNode (
+        param: ESTree.Pattern | null,
+        body: ESTree.BlockStatement
+    ): ESTree.CatchClause {
+        return {
+            type: NodeType.CatchClause,
+            param,
+            body,
+            metadata: { ignoredNode: false }
+        };
+    }
+
    /**
     * @param {ESTree.Expression} test
     * @param {ESTree.Expression} consequent
@@ -539,6 +556,26 @@ export class NodeFactory {
        };
    }

+    /**
+     * @param {BlockStatement} block
+     * @param {CatchClause | null} handler
+     * @param {BlockStatement | null} finalizer
+     * @returns {TryStatement}
+     */
+    public static tryStatement (
+        block: ESTree.BlockStatement,
+        handler?: ESTree.CatchClause | null,
+        finalizer?: ESTree.BlockStatement | null
+    ): ESTree.TryStatement {
+        return {
+            type: NodeType.TryStatement,
+            block,
+            handler,
+            finalizer,
+            metadata: { ignoredNode: false }
+        };
+    }
+
    /**
     * @param {VariableDeclarator[]} declarations
     * @param {string} kind
@@ -0,0 +1,131 @@
+import * as ESTree from 'estree';
+
+import { TNumericalExpressionDataToNodeConverterLiteralNodeGetter } from '../types/node/TNumericalExpressionDataToNodeConverterLiteralNodeGetter';
+import { TNumberNumericalExpressionData } from '../types/analyzers/number-numerical-expression-analyzer/TNumberNumericalExpressionData';
+
+import { NodeFactory } from './NodeFactory';
+import { NumberUtils } from '../utils/NumberUtils';
+
+/**
+ * Converts NumberNumericalExpressionData to node
+ */
+export class NumericalExpressionDataToNodeConverter {
+    /**
+     * @param {TNumberNumericalExpressionData} numberNumericalExpressionData
+     * @param {TNumericalExpressionDataToNodeConverterLiteralNodeGetter} literalNodeGetter
+     * @returns {Expression}
+     */
+    public static convert (
+        numberNumericalExpressionData: TNumberNumericalExpressionData,
+        literalNodeGetter: TNumericalExpressionDataToNodeConverterLiteralNodeGetter
+    ): ESTree.Expression {
+       return NumericalExpressionDataToNodeConverter.convertNumericalExpressionDataToNode(
+           numberNumericalExpressionData,
+           literalNodeGetter
+       );
+    }
+
+    /**
+     * @param {TNumberNumericalExpressionData} numberNumericalExpressionData
+     * @param {TNumericalExpressionDataToNodeConverterLiteralNodeGetter} literalNodeGetter
+     * @param {BinaryOperator} operator
+     * @returns {Expression}
+     */
+    private static convertNumericalExpressionDataToNode (
+        numberNumericalExpressionData: TNumberNumericalExpressionData,
+        literalNodeGetter: TNumericalExpressionDataToNodeConverterLiteralNodeGetter,
+        operator: ESTree.BinaryOperator = '+'
+    ): ESTree.Expression {
+        const numberNumericalExpressionDataLength: number = numberNumericalExpressionData.length;
+
+        const leftParts: TNumberNumericalExpressionData = numberNumericalExpressionDataLength > 1
+            ? numberNumericalExpressionData.slice(0, numberNumericalExpressionDataLength - 1)
+            : [numberNumericalExpressionData[0]];
+        const rightParts: TNumberNumericalExpressionData = numberNumericalExpressionDataLength > 1
+            ? numberNumericalExpressionData.slice(-1)
+            : [];
+
+        // trailing iterations
+        if (rightParts.length) {
+            return NumericalExpressionDataToNodeConverter
+                .convertPartsToBinaryExpression(operator, leftParts, rightParts, literalNodeGetter);
+        }
+
+        const firstLeftPartOrNumber: number | number[] | null = leftParts[0] ?? null;
+
+        // last iteration when only single left part is left
+        return Array.isArray(firstLeftPartOrNumber)
+            ? NumericalExpressionDataToNodeConverter.convertNumericalExpressionDataToNode(
+                firstLeftPartOrNumber,
+                literalNodeGetter,
+                '*'
+            )
+            : NumericalExpressionDataToNodeConverter.convertPartOrNumberToLiteralNode(
+                firstLeftPartOrNumber,
+                literalNodeGetter
+            );
+    }
+
+    /**
+     * @param {BinaryOperator} operator
+     * @param {TNumberNumericalExpressionData} leftParts
+     * @param {TNumberNumericalExpressionData} rightParts
+     * @param {TNumericalExpressionDataToNodeConverterLiteralNodeGetter} literalNodeGetter
+     * @returns {BinaryExpression}
+     */
+    private static convertPartsToBinaryExpression (
+        operator: ESTree.BinaryOperator,
+        leftParts: TNumberNumericalExpressionData,
+        rightParts: TNumberNumericalExpressionData,
+        literalNodeGetter: TNumericalExpressionDataToNodeConverterLiteralNodeGetter
+    ): ESTree.BinaryExpression {
+        const rightPartOrNumber: number | number[] = rightParts[0];
+
+        if (Array.isArray(rightPartOrNumber)) {
+            // right part is array with multiply numbers
+            return NodeFactory.binaryExpressionNode(
+                operator,
+                NumericalExpressionDataToNodeConverter.convertNumericalExpressionDataToNode(
+                    leftParts,
+                    literalNodeGetter
+                ),
+                NumericalExpressionDataToNodeConverter.convertNumericalExpressionDataToNode(
+                    rightPartOrNumber,
+                    literalNodeGetter,
+                    '*'
+                )
+            );
+        } else {
+            // right part is number
+            return NodeFactory.binaryExpressionNode(
+                operator,
+                NumericalExpressionDataToNodeConverter.convertNumericalExpressionDataToNode(
+                    leftParts,
+                    literalNodeGetter
+                ),
+                this.convertPartOrNumberToLiteralNode(
+                    rightPartOrNumber,
+                    literalNodeGetter
+                )
+            );
+        }
+    }
+
+    /**
+     * @param {number | number[]} partOrNumber
+     * @param {TNumericalExpressionDataToNodeConverterLiteralNodeGetter} literalNodeGetter
+     * @returns {Expression}
+     */
+    private static convertPartOrNumberToLiteralNode (
+        partOrNumber: number | number[],
+        literalNodeGetter: TNumericalExpressionDataToNodeConverterLiteralNodeGetter
+    ): ESTree.Expression {
+        const number: number = Array.isArray(partOrNumber)
+            ? partOrNumber[0]
+            : partOrNumber;
+        const isPositiveNumber: boolean = NumberUtils.isPositive(number);
+        const absoluteNumber: number = Math.abs(number);
+
+        return literalNodeGetter(absoluteNumber, isPositiveNumber);
+    }
+}