fix(negativeNumbers): convert negative literal numbers to unary expression with minus token

package.json

@@ -92,7 +92,7 @@
         "ts-node": "^10.9.2",
         "ts-patch": "^3.1.1",
         "tsconfig-paths": "4.2.0",
-        "typescript": "^5.3.3",
+        "typescript": "^5.4.5",
         "webpack": "^5.89.0",
         "webpack-cli": "^5.1.4",
         "webpack-merge": "^5.10.0",

src/transformer/descriptor/enum/enumDeclaration.ts

@@ -4,7 +4,7 @@ import { RandomPropertyAccessor } from '../random/random';
 import { IsTsAutoMockRandomEnabled } from '../../../options/random';
 import {
   createCall,
-  createNumericLiteral,
+  createExpressionForNegativeOrPositiveNumber,
   createStringLiteral,
 } from '../../../typescriptFactory/typescriptFactory';
 
@@ -34,7 +34,7 @@ function getEnumMemberValue(
     typeChecker.getConstantValue(member) || defaultValue;
 
   if (typeof value === 'number') {
-    return createNumericLiteral(value);
+    return createExpressionForNegativeOrPositiveNumber(value);
   }
 
   return createStringLiteral(value);

src/transformer/descriptor/literal/literal.ts

@@ -3,8 +3,8 @@ import { Scope } from '../../scope/scope';
 import { core } from '../../core/core';
 import { GetDescriptor } from '../descriptor';
 import {
+  createExpressionForNegativeOrPositiveNumber,
   createLiteral,
-  createNumericLiteral,
   createStringLiteral,
 } from '../../../typescriptFactory/typescriptFactory';
 
@@ -27,15 +27,15 @@ export function GetLiteralDescriptor(
 
 function GetLiteralTokenDescriptor(
   node: ts.LiteralTypeNode,
-): ts.StringLiteral | ts.NumericLiteral {
+): ts.StringLiteral | ts.Expression {
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   const nodeToken: any = node as any;
 
   if (nodeToken.kind === core.ts.SyntaxKind.NumericLiteral) {
-    // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-    return createNumericLiteral(parseInt(nodeToken.text, 10));
+    return createExpressionForNegativeOrPositiveNumber(
+      parseInt(nodeToken.text, 10),
+    );
   }
 
-  // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
   return createStringLiteral(nodeToken.text);
 }

src/typescriptFactory/typescriptFactory.ts

@@ -33,6 +33,7 @@ import type {
   ParameterDeclaration,
   PostfixUnaryExpression,
   PostfixUnaryOperator,
+  PrefixUnaryOperator,
   PrefixUnaryExpression,
   PrivateIdentifier,
   PropertyAccessExpression,
@@ -92,6 +93,26 @@ export function createNumericLiteral(
   return core.ts.factory.createNumericLiteral(value, numericLiteralFlags);
 }
 
+export function createExpressionForNegativeOrPositiveNumber(
+  value: number,
+): Expression {
+  if (value < 0) {
+    return createPrefixUnaryExpression(
+      core.ts.SyntaxKind.MinusToken,
+      createNumericLiteral(Math.abs(value)),
+    );
+  }
+
+  return createNumericLiteral(value);
+}
+
+export function createPrefixUnaryExpression(
+  unaryOperator: PrefixUnaryOperator,
+  operand: Expression,
+): Expression {
+  return core.ts.factory.createPrefixUnaryExpression(unaryOperator, operand);
+}
+
 export function createArrowFunction(
   block: ts.ConciseBody,
   parameter: ReadonlyArray<ts.ParameterDeclaration> = [],
@@ -298,13 +319,13 @@ export function createLogicalNot(operand: Expression): PrefixUnaryExpression {
 
 export function createLiteral(
   type: LiteralType,
-): StringLiteral | NumericLiteral | BigIntLiteral {
+): StringLiteral | Expression | BigIntLiteral {
   if (typeof type.value === 'string') {
     return createStringLiteral(type.value);
   }
 
   if (typeof type.value === 'number') {
-    return createNumericLiteral(type.value);
+    return createExpressionForNegativeOrPositiveNumber(type.value);
   }
 
   return core.ts.factory.createBigIntLiteral(type.value);

test/transformer/descriptor/enum.test.ts

@@ -15,6 +15,7 @@ describe('for enum', () => {
     Right = 1,
     Left = 3,
   }
+
   interface Interface {
     a: Direction;
     b: DirectionAssign;
@@ -55,3 +56,21 @@ describe('for enum with constant computed values', () => {
     expect(properties.a).toEqual(2);
   });
 });
+
+describe('for enum with negative values', () => {
+  it('should assign the values', () => {
+    enum AssignmentWithNegatives {
+      Negative1 = -4,
+      Positive = 1,
+      Negative2 = -7,
+    }
+
+    interface Interface {
+      enum: AssignmentWithNegatives;
+    }
+
+    const properties: Interface = createMock<Interface>();
+
+    expect(properties.enum).toEqual(-4);
+  });
+});

test/transformer/descriptor/literal/literal.test.ts

@@ -8,6 +8,7 @@ import {
   TypeUnionTokenAllBoolean,
   TypeUnionTokenNumber,
   TypeUnionTokenSameBoolean,
+  TypeUnionWithNegatives,
 } from '../utils/types/typeUnion';
 import { getObjectKeyValues } from '../../utilities/getObjectKeyValues';
 
@@ -26,22 +27,26 @@ describe('for literal', () => {
   describe('with a specific number', () => {
     interface Interface {
       a: 2;
+      b: -3;
     }
 
-    it('should set null', () => {
+    it('should set the number', () => {
       const properties: Interface = createMock<Interface>();
       expect(properties.a).toBe(2);
+      expect(properties.b).toBe(-3);
     });
   });
 
   describe('with import', () => {
     interface Interface {
       literal: TypeUnion;
+      literalWithNegatives: TypeUnionWithNegatives;
     }
 
     it('should set the first one', () => {
       const properties: Interface = createMock<Interface>();
       expect(properties.literal).toBe('1');
+      expect(properties.literalWithNegatives).toBe(-1);
     });
   });
 

test/transformer/descriptor/utils/types/typeUnion.ts

@@ -1,4 +1,5 @@
 export type TypeUnion = '1' | '2' | 'a' | 'b';
+export type TypeUnionWithNegatives = -1 | -2 | 3 | 2;
 export type TypeUnionToken = 'a' | 'b';
 export type TypeUnionTokenNumber = 1 | 1;
 export type TypeUnionTokenSameBoolean = true | true;