typia 5.0.4 → 5.0.5-dev.20230921

package/src/transformers/features/protobuf/CreateProtobufIsDecodeTransformer.ts

@@ -1,12 +1,12 @@
-import { ProtobufIsDecodeProgrammer } from "../../../programmers/protobuf/ProtobufIsDecodeProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateProtobufIsDecodeTransformer {
-    export const transform = GenericTransformer.factory(
-        "protobuf.createIsDecode",
-    )(
-        (project) => (modulo) =>
-            ProtobufIsDecodeProgrammer.write(project)(modulo),
-    );
-}
+import { ProtobufIsDecodeProgrammer } from "../../../programmers/protobuf/ProtobufIsDecodeProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateProtobufIsDecodeTransformer {
+    export const transform = GenericTransformer.factory(
+        "protobuf.createIsDecode",
+    )(
+        (project) => (modulo) =>
+            ProtobufIsDecodeProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/protobuf/CreateProtobufIsEncodeTransformer.ts

@@ -1,12 +1,12 @@
-import { ProtobufIsEncodeProgrammer } from "../../../programmers/protobuf/ProtobufIsEncodeProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateProtobufIsEncodeTransformer {
-    export const transform = GenericTransformer.factory(
-        "protobuf.createIsEncode",
-    )(
-        (project) => (modulo) =>
-            ProtobufIsEncodeProgrammer.write(project)(modulo),
-    );
-}
+import { ProtobufIsEncodeProgrammer } from "../../../programmers/protobuf/ProtobufIsEncodeProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateProtobufIsEncodeTransformer {
+    export const transform = GenericTransformer.factory(
+        "protobuf.createIsEncode",
+    )(
+        (project) => (modulo) =>
+            ProtobufIsEncodeProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/protobuf/CreateProtobufValidateDecodeTransformer.ts

@@ -1,12 +1,12 @@
-import { ProtobufValidateDecodeProgrammer } from "../../../programmers/protobuf/ProtobufValidateDecodeProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateProtobufValidateDecodeTransformer {
-    export const transform = GenericTransformer.factory(
-        "protobuf.createValidateDecode",
-    )(
-        (project) => (modulo) =>
-            ProtobufValidateDecodeProgrammer.write(project)(modulo),
-    );
-}
+import { ProtobufValidateDecodeProgrammer } from "../../../programmers/protobuf/ProtobufValidateDecodeProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateProtobufValidateDecodeTransformer {
+    export const transform = GenericTransformer.factory(
+        "protobuf.createValidateDecode",
+    )(
+        (project) => (modulo) =>
+            ProtobufValidateDecodeProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/protobuf/CreateProtobufValidateEncodeTransformer.ts

@@ -1,12 +1,12 @@
-import { ProtobufValidateEncodeProgrammer } from "../../../programmers/protobuf/ProtobufValidateEncodeProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateProtobufValidateEncodeTransformer {
-    export const transform = GenericTransformer.factory(
-        "protobuf.createValidateEncode",
-    )(
-        (project) => (modulo) =>
-            ProtobufValidateEncodeProgrammer.write(project)(modulo),
-    );
-}
+import { ProtobufValidateEncodeProgrammer } from "../../../programmers/protobuf/ProtobufValidateEncodeProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateProtobufValidateEncodeTransformer {
+    export const transform = GenericTransformer.factory(
+        "protobuf.createValidateEncode",
+    )(
+        (project) => (modulo) =>
+            ProtobufValidateEncodeProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/protobuf/ProtobufAssertDecodeTransformer.ts

@@ -1,10 +1,10 @@
-import { ProtobufAssertDecodeProgrammer } from "../../../programmers/protobuf/ProtobufAssertDecodeProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace ProtobufAssertDecodeTransformer {
-    export const transform = GenericTransformer.scalar("protobuf.assertDecode")(
-        (project) => (modulo) =>
-            ProtobufAssertDecodeProgrammer.write(project)(modulo),
-    );
-}
+import { ProtobufAssertDecodeProgrammer } from "../../../programmers/protobuf/ProtobufAssertDecodeProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace ProtobufAssertDecodeTransformer {
+    export const transform = GenericTransformer.scalar("protobuf.assertDecode")(
+        (project) => (modulo) =>
+            ProtobufAssertDecodeProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/protobuf/ProtobufAssertEncodeTransformer.ts

@@ -1,10 +1,10 @@
-import { ProtobufAssertEncodeProgrammer } from "../../../programmers/protobuf/ProtobufAssertEncodeProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace ProtobufAssertEncodeTransformer {
-    export const transform = GenericTransformer.scalar("protobuf.assertEncode")(
-        (project) => (modulo) =>
-            ProtobufAssertEncodeProgrammer.write(project)(modulo),
-    );
-}
+import { ProtobufAssertEncodeProgrammer } from "../../../programmers/protobuf/ProtobufAssertEncodeProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace ProtobufAssertEncodeTransformer {
+    export const transform = GenericTransformer.scalar("protobuf.assertEncode")(
+        (project) => (modulo) =>
+            ProtobufAssertEncodeProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/protobuf/ProtobufDecodeTransformer.ts

@@ -1,10 +1,10 @@
-import { ProtobufDecodeProgrammer } from "../../../programmers/protobuf/ProtobufDecodeProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace ProtobufDecodeTransformer {
-    export const transform = GenericTransformer.scalar("protobuf.decode")(
-        (project) => (modulo) =>
-            ProtobufDecodeProgrammer.write(project)(modulo),
-    );
-}
+import { ProtobufDecodeProgrammer } from "../../../programmers/protobuf/ProtobufDecodeProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace ProtobufDecodeTransformer {
+    export const transform = GenericTransformer.scalar("protobuf.decode")(
+        (project) => (modulo) =>
+            ProtobufDecodeProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/protobuf/ProtobufEncodeTransformer.ts

@@ -1,10 +1,10 @@
-import { ProtobufEncodeProgrammer } from "../../../programmers/protobuf/ProtobufEncodeProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace ProtobufEncodeTransformer {
-    export const transform = GenericTransformer.scalar("protobuf.encode")(
-        (project) => (modulo) =>
-            ProtobufEncodeProgrammer.write(project)(modulo),
-    );
-}
+import { ProtobufEncodeProgrammer } from "../../../programmers/protobuf/ProtobufEncodeProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace ProtobufEncodeTransformer {
+    export const transform = GenericTransformer.scalar("protobuf.encode")(
+        (project) => (modulo) =>
+            ProtobufEncodeProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/protobuf/ProtobufIsDecodeTransformer.ts

@@ -1,10 +1,10 @@
-import { ProtobufIsDecodeProgrammer } from "../../../programmers/protobuf/ProtobufIsDecodeProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace ProtobufIsDecodeTransformer {
-    export const transform = GenericTransformer.scalar("protobuf.isDecode")(
-        (project) => (modulo) =>
-            ProtobufIsDecodeProgrammer.write(project)(modulo),
-    );
-}
+import { ProtobufIsDecodeProgrammer } from "../../../programmers/protobuf/ProtobufIsDecodeProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace ProtobufIsDecodeTransformer {
+    export const transform = GenericTransformer.scalar("protobuf.isDecode")(
+        (project) => (modulo) =>
+            ProtobufIsDecodeProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/protobuf/ProtobufIsEncodeTransformer.ts

@@ -1,10 +1,10 @@
-import { ProtobufIsEncodeProgrammer } from "../../../programmers/protobuf/ProtobufIsEncodeProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace ProtobufIsEncodeTransformer {
-    export const transform = GenericTransformer.scalar("protobuf.isEncode")(
-        (project) => (modulo) =>
-            ProtobufIsEncodeProgrammer.write(project)(modulo),
-    );
-}
+import { ProtobufIsEncodeProgrammer } from "../../../programmers/protobuf/ProtobufIsEncodeProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace ProtobufIsEncodeTransformer {
+    export const transform = GenericTransformer.scalar("protobuf.isEncode")(
+        (project) => (modulo) =>
+            ProtobufIsEncodeProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/protobuf/ProtobufMessageTransformer.ts

@@ -1,33 +1,33 @@
-import ts from "typescript";
-
-import { ProtobufMessageProgrammer } from "../../../programmers/protobuf/ProtobufMessageProgrammer";
-
-import { IProject } from "../../IProject";
-import { TransformerError } from "../../TransformerError";
-
-export namespace ProtobufMessageTransformer {
-    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 TransformerError({
-                    code: "typia.protobuf.message",
-                    message: "generic argument is not specified.",
-                });
-
-            // GET TYPE INFO
-            const type: ts.Type = project.checker.getTypeFromTypeNode(
-                expression.typeArguments[0],
-            );
-            if (type.isTypeParameter())
-                throw new TransformerError({
-                    code: "tyipa.protobuf.message",
-                    message: "non-specified generic argument.",
-                });
-
-            // DO TRANSFORM
-            return ProtobufMessageProgrammer.write(project)(type);
-        };
-}
+import ts from "typescript";
+
+import { ProtobufMessageProgrammer } from "../../../programmers/protobuf/ProtobufMessageProgrammer";
+
+import { IProject } from "../../IProject";
+import { TransformerError } from "../../TransformerError";
+
+export namespace ProtobufMessageTransformer {
+    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 TransformerError({
+                    code: "typia.protobuf.message",
+                    message: "generic argument is not specified.",
+                });
+
+            // GET TYPE INFO
+            const type: ts.Type = project.checker.getTypeFromTypeNode(
+                expression.typeArguments[0],
+            );
+            if (type.isTypeParameter())
+                throw new TransformerError({
+                    code: "tyipa.protobuf.message",
+                    message: "non-specified generic argument.",
+                });
+
+            // DO TRANSFORM
+            return ProtobufMessageProgrammer.write(project)(type);
+        };
+}

package/src/transformers/features/protobuf/ProtobufValidateDecodeTransformer.ts

@@ -1,12 +1,12 @@
-import { ProtobufValidateDecodeProgrammer } from "../../../programmers/protobuf/ProtobufValidateDecodeProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace ProtobufValidateDecodeTransformer {
-    export const transform = GenericTransformer.scalar(
-        "protobuf.validateDecode",
-    )(
-        (project) => (modulo) =>
-            ProtobufValidateDecodeProgrammer.write(project)(modulo),
-    );
-}
+import { ProtobufValidateDecodeProgrammer } from "../../../programmers/protobuf/ProtobufValidateDecodeProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace ProtobufValidateDecodeTransformer {
+    export const transform = GenericTransformer.scalar(
+        "protobuf.validateDecode",
+    )(
+        (project) => (modulo) =>
+            ProtobufValidateDecodeProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/features/protobuf/ProtobufValidateEncodeTransformer.ts

@@ -1,12 +1,12 @@
-import { ProtobufValidateEncodeProgrammer } from "../../../programmers/protobuf/ProtobufValidateEncodeProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace ProtobufValidateEncodeTransformer {
-    export const transform = GenericTransformer.scalar(
-        "protobuf.validateEncode",
-    )(
-        (project) => (modulo) =>
-            ProtobufValidateEncodeProgrammer.write(project)(modulo),
-    );
-}
+import { ProtobufValidateEncodeProgrammer } from "../../../programmers/protobuf/ProtobufValidateEncodeProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace ProtobufValidateEncodeTransformer {
+    export const transform = GenericTransformer.scalar(
+        "protobuf.validateEncode",
+    )(
+        (project) => (modulo) =>
+            ProtobufValidateEncodeProgrammer.write(project)(modulo),
+    );
+}

package/src/transformers/internal/GenericTransformer.ts

@@ -1,104 +1,104 @@
-import ts from "typescript";
-
-import { IProject } from "../IProject";
-import { TransformerError } from "../TransformerError";
-
-export namespace GenericTransformer {
-    export const scalar =
-        (method: string) =>
-        (
-            programmer: (
-                project: IProject,
-            ) => (
-                modulo: ts.LeftHandSideExpression,
-            ) => (type: ts.Type, name: string) => ts.ArrowFunction,
-        ) =>
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (expression: ts.CallExpression) => {
-            // CHECK PARAMETER
-            if (expression.arguments.length !== 1)
-                throw new TransformerError({
-                    code: `typia.${method}`,
-                    message: `no input value.`,
-                });
-
-            // GET TYPE INFO
-            const [type, node, generic]: [ts.Type, ts.Node, boolean] =
-                expression.typeArguments && expression.typeArguments[0]
-                    ? [
-                          project.checker.getTypeFromTypeNode(
-                              expression.typeArguments[0],
-                          ),
-                          expression.typeArguments[0],
-                          true,
-                      ]
-                    : [
-                          project.checker.getTypeAtLocation(
-                              expression.arguments[0]!,
-                          ),
-                          expression.arguments[0]!,
-                          false,
-                      ];
-            if (type.isTypeParameter())
-                throw new TransformerError({
-                    code: `typia.${method}`,
-                    message: `non-specified generic argument.`,
-                });
-
-            // DO TRANSFORM
-            return ts.factory.createCallExpression(
-                programmer(project)(modulo)(
-                    type,
-                    generic
-                        ? node.getFullText().trim()
-                        : name(project.checker)(type)(node),
-                ),
-                undefined,
-                [expression.arguments[0]!],
-            );
-        };
-
-    export const factory =
-        (method: string) =>
-        (
-            programmer: (
-                project: IProject,
-            ) => (
-                modulo: ts.LeftHandSideExpression,
-            ) => (type: ts.Type, name: string) => ts.ArrowFunction,
-        ) =>
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (expression: ts.CallExpression) => {
-            // CHECK GENERIC ARGUMENT EXISTENCE
-            if (!expression.typeArguments?.[0])
-                throw new TransformerError({
-                    code: `typia.${method}`,
-                    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.${method}`,
-                    message: `non-specified generic argument.`,
-                });
-
-            // DO TRANSFORM
-            return programmer(project)(modulo)(type, node.getFullText().trim());
-        };
-
-    const name =
-        (checker: ts.TypeChecker) =>
-        (type: ts.Type) =>
-        (node: ts.Node): string =>
-            checker.typeToString(
-                type,
-                node,
-                ts.TypeFormatFlags.NodeBuilderFlagsMask,
-            );
-}
+import ts from "typescript";
+
+import { IProject } from "../IProject";
+import { TransformerError } from "../TransformerError";
+
+export namespace GenericTransformer {
+    export const scalar =
+        (method: string) =>
+        (
+            programmer: (
+                project: IProject,
+            ) => (
+                modulo: ts.LeftHandSideExpression,
+            ) => (type: ts.Type, name: string) => ts.ArrowFunction,
+        ) =>
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (expression: ts.CallExpression) => {
+            // CHECK PARAMETER
+            if (expression.arguments.length !== 1)
+                throw new TransformerError({
+                    code: `typia.${method}`,
+                    message: `no input value.`,
+                });
+
+            // GET TYPE INFO
+            const [type, node, generic]: [ts.Type, ts.Node, boolean] =
+                expression.typeArguments && expression.typeArguments[0]
+                    ? [
+                          project.checker.getTypeFromTypeNode(
+                              expression.typeArguments[0],
+                          ),
+                          expression.typeArguments[0],
+                          true,
+                      ]
+                    : [
+                          project.checker.getTypeAtLocation(
+                              expression.arguments[0]!,
+                          ),
+                          expression.arguments[0]!,
+                          false,
+                      ];
+            if (type.isTypeParameter())
+                throw new TransformerError({
+                    code: `typia.${method}`,
+                    message: `non-specified generic argument.`,
+                });
+
+            // DO TRANSFORM
+            return ts.factory.createCallExpression(
+                programmer(project)(modulo)(
+                    type,
+                    generic
+                        ? node.getFullText().trim()
+                        : name(project.checker)(type)(node),
+                ),
+                undefined,
+                [expression.arguments[0]!],
+            );
+        };
+
+    export const factory =
+        (method: string) =>
+        (
+            programmer: (
+                project: IProject,
+            ) => (
+                modulo: ts.LeftHandSideExpression,
+            ) => (type: ts.Type, name: string) => ts.ArrowFunction,
+        ) =>
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (expression: ts.CallExpression) => {
+            // CHECK GENERIC ARGUMENT EXISTENCE
+            if (!expression.typeArguments?.[0])
+                throw new TransformerError({
+                    code: `typia.${method}`,
+                    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.${method}`,
+                    message: `non-specified generic argument.`,
+                });
+
+            // DO TRANSFORM
+            return programmer(project)(modulo)(type, node.getFullText().trim());
+        };
+
+    const name =
+        (checker: ts.TypeChecker) =>
+        (type: ts.Type) =>
+        (node: ts.Node): string =>
+            checker.typeToString(
+                type,
+                node,
+                ts.TypeFormatFlags.NodeBuilderFlagsMask,
+            );
+}

package/src/typings/Atomic.ts

@@ -1,18 +1,18 @@
-export namespace Atomic {
-    export type Type = boolean | number | string | bigint;
-
-    export type Literal =
-        | "boolean"
-        | "integer"
-        | "number"
-        | "string"
-        | "bigint";
-
-    export type Mapper = {
-        boolean: boolean;
-        integer: number;
-        number: number;
-        string: string;
-        bigint: bigint;
-    };
-}
+export namespace Atomic {
+    export type Type = boolean | number | string | bigint;
+
+    export type Literal =
+        | "boolean"
+        | "integer"
+        | "number"
+        | "string"
+        | "bigint";
+
+    export type Mapper = {
+        boolean: boolean;
+        integer: number;
+        number: number;
+        string: string;
+        bigint: bigint;
+    };
+}

package/src/typings/ClassProperties.ts

@@ -1,5 +1,5 @@
-import { OmitNever } from "./OmitNever";
-
-export type ClassProperties<T extends object> = OmitNever<{
-    [K in keyof T]: T[K] extends Function ? never : T[K];
-}>;
+import { OmitNever } from "./OmitNever";
+
+export type ClassProperties<T extends object> = OmitNever<{
+    [K in keyof T]: T[K] extends Function ? never : T[K];
+}>;

package/src/typings/Customizable.ts

@@ -1,5 +1,5 @@
-export type Customizable = {
-    number: number;
-    string: string;
-    bigint: bigint;
-};
+export type Customizable = {
+    number: number;
+    string: string;
+    bigint: bigint;
+};

package/src/typings/OmitNever.ts

@@ -1,3 +1,3 @@
-import { SpecialFields } from "./SpecialFields";
-
-export type OmitNever<T extends object> = Omit<T, SpecialFields<T, never>>;
+import { SpecialFields } from "./SpecialFields";
+
+export type OmitNever<T extends object> = Omit<T, SpecialFields<T, never>>;