typia 7.0.0-dev.20240930 → 7.0.0-dev.20241002

package/src/programmers/notations/NotationGeneralProgrammer.ts

@@ -33,9 +33,10 @@ export namespace NotationGeneralProgrammer {
     rename: (str: string) => string;
   }
 
-  export const returnType =
-    (rename: (str: string) => string) => (type: string) =>
-      `typia.${StringUtil.capitalize(rename.name)}Case<${type}>`;
+  export const returnType = (props: {
+    rename: (str: string) => string;
+    type: string;
+  }) => `typia.${StringUtil.capitalize(props.rename.name)}Case<${props.type}>`;
 
   export const decompose = (props: {
     rename: (str: string) => string;
@@ -65,10 +66,15 @@ export namespace NotationGeneralProgrammer {
         undefined,
         composed.parameters,
         ts.factory.createTypeReferenceNode(
-          returnType(props.rename)(
-            props.name ??
-              TypeFactory.getFullName(props.context.checker)(props.type),
-          ),
+          returnType({
+            rename: props.rename,
+            type:
+              props.name ??
+              TypeFactory.getFullName({
+                checker: props.context.checker,
+                type: props.type,
+              }),
+          }),
         ),
         undefined,
         composed.body,
@@ -101,9 +107,9 @@ export namespace NotationGeneralProgrammer {
       .arrays()
       .filter((a) => a.recursive)
       .map((type, i) =>
-        StatementFactory.constant(
-          `${props.config.prefix}a${i}`,
-          ts.factory.createArrowFunction(
+        StatementFactory.constant({
+          name: `${props.config.prefix}a${i}`,
+          value: ts.factory.createArrowFunction(
             undefined,
             undefined,
             FeatureProgrammer.parameterDeclarations({
@@ -128,7 +134,7 @@ export namespace NotationGeneralProgrammer {
               },
             }),
           ),
-        ),
+        }),
       );
 
   const write_tuple_functions = (props: {
@@ -141,9 +147,9 @@ export namespace NotationGeneralProgrammer {
       .tuples()
       .filter((t) => t.recursive)
       .map((tuple, i) =>
-        StatementFactory.constant(
-          `${props.config.prefix}t${i}`,
-          ts.factory.createArrowFunction(
+        StatementFactory.constant({
+          name: `${props.config.prefix}t${i}`,
+          value: ts.factory.createArrowFunction(
             undefined,
             undefined,
             FeatureProgrammer.parameterDeclarations({
@@ -165,7 +171,7 @@ export namespace NotationGeneralProgrammer {
               },
             }),
           ),
-        ),
+        }),
       );
 
   /* -----------------------------------------------------------
@@ -243,7 +249,7 @@ export namespace NotationGeneralProgrammer {
         value: () =>
           explore_arrays({
             ...props,
-            elements: props.metadata.arrays,
+            arrays: props.metadata.arrays,
             explore: {
               ...props.explore,
               from: "array",
@@ -255,7 +261,7 @@ export namespace NotationGeneralProgrammer {
     if (props.metadata.sets.length)
       unions.push({
         type: "set",
-        is: () => ExpressionFactory.isInstanceOf("Set")(props.input),
+        is: () => ExpressionFactory.isInstanceOf("Set", props.input),
         value: () =>
           explore_sets({
             ...props,
@@ -269,7 +275,7 @@ export namespace NotationGeneralProgrammer {
     if (props.metadata.maps.length)
       unions.push({
         type: "map",
-        is: () => ExpressionFactory.isInstanceOf("Map")(props.input),
+        is: () => ExpressionFactory.isInstanceOf("Map", props.input),
         value: () =>
           explore_maps({
             ...props,
@@ -284,11 +290,11 @@ export namespace NotationGeneralProgrammer {
       if (native === "WeakSet" || native === "WeakMap") continue;
       unions.push({
         type: "native",
-        is: () => ExpressionFactory.isInstanceOf(native)(props.input),
+        is: () => ExpressionFactory.isInstanceOf(native, props.input),
         value: () =>
           native === "Boolean" || native === "Number" || native === "String"
             ? ts.factory.createCallExpression(
-                IdentifierFactory.access(props.input)("valueOf"),
+                IdentifierFactory.access(props.input, "valueOf"),
                 undefined,
                 undefined,
               )
@@ -307,7 +313,8 @@ export namespace NotationGeneralProgrammer {
           ExpressionFactory.isObject({
             checkNull: true,
             checkArray: false,
-          })(props.input),
+            input: props.input,
+          }),
         value: () =>
           explore_objects({
             ...props,
@@ -472,7 +479,7 @@ export namespace NotationGeneralProgrammer {
       return decode({
         ...props,
         input: ts.factory.createCallExpression(
-          IdentifierFactory.access(props.input)("slice"),
+          IdentifierFactory.access(props.input, "slice"),
           undefined,
           [ExpressionFactory.number(props.tuple.elements.length - 1)],
         ),
@@ -514,37 +521,47 @@ export namespace NotationGeneralProgrammer {
   }): ts.Expression =>
     ts.factory.createCallExpression(
       UnionExplorer.set({
-        checker: (input, metadata, explore) =>
-          IsProgrammer.decode({
-            context: props.context,
-            importer: props.importer,
-            input,
-            metadata,
-            explore,
-          }),
-        decoder: (input, array, explore) =>
-          ts.factory.createNewExpression(
+        config: {
+          checker: (v) =>
+            IsProgrammer.decode({
+              context: props.context,
+              importer: props.importer,
+              input: v.input,
+              metadata: v.definition,
+              explore: v.explore,
+            }),
+          decoder: (v) =>
+            ts.factory.createNewExpression(
+              ts.factory.createIdentifier("Set"),
+              [TypeFactory.keyword("any")],
+              [
+                decode_array({
+                  config: props.config,
+                  importer: props.importer,
+                  input: v.input,
+                  array: v.definition,
+                  explore: v.explore,
+                }),
+              ],
+            ),
+          empty: ts.factory.createNewExpression(
             ts.factory.createIdentifier("Set"),
             [TypeFactory.keyword("any")],
-            [
-              decode_array({
-                config: props.config,
-                importer: props.importer,
-                input,
-                array,
-                explore,
-              }),
-            ],
+            [],
           ),
-        empty: ts.factory.createNewExpression(
-          ts.factory.createIdentifier("Set"),
-          [TypeFactory.keyword("any")],
-          [],
-        ),
-        success: ts.factory.createTrue(),
-        failure: (input, expected) =>
-          create_throw_error({ importer: props.importer, expected, input }),
-      })([])(props.input, props.sets, props.explore),
+          success: ts.factory.createTrue(),
+          failure: (v) =>
+            create_throw_error({
+              importer: props.importer,
+              expected: v.expected,
+              input: v.input,
+            }),
+        },
+        parameters: [],
+        input: props.input,
+        sets: props.sets,
+        explore: props.explore,
+      }),
       undefined,
       undefined,
     );
@@ -559,52 +576,62 @@ export namespace NotationGeneralProgrammer {
   }): ts.Expression =>
     ts.factory.createCallExpression(
       UnionExplorer.map({
-        checker: (top, entry, explore) =>
-          ts.factory.createLogicalAnd(
-            IsProgrammer.decode({
-              context: props.context,
-              importer: props.importer,
-              input: ts.factory.createElementAccessExpression(top, 0),
-              metadata: entry[0],
-              explore: {
-                ...props.explore,
-                postfix: `${explore.postfix}[0]`,
-              },
-            }),
-            IsProgrammer.decode({
-              context: props.context,
-              importer: props.importer,
-              input: ts.factory.createElementAccessExpression(top, 1),
-              metadata: entry[1],
-              explore: {
-                ...props.explore,
-                postfix: `${props.explore.postfix}[1]`,
-              },
-            }),
-          ),
-        decoder: (input, array, explore) =>
-          ts.factory.createNewExpression(
-            ts.factory.createIdentifier("Map"),
-            [TypeFactory.keyword("any"), TypeFactory.keyword("any")],
-            [
-              decode_array({
-                config: props.config,
+        config: {
+          checker: (v) =>
+            ts.factory.createLogicalAnd(
+              IsProgrammer.decode({
+                context: props.context,
                 importer: props.importer,
-                input,
-                array,
-                explore,
+                input: ts.factory.createElementAccessExpression(v.input, 0),
+                metadata: v.definition[0],
+                explore: {
+                  ...props.explore,
+                  postfix: `${v.explore.postfix}[0]`,
+                },
               }),
-            ],
+              IsProgrammer.decode({
+                context: props.context,
+                importer: props.importer,
+                input: ts.factory.createElementAccessExpression(v.input, 1),
+                metadata: v.definition[1],
+                explore: {
+                  ...props.explore,
+                  postfix: `${props.explore.postfix}[1]`,
+                },
+              }),
+            ),
+          decoder: (v) =>
+            ts.factory.createNewExpression(
+              ts.factory.createIdentifier("Map"),
+              [TypeFactory.keyword("any"), TypeFactory.keyword("any")],
+              [
+                decode_array({
+                  config: props.config,
+                  importer: props.importer,
+                  input: v.input,
+                  array: v.definition,
+                  explore: v.explore,
+                }),
+              ],
+            ),
+          empty: ts.factory.createNewExpression(
+            ts.factory.createIdentifier("Map"),
+            [TypeFactory.keyword("any"), TypeFactory.keyword("any")],
+            [],
           ),
-        empty: ts.factory.createNewExpression(
-          ts.factory.createIdentifier("Map"),
-          [TypeFactory.keyword("any"), TypeFactory.keyword("any")],
-          [],
-        ),
-        success: ts.factory.createTrue(),
-        failure: (input, expected) =>
-          create_throw_error({ importer: props.importer, expected, input }),
-      })([])(props.input, props.maps, props.explore),
+          success: ts.factory.createTrue(),
+          failure: (v) =>
+            create_throw_error({
+              importer: props.importer,
+              expected: v.expected,
+              input: v.input,
+            }),
+        },
+        parameters: [],
+        input: props.input,
+        maps: props.maps,
+        explore: props.explore,
+      }),
       undefined,
       undefined,
     );
@@ -637,37 +664,47 @@ export namespace NotationGeneralProgrammer {
     config: FeatureProgrammer.IConfig;
     importer: FunctionImporter;
     input: ts.Expression;
-    elements: MetadataArray[];
+    arrays: MetadataArray[];
     explore: FeatureProgrammer.IExplore;
   }): ts.Expression =>
     explore_array_like_union_types({
       ...props,
-      factory: UnionExplorer.array({
-        checker: (input, metadata, explore) =>
-          IsProgrammer.decode({
-            context: props.context,
-            importer: props.importer,
-            input,
-            metadata,
-            explore,
-          }),
-        decoder: (input, array, explore) =>
-          decode_array({
-            config: props.config,
-            importer: props.importer,
-            input,
-            array,
-            explore,
-          }),
-        empty: ts.factory.createIdentifier("[]"),
-        success: ts.factory.createTrue(),
-        failure: (input, expected) =>
-          create_throw_error({
-            importer: props.importer,
-            expected,
-            input,
-          }),
-      }),
+      factory: (next) =>
+        UnionExplorer.array({
+          config: {
+            checker: (v) =>
+              IsProgrammer.decode({
+                context: props.context,
+                importer: props.importer,
+                input: v.input,
+                metadata: v.definition,
+                explore: v.explore,
+              }),
+            decoder: (v) =>
+              decode_array({
+                config: props.config,
+                importer: props.importer,
+                input: v.input,
+                array: v.definition,
+                explore: v.explore,
+              }),
+            empty: ts.factory.createIdentifier("[]"),
+            success: ts.factory.createTrue(),
+            failure: (v) =>
+              create_throw_error({
+                importer: props.importer,
+                expected: v.expected,
+                input: v.input,
+              }),
+          },
+          parameters: next.parameters,
+          input: next.input,
+          arrays: next.definitions,
+          explore: next.explore,
+        }),
+      definitions: props.arrays,
+      input: props.input,
+      explore: props.explore,
     });
 
   const explore_array_like_union_types = <
@@ -675,23 +712,27 @@ export namespace NotationGeneralProgrammer {
   >(props: {
     config: FeatureProgrammer.IConfig;
     importer: FunctionImporter;
-    factory: (
-      parameters: ts.ParameterDeclaration[],
-    ) => (
-      input: ts.Expression,
-      elements: T[],
-      explore: FeatureProgrammer.IExplore,
-    ) => ts.ArrowFunction;
+    factory: (next: {
+      parameters: ts.ParameterDeclaration[];
+      input: ts.Expression;
+      definitions: T[];
+      explore: FeatureProgrammer.IExplore;
+    }) => ts.ArrowFunction;
     input: ts.Expression;
-    elements: T[];
+    definitions: T[];
     explore: FeatureProgrammer.IExplore;
   }): ts.Expression => {
     const arrow =
       (parameters: ts.ParameterDeclaration[]) =>
       (explore: FeatureProgrammer.IExplore) =>
       (input: ts.Expression): ts.ArrowFunction =>
-        props.factory(parameters)(input, props.elements, explore);
-    if (props.elements.every((e) => e.type.recursive === false))
+        props.factory({
+          parameters,
+          input,
+          definitions: props.definitions,
+          explore,
+        });
+    if (props.definitions.every((e) => e.type.recursive === false))
       ts.factory.createCallExpression(
         arrow([])(props.explore)(props.input),
         undefined,
@@ -707,7 +748,7 @@ export namespace NotationGeneralProgrammer {
       ts.factory.createIdentifier(
         props.importer.emplaceUnion(
           props.config.prefix,
-          props.elements.map((e) => e.type.name).join(" | "),
+          props.definitions.map((e) => e.type.name).join(" | "),
           () =>
             arrow(
               FeatureProgrammer.parameterDeclarations({
@@ -739,18 +780,25 @@ export namespace NotationGeneralProgrammer {
     rename: (str: string) => string;
     context: ITypiaContext;
     importer: FunctionImporter;
-  }): FeatureProgrammer.IConfig => {
-    const config: FeatureProgrammer.IConfig = {
+  }): FeatureProgrammer.IConfig<ts.Expression> => {
+    const config: FeatureProgrammer.IConfig<ts.Expression> = {
       types: {
         input: (type, name) =>
           ts.factory.createTypeReferenceNode(
-            name ?? TypeFactory.getFullName(props.context.checker)(type),
+            name ??
+              TypeFactory.getFullName({ checker: props.context.checker, type }),
           ),
         output: (type, name) =>
           ts.factory.createTypeReferenceNode(
-            returnType(props.rename)(
-              name ?? TypeFactory.getFullName(props.context.checker)(type),
-            ),
+            returnType({
+              rename: props.rename,
+              type:
+                name ??
+                TypeFactory.getFullName({
+                  checker: props.context.checker,
+                  type,
+                }),
+            }),
           ),
       },
       prefix: PREFIX,
@@ -782,30 +830,40 @@ export namespace NotationGeneralProgrammer {
             input: next.input,
             explore: next.explore,
           }),
-        joiner: NotationJoiner.object(props.rename),
+        joiner: (next) =>
+          NotationJoiner.object({
+            rename: props.rename,
+            input: next.input!,
+            entries: next.entries,
+          }),
         unionizer: (next) =>
-          decode_union_object((input, object, explore) =>
-            IsProgrammer.decode_object({
-              context: props.context,
-              importer: props.importer,
-              object,
-              input,
-              explore,
-            }),
-          )((input, object, explore) =>
-            decode_object({
-              importer: props.importer,
-              object,
-              input,
-              explore,
-            }),
-          )((exp) => exp)((input, expected) =>
-            create_throw_error({
-              importer: props.importer,
-              expected,
-              input,
-            }),
-          )(next.input, next.objects, next.explore),
+          decode_union_object({
+            checker: (v) =>
+              IsProgrammer.decode_object({
+                context: props.context,
+                importer: props.importer,
+                object: v.object,
+                input: v.input,
+                explore: v.explore,
+              }),
+            decoder: (v) =>
+              decode_object({
+                importer: props.importer,
+                object: v.object,
+                input: v.input,
+                explore: v.explore,
+              }),
+            success: (exp) => exp,
+            escaper: (v) =>
+              create_throw_error({
+                importer: props.importer,
+                expected: v.expected,
+                input: v.input,
+              }),
+            input: next.input,
+            objects: next.objects,
+            explore: next.explore,
+          }),
         failure: (next) =>
           create_throw_error({
             importer: props.importer,

package/src/programmers/notations/NotationIsGeneralProgrammer.ts

@@ -43,8 +43,14 @@ export namespace NotationIsGeneralProgrammer {
       statements: [
         ...is.statements,
         ...notation.statements,
-        StatementFactory.constant("__is", is.arrow),
-        StatementFactory.constant("__notation", notation.arrow),
+        StatementFactory.constant({
+          name: "__is",
+          value: is.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__notation",
+          value: notation.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,

package/src/programmers/notations/NotationValidateGeneralProgrammer.ts

@@ -43,8 +43,14 @@ export namespace NotationValidateGeneralProgrammer {
       statements: [
         ...validate.statements,
         ...notation.statements,
-        StatementFactory.constant("__validate", validate.arrow),
-        StatementFactory.constant("__notation", notation.arrow),
+        StatementFactory.constant({
+          name: "__validate",
+          value: validate.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__notation",
+          value: notation.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,
@@ -56,9 +62,9 @@ export namespace NotationValidateGeneralProgrammer {
         undefined,
         ts.factory.createBlock(
           [
-            StatementFactory.constant(
-              "result",
-              ts.factory.createAsExpression(
+            StatementFactory.constant({
+              name: "result",
+              value: ts.factory.createAsExpression(
                 ts.factory.createCallExpression(
                   ts.factory.createIdentifier("__validate"),
                   undefined,
@@ -66,7 +72,7 @@ export namespace NotationValidateGeneralProgrammer {
                 ),
                 TypeFactory.keyword("any"),
               ),
-            ),
+            }),
             ts.factory.createIfStatement(
               ts.factory.createIdentifier("result.success"),
               ts.factory.createExpressionStatement(

package/src/programmers/protobuf/ProtobufAssertDecodeProgrammer.ts

@@ -44,8 +44,14 @@ export namespace ProtobufAssertDecodeProgrammer {
       statements: [
         ...assert.statements,
         ...decode.statements,
-        StatementFactory.constant("__assert", assert.arrow),
-        StatementFactory.constant("__decode", decode.arrow),
+        StatementFactory.constant({
+          name: "__assert",
+          value: assert.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__decode",
+          value: decode.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,

package/src/programmers/protobuf/ProtobufAssertEncodeProgrammer.ts

@@ -46,8 +46,14 @@ export namespace ProtobufAssertEncodeProgrammer {
       statements: [
         ...assert.statements,
         ...encode.statements,
-        StatementFactory.constant("__assert", assert.arrow),
-        StatementFactory.constant("__encode", encode.arrow),
+        StatementFactory.constant({
+          name: "__assert",
+          value: assert.arrow,
+        }),
+        StatementFactory.constant({
+          name: "__encode",
+          value: encode.arrow,
+        }),
       ],
       arrow: ts.factory.createArrowFunction(
         undefined,