typia 7.0.0-dev.20240916 → 7.0.0-dev.20240918

package/src/programmers/misc/MiscLiteralsProgrammer.ts

@@ -17,24 +17,27 @@ export namespace MiscLiteralsProgrammer {
     type: ts.Type;
   }
   export const write = (props: IProps) => {
-    const result = MetadataFactory.analyze(
-      props.context.checker,
-      props.context.transformer,
-    )({
-      escape: true,
-      constant: true,
-      absorb: true,
-      validate: (meta) => {
-        const length: number =
-          meta.constants
-            .map((c) => c.values.length)
-            .reduce((a, b) => a + b, 0) +
-          meta.atomics.filter((a) => a.type === "boolean").length;
-        if (0 === length) return [ErrorMessages.NO];
-        else if (meta.size() !== length) return [ErrorMessages.ONLY];
-        return [];
+    const result = MetadataFactory.analyze({
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      options: {
+        escape: true,
+        constant: true,
+        absorb: true,
+        validate: (meta) => {
+          const length: number =
+            meta.constants
+              .map((c) => c.values.length)
+              .reduce((a, b) => a + b, 0) +
+            meta.atomics.filter((a) => a.type === "boolean").length;
+          if (0 === length) return [ErrorMessages.NO];
+          else if (meta.size() !== length) return [ErrorMessages.ONLY];
+          return [];
+        },
       },
-    })(new MetadataCollection())(props.type);
+      collection: new MetadataCollection(),
+      type: props.type,
+    });
     if (result.success === false)
       throw TransformerError.from(`typia.misc.literals`)(result.errors);
 

package/src/programmers/misc/MiscPruneProgrammer.ts

@@ -518,14 +518,17 @@ export namespace MiscPruneProgrammer {
   const initializer: FeatureProgrammer.IConfig["initializer"] =
     (project) => (importer) => (type) => {
       const collection = new MetadataCollection();
-      const result = MetadataFactory.analyze(
-        project.checker,
-        project.transformer,
-      )({
-        escape: false,
-        constant: true,
-        absorb: true,
-      })(collection)(type);
+      const result = MetadataFactory.analyze({
+        checker: project.checker,
+        transformer: project.transformer,
+        options: {
+          escape: false,
+          constant: true,
+          absorb: true,
+        },
+        collection,
+        type,
+      });
       if (result.success === false)
         throw TransformerError.from(`typia.misc.${importer.method}`)(
           result.errors,

package/src/programmers/notations/NotationGeneralProgrammer.ts

@@ -665,14 +665,17 @@ export namespace NotationGeneralProgrammer {
   const initializer: FeatureProgrammer.IConfig["initializer"] =
     (project) => (importer) => (type) => {
       const collection = new MetadataCollection();
-      const result = MetadataFactory.analyze(
-        project.checker,
-        project.transformer,
-      )({
-        escape: false,
-        constant: true,
-        absorb: true,
-      })(collection)(type);
+      const result = MetadataFactory.analyze({
+        checker: project.checker,
+        transformer: project.transformer,
+        options: {
+          escape: false,
+          constant: true,
+          absorb: true,
+        },
+        collection,
+        type,
+      });
       if (result.success === false)
         throw TransformerError.from(`typia.misc.${importer.method}`)(
           result.errors,

package/src/programmers/protobuf/ProtobufDecodeProgrammer.ts

@@ -32,10 +32,13 @@ export namespace ProtobufDecodeProgrammer {
     name: string | undefined;
   }): FeatureProgrammer.IDecomposed => {
     const collection: MetadataCollection = new MetadataCollection();
-    const meta: Metadata = ProtobufFactory.metadata(props.modulo.getText())(
-      props.context.checker,
-      props.context.transformer,
-    )(collection)(props.type);
+    const meta: Metadata = ProtobufFactory.metadata({
+      method: props.modulo.getText(),
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      collection,
+      type: props.type,
+    });
     return {
       functions: Object.fromEntries(
         collection

package/src/programmers/protobuf/ProtobufEncodeProgrammer.ts

@@ -36,10 +36,13 @@ export namespace ProtobufEncodeProgrammer {
     name: string | undefined;
   }): FeatureProgrammer.IDecomposed => {
     const collection: MetadataCollection = new MetadataCollection();
-    const meta: Metadata = ProtobufFactory.metadata(props.modulo.getText())(
-      props.context.checker,
-      props.context.transformer,
-    )(collection)(props.type);
+    const meta: Metadata = ProtobufFactory.metadata({
+      method: props.modulo.getText(),
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      collection,
+      type: props.type,
+    });
 
     const callEncoder = (writer: string) => (factory: ts.NewExpression) =>
       StatementFactory.constant(

package/src/programmers/protobuf/ProtobufMessageProgrammer.ts

@@ -23,10 +23,13 @@ export namespace ProtobufMessageProgrammer {
   export const write = (props: IProps) => {
     // PARSE TARGET TYPE
     const collection: MetadataCollection = new MetadataCollection();
-    ProtobufFactory.metadata("message")(
-      props.context.checker,
-      props.context.transformer,
-    )(collection)(props.type);
+    ProtobufFactory.metadata({
+      method: "message",
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      collection,
+      type: props.type,
+    });
 
     // STRINGIFY
     const hierarchies: Map<string, Hierarchy> = new Map();

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

@@ -61,15 +61,18 @@ export namespace JsonApplicationTransformer {
     });
     const results: ValidationPipe<Metadata, MetadataFactory.IError>[] =
       types.map((type) =>
-        MetadataFactory.analyze(
-          props.context.checker,
-          props.context.transformer,
-        )({
-          escape: true,
-          constant: true,
-          absorb: false,
-          validate: JsonApplicationProgrammer.validate,
-        })(collection)(type),
+        MetadataFactory.analyze({
+          checker: props.context.checker,
+          transformer: props.context.transformer,
+          options: {
+            escape: true,
+            constant: true,
+            absorb: false,
+            validate: JsonApplicationProgrammer.validate,
+          },
+          collection,
+          type,
+        }),
       );
 
     // REPORT BUG IF REQUIRED

package/src/transformers/features/llm/LlmApplicationTransformer.ts

@@ -36,16 +36,19 @@ export namespace LlmApplicationTransformer {
       replace: MetadataCollection.replace,
     });
     const result: ValidationPipe<Metadata, MetadataFactory.IError> =
-      MetadataFactory.analyze(
-        props.context.checker,
-        props.context.transformer,
-      )({
-        escape: true,
-        constant: true,
-        absorb: false,
-        functional: true,
-        validate: LlmApplicationProgrammer.validate,
-      })(collection)(type);
+      MetadataFactory.analyze({
+        checker: props.context.checker,
+        transformer: props.context.transformer,
+        options: {
+          escape: true,
+          constant: true,
+          absorb: false,
+          functional: true,
+          validate: LlmApplicationProgrammer.validate,
+        },
+        collection,
+        type,
+      });
     if (result.success === false)
       throw TransformerError.from("typia.llm.application")(result.errors);
 

package/src/transformers/features/llm/LlmSchemaTransformer.ts

@@ -34,15 +34,18 @@ export namespace LlmSchemaTransformer {
       replace: MetadataCollection.replace,
     });
     const result: ValidationPipe<Metadata, MetadataFactory.IError> =
-      MetadataFactory.analyze(
-        props.context.checker,
-        props.context.transformer,
-      )({
-        escape: true,
-        constant: true,
-        absorb: false,
-        validate: LlmSchemaProgrammer.validate,
-      })(collection)(type);
+      MetadataFactory.analyze({
+        checker: props.context.checker,
+        transformer: props.context.transformer,
+        options: {
+          escape: true,
+          constant: true,
+          absorb: false,
+          validate: LlmSchemaProgrammer.validate,
+        },
+        collection,
+        type,
+      });
     if (result.success === false)
       throw TransformerError.from("typia.llm.schema")(result.errors);
 

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

@@ -39,15 +39,18 @@ export namespace ReflectMetadataTransformer {
     // 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);
+      const result = MetadataFactory.analyze({
+        checker: props.context.checker,
+        transformer: props.context.transformer,
+        options: {
+          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;

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

@@ -62,14 +62,17 @@ const getMetadata = (props: {
     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);
+    MetadataFactory.analyze({
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      options: {
+        escape: false,
+        constant: true,
+        absorb: false,
+      },
+      collection,
+      type,
+    });
   if (result.success === false)
     throw TransformerError.from("typia.reflect.name")(result.errors);
   return result.data;