typia 7.0.0-dev.20241002 → 7.0.0-dev.20241003

package/src/programmers/CheckerProgrammer.ts

@@ -276,9 +276,10 @@ export namespace CheckerProgrammer {
         type: next.type,
       });
       if (result.success === false)
-        throw TransformerError.from(`typia.${next.importer.method}`)(
-          result.errors,
-        );
+        throw TransformerError.from({
+          code: `typia.${next.importer.method}`,
+          errors: result.errors,
+        });
       return [collection, result.data];
     },
     addition: props.config.addition,
@@ -827,15 +828,15 @@ export namespace CheckerProgrammer {
 
     if (instances.length) {
       const transformer =
-        (merger: (x: ts.Expression, y: ts.Expression) => ts.Expression) =>
-        (ins: IInstance) =>
-          ins.body
+        (merge: (x: ts.Expression, y: ts.Expression) => ts.Expression) =>
+        (instance: IInstance) =>
+          instance.body
             ? {
-                expression: merger(ins.head, ins.body),
+                expression: merge(instance.head, instance.body),
                 combined: true,
               }
             : {
-                expression: ins.head,
+                expression: instance.head,
                 combined: false,
               };
       if (instances.length === 1)

package/src/programmers/RandomProgrammer.ts

@@ -69,9 +69,10 @@ export namespace RandomProgrammer {
       type: props.type,
     });
     if (result.success === false)
-      throw TransformerError.from(`typia.${props.importer.method}`)(
-        result.errors,
-      );
+      throw TransformerError.from({
+        code: `typia.${props.importer.method}`,
+        errors: result.errors,
+      });
 
     // GENERATE FUNCTION
     const functions: Record<string, ts.VariableStatement> = Object.fromEntries([

package/src/programmers/functional/FunctionalAssertFunctionProgrammer.ts

@@ -81,9 +81,10 @@ export namespace FunctionalAssertFunctionProgrammer {
     name: string;
     variable: ts.VariableStatement;
   } => {
-    const name: string = StringUtil.escapeDuplicate(
-      props.parameters.map((p) => p.name.getText()),
-    )("errorFactoryWrapper");
+    const name: string = StringUtil.escapeDuplicate({
+      keep: props.parameters.map((p) => p.name.getText()),
+      input: "errorFactoryWrapper",
+    });
     const variable: ts.VariableStatement = ts.factory.createVariableStatement(
       undefined,
       ts.factory.createVariableDeclarationList(

package/src/programmers/functional/FunctionalAssertParametersProgrammer.ts

@@ -112,18 +112,6 @@ export namespace FunctionalAssertParametersProgrammer {
             replacer: `$input.parameters[${i}]`,
           }),
         }),
-        //   project)(modulo)(equals)(
-        //   p.type
-        //     ? project.checker.getTypeFromTypeNode(p.type)
-        //     : project.checker.getTypeFromTypeNode(TypeFactory.keyword("any")),
-        //   undefined,
-        //   FunctionalAssertFunctionProgrammer.hookPath({
-        //     wrapper: props.wrapper,
-        //     replacer: `$input.parameters[${i}]`,
-        //   }),
-        // ),
-        // undefined,
-        // [ts.factory.createIdentifier(p.name.getText())],
       }),
     ),
     expressions: props.parameters.map((p, i) =>

package/src/programmers/functional/FunctionalIsReturnProgrammer.ts

@@ -75,9 +75,10 @@ export namespace FunctionalIsReturnProgrammer {
         ts.factory.createIdentifier(p.name.getText()),
       ),
     );
-    const name: string = StringUtil.escapeDuplicate(
-      props.declaration.parameters.map((p) => p.name.getText()),
-    )("result");
+    const name: string = StringUtil.escapeDuplicate({
+      keep: props.declaration.parameters.map((p) => p.name.getText()),
+      input: "result",
+    });
     return {
       async,
       functions: [

package/src/programmers/functional/FunctionalValidateParametersProgrammer.ts

@@ -101,9 +101,10 @@ export namespace FunctionalValidateParametersProgrammer {
   };
 
   export const decompose = (props: IDecomposeProps): IDecomposeOutput => {
-    const resultName: string = StringUtil.escapeDuplicate(
-      props.declaration.parameters.map((p) => p.name.getText()),
-    )("paramErrorResults");
+    const resultName: string = StringUtil.escapeDuplicate({
+      keep: props.declaration.parameters.map((p) => p.name.getText()),
+      input: "paramErrorResults",
+    });
     const validationResultArray: ts.ArrayLiteralExpression =
       ts.factory.createArrayLiteralExpression(
         props.declaration.parameters.map((p, i) =>

package/src/programmers/functional/FunctionalValidateReturnProgrammer.ts

@@ -76,9 +76,10 @@ export namespace FunctionalValidateReturnProgrammer {
       ),
     );
 
-    const name: string = StringUtil.escapeDuplicate(
-      props.declaration.parameters.map((p) => p.name.getText()),
-    )("result");
+    const name: string = StringUtil.escapeDuplicate({
+      keep: props.declaration.parameters.map((p) => p.name.getText()),
+      input: "result",
+    });
     return {
       async,
       functions: [

package/src/programmers/helpers/UnionPredicator.ts

@@ -20,7 +20,7 @@ export namespace UnionPredicator {
       for (const prop of obj.properties) {
         const key: string | null = prop.key.getSoleLiteral();
         if (key !== null)
-          MapUtil.take(matrix)(key, () =>
+          MapUtil.take(matrix, key, () =>
             ArrayUtil.repeat(objects.length, () => null),
           );
       }

package/src/programmers/http/HttpFormDataProgrammer.ts

@@ -45,9 +45,10 @@ export namespace HttpFormDataProgrammer {
       type: props.type,
     });
     if (result.success === false)
-      throw TransformerError.from(`typia.http.${props.importer.method}`)(
-        result.errors,
-      );
+      throw TransformerError.from({
+        code: `typia.http.${props.importer.method}`,
+        errors: result.errors,
+      });
 
     // DO TRANSFORM
     const object: MetadataObject = result.data.objects[0]!;

package/src/programmers/http/HttpHeadersProgrammer.ts

@@ -49,9 +49,10 @@ export namespace HttpHeadersProgrammer {
       type: props.type,
     });
     if (result.success === false)
-      throw TransformerError.from(`typia.http.${props.importer.method}`)(
-        result.errors,
-      );
+      throw TransformerError.from({
+        code: `typia.http.${props.importer.method}`,
+        errors: result.errors,
+      });
 
     // DO TRANSFORM
     const object: MetadataObject = result.data.objects[0]!;
@@ -188,7 +189,7 @@ export namespace HttpHeadersProgrammer {
         const key: string | null = prop.key.getSoleLiteral();
         if (key === null) continue;
 
-        MapUtil.take(counter)(key.toLowerCase(), () => new Set()).add(key);
+        MapUtil.take(counter, key.toLowerCase(), () => new Set()).add(key);
       }
       for (const [key, set] of counter)
         if (set.size > 1)

package/src/programmers/http/HttpParameterProgrammer.ts

@@ -30,7 +30,10 @@ export namespace HttpParameterProgrammer {
       type: props.type,
     });
     if (result.success === false)
-      throw TransformerError.from(props.modulo.getText())(result.errors);
+      throw TransformerError.from({
+        code: props.modulo.getText(),
+        errors: result.errors,
+      });
 
     const atomic = [...HttpMetadataUtil.atomics(result.data)][0]!;
     const importer: FunctionImporter = new FunctionImporter(

package/src/programmers/http/HttpQueryProgrammer.ts

@@ -53,9 +53,10 @@ export namespace HttpQueryProgrammer {
       type: props.type,
     });
     if (result.success === false)
-      throw TransformerError.from(`typia.http.${props.importer.method}`)(
-        result.errors,
-      );
+      throw TransformerError.from({
+        code: `typia.http.${props.importer.method}`,
+        errors: result.errors,
+      });
 
     // DO TRANSFORM
     const object: MetadataObject = result.data.objects[0]!;

package/src/programmers/misc/MiscCloneProgrammer.ts

@@ -977,9 +977,10 @@ export namespace MiscCloneProgrammer {
       type: props.type,
     });
     if (result.success === false)
-      throw TransformerError.from(`typia.misc.${props.importer.method}`)(
-        result.errors,
-      );
+      throw TransformerError.from({
+        code: `typia.misc.${props.importer.method}`,
+        errors: result.errors,
+      });
     return [collection, result.data];
   };
 

package/src/programmers/misc/MiscLiteralsProgrammer.ts

@@ -39,7 +39,10 @@ export namespace MiscLiteralsProgrammer {
       type: props.type,
     });
     if (result.success === false)
-      throw TransformerError.from(`typia.misc.literals`)(result.errors);
+      throw TransformerError.from({
+        code: `typia.misc.literals`,
+        errors: result.errors,
+      });
 
     const metadata: Metadata = result.data;
     const values: Set<Atomic.Type | null> = new Set([

package/src/programmers/misc/MiscPruneProgrammer.ts

@@ -684,9 +684,10 @@ export namespace MiscPruneProgrammer {
       type: props.type,
     });
     if (result.success === false)
-      throw TransformerError.from(`typia.misc.${props.importer.method}`)(
-        result.errors,
-      );
+      throw TransformerError.from({
+        code: `typia.misc.${props.importer.method}`,
+        errors: result.errors,
+      });
     return [collection, result.data];
   };
 

package/src/programmers/notations/NotationGeneralProgrammer.ts

@@ -722,19 +722,24 @@ export namespace NotationGeneralProgrammer {
     definitions: T[];
     explore: FeatureProgrammer.IExplore;
   }): ts.Expression => {
-    const arrow =
-      (parameters: ts.ParameterDeclaration[]) =>
-      (explore: FeatureProgrammer.IExplore) =>
-      (input: ts.Expression): ts.ArrowFunction =>
-        props.factory({
-          parameters,
-          input,
-          definitions: props.definitions,
-          explore,
-        });
+    const arrow = (next: {
+      parameters: ts.ParameterDeclaration[];
+      explore: FeatureProgrammer.IExplore;
+      input: ts.Expression;
+    }): ts.ArrowFunction =>
+      props.factory({
+        parameters: next.parameters,
+        definitions: props.definitions,
+        explore: next.explore,
+        input: next.input,
+      });
     if (props.definitions.every((e) => e.type.recursive === false))
       ts.factory.createCallExpression(
-        arrow([])(props.explore)(props.input),
+        arrow({
+          parameters: [],
+          explore: props.explore,
+          input: props.input,
+        }),
         undefined,
         [],
       );
@@ -750,16 +755,18 @@ export namespace NotationGeneralProgrammer {
           props.config.prefix,
           props.definitions.map((e) => e.type.name).join(" | "),
           () =>
-            arrow(
-              FeatureProgrammer.parameterDeclarations({
+            arrow({
+              parameters: FeatureProgrammer.parameterDeclarations({
                 config: props.config,
                 type: TypeFactory.keyword("any"),
                 input: ts.factory.createIdentifier("input"),
               }),
-            )({
-              ...arrayExplore,
-              postfix: "",
-            })(ts.factory.createIdentifier("input")),
+              explore: {
+                ...arrayExplore,
+                postfix: "",
+              },
+              input: ts.factory.createIdentifier("input"),
+            }),
         ),
       ),
       undefined,
@@ -904,9 +911,10 @@ export namespace NotationGeneralProgrammer {
       type: props.type,
     });
     if (result.success === false)
-      throw TransformerError.from(`typia.misc.${props.importer.method}`)(
-        result.errors,
-      );
+      throw TransformerError.from({
+        code: `typia.misc.${props.importer.method}`,
+        errors: result.errors,
+      });
     return [collection, result.data];
   };
 

package/src/programmers/protobuf/ProtobufMessageProgrammer.ts

@@ -57,7 +57,7 @@ export namespace ProtobufMessageProgrammer {
     let hierarchies: Map<string, Hierarchy> = props.hierarchies;
     const accessors: string[] = props.object.name.split(".");
     accessors.forEach((access, i) => {
-      const hierarchy: Hierarchy = MapUtil.take(hierarchies)(access, () => ({
+      const hierarchy: Hierarchy = MapUtil.take(hierarchies, access, () => ({
         key: access,
         object: null!,
         children: new Map(),

package/src/transformers/CallExpressionTransformer.ts

@@ -113,42 +113,42 @@ import { ReflectMetadataTransformer } from "./features/reflect/ReflectMetadataTr
 import { ReflectNameTransformer } from "./features/reflect/ReflectNameTransformer";
 
 export namespace CallExpressionTransformer {
-  export const transform =
-    (context: ITypiaContext) =>
-    (expression: ts.CallExpression): ts.Expression | null => {
-      //----
-      // VALIDATIONS
-      //----
-      // SIGNATURE DECLARATION
-      const declaration: ts.Declaration | undefined =
-        context.checker.getResolvedSignature(expression)?.declaration;
-      if (!declaration) return expression;
-
-      // FILE PATH
-      const location: string = path.resolve(
-        declaration.getSourceFile().fileName,
-      );
-      if (isTarget(location) === false) return expression;
-
-      //----
-      // TRANSFORMATION
-      //----
-      // FUNCTION NAME
-      const module: string = location.split(path.sep).at(-1)!.split(".")[0]!;
-      const { name } = context.checker.getTypeAtLocation(declaration).symbol;
-
-      // FIND TRANSFORMER
-      const functor: (() => Task) | undefined = FUNCTORS[module]?.[name];
-      if (functor === undefined) return expression;
-
-      // RETURNS WITH TRANSFORMATION
-      const result: ts.Expression | null = functor()({
-        context,
-        modulo: expression.expression,
-        expression,
-      });
-      return result ?? expression;
-    };
+  export const transform = (props: {
+    context: ITypiaContext;
+    expression: ts.CallExpression;
+  }): ts.Expression | null => {
+    //----
+    // VALIDATIONS
+    //----
+    // SIGNATURE DECLARATION
+    const declaration: ts.Declaration | undefined =
+      props.context.checker.getResolvedSignature(props.expression)?.declaration;
+    if (!declaration) return props.expression;
+
+    // FILE PATH
+    const location: string = path.resolve(declaration.getSourceFile().fileName);
+    if (isTarget(location) === false) return props.expression;
+
+    //----
+    // TRANSFORMATION
+    //----
+    // FUNCTION NAME
+    const module: string = location.split(path.sep).at(-1)!.split(".")[0]!;
+    const { name } =
+      props.context.checker.getTypeAtLocation(declaration).symbol;
+
+    // FIND TRANSFORMER
+    const functor: (() => Task) | undefined = FUNCTORS[module]?.[name];
+    if (functor === undefined) return props.expression;
+
+    // RETURNS WITH TRANSFORMATION
+    const result: ts.Expression | null = functor()({
+      context: props.context,
+      modulo: props.expression.expression,
+      expression: props.expression,
+    });
+    return result ?? props.expression;
+  };
 
   const isTarget = (location: string): boolean => {
     const files: string[] = Object.keys(FUNCTORS);

package/src/transformers/FileTransformer.ts

@@ -13,48 +13,58 @@ export namespace FileTransformer {
     (file: ts.SourceFile): ts.SourceFile => {
       if (file.isDeclarationFile) return file;
 
-      const project: ITypiaContext = {
+      const context: ITypiaContext = {
         ...environments,
         transformer,
       };
-      checkJsDocParsingMode.get(project, file);
+      checkJsDocParsingMode.get(context, file);
 
       return ts.visitEachChild(
         file,
-        (node) => iterate_node(project)(node),
+        (node) =>
+          iterate_node({
+            context,
+            node,
+          }),
         transformer,
       );
     };
 
-  const iterate_node =
-    (project: ITypiaContext) =>
-    (node: ts.Node): ts.Node =>
-      ts.visitEachChild(
-        try_transform_node(project)(node) ?? node,
-        (child) => iterate_node(project)(child),
-        project.transformer,
-      );
+  const iterate_node = (props: {
+    context: ITypiaContext;
+    node: ts.Node;
+  }): ts.Node =>
+    ts.visitEachChild(
+      try_transform_node(props) ?? props.node,
+      (node) =>
+        iterate_node({
+          context: props.context,
+          node,
+        }),
+      props.context.transformer,
+    );
 
-  const try_transform_node =
-    (project: ITypiaContext) =>
-    (node: ts.Node): ts.Node | null => {
-      try {
-        return NodeTransformer.transform(project)(node);
-      } catch (exp) {
-        // ONLY ACCEPT TRANSFORMER-ERROR
-        if (!isTransformerError(exp)) throw exp;
+  const try_transform_node = (props: {
+    context: ITypiaContext;
+    node: ts.Node;
+  }): ts.Node | null => {
+    try {
+      return NodeTransformer.transform(props);
+    } catch (exp) {
+      // ONLY ACCEPT TRANSFORMER-ERROR
+      if (!isTransformerError(exp)) throw exp;
 
-        // REPORT DIAGNOSTIC
-        const diagnostic = ts.createDiagnosticForNode(node, {
-          key: exp.code,
-          category: ts.DiagnosticCategory.Error,
-          message: exp.message,
-          code: `(${exp.code})` as any,
-        });
-        project.extras.addDiagnostic(diagnostic);
-        return null;
-      }
-    };
+      // REPORT DIAGNOSTIC
+      const diagnostic = ts.createDiagnosticForNode(props.node, {
+        key: exp.code,
+        category: ts.DiagnosticCategory.Error,
+        message: exp.message,
+        code: `(${exp.code})` as any,
+      });
+      props.context.extras.addDiagnostic(diagnostic);
+      return null;
+    }
+  };
 }
 
 const isTransformerError = (error: any): error is TransformerError =>
@@ -65,12 +75,12 @@ const isTransformerError = (error: any): error is TransformerError =>
   typeof error.message === "string";
 
 const checkJsDocParsingMode = new Singleton(
-  (project: ITypiaContext, file: ts.SourceFile) => {
+  (context: ITypiaContext, file: ts.SourceFile) => {
     if (
       typeof file.jsDocParsingMode === "number" &&
       file.jsDocParsingMode !== 0
     ) {
-      project.extras.addDiagnostic(
+      context.extras.addDiagnostic(
         ts.createDiagnosticForNode(file, {
           code: `(typia setup)` as any,
           key: "jsDocParsingMode",

package/src/transformers/NodeTransformer.ts

@@ -4,10 +4,14 @@ import { CallExpressionTransformer } from "./CallExpressionTransformer";
 import { ITypiaContext } from "./ITypiaContext";
 
 export namespace NodeTransformer {
-  export const transform =
-    (project: ITypiaContext) =>
-    (expression: ts.Node): ts.Node | null =>
-      ts.isCallExpression(expression) && expression.parent
-        ? CallExpressionTransformer.transform(project)(expression)
-        : expression;
+  export const transform = (props: {
+    context: ITypiaContext;
+    node: ts.Node;
+  }): ts.Node | null =>
+    ts.isCallExpression(props.node) && props.node.parent
+      ? CallExpressionTransformer.transform({
+          context: props.context,
+          expression: props.node,
+        })
+      : props.node;
 }

package/src/transformers/TransformerError.ts

@@ -23,33 +23,32 @@ export namespace TransformerError {
     message: string;
   }
 
-  export const from =
-    (method: string) =>
-    (errors: MetadataFactory.IError[]): TransformerError => {
-      const body: string = errors
-        .map((e) => {
-          const subject: string =
-            e.explore.object === null
-              ? ""
-              : join(e.explore.object)(e.explore.property);
-          const middle: string = e.explore.parameter
-            ? `(parameter: ${JSON.stringify(e.explore.parameter)})`
-            : e.explore.output
-              ? "(return type)"
-              : "";
-          const type: string = `${subject.length ? `${subject}: ` : ""}${
-            e.name
-          }`;
-          return `- ${type}${middle}\n${e.messages
-            .map((msg) => `  - ${msg}`)
-            .join("\n")}`;
-        })
-        .join("\n\n");
-      return new TransformerError({
-        code: method,
-        message: `unsupported type detected\n\n${body}`,
-      });
-    };
+  export const from = (props: {
+    code: string;
+    errors: MetadataFactory.IError[];
+  }): TransformerError => {
+    const body: string = props.errors
+      .map((e) => {
+        const subject: string =
+          e.explore.object === null
+            ? ""
+            : join(e.explore.object)(e.explore.property);
+        const middle: string = e.explore.parameter
+          ? `(parameter: ${JSON.stringify(e.explore.parameter)})`
+          : e.explore.output
+            ? "(return type)"
+            : "";
+        const type: string = `${subject.length ? `${subject}: ` : ""}${e.name}`;
+        return `- ${type}${middle}\n${e.messages
+          .map((msg) => `  - ${msg}`)
+          .join("\n")}`;
+      })
+      .join("\n\n");
+    return new TransformerError({
+      code: props.code,
+      message: `unsupported type detected\n\n${body}`,
+    });
+  };
 
   const join = (object: MetadataObject) => (key: string | object | null) => {
     if (key === null) return object.name;

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

@@ -83,7 +83,10 @@ export namespace JsonApplicationTransformer {
       else metadatas.push(r.data);
     }
     if (errors.length)
-      throw TransformerError.from("typia.json.application")(errors);
+      throw TransformerError.from({
+        code: "typia.json.application",
+        errors,
+      });
 
     // APPLICATION
     const app: IJsonApplication<any> =

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

@@ -50,7 +50,10 @@ export namespace LlmApplicationTransformer {
         type,
       });
     if (result.success === false)
-      throw TransformerError.from("typia.llm.application")(result.errors);
+      throw TransformerError.from({
+        code: "typia.llm.application",
+        errors: result.errors,
+      });
 
     // GENERATE LLM APPLICATION
     const schema: ILlmApplication = LlmApplicationProgrammer.write(result.data);

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

@@ -47,7 +47,10 @@ export namespace LlmSchemaTransformer {
         type,
       });
     if (result.success === false)
-      throw TransformerError.from("typia.llm.schema")(result.errors);
+      throw TransformerError.from({
+        code: "typia.llm.schema",
+        errors: result.errors,
+      });
 
     // GENERATE LLM SCHEMA
     const schema: ILlmSchema = LlmSchemaProgrammer.write(result.data);