typia 5.0.0-dev.20230730 → 5.0.0-dev.20230805

package/src/transformers/features/CreateValidateTransformer.ts

@@ -1,13 +1,13 @@
-import { ValidateProgrammer } from "../../programmers/ValidateProgrammer";
-
-import { GenericTransformer } from "../internal/GenericTransformer";
-
-export namespace CreateValidateTransformer {
-    export const transform = (equals: boolean) =>
-        GenericTransformer.factory(
-            equals ? "createValidateEquals" : "createValidate",
-        )(
-            (project) => (modulo) =>
-                ValidateProgrammer.write(project)(modulo)(equals),
-        );
-}
+import { ValidateProgrammer } from "../../programmers/ValidateProgrammer";
+
+import { GenericTransformer } from "../internal/GenericTransformer";
+
+export namespace CreateValidateTransformer {
+    export const transform = (equals: boolean) =>
+        GenericTransformer.factory(
+            equals ? "createValidateEquals" : "createValidate",
+        )(
+            (project) => (modulo) =>
+                ValidateProgrammer.write(project)(modulo)(equals),
+        );
+}

package/src/transformers/features/IsTransformer.ts

@@ -1,11 +1,11 @@
-import { IsProgrammer } from "../../programmers/IsProgrammer";
-
-import { GenericTransformer } from "../internal/GenericTransformer";
-
-export namespace IsTransformer {
-    export const transform = (equals: boolean) =>
-        GenericTransformer.scalar(equals ? "equals" : "is")(
-            (project) => (modulo) =>
-                IsProgrammer.write(project)(modulo)(equals),
-        );
-}
+import { IsProgrammer } from "../../programmers/IsProgrammer";
+
+import { GenericTransformer } from "../internal/GenericTransformer";
+
+export namespace IsTransformer {
+    export const transform = (equals: boolean) =>
+        GenericTransformer.scalar(equals ? "equals" : "is")(
+            (project) => (modulo) =>
+                IsProgrammer.write(project)(modulo)(equals),
+        );
+}

package/src/transformers/features/RandomTransformer.ts

@@ -1,42 +1,42 @@
-import ts from "typescript";
-
-import { RandomProgrammer } from "../../programmers/RandomProgrammer";
-
-import { IProject } from "../IProject";
-
-export namespace RandomTransformer {
-    export const transform =
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (expression: ts.CallExpression): ts.Expression => {
-            // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments?.[0]) throw new Error(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(NO_GENERIC_ARGUMENT);
-
-            // DO TRANSFORM
-            return ts.factory.createCallExpression(
-                RandomProgrammer.write({
-                    ...project,
-                    options: {
-                        ...project.options,
-                        functional: false,
-                        numeric: false,
-                    },
-                })(modulo)()(type, node.getFullText().trim()),
-                undefined,
-                expression.arguments.length
-                    ? [expression.arguments[0]!]
-                    : undefined,
-            );
-        };
-}
-
-const NOT_SPECIFIED =
-    "Error on typia.random(): generic argument is not specified.";
-const 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 const transform =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (expression: ts.CallExpression): ts.Expression => {
+            // CHECK GENERIC ARGUMENT EXISTENCE
+            if (!expression.typeArguments?.[0]) throw new Error(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(NO_GENERIC_ARGUMENT);
+
+            // DO TRANSFORM
+            return ts.factory.createCallExpression(
+                RandomProgrammer.write({
+                    ...project,
+                    options: {
+                        ...project.options,
+                        functional: false,
+                        numeric: false,
+                    },
+                })(modulo)()(type, node.getFullText().trim()),
+                undefined,
+                expression.arguments.length
+                    ? [expression.arguments[0]!]
+                    : undefined,
+            );
+        };
+}
+
+const NOT_SPECIFIED =
+    "Error on typia.random(): generic argument is not specified.";
+const NO_GENERIC_ARGUMENT =
+    "Error on typia.random(): non-specified generic argument.";

package/src/transformers/features/ValidateTransformer.ts

@@ -1,11 +1,11 @@
-import { ValidateProgrammer } from "../../programmers/ValidateProgrammer";
-
-import { GenericTransformer } from "../internal/GenericTransformer";
-
-export namespace ValidateTransformer {
-    export const transform = (equals: boolean) =>
-        GenericTransformer.scalar(equals ? "validateEquals" : "validate")(
-            (project) => (modulo) =>
-                ValidateProgrammer.write(project)(modulo)(equals),
-        );
-}
+import { ValidateProgrammer } from "../../programmers/ValidateProgrammer";
+
+import { GenericTransformer } from "../internal/GenericTransformer";
+
+export namespace ValidateTransformer {
+    export const transform = (equals: boolean) =>
+        GenericTransformer.scalar(equals ? "validateEquals" : "validate")(
+            (project) => (modulo) =>
+                ValidateProgrammer.write(project)(modulo)(equals),
+        );
+}

package/src/transformers/features/json/JsonApplicationTransformer.ts

@@ -1,102 +1,102 @@
-import ts from "typescript";
-
-import { LiteralFactory } from "../../../factories/LiteralFactory";
-import { MetadataCollection } from "../../../factories/MetadataCollection";
-import { MetadataFactory } from "../../../factories/MetadataFactory";
-
-import { IJsonApplication } from "../../../schemas/json/IJsonApplication";
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { JsonApplicationProgrammer } from "../../../programmers/json/JsonApplicationProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace JsonApplicationTransformer {
-    export const transform =
-        ({ checker }: IProject) =>
-        (expression: ts.CallExpression): ts.Expression => {
-            if (!expression.typeArguments?.length)
-                throw new Error(NO_GENERIC_ARGUMENT);
-
-            //----
-            // GET ARGUMENTS
-            //----
-            // 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(GENERIC_ARGUMENT);
-
-            // ADDITIONAL PARAMETERS
-            const purpose: "swagger" | "ajv" = get_parameter(
-                checker,
-                "Purpose",
-                expression.typeArguments[1],
-                (str) => str === "swagger" || str === "ajv",
-                () => "swagger",
-            );
-
-            //----
-            // GENERATORS
-            //----
-            // METADATA
-            const collection: MetadataCollection = new MetadataCollection();
-            const metadatas: Array<Metadata> = types.map((type) =>
-                MetadataFactory.analyze(checker)({
-                    resolve: true,
-                    constant: true,
-                    absorb: false,
-                    validate: (meta) => {
-                        if (meta.atomics.find((str) => str === "bigint"))
-                            throw new Error(NO_BIGIT);
-                    },
-                })(collection)(type),
-            );
-
-            // APPLICATION
-            const app: IJsonApplication = JsonApplicationProgrammer.write({
-                purpose,
-            })(metadatas);
-
-            // RETURNS WITH LITERAL EXPRESSION
-            return LiteralFactory.generate(app);
-        };
-
-    const get_parameter = <T extends string>(
-        checker: ts.TypeChecker,
-        name: string,
-        node: ts.TypeNode | undefined,
-        predicator: (value: string) => boolean,
-        defaulter: () => T,
-    ): T => {
-        if (!node) return defaulter();
-
-        // CHECK LITERAL TYPE
-        const type: ts.Type = checker.getTypeFromTypeNode(node);
-        if (!type.isLiteral())
-            throw new Error(
-                `Error on typia.application(): generic argument "${name}" must be constant.`,
-            );
-
-        // GET VALUE AND VALIDATE IT
-        const value = type.value;
-        if (typeof value !== "string" || predicator(value) === false)
-            throw new Error(
-                `Error on typia.application(): invalid value on generic argument "${name}".`,
-            );
-        return value as T;
-    };
-}
-
-const NO_GENERIC_ARGUMENT =
-    "Error on typia.application(): no generic argument.";
-const GENERIC_ARGUMENT =
-    "Error on typia.application(): non-specified generic argument(s).";
-const NO_BIGIT = "Error on typia.application(): does not allow bigint type.";
+import ts from "typescript";
+
+import { LiteralFactory } from "../../../factories/LiteralFactory";
+import { MetadataCollection } from "../../../factories/MetadataCollection";
+import { MetadataFactory } from "../../../factories/MetadataFactory";
+
+import { IJsonApplication } from "../../../schemas/json/IJsonApplication";
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { JsonApplicationProgrammer } from "../../../programmers/json/JsonApplicationProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace JsonApplicationTransformer {
+    export const transform =
+        ({ checker }: IProject) =>
+        (expression: ts.CallExpression): ts.Expression => {
+            if (!expression.typeArguments?.length)
+                throw new Error(NO_GENERIC_ARGUMENT);
+
+            //----
+            // GET ARGUMENTS
+            //----
+            // 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(GENERIC_ARGUMENT);
+
+            // ADDITIONAL PARAMETERS
+            const purpose: "swagger" | "ajv" = get_parameter(
+                checker,
+                "Purpose",
+                expression.typeArguments[1],
+                (str) => str === "swagger" || str === "ajv",
+                () => "swagger",
+            );
+
+            //----
+            // GENERATORS
+            //----
+            // METADATA
+            const collection: MetadataCollection = new MetadataCollection();
+            const metadatas: Array<Metadata> = types.map((type) =>
+                MetadataFactory.analyze(checker)({
+                    resolve: true,
+                    constant: true,
+                    absorb: false,
+                    validate: (meta) => {
+                        if (meta.atomics.find((str) => str === "bigint"))
+                            throw new Error(NO_BIGIT);
+                    },
+                })(collection)(type),
+            );
+
+            // APPLICATION
+            const app: IJsonApplication = JsonApplicationProgrammer.write({
+                purpose,
+            })(metadatas);
+
+            // RETURNS WITH LITERAL EXPRESSION
+            return LiteralFactory.generate(app);
+        };
+
+    const get_parameter = <T extends string>(
+        checker: ts.TypeChecker,
+        name: string,
+        node: ts.TypeNode | undefined,
+        predicator: (value: string) => boolean,
+        defaulter: () => T,
+    ): T => {
+        if (!node) return defaulter();
+
+        // CHECK LITERAL TYPE
+        const type: ts.Type = checker.getTypeFromTypeNode(node);
+        if (!type.isLiteral())
+            throw new Error(
+                `Error on typia.application(): generic argument "${name}" must be constant.`,
+            );
+
+        // GET VALUE AND VALIDATE IT
+        const value = type.value;
+        if (typeof value !== "string" || predicator(value) === false)
+            throw new Error(
+                `Error on typia.application(): invalid value on generic argument "${name}".`,
+            );
+        return value as T;
+    };
+}
+
+const NO_GENERIC_ARGUMENT =
+    "Error on typia.application(): no generic argument.";
+const GENERIC_ARGUMENT =
+    "Error on typia.application(): non-specified generic argument(s).";
+const NO_BIGIT = "Error on typia.application(): does not allow bigint type.";

package/src/transformers/features/json/JsonAssertParseTransformer.ts

@@ -1,10 +1,10 @@
-import { JsonAssertParseProgrammer } from "../../../programmers/json/JsonAssertParseProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace JsonAssertParseTransformer {
-    export const transform = GenericTransformer.scalar("assertParse")(
-        (project) => (modulo) =>
-            JsonAssertParseProgrammer.write(project)(modulo),
-    );
-}
+import { JsonAssertParseProgrammer } from "../../../programmers/json/JsonAssertParseProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace JsonAssertParseTransformer {
+    export const transform = GenericTransformer.scalar("assertParse")(
+        (project) => (modulo) =>
+            JsonAssertParseProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/json/JsonAssertStringifyTransformer.ts

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

package/src/transformers/features/json/JsonCreateAssertParseTransformer.ts

@@ -1,10 +1,10 @@
-import { JsonAssertParseProgrammer } from "../../../programmers/json/JsonAssertParseProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace JsonCreateAssertParseTransformer {
-    export const transform = GenericTransformer.factory("createAssertParse")(
-        (project) => (modulo) =>
-            JsonAssertParseProgrammer.write(project)(modulo),
-    );
-}
+import { JsonAssertParseProgrammer } from "../../../programmers/json/JsonAssertParseProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace JsonCreateAssertParseTransformer {
+    export const transform = GenericTransformer.factory("createAssertParse")(
+        (project) => (modulo) =>
+            JsonAssertParseProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/json/JsonCreateAssertStringifyTransformer.ts

@@ -1,12 +1,12 @@
-import { JsonAssertStringifyProgrammer } from "../../../programmers/json/JsonAssertStringifyProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace JsonCreateAssertStringifyTransformer {
-    export const transform = GenericTransformer.factory(
-        "createAssertStringify",
-    )(
-        (project) => (modulo) =>
-            JsonAssertStringifyProgrammer.write(project)(modulo),
-    );
-}
+import { JsonAssertStringifyProgrammer } from "../../../programmers/json/JsonAssertStringifyProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace JsonCreateAssertStringifyTransformer {
+    export const transform = GenericTransformer.factory(
+        "createAssertStringify",
+    )(
+        (project) => (modulo) =>
+            JsonAssertStringifyProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/json/JsonCreateIsParseTransformer.ts

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

package/src/transformers/features/json/JsonCreateIsStringifyTransformer.ts

@@ -1,10 +1,10 @@
-import { JsonIsStringifyProgrammer } from "../../../programmers/json/JsonIsStringifyProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace JsonCreateIsStringifyTransformer {
-    export const transform = GenericTransformer.factory("createIsStringify")(
-        (project) => (modulo) =>
-            JsonIsStringifyProgrammer.write(project)(modulo),
-    );
-}
+import { JsonIsStringifyProgrammer } from "../../../programmers/json/JsonIsStringifyProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace JsonCreateIsStringifyTransformer {
+    export const transform = GenericTransformer.factory("createIsStringify")(
+        (project) => (modulo) =>
+            JsonIsStringifyProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/json/JsonCreateStringifyTransformer.ts

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

package/src/transformers/features/json/JsonCreateValidateParseTransformer.ts

@@ -1,10 +1,10 @@
-import { JsonValidateParseProgrammer } from "../../../programmers/json/JsonValidateParseProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace JsonCreateValidateParseTransformer {
-    export const transform = GenericTransformer.factory("createValidateParse")(
-        (project) => (modulo) =>
-            JsonValidateParseProgrammer.write(project)(modulo),
-    );
-}
+import { JsonValidateParseProgrammer } from "../../../programmers/json/JsonValidateParseProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace JsonCreateValidateParseTransformer {
+    export const transform = GenericTransformer.factory("createValidateParse")(
+        (project) => (modulo) =>
+            JsonValidateParseProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/json/JsonCreateValidateStringifyProgrammer.ts

@@ -1,12 +1,12 @@
-import { JsonValidateStringifyProgrammer } from "../../../programmers/json/JsonValidateStringifyProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace JsonCreateValidateStringifyTransformer {
-    export const transform = GenericTransformer.factory(
-        "createValidateStringify",
-    )(
-        (project) => (modulo) =>
-            JsonValidateStringifyProgrammer.write(project)(modulo),
-    );
-}
+import { JsonValidateStringifyProgrammer } from "../../../programmers/json/JsonValidateStringifyProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace JsonCreateValidateStringifyTransformer {
+    export const transform = GenericTransformer.factory(
+        "createValidateStringify",
+    )(
+        (project) => (modulo) =>
+            JsonValidateStringifyProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/json/JsonIsParseTransformer.ts

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

package/src/transformers/features/json/JsonIsStringifyTransformer.ts

@@ -1,10 +1,10 @@
-import { JsonIsStringifyProgrammer } from "../../../programmers/json/JsonIsStringifyProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace JsonIsStringifyTransformer {
-    export const transform = GenericTransformer.scalar("isStringify")(
-        (project) => (modulo) =>
-            JsonIsStringifyProgrammer.write(project)(modulo),
-    );
-}
+import { JsonIsStringifyProgrammer } from "../../../programmers/json/JsonIsStringifyProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace JsonIsStringifyTransformer {
+    export const transform = GenericTransformer.scalar("isStringify")(
+        (project) => (modulo) =>
+            JsonIsStringifyProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/json/JsonStringifyTransformer.ts

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