typia 3.6.10 → 3.7.0-dev.20230331

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

@@ -1,55 +1,55 @@
-import ts from "typescript";
-
-import { LiteralFactory } from "../../../factories/LiteralFactory";
-import { MetadataCollection } from "../../../factories/MetadataCollection";
-import { MetadataFactory } from "../../../factories/MetadataFactory";
-
-import { IMetadataApplication } from "../../../metadata/IMetadataApplication";
-import { Metadata } from "../../../metadata/Metadata";
-
-import { IProject } from "../../IProject";
-
-export namespace MetadataTransformer {
-    export function transform(
-        { checker }: IProject,
-        _modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        if (!expression.typeArguments?.length)
-            throw new Error(ErrorMessages.NO_GENERIC_ARGUMENT);
-
-        // VALIDATE TUPLE ARGUMENTS
-        const top: ts.Node = expression.typeArguments[0]!;
-        if (!ts.isTupleTypeNode(top)) return expression;
-        else if (top.elements.some((child) => !ts.isTypeNode(child)))
-            return expression;
-
-        // GET TYPES
-        const types: ts.Type[] = top.elements.map((child) =>
-            checker.getTypeFromTypeNode(child as ts.TypeNode),
-        );
-        if (types.some((t) => t.isTypeParameter()))
-            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
-
-        // METADATA
-        const collection: MetadataCollection = new MetadataCollection();
-        const metadatas: Array<Metadata> = types.map((type) =>
-            MetadataFactory.generate(checker, collection, type, {
-                resolve: false,
-                constant: true,
-            }),
-        );
-
-        // CONVERT TO PRIMITIVE TYPE
-        const app: IMetadataApplication = {
-            metadatas: metadatas.map((metadata) => metadata.toJSON()),
-            collection: collection.objects().map((obj) => obj.toJSON()),
-        };
-        return LiteralFactory.generate(app);
-    }
-}
-
-const enum ErrorMessages {
-    NO_GENERIC_ARGUMENT = "Error on typia.metadata(): no generic argument.",
-    GENERIC_ARGUMENT = "Error on typia.metadata(): non-specified generic argument(s).",
-}
+import ts from "typescript";
+
+import { LiteralFactory } from "../../../factories/LiteralFactory";
+import { MetadataCollection } from "../../../factories/MetadataCollection";
+import { MetadataFactory } from "../../../factories/MetadataFactory";
+
+import { IMetadataApplication } from "../../../metadata/IMetadataApplication";
+import { Metadata } from "../../../metadata/Metadata";
+
+import { IProject } from "../../IProject";
+
+export namespace MetadataTransformer {
+    export function transform(
+        { checker }: IProject,
+        _modulo: ts.LeftHandSideExpression,
+        expression: ts.CallExpression,
+    ): ts.Expression {
+        if (!expression.typeArguments?.length)
+            throw new Error(ErrorMessages.NO_GENERIC_ARGUMENT);
+
+        // VALIDATE TUPLE ARGUMENTS
+        const top: ts.Node = expression.typeArguments[0]!;
+        if (!ts.isTupleTypeNode(top)) return expression;
+        else if (top.elements.some((child) => !ts.isTypeNode(child)))
+            return expression;
+
+        // GET TYPES
+        const types: ts.Type[] = top.elements.map((child) =>
+            checker.getTypeFromTypeNode(child as ts.TypeNode),
+        );
+        if (types.some((t) => t.isTypeParameter()))
+            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
+
+        // METADATA
+        const collection: MetadataCollection = new MetadataCollection();
+        const metadatas: Array<Metadata> = types.map((type) =>
+            MetadataFactory.generate(checker, collection, type, {
+                resolve: false,
+                constant: true,
+            }),
+        );
+
+        // CONVERT TO PRIMITIVE TYPE
+        const app: IMetadataApplication = {
+            metadatas: metadatas.map((metadata) => metadata.toJSON()),
+            collection: collection.objects().map((obj) => obj.toJSON()),
+        };
+        return LiteralFactory.generate(app);
+    }
+}
+
+const enum ErrorMessages {
+    NO_GENERIC_ARGUMENT = "Error on typia.metadata(): no generic argument.",
+    GENERIC_ARGUMENT = "Error on typia.metadata(): non-specified generic argument(s).",
+}

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

@@ -1,9 +1,9 @@
-import { PruneProgrammer } from "../../../programmers/PruneProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace PruneTransformer {
-    export const transform = GenericTransformer.scalar("prune")(
-        (project, modulo) => PruneProgrammer.generate(project, modulo),
-    );
-}
+import { PruneProgrammer } from "../../../programmers/PruneProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace PruneTransformer {
+    export const transform = GenericTransformer.scalar("prune")(
+        (project, modulo) => PruneProgrammer.generate(project, modulo),
+    );
+}

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

@@ -1,48 +1,48 @@
-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 {
-        // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments?.[0])
-            throw new Error(ErrorMessages.NOT_SPECIFIED);
-
-        // GET TYPE INFO
-        const node: ts.TypeNode = expression.typeArguments[0];
-        const type: ts.Type = project.checker.getTypeFromTypeNode(node);
-
-        if (type.isTypeParameter())
-            throw new Error(ErrorMessages.NO_GENERIC_ARGUMENT);
-
-        // DO TRANSFORM
-        return ts.factory.createCallExpression(
-            RandomProgrammer.generate(
-                {
-                    ...project,
-                    options: {
-                        ...project.options,
-                        functional: false,
-                        numeric: false,
-                    },
-                },
-                modulo,
-            )(type, node.getFullText().trim()),
-            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.",
-}
+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 {
+        // CHECK GENERIC ARGUMENT EXISTENCE
+        if (!expression.typeArguments?.[0])
+            throw new Error(ErrorMessages.NOT_SPECIFIED);
+
+        // GET TYPE INFO
+        const node: ts.TypeNode = expression.typeArguments[0];
+        const type: ts.Type = project.checker.getTypeFromTypeNode(node);
+
+        if (type.isTypeParameter())
+            throw new Error(ErrorMessages.NO_GENERIC_ARGUMENT);
+
+        // DO TRANSFORM
+        return ts.factory.createCallExpression(
+            RandomProgrammer.generate(
+                {
+                    ...project,
+                    options: {
+                        ...project.options,
+                        functional: false,
+                        numeric: false,
+                    },
+                },
+                modulo,
+            )(type, node.getFullText().trim()),
+            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

@@ -1,9 +1,9 @@
-import { ValidateCloneProgrammer } from "../../../programmers/ValidateCloneProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace ValidateCloneTransformer {
-    export const transform = GenericTransformer.scalar("validatClone")(
-        (project, modulo) => ValidateCloneProgrammer.generate(project, modulo),
-    );
-}
+import { ValidateCloneProgrammer } from "../../../programmers/ValidateCloneProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace ValidateCloneTransformer {
+    export const transform = GenericTransformer.scalar("validatClone")(
+        (project, modulo) => ValidateCloneProgrammer.generate(project, modulo),
+    );
+}

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

@@ -1,9 +1,9 @@
-import { ValidatePruneProgrammer } from "../../../programmers/ValidatePruneProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace ValidatePruneTransformer {
-    export const transform = GenericTransformer.scalar("validatPrune")(
-        (project, modulo) => ValidatePruneProgrammer.generate(project, modulo),
-    );
-}
+import { ValidatePruneProgrammer } from "../../../programmers/ValidatePruneProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace ValidatePruneTransformer {
+    export const transform = GenericTransformer.scalar("validatPrune")(
+        (project, modulo) => ValidatePruneProgrammer.generate(project, modulo),
+    );
+}

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

@@ -1,9 +1,9 @@
-import { AssertParseProgrammer } from "../../../programmers/AssertParseProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace AssertParseTransformer {
-    export const transform = GenericTransformer.scalar("assertParse")(
-        (project, modulo) => AssertParseProgrammer.generate(project, modulo),
-    );
-}
+import { AssertParseProgrammer } from "../../../programmers/AssertParseProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace AssertParseTransformer {
+    export const transform = GenericTransformer.scalar("assertParse")(
+        (project, modulo) => AssertParseProgrammer.generate(project, modulo),
+    );
+}

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

@@ -1,9 +1,9 @@
-import { AssertParseProgrammer } from "../../../programmers/AssertParseProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateAssertParseTransformer {
-    export const transform = GenericTransformer.factory("createAssertParse")(
-        (project, modulo) => AssertParseProgrammer.generate(project, modulo),
-    );
-}
+import { AssertParseProgrammer } from "../../../programmers/AssertParseProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateAssertParseTransformer {
+    export const transform = GenericTransformer.factory("createAssertParse")(
+        (project, modulo) => AssertParseProgrammer.generate(project, modulo),
+    );
+}

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

@@ -1,9 +1,9 @@
-import { IsParseProgrammer } from "../../../programmers/IsParseProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateIsParseTransformer {
-    export const transform = GenericTransformer.factory("createIsParse")(
-        (project, modulo) => IsParseProgrammer.generate(project, modulo),
-    );
-}
+import { IsParseProgrammer } from "../../../programmers/IsParseProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateIsParseTransformer {
+    export const transform = GenericTransformer.factory("createIsParse")(
+        (project, modulo) => IsParseProgrammer.generate(project, modulo),
+    );
+}

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

@@ -1,9 +1,9 @@
-import { ValidateParseProgrammer } from "../../../programmers/ValidateParseProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateValidateParseTransformer {
-    export const transform = GenericTransformer.factory("createValidateParse")(
-        (project, modulo) => ValidateParseProgrammer.generate(project, modulo),
-    );
-}
+import { ValidateParseProgrammer } from "../../../programmers/ValidateParseProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateValidateParseTransformer {
+    export const transform = GenericTransformer.factory("createValidateParse")(
+        (project, modulo) => ValidateParseProgrammer.generate(project, modulo),
+    );
+}

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

@@ -1,9 +1,9 @@
-import { IsParseProgrammer } from "../../../programmers/IsParseProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace IsParseTransformer {
-    export const transform = GenericTransformer.scalar("isParse")(
-        (project, modulo) => IsParseProgrammer.generate(project, modulo),
-    );
-}
+import { IsParseProgrammer } from "../../../programmers/IsParseProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace IsParseTransformer {
+    export const transform = GenericTransformer.scalar("isParse")(
+        (project, modulo) => IsParseProgrammer.generate(project, modulo),
+    );
+}

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

@@ -1,9 +1,9 @@
-import { ValidateParseProgrammer } from "../../../programmers/ValidateParseProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace ValidateParseTransformer {
-    export const transform = GenericTransformer.scalar("validatParse")(
-        (project, modulo) => ValidateParseProgrammer.generate(project, modulo),
-    );
-}
+import { ValidateParseProgrammer } from "../../../programmers/ValidateParseProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace ValidateParseTransformer {
+    export const transform = GenericTransformer.scalar("validatParse")(
+        (project, modulo) => ValidateParseProgrammer.generate(project, modulo),
+    );
+}

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

@@ -1,10 +1,10 @@
-import { AssertStringifyProgrammer } from "../../../programmers/AssertStringifyProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace AssertStringifyTransformer {
-    export const transform = GenericTransformer.scalar("assertStringify")(
-        (project, modulo) =>
-            AssertStringifyProgrammer.generate(project, modulo),
-    );
-}
+import { AssertStringifyProgrammer } from "../../../programmers/AssertStringifyProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace AssertStringifyTransformer {
+    export const transform = GenericTransformer.scalar("assertStringify")(
+        (project, modulo) =>
+            AssertStringifyProgrammer.generate(project, modulo),
+    );
+}

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

@@ -1,9 +1,9 @@
-import { AssertStringifyProgrammer } from "../../../programmers/AssertStringifyProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateAssertStringifyTransformer {
-    export const transform = GenericTransformer.factory(
-        "createAssertStringify",
-    )((project, modulo) => AssertStringifyProgrammer.generate(project, modulo));
-}
+import { AssertStringifyProgrammer } from "../../../programmers/AssertStringifyProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateAssertStringifyTransformer {
+    export const transform = GenericTransformer.factory(
+        "createAssertStringify",
+    )((project, modulo) => AssertStringifyProgrammer.generate(project, modulo));
+}

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

@@ -1,9 +1,9 @@
-import { IsStringifyProgrammer } from "../../../programmers/IsStringifyProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateIsStringifyTransformer {
-    export const transform = GenericTransformer.factory("createIsStringify")(
-        (project, modulo) => IsStringifyProgrammer.generate(project, modulo),
-    );
-}
+import { IsStringifyProgrammer } from "../../../programmers/IsStringifyProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateIsStringifyTransformer {
+    export const transform = GenericTransformer.factory("createIsStringify")(
+        (project, modulo) => IsStringifyProgrammer.generate(project, modulo),
+    );
+}

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

@@ -1,9 +1,9 @@
-import { StringifyProgrammer } from "../../../programmers/StringifyProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateStringifyTransformer {
-    export const transform = GenericTransformer.factory("createStringify")(
-        (project, modulo) => StringifyProgrammer.generate(project, modulo),
-    );
-}
+import { StringifyProgrammer } from "../../../programmers/StringifyProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateStringifyTransformer {
+    export const transform = GenericTransformer.factory("createStringify")(
+        (project, modulo) => StringifyProgrammer.generate(project, modulo),
+    );
+}

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

@@ -1,11 +1,11 @@
-import { ValidateStringifyProgrammer } from "../../../programmers/ValidateStringifyProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateValidateStringifyTransformer {
-    export const transform = GenericTransformer.factory(
-        "createValidateStringify",
-    )((project, modulo) =>
-        ValidateStringifyProgrammer.generate(project, modulo),
-    );
-}
+import { ValidateStringifyProgrammer } from "../../../programmers/ValidateStringifyProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateValidateStringifyTransformer {
+    export const transform = GenericTransformer.factory(
+        "createValidateStringify",
+    )((project, modulo) =>
+        ValidateStringifyProgrammer.generate(project, modulo),
+    );
+}

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

@@ -1,9 +1,9 @@
-import { IsStringifyProgrammer } from "../../../programmers/IsStringifyProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace IsStringifyTransformer {
-    export const transform = GenericTransformer.scalar("isStringify")(
-        (project, modulo) => IsStringifyProgrammer.generate(project, modulo),
-    );
-}
+import { IsStringifyProgrammer } from "../../../programmers/IsStringifyProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace IsStringifyTransformer {
+    export const transform = GenericTransformer.scalar("isStringify")(
+        (project, modulo) => IsStringifyProgrammer.generate(project, modulo),
+    );
+}

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

@@ -1,9 +1,9 @@
-import { StringifyProgrammer } from "../../../programmers/StringifyProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace StringifyTransformer {
-    export const transform = GenericTransformer.scalar("stringify")(
-        (project, modulo) => StringifyProgrammer.generate(project, modulo),
-    );
-}
+import { StringifyProgrammer } from "../../../programmers/StringifyProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace StringifyTransformer {
+    export const transform = GenericTransformer.scalar("stringify")(
+        (project, modulo) => StringifyProgrammer.generate(project, modulo),
+    );
+}

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

@@ -1,10 +1,10 @@
-import { ValidateStringifyProgrammer } from "../../../programmers/ValidateStringifyProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace ValidateStringifyTransformer {
-    export const transform = GenericTransformer.scalar("validatStringify")(
-        (project, modulo) =>
-            ValidateStringifyProgrammer.generate(project, modulo),
-    );
-}
+import { ValidateStringifyProgrammer } from "../../../programmers/ValidateStringifyProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace ValidateStringifyTransformer {
+    export const transform = GenericTransformer.scalar("validatStringify")(
+        (project, modulo) =>
+            ValidateStringifyProgrammer.generate(project, modulo),
+    );
+}

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

@@ -1,11 +1,11 @@
-import { AssertProgrammer } from "../../../programmers/AssertProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace AssertTransformer {
-    export const transform = (equals: boolean) =>
-        GenericTransformer.scalar(equals ? "assertEquals" : "assert")(
-            (project, modulo) =>
-                AssertProgrammer.generate(project, modulo, equals),
-        );
-}
+import { AssertProgrammer } from "../../../programmers/AssertProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace AssertTransformer {
+    export const transform = (equals: boolean) =>
+        GenericTransformer.scalar(equals ? "assertEquals" : "assert")(
+            (project, modulo) =>
+                AssertProgrammer.generate(project, modulo, equals),
+        );
+}

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

@@ -1,12 +1,12 @@
-import { AssertProgrammer } from "../../../programmers/AssertProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateAssertTransformer {
-    export const transform = (equals: boolean) =>
-        GenericTransformer.factory(
-            equals ? "createAssertEquals" : "createAssert",
-        )((project, modulo) =>
-            AssertProgrammer.generate(project, modulo, equals),
-        );
-}
+import { AssertProgrammer } from "../../../programmers/AssertProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateAssertTransformer {
+    export const transform = (equals: boolean) =>
+        GenericTransformer.factory(
+            equals ? "createAssertEquals" : "createAssert",
+        )((project, modulo) =>
+            AssertProgrammer.generate(project, modulo, equals),
+        );
+}

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

@@ -1,10 +1,10 @@
-import { IsProgrammer } from "../../../programmers/IsProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateIsTransformer {
-    export const transform = (equals: boolean) =>
-        GenericTransformer.factory(equals ? "createEquals" : "createIs")(
-            (project, modulo) => IsProgrammer.generate(project, modulo, equals),
-        );
-}
+import { IsProgrammer } from "../../../programmers/IsProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateIsTransformer {
+    export const transform = (equals: boolean) =>
+        GenericTransformer.factory(equals ? "createEquals" : "createIs")(
+            (project, modulo) => IsProgrammer.generate(project, modulo, equals),
+        );
+}