typia 5.0.4 → 5.0.5-dev.20230921-2

package/src/transformers/features/RandomTransformer.ts

@@ -1,46 +1,46 @@
-import ts from "typescript";
-
-import { RandomProgrammer } from "../../programmers/RandomProgrammer";
-
-import { IProject } from "../IProject";
-import { TransformerError } from "../TransformerError";
-
-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 TransformerError({
-                    code: `typia.${modulo.getText()}`,
-                    message: "generic argument is 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 TransformerError({
-                    code: `typia.${modulo.getText()}`,
-                    message: "non-specified 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,
-            );
-        };
-}
+import ts from "typescript";
+
+import { RandomProgrammer } from "../../programmers/RandomProgrammer";
+
+import { IProject } from "../IProject";
+import { TransformerError } from "../TransformerError";
+
+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 TransformerError({
+                    code: `typia.${modulo.getText()}`,
+                    message: "generic argument is 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 TransformerError({
+                    code: `typia.${modulo.getText()}`,
+                    message: "non-specified 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,
+            );
+        };
+}

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,118 +1,118 @@
-import ts from "typescript";
-
-import { JsonMetadataFactory } from "../../../factories/JsonMetadataFactory";
-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 { ValidationPipe } from "../../../typings/ValidationPipe";
-
-import { IProject } from "../../IProject";
-import { TransformerError } from "../../TransformerError";
-
-export namespace JsonApplicationTransformer {
-    export const transform =
-        ({ checker }: IProject) =>
-        (expression: ts.CallExpression): ts.Expression => {
-            if (!expression.typeArguments?.length)
-                throw new TransformerError({
-                    code: "typia.json.application",
-                    message: "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 TransformerError({
-                    code: "typia.json.application",
-                    message: "non-specified generic argument(s).",
-                });
-
-            // 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({
-                replace: MetadataCollection.replace,
-            });
-            const results: ValidationPipe<Metadata, MetadataFactory.IError>[] =
-                types.map((type) =>
-                    MetadataFactory.analyze(checker)({
-                        escape: true,
-                        constant: true,
-                        absorb: false,
-                        validate: JsonMetadataFactory.validate,
-                    })(collection)(type),
-                );
-
-            // REPORT BUG IF REQUIRED
-            const metadatas: Metadata[] = [];
-            const errors: MetadataFactory.IError[] = [];
-            for (const r of results) {
-                if (r.success === false) errors.push(...r.errors);
-                else metadatas.push(r.data);
-            }
-            if (errors.length)
-                throw TransformerError.from("typia.json.application")(errors);
-
-            // 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 TransformerError({
-                code: "typia.json.application",
-                message: `generic argument "${name}" must be constant.`,
-            });
-
-        // GET VALUE AND VALIDATE IT
-        const value = type.value;
-        if (typeof value !== "string" || predicator(value) === false)
-            throw new TransformerError({
-                code: "typia.json.application",
-                message: `invalid value on generic argument "${name}".`,
-            });
-        return value as T;
-    };
-}
+import ts from "typescript";
+
+import { JsonMetadataFactory } from "../../../factories/JsonMetadataFactory";
+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 { ValidationPipe } from "../../../typings/ValidationPipe";
+
+import { IProject } from "../../IProject";
+import { TransformerError } from "../../TransformerError";
+
+export namespace JsonApplicationTransformer {
+    export const transform =
+        ({ checker }: IProject) =>
+        (expression: ts.CallExpression): ts.Expression => {
+            if (!expression.typeArguments?.length)
+                throw new TransformerError({
+                    code: "typia.json.application",
+                    message: "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 TransformerError({
+                    code: "typia.json.application",
+                    message: "non-specified generic argument(s).",
+                });
+
+            // 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({
+                replace: MetadataCollection.replace,
+            });
+            const results: ValidationPipe<Metadata, MetadataFactory.IError>[] =
+                types.map((type) =>
+                    MetadataFactory.analyze(checker)({
+                        escape: true,
+                        constant: true,
+                        absorb: false,
+                        validate: JsonMetadataFactory.validate,
+                    })(collection)(type),
+                );
+
+            // REPORT BUG IF REQUIRED
+            const metadatas: Metadata[] = [];
+            const errors: MetadataFactory.IError[] = [];
+            for (const r of results) {
+                if (r.success === false) errors.push(...r.errors);
+                else metadatas.push(r.data);
+            }
+            if (errors.length)
+                throw TransformerError.from("typia.json.application")(errors);
+
+            // 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 TransformerError({
+                code: "typia.json.application",
+                message: `generic argument "${name}" must be constant.`,
+            });
+
+        // GET VALUE AND VALIDATE IT
+        const value = type.value;
+        if (typeof value !== "string" || predicator(value) === false)
+            throw new TransformerError({
+                code: "typia.json.application",
+                message: `invalid value on generic argument "${name}".`,
+            });
+        return value as T;
+    };
+}

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),
+    );
+}

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

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