Sync with dev

src/analyzers/number-numerical-expression-analyzer/NumberNumericalExpressionAnalyzer.ts

@@ -19,6 +19,11 @@ export class NumberNumericalExpressionAnalyzer implements INumberNumericalExpres
      */
     public static readonly defaultAdditionalPartsCount: number = 3;
 
+    /**
+     * @type {number}
+     */
+    private static readonly delta: number = 10000;
+
     /**
      * @type {Map<number, number[]>}
      */
@@ -70,8 +75,8 @@ export class NumberNumericalExpressionAnalyzer implements INumberNumericalExpres
 
         const upperNumberLimit: number = Math.min(Math.abs(number * 2), Number.MAX_SAFE_INTEGER);
 
-        const from: number = Math.min(-10000, -upperNumberLimit);
-        const to: number = Math.max(10000, upperNumberLimit);
+        const from: number = Math.min(-NumberNumericalExpressionAnalyzer.delta, -upperNumberLimit);
+        const to: number = Math.max(NumberNumericalExpressionAnalyzer.delta, upperNumberLimit);
 
         let temporarySum = 0;
 

src/node-transformers/converting-transformers/NumberToNumericalExpressionTransformer.ts

@@ -16,6 +16,7 @@ import { AbstractNodeTransformer } from '../AbstractNodeTransformer';
 import { NodeGuards } from '../../node/NodeGuards';
 import { NodeFactory } from '../../node/NodeFactory';
 import { NumberNumericalExpressionAnalyzer } from '../../analyzers/number-numerical-expression-analyzer/NumberNumericalExpressionAnalyzer';
+import { NumberUtils } from '../../utils/NumberUtils';
 import { NumericalExpressionDataToNodeConverter } from '../../node/NumericalExpressionDataToNodeConverter';
 
 /**
@@ -86,23 +87,41 @@ export class NumberToNumericalExpressionTransformer extends AbstractNodeTransfor
             return literalNode;
         }
 
-        const numberNumericalExpressionData: TNumberNumericalExpressionData = this.numberNumericalExpressionAnalyzer.analyze(
-            literalNode.value,
-            NumberNumericalExpressionAnalyzer.defaultAdditionalPartsCount
-        );
+        const baseNumber: number = literalNode.value;
+        const [integerPart, decimalPart] = NumberUtils.extractIntegerAndDecimalParts(baseNumber);
+        const integerNumberNumericalExpressionData: TNumberNumericalExpressionData = this.numberNumericalExpressionAnalyzer
+            .analyze(
+                integerPart,
+                NumberNumericalExpressionAnalyzer.defaultAdditionalPartsCount
+            );
 
-        return NumericalExpressionDataToNodeConverter.convert(
-            numberNumericalExpressionData,
-            (number: number, isPositiveNumber: boolean) => {
-                const numberLiteralNode: ESTree.Literal = NodeFactory.literalNode(number);
+        if (decimalPart) {
+            return NumericalExpressionDataToNodeConverter.convertFloatNumberData(
+                integerNumberNumericalExpressionData,
+                decimalPart,
+                this.getNumberNumericalExpressionLiteralNode
+            );
+        } else {
+            return NumericalExpressionDataToNodeConverter.convertIntegerNumberData(
+                integerNumberNumericalExpressionData,
+                this.getNumberNumericalExpressionLiteralNode
+            );
+        }
+    }
 
-                return isPositiveNumber
-                    ? numberLiteralNode
-                    : NodeFactory.unaryExpressionNode(
-                        '-',
-                        numberLiteralNode
-                    );
-            }
-        );
+    /**
+     * @param {number} number
+     * @param {boolean} isPositiveNumber
+     * @returns {Expression}
+     */
+    private getNumberNumericalExpressionLiteralNode (number: number, isPositiveNumber: boolean): ESTree.Expression {
+        const numberLiteralNode: ESTree.Literal = NodeFactory.literalNode(number);
+
+        return isPositiveNumber
+            ? numberLiteralNode
+            : NodeFactory.unaryExpressionNode(
+                '-',
+                numberLiteralNode
+            );
     }
 }

src/node-transformers/string-array-transformers/StringArrayRotateFunctionTransformer.ts

@@ -226,7 +226,7 @@ export class StringArrayRotateFunctionTransformer extends AbstractNodeTransforme
                 StringArrayRotateFunctionTransformer.comparisonExpressionAdditionalPartsCount
             );
 
-        const comparisonExpressionNode: ESTree.Expression = NumericalExpressionDataToNodeConverter.convert(
+        const comparisonExpressionNode: ESTree.Expression = NumericalExpressionDataToNodeConverter.convertIntegerNumberData(
             comparisonExpressionNumberNumericalExpressionData,
             ((number: number, isPositiveNumber) => {
                 const literalNode: ESTree.Literal = NodeFactory.literalNode(

src/node/NumericalExpressionDataToNodeConverter.ts

@@ -15,7 +15,7 @@ export class NumericalExpressionDataToNodeConverter {
      * @param {TNumericalExpressionDataToNodeConverterLiteralNodeGetter} literalNodeGetter
      * @returns {Expression}
      */
-    public static convert (
+    public static convertIntegerNumberData (
         numberNumericalExpressionData: TNumberNumericalExpressionData,
         literalNodeGetter: TNumericalExpressionDataToNodeConverterLiteralNodeGetter
     ): ESTree.Expression {
@@ -25,6 +25,30 @@ export class NumericalExpressionDataToNodeConverter {
        );
     }
 
+    /**
+     * @param {TNumberNumericalExpressionData} integerNumberNumericalExpressionData
+     * @param {number} decimalPart
+     * @param {TNumericalExpressionDataToNodeConverterLiteralNodeGetter} literalNodeGetter
+     * @returns {Expression}
+     */
+    public static convertFloatNumberData (
+        integerNumberNumericalExpressionData: TNumberNumericalExpressionData,
+        decimalPart: number,
+        literalNodeGetter: TNumericalExpressionDataToNodeConverterLiteralNodeGetter
+    ): ESTree.Expression {
+        const integerNumberNumericalExpressionNode: ESTree.Expression = NumericalExpressionDataToNodeConverter
+            .convertNumericalExpressionDataToNode(
+                integerNumberNumericalExpressionData,
+                literalNodeGetter
+            );
+
+        return NodeFactory.binaryExpressionNode(
+            '+',
+            integerNumberNumericalExpressionNode,
+            NodeFactory.literalNode(decimalPart)
+        );
+    }
+
     /**
      * @param {TNumberNumericalExpressionData} numberNumericalExpressionData
      * @param {TNumericalExpressionDataToNodeConverterLiteralNodeGetter} literalNodeGetter

src/utils/NumberUtils.ts

@@ -15,6 +15,19 @@ export class NumberUtils {
         return `${Utils.hexadecimalPrefix}${basePart}`;
     }
 
+    /**
+     * @param {number} number
+     * @returns {[number, (number | null)]}
+     */
+    public static extractIntegerAndDecimalParts (number: number): [number, number | null] {
+        const integerPart: number = Math.trunc(number);
+        const decimalPart: number | null = number !== integerPart
+            ? number % 1
+            : null;
+
+        return [integerPart, decimalPart];
+    }
+
     /**
      * @param {number} number
      * @returns {boolean}