typia 6.6.3-dev.20240801 → 6.7.0-dev.20240802

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,10 +1,10 @@
-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,10 +1,10 @@
-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/features/reflect/ReflectMetadataTransformer.ts

@@ -1,62 +1,62 @@
-import ts from "typescript";
-
-import { LiteralFactory } from "../../../factories/LiteralFactory";
-import { MetadataCollection } from "../../../factories/MetadataCollection";
-import { MetadataFactory } from "../../../factories/MetadataFactory";
-
-import { IMetadataApplication } from "../../../schemas/metadata/IMetadataApplication";
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { IProject } from "../../IProject";
-import { TransformerError } from "../../TransformerError";
-
-export namespace ReflectMetadataTransformer {
-  export const transform =
-    (project: IProject) =>
-    (expression: ts.CallExpression): ts.Expression => {
-      if (!expression.typeArguments?.length)
-        throw new TransformerError({
-          code: "typia.reflect.metadata",
-          message: "no generic argument.",
-        });
-
-      // VALIDATE TUPLE ARGUMENTS
-      const top: ts.Node = expression.typeArguments[0]!;
-      if (!ts.isTupleTypeNode(top)) return expression;
-      else if (top.elements.some((child) => !ts.isTypeNode(child)))
-        return expression;
-
-      // GET TYPES
-      const types: ts.Type[] = top.elements.map((child) =>
-        project.checker.getTypeFromTypeNode(child as ts.TypeNode),
-      );
-      if (types.some((t) => t.isTypeParameter()))
-        throw new TransformerError({
-          code: "typia.reflect.metadata",
-          message: "non-specified generic argument(s).",
-        });
-
-      // METADATA
-      const collection: MetadataCollection = new MetadataCollection();
-      const metadatas: Array<Metadata> = types.map((type) => {
-        const result = MetadataFactory.analyze(
-          project.checker,
-          project.context,
-        )({
-          escape: true,
-          constant: true,
-          absorb: true,
-        })(collection)(type);
-        if (result.success === false)
-          throw TransformerError.from("typia.reflect.metadata")(result.errors);
-        return result.data;
-      });
-
-      // CONVERT TO PRIMITIVE TYPE
-      const app: IMetadataApplication = {
-        metadatas: metadatas.map((metadata) => metadata.toJSON()),
-        components: collection.toJSON(),
-      };
-      return LiteralFactory.generate(app);
-    };
-}
+import ts from "typescript";
+
+import { LiteralFactory } from "../../../factories/LiteralFactory";
+import { MetadataCollection } from "../../../factories/MetadataCollection";
+import { MetadataFactory } from "../../../factories/MetadataFactory";
+
+import { IMetadataApplication } from "../../../schemas/metadata/IMetadataApplication";
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { IProject } from "../../IProject";
+import { TransformerError } from "../../TransformerError";
+
+export namespace ReflectMetadataTransformer {
+  export const transform =
+    (project: IProject) =>
+    (expression: ts.CallExpression): ts.Expression => {
+      if (!expression.typeArguments?.length)
+        throw new TransformerError({
+          code: "typia.reflect.metadata",
+          message: "no generic argument.",
+        });
+
+      // VALIDATE TUPLE ARGUMENTS
+      const top: ts.Node = expression.typeArguments[0]!;
+      if (!ts.isTupleTypeNode(top)) return expression;
+      else if (top.elements.some((child) => !ts.isTypeNode(child)))
+        return expression;
+
+      // GET TYPES
+      const types: ts.Type[] = top.elements.map((child) =>
+        project.checker.getTypeFromTypeNode(child as ts.TypeNode),
+      );
+      if (types.some((t) => t.isTypeParameter()))
+        throw new TransformerError({
+          code: "typia.reflect.metadata",
+          message: "non-specified generic argument(s).",
+        });
+
+      // METADATA
+      const collection: MetadataCollection = new MetadataCollection();
+      const metadatas: Array<Metadata> = types.map((type) => {
+        const result = MetadataFactory.analyze(
+          project.checker,
+          project.context,
+        )({
+          escape: true,
+          constant: true,
+          absorb: true,
+        })(collection)(type);
+        if (result.success === false)
+          throw TransformerError.from("typia.reflect.metadata")(result.errors);
+        return result.data;
+      });
+
+      // CONVERT TO PRIMITIVE TYPE
+      const app: IMetadataApplication = {
+        metadatas: metadatas.map((metadata) => metadata.toJSON()),
+        components: collection.toJSON(),
+      };
+      return LiteralFactory.generate(app);
+    };
+}

package/src/transformers/features/reflect/ReflectNameTransformer.ts

@@ -1,66 +1,66 @@
-import ts from "typescript";
-
-import { MetadataCollection } from "../../../factories/MetadataCollection";
-import { MetadataFactory } from "../../../factories/MetadataFactory";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { ValidationPipe } from "../../../typings/ValidationPipe";
-
-import { IProject } from "../../IProject";
-import { TransformerError } from "../../TransformerError";
-
-export namespace ReflectNameTransformer {
-  export const transform =
-    (project: IProject) =>
-    (expression: ts.CallExpression): ts.Expression => {
-      if (!expression.typeArguments?.length)
-        throw new TransformerError({
-          code: "typia.reflect.metadata",
-          message: "no generic argument.",
-        });
-      const top: ts.Node = expression.typeArguments[0]!;
-      const regular: boolean = (() => {
-        // CHECK SECOND ARGUMENT EXISTENCE
-        const second: ts.Node | undefined = expression.typeArguments[1]!;
-        if (second === undefined) return false;
-
-        // GET BOOELAN VALUE
-        const value: Metadata = getMetadata(project)(second);
-        return value.size() === 1 &&
-          value.constants.length === 1 &&
-          value.constants[0]!.type === "boolean" &&
-          value.constants[0]!.values.length === 1
-          ? (value.constants[0]!.values[0]!.value as boolean)
-          : false;
-      })();
-
-      // RETURNS NAME
-      return ts.factory.createStringLiteral(
-        regular ? getMetadata(project)(top).getName() : top.getFullText(),
-      );
-    };
-}
-
-const getMetadata =
-  (project: IProject) =>
-  (node: ts.Node): Metadata => {
-    const type: ts.Type = project.checker.getTypeFromTypeNode(
-      node as ts.TypeNode,
-    );
-    const collection: MetadataCollection = new MetadataCollection({
-      replace: MetadataCollection.replace,
-    });
-    const result: ValidationPipe<Metadata, MetadataFactory.IError> =
-      MetadataFactory.analyze(
-        project.checker,
-        project.context,
-      )({
-        escape: false,
-        constant: true,
-        absorb: false,
-      })(collection)(type);
-    if (result.success === false)
-      throw TransformerError.from("typia.reflect.name")(result.errors);
-    return result.data;
-  };
+import ts from "typescript";
+
+import { MetadataCollection } from "../../../factories/MetadataCollection";
+import { MetadataFactory } from "../../../factories/MetadataFactory";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { ValidationPipe } from "../../../typings/ValidationPipe";
+
+import { IProject } from "../../IProject";
+import { TransformerError } from "../../TransformerError";
+
+export namespace ReflectNameTransformer {
+  export const transform =
+    (project: IProject) =>
+    (expression: ts.CallExpression): ts.Expression => {
+      if (!expression.typeArguments?.length)
+        throw new TransformerError({
+          code: "typia.reflect.metadata",
+          message: "no generic argument.",
+        });
+      const top: ts.Node = expression.typeArguments[0]!;
+      const regular: boolean = (() => {
+        // CHECK SECOND ARGUMENT EXISTENCE
+        const second: ts.Node | undefined = expression.typeArguments[1]!;
+        if (second === undefined) return false;
+
+        // GET BOOELAN VALUE
+        const value: Metadata = getMetadata(project)(second);
+        return value.size() === 1 &&
+          value.constants.length === 1 &&
+          value.constants[0]!.type === "boolean" &&
+          value.constants[0]!.values.length === 1
+          ? (value.constants[0]!.values[0]!.value as boolean)
+          : false;
+      })();
+
+      // RETURNS NAME
+      return ts.factory.createStringLiteral(
+        regular ? getMetadata(project)(top).getName() : top.getFullText(),
+      );
+    };
+}
+
+const getMetadata =
+  (project: IProject) =>
+  (node: ts.Node): Metadata => {
+    const type: ts.Type = project.checker.getTypeFromTypeNode(
+      node as ts.TypeNode,
+    );
+    const collection: MetadataCollection = new MetadataCollection({
+      replace: MetadataCollection.replace,
+    });
+    const result: ValidationPipe<Metadata, MetadataFactory.IError> =
+      MetadataFactory.analyze(
+        project.checker,
+        project.context,
+      )({
+        escape: false,
+        constant: true,
+        absorb: false,
+      })(collection)(type);
+    if (result.success === false)
+      throw TransformerError.from("typia.reflect.name")(result.errors);
+    return result.data;
+  };

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 === 0)
-        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,
-      );
-    };
-
-  export const factory =
-    (method: string) =>
-    (
-      programmer: (
-        project: IProject,
-      ) => (
-        modulo: ts.LeftHandSideExpression,
-      ) => (
-        type: ts.Type,
-        name: string,
-        init?: ts.Expression,
-      ) => 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(),
-        expression.arguments[0],
-      );
-    };
-
-  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.Expression | ts.ArrowFunction,
+    ) =>
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (expression: ts.CallExpression) => {
+      // CHECK PARAMETER
+      if (expression.arguments.length === 0)
+        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,
+      );
+    };
+
+  export const factory =
+    (method: string) =>
+    (
+      programmer: (
+        project: IProject,
+      ) => (
+        modulo: ts.LeftHandSideExpression,
+      ) => (
+        type: ts.Type,
+        name: string,
+        init?: ts.Expression,
+      ) => ts.Expression | 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(),
+        expression.arguments[0],
+      );
+    };
+
+  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,13 +1,13 @@
-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;
+};