typia 7.0.0-dev.20241002-2 → 7.0.0-dev.20241005

package/src/programmers/notations/NotationGeneralProgrammer.ts

@@ -21,7 +21,7 @@ import { StringUtil } from "../../utils/StringUtil";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { IsProgrammer } from "../IsProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
 import { NotationJoiner } from "../helpers/NotationJoiner";
 import { UnionExplorer } from "../helpers/UnionExplorer";
 import { decode_union_object } from "../internal/decode_union_object";
@@ -42,7 +42,7 @@ export namespace NotationGeneralProgrammer {
     rename: (str: string) => string;
     validated: boolean;
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name: string | undefined;
   }): FeatureProgrammer.IDecomposed => {
@@ -51,7 +51,7 @@ export namespace NotationGeneralProgrammer {
       config.addition = (collection) =>
         IsProgrammer.write_function_statements({
           context: props.context,
-          importer: props.importer,
+          functor: props.functor,
           collection,
         });
     const composed: FeatureProgrammer.IComposed = FeatureProgrammer.compose({
@@ -83,16 +83,16 @@ export namespace NotationGeneralProgrammer {
   };
 
   export const write = (props: IProps) => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       ...props,
-      importer,
+      functor,
       validated: true,
     });
     return FeatureProgrammer.writeDecomposed({
-      importer,
+      functor,
       modulo: props.modulo,
       result,
     });
@@ -100,7 +100,7 @@ export namespace NotationGeneralProgrammer {
 
   const write_array_functions = (props: {
     config: FeatureProgrammer.IConfig;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     collection: MetadataCollection;
   }): ts.VariableStatement[] =>
     props.collection
@@ -138,9 +138,10 @@ export namespace NotationGeneralProgrammer {
       );
 
   const write_tuple_functions = (props: {
-    context: ITypiaContext;
     config: FeatureProgrammer.IConfig;
-    importer: FunctionImporter;
+    rename: (str: string) => string;
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
     collection: MetadataCollection;
   }): ts.VariableStatement[] =>
     props.collection
@@ -178,9 +179,10 @@ export namespace NotationGeneralProgrammer {
         DECODERS
     ----------------------------------------------------------- */
   const decode = (props: {
-    context: ITypiaContext;
     config: FeatureProgrammer.IConfig;
-    importer: FunctionImporter;
+    rename: (str: string) => string;
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
     metadata: Metadata;
     explore: FeatureProgrammer.IExplore;
     input: ts.Expression;
@@ -193,11 +195,15 @@ export namespace NotationGeneralProgrammer {
         (t) => !!t.type.elements.length && t.type.elements.every((e) => e.any),
       )
     )
-      return ts.factory.createCallExpression(
-        props.importer.use("any"),
-        undefined,
-        [props.input],
-      );
+      return ExpressionFactory.currying({
+        function: props.context.importer.internal("notationAny"),
+        arguments: [
+          props.context.importer.internal(
+            `notation${StringUtil.capitalize(props.rename.name)}`,
+          ),
+          props.input,
+        ],
+      });
 
     interface IUnion {
       type: string;
@@ -355,7 +361,7 @@ export namespace NotationGeneralProgrammer {
   };
 
   const decode_object = (props: {
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     object: MetadataObject;
     input: ts.Expression;
     explore: FeatureProgrammer.IExplore;
@@ -366,7 +372,7 @@ export namespace NotationGeneralProgrammer {
         path: false,
         prefix: PREFIX,
       },
-      importer: props.importer,
+      functor: props.functor,
       object: props.object,
       input: props.input,
       explore: props.explore,
@@ -374,7 +380,7 @@ export namespace NotationGeneralProgrammer {
 
   const decode_array = (props: {
     config: FeatureProgrammer.IConfig;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     input: ts.Expression;
     array: MetadataArray;
     explore: FeatureProgrammer.IExplore;
@@ -382,7 +388,7 @@ export namespace NotationGeneralProgrammer {
     props.array.type.recursive
       ? ts.factory.createCallExpression(
           ts.factory.createIdentifier(
-            props.importer.useLocal(
+            props.functor.useLocal(
               `${props.config.prefix}a${props.array.type.index}`,
             ),
           ),
@@ -401,14 +407,14 @@ export namespace NotationGeneralProgrammer {
 
   const decode_array_inline = (props: {
     config: FeatureProgrammer.IConfig;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     input: ts.Expression;
     array: MetadataArray;
     explore: FeatureProgrammer.IExplore;
   }) =>
     FeatureProgrammer.decode_array({
       config: props.config,
-      importer: props.importer,
+      functor: props.functor,
       combiner: NotationJoiner.array,
       array: props.array,
       input: props.input,
@@ -416,9 +422,10 @@ export namespace NotationGeneralProgrammer {
     });
 
   const decode_tuple = (props: {
-    context: ITypiaContext;
     config: FeatureProgrammer.IConfig;
-    importer: FunctionImporter;
+    rename: (str: string) => string;
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
     tuple: MetadataTuple;
     explore: FeatureProgrammer.IExplore;
     input: ts.Expression;
@@ -426,7 +433,7 @@ export namespace NotationGeneralProgrammer {
     props.tuple.type.recursive
       ? ts.factory.createCallExpression(
           ts.factory.createIdentifier(
-            props.importer.useLocal(
+            props.functor.useLocal(
               `${props.config.prefix}t${props.tuple.type.index}`,
             ),
           ),
@@ -447,8 +454,9 @@ export namespace NotationGeneralProgrammer {
 
   const decode_tuple_inline = (props: {
     context: ITypiaContext;
+    rename: (str: string) => string;
     config: FeatureProgrammer.IConfig;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     explore: FeatureProgrammer.IExplore;
     tuple: MetadataTupleType;
     input: ts.Expression;
@@ -514,7 +522,7 @@ export namespace NotationGeneralProgrammer {
   const explore_sets = (props: {
     context: ITypiaContext;
     config: FeatureProgrammer.IConfig;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     input: ts.Expression;
     explore: FeatureProgrammer.IExplore;
     sets: Metadata[];
@@ -525,7 +533,7 @@ export namespace NotationGeneralProgrammer {
           checker: (v) =>
             IsProgrammer.decode({
               context: props.context,
-              importer: props.importer,
+              functor: props.functor,
               input: v.input,
               metadata: v.definition,
               explore: v.explore,
@@ -537,7 +545,7 @@ export namespace NotationGeneralProgrammer {
               [
                 decode_array({
                   config: props.config,
-                  importer: props.importer,
+                  functor: props.functor,
                   input: v.input,
                   array: v.definition,
                   explore: v.explore,
@@ -552,7 +560,8 @@ export namespace NotationGeneralProgrammer {
           success: ts.factory.createTrue(),
           failure: (v) =>
             create_throw_error({
-              importer: props.importer,
+              context: props.context,
+              functor: props.functor,
               expected: v.expected,
               input: v.input,
             }),
@@ -569,7 +578,7 @@ export namespace NotationGeneralProgrammer {
   const explore_maps = (props: {
     context: ITypiaContext;
     config: FeatureProgrammer.IConfig;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     input: ts.Expression;
     maps: Metadata.Entry[];
     explore: FeatureProgrammer.IExplore;
@@ -581,7 +590,7 @@ export namespace NotationGeneralProgrammer {
             ts.factory.createLogicalAnd(
               IsProgrammer.decode({
                 context: props.context,
-                importer: props.importer,
+                functor: props.functor,
                 input: ts.factory.createElementAccessExpression(v.input, 0),
                 metadata: v.definition[0],
                 explore: {
@@ -591,7 +600,7 @@ export namespace NotationGeneralProgrammer {
               }),
               IsProgrammer.decode({
                 context: props.context,
-                importer: props.importer,
+                functor: props.functor,
                 input: ts.factory.createElementAccessExpression(v.input, 1),
                 metadata: v.definition[1],
                 explore: {
@@ -607,7 +616,7 @@ export namespace NotationGeneralProgrammer {
               [
                 decode_array({
                   config: props.config,
-                  importer: props.importer,
+                  functor: props.functor,
                   input: v.input,
                   array: v.definition,
                   explore: v.explore,
@@ -622,7 +631,8 @@ export namespace NotationGeneralProgrammer {
           success: ts.factory.createTrue(),
           failure: (v) =>
             create_throw_error({
-              importer: props.importer,
+              context: props.context,
+              functor: props.functor,
               expected: v.expected,
               input: v.input,
             }),
@@ -638,21 +648,21 @@ export namespace NotationGeneralProgrammer {
 
   const explore_objects = (props: {
     config: FeatureProgrammer.IConfig;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     input: ts.Expression;
     metadata: Metadata;
     explore: FeatureProgrammer.IExplore;
   }) => {
     if (props.metadata.objects.length === 1)
       return decode_object({
-        importer: props.importer,
+        functor: props.functor,
         object: props.metadata.objects[0]!,
         input: props.input,
         explore: props.explore,
       });
     return ts.factory.createCallExpression(
       ts.factory.createIdentifier(
-        props.importer.useLocal(`${PREFIX}u${props.metadata.union_index!}`),
+        props.functor.useLocal(`${PREFIX}u${props.metadata.union_index!}`),
       ),
       undefined,
       FeatureProgrammer.argumentsArray(props),
@@ -662,7 +672,7 @@ export namespace NotationGeneralProgrammer {
   const explore_arrays = (props: {
     context: ITypiaContext;
     config: FeatureProgrammer.IConfig;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     input: ts.Expression;
     arrays: MetadataArray[];
     explore: FeatureProgrammer.IExplore;
@@ -675,7 +685,7 @@ export namespace NotationGeneralProgrammer {
             checker: (v) =>
               IsProgrammer.decode({
                 context: props.context,
-                importer: props.importer,
+                functor: props.functor,
                 input: v.input,
                 metadata: v.definition,
                 explore: v.explore,
@@ -683,7 +693,7 @@ export namespace NotationGeneralProgrammer {
             decoder: (v) =>
               decode_array({
                 config: props.config,
-                importer: props.importer,
+                functor: props.functor,
                 input: v.input,
                 array: v.definition,
                 explore: v.explore,
@@ -692,7 +702,8 @@ export namespace NotationGeneralProgrammer {
             success: ts.factory.createTrue(),
             failure: (v) =>
               create_throw_error({
-                importer: props.importer,
+                context: props.context,
+                functor: props.functor,
                 expected: v.expected,
                 input: v.input,
               }),
@@ -711,7 +722,7 @@ export namespace NotationGeneralProgrammer {
     T extends MetadataArray | MetadataTuple,
   >(props: {
     config: FeatureProgrammer.IConfig;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     factory: (next: {
       parameters: ts.ParameterDeclaration[];
       input: ts.Expression;
@@ -722,19 +733,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,
         [],
       );
@@ -746,20 +762,22 @@ export namespace NotationGeneralProgrammer {
     };
     return ts.factory.createCallExpression(
       ts.factory.createIdentifier(
-        props.importer.emplaceUnion(
+        props.functor.emplaceUnion(
           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,
@@ -779,7 +797,7 @@ export namespace NotationGeneralProgrammer {
   const configure = (props: {
     rename: (str: string) => string;
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
   }): FeatureProgrammer.IConfig<ts.Expression> => {
     const config: FeatureProgrammer.IConfig<ts.Expression> = {
       types: {
@@ -807,9 +825,10 @@ export namespace NotationGeneralProgrammer {
       initializer,
       decoder: (next) =>
         decode({
-          context: props.context,
           config,
-          importer: props.importer,
+          rename: props.rename,
+          context: props.context,
+          functor: props.functor,
           metadata: next.metadata,
           explore: next.explore,
           input: next.input,
@@ -818,14 +837,14 @@ export namespace NotationGeneralProgrammer {
         checker: (next) =>
           IsProgrammer.decode({
             context: props.context,
-            importer: props.importer,
+            functor: props.functor,
             input: next.input,
             metadata: next.metadata,
             explore: next.explore,
           }),
         decoder: (next) =>
           decode_object({
-            importer: props.importer,
+            functor: props.functor,
             object: next.object,
             input: next.input,
             explore: next.explore,
@@ -841,14 +860,14 @@ export namespace NotationGeneralProgrammer {
             checker: (v) =>
               IsProgrammer.decode_object({
                 context: props.context,
-                importer: props.importer,
+                functor: props.functor,
                 object: v.object,
                 input: v.input,
                 explore: v.explore,
               }),
             decoder: (v) =>
               decode_object({
-                importer: props.importer,
+                functor: props.functor,
                 object: v.object,
                 input: v.input,
                 explore: v.explore,
@@ -856,7 +875,8 @@ export namespace NotationGeneralProgrammer {
             success: (exp) => exp,
             escaper: (v) =>
               create_throw_error({
-                importer: props.importer,
+                context: props.context,
+                functor: props.functor,
                 expected: v.expected,
                 input: v.input,
               }),
@@ -866,7 +886,8 @@ export namespace NotationGeneralProgrammer {
           }),
         failure: (next) =>
           create_throw_error({
-            importer: props.importer,
+            context: props.context,
+            functor: props.functor,
             expected: next.expected,
             input: next.input,
           }),
@@ -874,14 +895,15 @@ export namespace NotationGeneralProgrammer {
       generator: {
         arrays: (collection) =>
           write_array_functions({
-            importer: props.importer,
+            functor: props.functor,
             config,
             collection,
           }),
         tuples: (collection) =>
           write_tuple_functions({
+            rename: props.rename,
             context: props.context,
-            importer: props.importer,
+            functor: props.functor,
             config,
             collection,
           }),
@@ -904,24 +926,30 @@ export namespace NotationGeneralProgrammer {
       type: props.type,
     });
     if (result.success === false)
-      throw TransformerError.from(`typia.misc.${props.importer.method}`)(
-        result.errors,
-      );
+      throw TransformerError.from({
+        code: props.functor.method,
+        errors: result.errors,
+      });
     return [collection, result.data];
   };
 
   const create_throw_error = (props: {
-    importer: FunctionImporter;
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
     expected: string;
     input: ts.Expression;
   }) =>
     ts.factory.createExpressionStatement(
       ts.factory.createCallExpression(
-        props.importer.use("throws"),
-        [],
+        props.context.importer.internal("throwTypeGuardError"),
+        undefined,
         [
           ts.factory.createObjectLiteralExpression(
             [
+              ts.factory.createPropertyAssignment(
+                "method",
+                ts.factory.createStringLiteral(props.functor.method),
+              ),
               ts.factory.createPropertyAssignment(
                 "expected",
                 ts.factory.createStringLiteral(props.expected),

package/src/programmers/notations/NotationIsGeneralProgrammer.ts

@@ -9,7 +9,7 @@ import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { IsProgrammer } from "../IsProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
 import { NotationGeneralProgrammer } from "./NotationGeneralProgrammer";
 
 export namespace NotationIsGeneralProgrammer {
@@ -20,7 +20,7 @@ export namespace NotationIsGeneralProgrammer {
   export const decompose = (props: {
     rename: (str: string) => string;
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name: string | undefined;
   }): FeatureProgrammer.IDecomposed => {
@@ -89,16 +89,16 @@ export namespace NotationIsGeneralProgrammer {
   };
 
   export const write = (props: IProps): ts.CallExpression => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       ...props,
-      importer,
+      functor,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };

package/src/programmers/notations/NotationValidateGeneralProgrammer.ts

@@ -9,7 +9,7 @@ import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { ValidateProgrammer } from "../ValidateProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
 import { NotationGeneralProgrammer } from "./NotationGeneralProgrammer";
 
 export namespace NotationValidateGeneralProgrammer {
@@ -21,7 +21,7 @@ export namespace NotationValidateGeneralProgrammer {
     rename: (str: string) => string;
     context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name: string | undefined;
   }): FeatureProgrammer.IDecomposed => {
@@ -101,16 +101,16 @@ export namespace NotationValidateGeneralProgrammer {
   };
 
   export const write = (props: IProps): ts.CallExpression => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       ...props,
-      importer,
+      functor,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };

package/src/programmers/protobuf/ProtobufAssertDecodeProgrammer.ts

@@ -7,14 +7,14 @@ import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { AssertProgrammer } from "../AssertProgrammer";
 import { FeatureProgrammer } from "../FeatureProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
 import { ProtobufDecodeProgrammer } from "./ProtobufDecodeProgrammer";
 
 export namespace ProtobufAssertDecodeProgrammer {
   export const decompose = (props: {
     context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name: string | undefined;
     init?: ts.Expression | undefined;
@@ -79,16 +79,16 @@ export namespace ProtobufAssertDecodeProgrammer {
   };
 
   export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       ...props,
-      importer,
+      functor,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };

package/src/programmers/protobuf/ProtobufAssertEncodeProgrammer.ts

@@ -9,14 +9,14 @@ import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { AssertProgrammer } from "../AssertProgrammer";
 import { FeatureProgrammer } from "../FeatureProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
 import { ProtobufEncodeProgrammer } from "./ProtobufEncodeProgrammer";
 
 export namespace ProtobufAssertEncodeProgrammer {
   export const decompose = (props: {
     context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name: string | undefined;
     init?: ts.Expression | undefined;
@@ -83,16 +83,16 @@ export namespace ProtobufAssertEncodeProgrammer {
   };
 
   export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       ...props,
-      importer,
+      functor,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };