typia 6.10.0 → 7.0.0-dev.20240916

package/src/transformers/features/notations/NotationValidateGeneralTransformer.ts

@@ -2,14 +2,19 @@ import { NotationValidateGeneralProgrammer } from "../../../programmers/notation
 
 import { StringUtil } from "../../../utils/StringUtil";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace NotationValidateGeneralTransformer {
-  export const transform = (rename: (str: string) => string) =>
-    GenericTransformer.scalar(
-      `notations.validate${StringUtil.capitalize(rename.name)}`,
-    )(
-      (project) => (modulo) =>
-        NotationValidateGeneralProgrammer.write(rename)(project)(modulo),
-    );
+  export const transform =
+    (rename: (str: string) => string) => (props: ITransformProps) =>
+      GenericTransformer.scalar({
+        ...props,
+        method: `notations.validate${StringUtil.capitalize(rename.name)}`,
+        write: (x) =>
+          NotationValidateGeneralProgrammer.write({
+            ...x,
+            rename,
+          }),
+      });
 }

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

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

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

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

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

@@ -1,12 +1,13 @@
 import { ProtobufAssertDecodeProgrammer } from "../../../programmers/protobuf/ProtobufAssertDecodeProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace ProtobufCreateAssertDecodeTransformer {
-  export const transform = GenericTransformer.factory(
-    "protobuf.createAssertDecode",
-  )(
-    (project) => (modulo) =>
-      ProtobufAssertDecodeProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "protobuf.createAssertDecode",
+      write: ProtobufAssertDecodeProgrammer.write,
+    });
 }

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

@@ -1,12 +1,13 @@
 import { ProtobufAssertEncodeProgrammer } from "../../../programmers/protobuf/ProtobufAssertEncodeProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace ProtobufCreateAssertEncodeTransformer {
-  export const transform = GenericTransformer.factory(
-    "protobuf.createAssertEncode",
-  )(
-    (project) => (modulo) =>
-      ProtobufAssertEncodeProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "protobuf.createAssertEncode",
+      write: ProtobufAssertEncodeProgrammer.write,
+    });
 }

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

@@ -1,9 +1,13 @@
 import { ProtobufDecodeProgrammer } from "../../../programmers/protobuf/ProtobufDecodeProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace ProtobufCreateDecodeTransformer {
-  export const transform = GenericTransformer.factory("protobuf.createDecode")(
-    (project) => (modulo) => ProtobufDecodeProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "protobuf.createDecode",
+      write: ProtobufDecodeProgrammer.write,
+    });
 }

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

@@ -1,9 +1,13 @@
 import { ProtobufEncodeProgrammer } from "../../../programmers/protobuf/ProtobufEncodeProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace ProtobufCreateEncodeTransformer {
-  export const transform = GenericTransformer.factory("protobuf.createEncode")(
-    (project) => (modulo) => ProtobufEncodeProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "protobuf.createEncode",
+      write: ProtobufEncodeProgrammer.write,
+    });
 }

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

@@ -1,9 +1,13 @@
 import { ProtobufIsDecodeProgrammer } from "../../../programmers/protobuf/ProtobufIsDecodeProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace ProtobufCreateIsDecodeTransformer {
-  export const transform = GenericTransformer.factory(
-    "protobuf.createIsDecode",
-  )((project) => (modulo) => ProtobufIsDecodeProgrammer.write(project)(modulo));
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "protobuf.createIsDecode",
+      write: ProtobufIsDecodeProgrammer.write,
+    });
 }

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

@@ -1,9 +1,13 @@
 import { ProtobufIsEncodeProgrammer } from "../../../programmers/protobuf/ProtobufIsEncodeProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace ProtobufCreateIsEncodeTransformer {
-  export const transform = GenericTransformer.factory(
-    "protobuf.createIsEncode",
-  )((project) => (modulo) => ProtobufIsEncodeProgrammer.write(project)(modulo));
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "protobuf.createIsEncode",
+      write: ProtobufIsEncodeProgrammer.write,
+    });
 }

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -2,32 +2,34 @@ import ts from "typescript";
 
 import { ProtobufMessageProgrammer } from "../../../programmers/protobuf/ProtobufMessageProgrammer";
 
-import { IProject } from "../../IProject";
+import { ITransformProps } from "../../ITransformProps";
 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.",
-        });
+  export const transform = (
+    props: Pick<ITransformProps, "context" | "expression">,
+  ): ts.Expression => {
+    // CHECK GENERIC ARGUMENT EXISTENCE
+    if (!props.expression.typeArguments || !props.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.",
-        });
+    // GET TYPE INFO
+    const type: ts.Type = props.context.checker.getTypeFromTypeNode(
+      props.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);
-    };
+    // DO TRANSFORM
+    return ProtobufMessageProgrammer.write({
+      context: props.context,
+      type,
+    });
+  };
 }

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

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

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

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

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

@@ -7,57 +7,57 @@ import { MetadataFactory } from "../../../factories/MetadataFactory";
 import { IMetadataApplication } from "../../../schemas/metadata/IMetadataApplication";
 import { Metadata } from "../../../schemas/metadata/Metadata";
 
-import { IProject } from "../../IProject";
+import { ITransformProps } from "../../ITransformProps";
 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,
-          functional: true,
-        })(collection)(type);
-        if (result.success === false)
-          throw TransformerError.from("typia.reflect.metadata")(result.errors);
-        return result.data;
+  export const transform = (
+    props: Pick<ITransformProps, "context" | "expression">,
+  ): ts.Expression => {
+    if (!props.expression.typeArguments?.length)
+      throw new TransformerError({
+        code: "typia.reflect.metadata",
+        message: "no generic argument.",
       });
 
-      // CONVERT TO PRIMITIVE TYPE
-      const app: IMetadataApplication = {
-        metadatas: metadatas.map((metadata) => metadata.toJSON()),
-        components: collection.toJSON(),
-      };
-      return LiteralFactory.generate(app);
+    // VALIDATE TUPLE ARGUMENTS
+    const top: ts.Node = props.expression.typeArguments[0]!;
+    if (!ts.isTupleTypeNode(top)) return props.expression;
+    else if (top.elements.some((child) => !ts.isTypeNode(child)))
+      return props.expression;
+
+    // GET TYPES
+    const types: ts.Type[] = top.elements.map((child) =>
+      props.context.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(
+        props.context.checker,
+        props.context.transformer,
+      )({
+        escape: true,
+        constant: true,
+        absorb: true,
+        functional: 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

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