typia 5.0.0-dev.20230711 → 5.0.0-dev.20230713

package/src/transformers/features/{stringifiers → json}/StringifyTransformer.ts

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

package/src/transformers/features/{parsers → json}/ValidateParseTransformer.ts

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

package/src/transformers/features/{stringifiers → json}/ValidateStringifyTransformer.ts

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

package/src/transformers/features/{miscellaneous → misc}/ApplicationTransformer.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 { Metadata } from "../../../metadata/Metadata";
-import { IJsonApplication } from "../../../schemas/IJsonApplication";
-
-import { ApplicationProgrammer } from "../../../programmers/ApplicationProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace ApplicationTransformer {
-    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 = ApplicationProgrammer.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 { Metadata } from "../../../metadata/Metadata";
+import { IJsonApplication } from "../../../schemas/IJsonApplication";
+
+import { JsonApplicationProgrammer } from "../../../programmers/json/JsonApplicationProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace ApplicationTransformer {
+    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/{miscellaneous → misc}/AssertCloneTransformer.ts

@@ -1,9 +1,10 @@
-import { AssertCloneProgrammer } from "../../../programmers/AssertCloneProgrammer";
+import { MiscAssertCloneProgrammer } from "../../../programmers/misc/MiscAssertCloneProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace AssertCloneTransformer {
     export const transform = GenericTransformer.scalar("assertClone")(
-        (project) => (modulo) => AssertCloneProgrammer.write(project)(modulo),
+        (project) => (modulo) =>
+            MiscAssertCloneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/{miscellaneous → misc}/AssertPruneTransformer.ts

@@ -1,9 +1,10 @@
-import { AssertPruneProgrammer } from "../../../programmers/AssertPruneProgrammer";
+import { MiscAssertPruneProgrammer } from "../../../programmers/misc/MiscAssertPruneProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace AssertPruneTransformer {
     export const transform = GenericTransformer.scalar("assertPrune")(
-        (project) => (modulo) => AssertPruneProgrammer.write(project)(modulo),
+        (project) => (modulo) =>
+            MiscAssertPruneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/{miscellaneous → misc}/CloneTransformer.ts

@@ -1,9 +1,9 @@
-import { CloneProgrammer } from "../../../programmers/CloneProgrammer";
+import { MiscCloneProgrammer } from "../../../programmers/misc/MiscCloneProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CloneTransformer {
     export const transform = GenericTransformer.scalar("clone")(
-        (project) => (modulo) => CloneProgrammer.write(project)(modulo),
+        (project) => (modulo) => MiscCloneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/{miscellaneous → misc}/CreateAssertCloneTransformer.ts

@@ -1,9 +1,10 @@
-import { AssertCloneProgrammer } from "../../../programmers/AssertCloneProgrammer";
+import { MiscAssertCloneProgrammer } from "../../../programmers/misc/MiscAssertCloneProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateAssertCloneTransformer {
     export const transform = GenericTransformer.factory("createAssertClone")(
-        (project) => (modulo) => AssertCloneProgrammer.write(project)(modulo),
+        (project) => (modulo) =>
+            MiscAssertCloneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/{miscellaneous → misc}/CreateAssertPruneTransformer.ts

@@ -1,9 +1,10 @@
-import { AssertPruneProgrammer } from "../../../programmers/AssertPruneProgrammer";
+import { MiscAssertPruneProgrammer } from "../../../programmers/misc/MiscAssertPruneProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateAssertPruneTransformer {
     export const transform = GenericTransformer.factory("createAssertPrune")(
-        (project) => (modulo) => AssertPruneProgrammer.write(project)(modulo),
+        (project) => (modulo) =>
+            MiscAssertPruneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/{miscellaneous → misc}/CreateCloneTransformer.ts

@@ -1,9 +1,9 @@
-import { CloneProgrammer } from "../../../programmers/CloneProgrammer";
+import { MiscCloneProgrammer } from "../../../programmers/misc/MiscCloneProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateCloneTransformer {
     export const transform = GenericTransformer.factory("createClone")(
-        (project) => (modulo) => CloneProgrammer.write(project)(modulo),
+        (project) => (modulo) => MiscCloneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/{miscellaneous → misc}/CreateIsCloneTransformer.ts

@@ -1,9 +1,9 @@
-import { IsCloneProgrammer } from "../../../programmers/IsCloneProgrammer";
+import { MiscIsCloneProgrammer } from "../../../programmers/misc/MiscIsCloneProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateIsCloneTransformer {
     export const transform = GenericTransformer.factory("createIsClone")(
-        (project) => (modulo) => IsCloneProgrammer.write(project)(modulo),
+        (project) => (modulo) => MiscIsCloneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/{miscellaneous → misc}/CreatePruneTransformer.ts

@@ -1,9 +1,9 @@
-import { PruneProgrammer } from "../../../programmers/PruneProgrammer";
+import { MiscPruneProgrammer } from "../../../programmers/misc/MiscPruneProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreatePruneTransformer {
     export const transform = GenericTransformer.factory("createPrune")(
-        (project) => (modulo) => PruneProgrammer.write(project)(modulo),
+        (project) => (modulo) => MiscPruneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/{miscellaneous → misc}/CreateValidateCloneTransformer.ts

@@ -1,9 +1,10 @@
-import { ValidateCloneProgrammer } from "../../../programmers/ValidateCloneProgrammer";
+import { MiscValidateCloneProgrammer } from "../../../programmers/misc/MiscValidateCloneProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateValidateCloneTransformer {
     export const transform = GenericTransformer.factory("createValidateClone")(
-        (project) => (modulo) => ValidateCloneProgrammer.write(project)(modulo),
+        (project) => (modulo) =>
+            MiscValidateCloneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/{miscellaneous → misc}/CreateValidatePruneTransformer.ts

@@ -1,9 +1,10 @@
-import { ValidatePruneProgrammer } from "../../../programmers/ValidatePruneProgrammer";
+import { MiscValidatePruneProgrammer } from "../../../programmers/misc/MiscValidatePruneProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace CreateValidatePruneTransformer {
     export const transform = GenericTransformer.factory("createValidatePrune")(
-        (project) => (modulo) => ValidatePruneProgrammer.write(project)(modulo),
+        (project) => (modulo) =>
+            MiscValidatePruneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/{miscellaneous → misc}/IsCloneTransformer.ts

@@ -1,9 +1,9 @@
-import { IsCloneProgrammer } from "../../../programmers/IsCloneProgrammer";
+import { MiscIsCloneProgrammer } from "../../../programmers/misc/MiscIsCloneProgrammer";
 
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace IsCloneTransformer {
     export const transform = GenericTransformer.scalar("isClone")(
-        (project) => (modulo) => IsCloneProgrammer.write(project)(modulo),
+        (project) => (modulo) => MiscIsCloneProgrammer.write(project)(modulo),
     );
 }

package/src/transformers/features/{miscellaneous → misc}/LiteralsTransformer.ts

@@ -1,6 +1,6 @@
 import ts from "typescript";
 
-import { LiteralsProgrammer } from "../../../programmers/LiteralsProgrammer";
+import { MiscLiteralsProgrammer } from "../../../programmers/misc/MiscLiteralsProgrammer";
 
 import { IProject } from "../../IProject";
 
@@ -18,7 +18,7 @@ export namespace LiteralsTransformer {
             if (type.isTypeParameter()) throw new Error(NO_GENERIC_ARGUMENT);
 
             // DO TRANSFORM
-            return LiteralsProgrammer.write(project)(type);
+            return MiscLiteralsProgrammer.write(project)(type);
         };
 }
 

package/src/transformers/features/{miscellaneous → misc}/PruneTransformer.ts

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

package/src/transformers/features/{miscellaneous → misc}/ValidateCloneTransformer.ts

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

package/src/transformers/features/{miscellaneous → misc}/ValidatePruneTransformer.ts

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

package/src/transformers/features/{protocols → protobuf}/MessageTransformer.ts

@@ -1,31 +1,31 @@
-import ts from "typescript";
-
-import { MessageProgrammer } from "../../../programmers/MessageProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace MessageTransformer {
-    export const transform =
-        (project: IProject) =>
-        (_modulo: ts.LeftHandSideExpression) =>
-        (expression: ts.CallExpression): ts.Expression => {
-            // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments || !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 MessageProgrammer.generate(project)(type);
-        };
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.message(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.message(): non-specified generic argument.",
-}
+import ts from "typescript";
+
+import { ProtobufMessageProgrammer } from "../../../programmers/protobuf/ProtobufMessageProgrammer";
+
+import { IProject } from "../../IProject";
+
+export namespace MessageTransformer {
+    export const transform =
+        (project: IProject) =>
+        (_modulo: ts.LeftHandSideExpression) =>
+        (expression: ts.CallExpression): ts.Expression => {
+            // CHECK GENERIC ARGUMENT EXISTENCE
+            if (!expression.typeArguments || !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 ProtobufMessageProgrammer.generate(project)(type);
+        };
+}
+
+const enum ErrorMessages {
+    NOT_SPECIFIED = "Error on typia.message(): generic argument is not specified.",
+    GENERIC_ARGUMENT = "Error on typia.message(): non-specified generic argument.",
+}

package/src/utils/Escaper.ts

@@ -1,46 +1,46 @@
-export namespace Escaper {
-    export const variable = (str: string): boolean =>
-        reserved(str) === false && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/g.test(str);
-
-    export const reserved = (str: string): boolean => RESERVED.has(str);
-}
-
-const RESERVED: Set<string> = new Set([
-    "break",
-    "case",
-    "catch",
-    "class",
-    "const",
-    "continue",
-    "debugger",
-    "default",
-    "delete",
-    "do",
-    "else",
-    "enum",
-    "export",
-    "extends",
-    "false",
-    "finally",
-    "for",
-    "function",
-    "if",
-    "import",
-    "in",
-    "instanceof",
-    "new",
-    "null",
-    "package",
-    "return",
-    "super",
-    "switch",
-    "this",
-    "throw",
-    "true",
-    "try",
-    "typeof",
-    "var",
-    "void",
-    "while",
-    "with",
-]);
+export namespace Escaper {
+    export const variable = (str: string): boolean =>
+        reserved(str) === false && /^[a-zA-Z_$][a-zA-Z_$0-9]*$/g.test(str);
+
+    export const reserved = (str: string): boolean => RESERVED.has(str);
+}
+
+const RESERVED: Set<string> = new Set([
+    "break",
+    "case",
+    "catch",
+    "class",
+    "const",
+    "continue",
+    "debugger",
+    "default",
+    "delete",
+    "do",
+    "else",
+    "enum",
+    "export",
+    "extends",
+    "false",
+    "finally",
+    "for",
+    "function",
+    "if",
+    "import",
+    "in",
+    "instanceof",
+    "new",
+    "null",
+    "package",
+    "return",
+    "super",
+    "switch",
+    "this",
+    "throw",
+    "true",
+    "try",
+    "typeof",
+    "var",
+    "void",
+    "while",
+    "with",
+]);