typia 3.5.0-dev.20230212 → 3.5.0-dev.20230214

package/src/transformers/CallExpressionTransformer.ts

@@ -3,14 +3,24 @@ import ts from "typescript";
 
 import { IProject } from "./IProject";
 import { ApplicationTransformer } from "./features/miscellaneous/ApplicationTransformer";
+import { AssertCloneTransformer } from "./features/miscellaneous/AssertCloneTransformer";
 import { AssertPruneTransformer } from "./features/miscellaneous/AssertPruneTransformer";
+import { CloneTransformer } from "./features/miscellaneous/CloneTransformer";
+import { CreateAssertCloneTransformer } from "./features/miscellaneous/CreateAssertCloneTransformer";
 import { CreateAssertPruneTransformer } from "./features/miscellaneous/CreateAssertPruneTransformer";
+import { CreateCloneTransformer } from "./features/miscellaneous/CreateCloneTransformer";
+import { CreateIsCloneTransformer } from "./features/miscellaneous/CreateIsCloneTransformer";
 import { CreateIsPruneTransformer } from "./features/miscellaneous/CreateIsPruneTransformer";
 import { CreatePruneTransformer } from "./features/miscellaneous/CreatePruneTransformer";
+import { CreateRandomTransformer } from "./features/miscellaneous/CreateRandomGenerator";
+import { CreateValidateCloneTransformer } from "./features/miscellaneous/CreateValidateCloneTransformer";
 import { CreateValidatePruneTransformer } from "./features/miscellaneous/CreateValidatePruneTransformer";
+import { IsCloneTransformer } from "./features/miscellaneous/IsCloneTransformer";
 import { IsPruneTransformer } from "./features/miscellaneous/IsPruneTransformer";
 import { MetadataTransformer } from "./features/miscellaneous/MetadataTransformer";
 import { PruneTransformer } from "./features/miscellaneous/PruneTransformer";
+import { RandomTransformer } from "./features/miscellaneous/RandomTransformer";
+import { ValidateCloneTransformer } from "./features/miscellaneous/ValidateCloneTransformer";
 import { ValidatePruneTransformer } from "./features/miscellaneous/ValidatePruneTransformer";
 import { AssertParseTransformer } from "./features/parsers/AssertParseTransformer";
 import { CreateAssertParseTransformer } from "./features/parsers/CreateAssertParseTransformer";
@@ -96,14 +106,21 @@ const FUNCTORS: Record<string, () => Task> = {
     validateParse: () => ValidateParseTransformer.transform,
 
     // STRINGIFY FUNCTIONS
+    application: () => ApplicationTransformer.transform,
     stringify: () => StringifyTransformer.transform,
     assertStringify: () => AssertStringifyTransformer.transform,
     isStringify: () => IsStringifyTransformer.transform,
     validateStringify: () => ValidateStringifyTransformer.transform,
 
     // MISC
-    application: () => ApplicationTransformer.transform,
     metadata: () => MetadataTransformer.transform,
+    random: () => RandomTransformer.transform,
+
+    clone: () => CloneTransformer.transform,
+    assertClone: () => AssertCloneTransformer.transform,
+    isClone: () => IsCloneTransformer.transform,
+    validateClone: () => ValidateCloneTransformer.transform,
+
     prune: () => PruneTransformer.transform,
     assertPrune: () => AssertPruneTransformer.transform,
     isPrune: () => IsPruneTransformer.transform,
@@ -135,6 +152,12 @@ const FUNCTORS: Record<string, () => Task> = {
     createValidateStringify: () => CreateValidateStringifyTransformer.transform,
 
     // MISC
+    createRandom: () => CreateRandomTransformer.transform,
+    createClone: () => CreateCloneTransformer.transform,
+    createAssertClone: () => CreateAssertCloneTransformer.transform,
+    createIsClone: () => CreateIsCloneTransformer.transform,
+    createValidateClone: () => CreateValidateCloneTransformer.transform,
+
     createPrune: () => CreatePruneTransformer.transform,
     createAssertPrune: () => CreateAssertPruneTransformer.transform,
     createIsPrune: () => CreateIsPruneTransformer.transform,

package/src/transformers/features/miscellaneous/AssertCloneTransformer.ts

@@ -0,0 +1,38 @@
+import ts from "typescript";
+
+import { AssertCloneProgrammer } from "../../../programmers/AssertCloneProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace AssertCloneTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        if (expression.arguments.length !== 1)
+            throw new Error(ErrorMessages.NO_INPUT_VALUE);
+
+        // GET TYPE INFO
+        const type: ts.Type =
+            expression.typeArguments && expression.typeArguments[0]
+                ? project.checker.getTypeFromTypeNode(
+                      expression.typeArguments[0],
+                  )
+                : project.checker.getTypeAtLocation(expression.arguments[0]!);
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+
+        // DO TRANSFORM
+        return ts.factory.createCallExpression(
+            AssertCloneProgrammer.generate(project, modulo)(type),
+            undefined,
+            [expression.arguments[0]!],
+        );
+    }
+}
+
+const enum ErrorMessages {
+    NO_INPUT_VALUE = "Error on typia.assertClone(): no input value.",
+    GENERIC_ARGUMENT = "Error on typia.assertClone(): non-specified generic argument.",
+}

package/src/transformers/features/miscellaneous/CloneTransformer.ts

@@ -0,0 +1,46 @@
+import ts from "typescript";
+
+import { CloneProgrammer } from "../../../programmers/CloneProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace CloneTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        if (expression.arguments.length !== 1)
+            throw new Error(ErrorMessages.NO_INPUT_VALUE);
+
+        const type: ts.Type =
+            expression.typeArguments && expression.typeArguments[0]
+                ? project.checker.getTypeFromTypeNode(
+                      expression.typeArguments[0],
+                  )
+                : project.checker.getTypeAtLocation(expression.arguments[0]!);
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+
+        return ts.factory.createCallExpression(
+            CloneProgrammer.generate(
+                {
+                    ...project,
+                    options: {
+                        ...project.options,
+                        functional: false,
+                        numeric: false,
+                    },
+                },
+                modulo,
+            )(type),
+            undefined,
+            [expression.arguments[0]!],
+        );
+    }
+}
+
+const enum ErrorMessages {
+    NO_INPUT_VALUE = "Error on typia.clone(): no input value.",
+    GENERIC_ARGUMENT = "Error on typia.clone(): non-specified generic argument.",
+}

package/src/transformers/features/miscellaneous/CreateAssertCloneTransformer.ts

@@ -0,0 +1,32 @@
+import ts from "typescript";
+
+import { AssertCloneProgrammer } from "../../../programmers/AssertCloneProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace CreateAssertCloneTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        // CHECK GENERIC ARGUMENT EXISTENCE
+        if (!expression.typeArguments?.[0])
+            throw new Error(ErrorMessages.NOT_SPECIFIED);
+
+        // GET TYPE INFO
+        const type: ts.Type = project.checker.getTypeFromTypeNode(
+            expression.typeArguments[0],
+        );
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+
+        // DO TRANSFORM
+        return AssertCloneProgrammer.generate(project, modulo)(type);
+    }
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.assertClone(): generic argument is not specified.",
+    GENERIC_ARGUMENT = "Error on typia.assertClone(): non-specified generic argument.",
+}

package/src/transformers/features/miscellaneous/CreateAssertPruneTransformer.ts

@@ -11,7 +11,7 @@ export namespace CreateAssertPruneTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/miscellaneous/CreateCloneTransformer.ts

@@ -0,0 +1,31 @@
+import ts from "typescript";
+
+import { CloneProgrammer } from "../../../programmers/CloneProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace CreateCloneTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        // CHECK GENERIC ARGUMENT EXISTENCE
+        if (!expression.typeArguments?.[0])
+            throw new Error(ErrorMessages.NOT_SPECIFIED);
+
+        // GET TYPE INFO
+        const type: ts.Type = project.checker.getTypeFromTypeNode(
+            expression.typeArguments[0],
+        );
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+
+        return CloneProgrammer.generate(project, modulo)(type);
+    }
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.clone(): generic argument is not specified.",
+    GENERIC_ARGUMENT = "Error on typia.clone(): non-specified generic argument.",
+}

package/src/transformers/features/miscellaneous/CreateIsCloneTransformer.ts

@@ -0,0 +1,32 @@
+import ts from "typescript";
+
+import { IsCloneProgrammer } from "../../../programmers/IsCloneProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace CreateIsCloneTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        // CHECK GENERIC ARGUMENT EXISTENCE
+        if (!expression.typeArguments?.[0])
+            throw new Error(ErrorMessages.NOT_SPECIFIED);
+
+        // GET TYPE INFO
+        const type: ts.Type = project.checker.getTypeFromTypeNode(
+            expression.typeArguments[0],
+        );
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+
+        // DO TRANSFORM
+        return IsCloneProgrammer.generate(project, modulo)(type);
+    }
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.isClone(): generic argument is not specified.",
+    GENERIC_ARGUMENT = "Error on typia.isClone(): non-specified generic argument.",
+}

package/src/transformers/features/miscellaneous/CreateIsPruneTransformer.ts

@@ -11,7 +11,7 @@ export namespace CreateIsPruneTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/miscellaneous/CreatePruneTransformer.ts

@@ -11,7 +11,7 @@ export namespace CreatePruneTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/miscellaneous/CreateRandomGenerator.ts

@@ -0,0 +1,39 @@
+import ts from "typescript";
+
+import { RandomProgrammer } from "../../../programmers/RandomProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace CreateRandomTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        if (!expression.typeArguments?.[0])
+            throw new Error(ErrorMessages.NOT_SPECIFIED);
+
+        const type: ts.Type | undefined = project.checker.getTypeFromTypeNode(
+            expression.typeArguments[0],
+        );
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.NO_GENERIC_ARGUMENT);
+
+        return RandomProgrammer.generate(
+            {
+                ...project,
+                options: {
+                    ...project.options,
+                    functional: false,
+                    numeric: false,
+                },
+            },
+            modulo,
+        )(type);
+    }
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.createRandom(): generic argument is not specified.",
+    NO_GENERIC_ARGUMENT = "Error on typia.createRandom(): non-specified generic argument.",
+}

package/src/transformers/features/miscellaneous/CreateValidateCloneTransformer.ts

@@ -0,0 +1,32 @@
+import ts from "typescript";
+
+import { ValidateCloneProgrammer } from "../../../programmers/ValidateCloneProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace CreateValidateCloneTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        // CHECK GENERIC ARGUMENT EXISTENCE
+        if (!expression.typeArguments?.[0])
+            throw new Error(ErrorMessages.NOT_SPECIFIED);
+
+        // GET TYPE INFO
+        const type: ts.Type = project.checker.getTypeFromTypeNode(
+            expression.typeArguments[0],
+        );
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+
+        // DO TRANSFORM
+        return ValidateCloneProgrammer.generate(project, modulo)(type);
+    }
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.validateClone(): generic argument is not specified.",
+    GENERIC_ARGUMENT = "Error on typia.validateClone(): non-specified generic argument.",
+}

package/src/transformers/features/miscellaneous/CreateValidatePruneTransformer.ts

@@ -11,7 +11,7 @@ export namespace CreateValidatePruneTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/miscellaneous/IsCloneTransformer.ts

@@ -0,0 +1,38 @@
+import ts from "typescript";
+
+import { IsCloneProgrammer } from "../../../programmers/IsCloneProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace IsCloneTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        if (expression.arguments.length !== 1)
+            throw new Error(ErrorMessages.NO_INPUT_VALUE);
+
+        // GET TYPE INFO
+        const type: ts.Type =
+            expression.typeArguments && expression.typeArguments[0]
+                ? project.checker.getTypeFromTypeNode(
+                      expression.typeArguments[0],
+                  )
+                : project.checker.getTypeAtLocation(expression.arguments[0]!);
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+
+        // DO TRANSFORM
+        return ts.factory.createCallExpression(
+            IsCloneProgrammer.generate(project, modulo)(type),
+            undefined,
+            [expression.arguments[0]!],
+        );
+    }
+}
+
+const enum ErrorMessages {
+    NO_INPUT_VALUE = "Error on typia.isClone(): no input value.",
+    GENERIC_ARGUMENT = "Error on typia.isClone(): non-specified generic argument.",
+}

package/src/transformers/features/miscellaneous/RandomTransformer.ts

@@ -0,0 +1,45 @@
+import ts from "typescript";
+
+import { RandomProgrammer } from "../../../programmers/RandomProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace RandomTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        if (!expression.typeArguments?.[0])
+            throw new Error(ErrorMessages.NOT_SPECIFIED);
+
+        const type: ts.Type | undefined = project.checker.getTypeFromTypeNode(
+            expression.typeArguments[0],
+        );
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.NO_GENERIC_ARGUMENT);
+
+        return ts.factory.createCallExpression(
+            RandomProgrammer.generate(
+                {
+                    ...project,
+                    options: {
+                        ...project.options,
+                        functional: false,
+                        numeric: false,
+                    },
+                },
+                modulo,
+            )(type),
+            undefined,
+            expression.arguments.length
+                ? [expression.arguments[0]!]
+                : undefined,
+        );
+    }
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.random(): generic argument is not specified.",
+    NO_GENERIC_ARGUMENT = "Error on typia.random(): non-specified generic argument.",
+}

package/src/transformers/features/miscellaneous/ValidateCloneTransformer.ts

@@ -0,0 +1,38 @@
+import ts from "typescript";
+
+import { ValidateCloneProgrammer } from "../../../programmers/ValidateCloneProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace ValidateCloneTransformer {
+    export function transform(
+        project: IProject,
+        modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        if (expression.arguments.length !== 1)
+            throw new Error(ErrorMessages.NO_INPUT_VALUE);
+
+        // GET TYPE INFO
+        const type: ts.Type =
+            expression.typeArguments && expression.typeArguments[0]
+                ? project.checker.getTypeFromTypeNode(
+                      expression.typeArguments[0],
+                  )
+                : project.checker.getTypeAtLocation(expression.arguments[0]!);
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+
+        // DO TRANSFORM
+        return ts.factory.createCallExpression(
+            ValidateCloneProgrammer.generate(project, modulo)(type),
+            undefined,
+            [expression.arguments[0]!],
+        );
+    }
+}
+
+const enum ErrorMessages {
+    NO_INPUT_VALUE = "Error on typia.validateClone(): no input value.",
+    GENERIC_ARGUMENT = "Error on typia.validateClone(): non-specified generic argument.",
+}

package/src/transformers/features/parsers/AssertParseTransformer.ts

@@ -11,7 +11,7 @@ export namespace AssertParseTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXVALIDATETENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/parsers/CreateAssertParseTransformer.ts

@@ -11,7 +11,7 @@ export namespace CreateAssertParseTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXASSERTTENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/parsers/CreateIsParseTransformer.ts

@@ -11,7 +11,7 @@ export namespace CreateIsParseTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/parsers/CreateValidateParseTransformer.ts

@@ -11,7 +11,7 @@ export namespace CreateValidateParseTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXVALIDATETENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/parsers/IsParseTransformer.ts

@@ -11,7 +11,7 @@ export namespace IsParseTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXVALIDATETENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/parsers/ValidateParseTransformer.ts

@@ -11,7 +11,7 @@ export namespace ValidateParseTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXVALIDATETENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/stringifiers/CreateAssertStringifyTransformer.ts

@@ -11,7 +11,7 @@ export namespace CreateAssertStringifyTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/stringifiers/CreateIsStringifyTransformer.ts

@@ -11,7 +11,7 @@ export namespace CreateIsStringifyTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/stringifiers/CreateStringifyTransformer.ts

@@ -11,7 +11,7 @@ export namespace CreateStringifyTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/stringifiers/CreateValidateStringifyProgrammer.ts

@@ -11,7 +11,7 @@ export namespace CreateValidateStringifyTransformer {
         expression: ts.CallExpression,
     ): ts.Expression {
         // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
+        if (!expression.typeArguments?.[0])
             throw new Error(ErrorMessages.NOT_SPECIFIED);
 
         // GET TYPE INFO

package/src/transformers/features/validators/CreateAssertTransformer.ts

@@ -18,7 +18,7 @@ export namespace CreateAssertTransformer {
             expression: ts.CallExpression,
         ): ts.Expression {
             // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments || !expression.typeArguments[0])
+            if (!expression.typeArguments?.[0])
                 throw new Error(MESSAGES.NOT_SPECIFIED);
 
             // GET TYPE INFO

package/src/transformers/features/validators/CreateIsTransformer.ts

@@ -18,7 +18,7 @@ export namespace CreateIsTransformer {
             expression: ts.CallExpression,
         ): ts.Expression {
             // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments || !expression.typeArguments[0])
+            if (!expression.typeArguments?.[0])
                 throw new Error(MESSAGES.NOT_SPECIFIED);
 
             // GET TYPE INFO

package/src/transformers/features/validators/CreateValidateTransformer.ts

@@ -18,7 +18,7 @@ export namespace CreateValidateTransformer {
             expression: ts.CallExpression,
         ): ts.Expression {
             // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments || !expression.typeArguments[0])
+            if (!expression.typeArguments?.[0])
                 throw new Error(MESSAGES.NOT_SPECIFIED);
 
             // GET TYPE INFO