typia 7.0.0-dev.20240919 → 7.0.0-dev.20240921

package/src/programmers/helpers/StringifyJoinder.ts

@@ -9,52 +9,54 @@ import { FunctionImporter } from "./FunctionImporter";
 import { IExpressionEntry } from "./IExpressionEntry";
 
 export namespace StringifyJoiner {
-  export const object =
-    (importer: FunctionImporter) =>
-    (props: { entries: IExpressionEntry<ts.Expression>[] }): ts.Expression => {
-      // CHECK AND SORT ENTRIES
-      if (props.entries.length === 0)
-        return ts.factory.createStringLiteral("{}");
+  export const object = (props: {
+    importer: FunctionImporter;
+    entries: IExpressionEntry<ts.Expression>[];
+  }): ts.Expression => {
+    // CHECK AND SORT ENTRIES
+    if (props.entries.length === 0) return ts.factory.createStringLiteral("{}");
 
-      // PROPERTIES
-      const regular: IExpressionEntry<ts.Expression>[] = props.entries.filter(
-        (entry) => entry.key.isSoleLiteral(),
-      );
-      const dynamic: IExpressionEntry<ts.Expression>[] = props.entries.filter(
-        (entry) => !entry.key.isSoleLiteral(),
-      );
-      const expressions: ts.Expression[] = [
-        ...stringify_regular_properties(regular, dynamic),
-        ...(dynamic.length
-          ? [
-              stringify_dynamic_properties(
-                dynamic,
-                regular.map((r) => r.key.getSoleLiteral()!),
-              ),
-            ]
-          : []),
-      ];
+    // PROPERTIES
+    const regular: IExpressionEntry<ts.Expression>[] = props.entries.filter(
+      (entry) => entry.key.isSoleLiteral(),
+    );
+    const dynamic: IExpressionEntry<ts.Expression>[] = props.entries.filter(
+      (entry) => !entry.key.isSoleLiteral(),
+    );
+    const expressions: ts.Expression[] = [
+      ...stringify_regular_properties(regular, dynamic),
+      ...(dynamic.length
+        ? [
+            stringify_dynamic_properties(
+              dynamic,
+              regular.map((r) => r.key.getSoleLiteral()!),
+            ),
+          ]
+        : []),
+    ];
 
-      // POP LAST COMMA, IF REQUIRED
-      const filtered: ts.Expression[] =
-        (regular.length &&
-          regular[regular.length - 1]!.meta.isRequired() &&
-          dynamic.length === 0) ||
-        (regular.length === 0 && dynamic.length)
-          ? expressions
-          : [
-              ts.factory.createCallExpression(importer.use("tail"), undefined, [
-                TemplateFactory.generate(expressions),
-              ]),
-            ];
+    // POP LAST COMMA, IF REQUIRED
+    const filtered: ts.Expression[] =
+      (regular.length &&
+        regular[regular.length - 1]!.meta.isRequired() &&
+        dynamic.length === 0) ||
+      (regular.length === 0 && dynamic.length)
+        ? expressions
+        : [
+            ts.factory.createCallExpression(
+              props.importer.use("tail"),
+              undefined,
+              [TemplateFactory.generate(expressions)],
+            ),
+          ];
 
-      // RETURNS WITH OBJECT BRACKET
-      return TemplateFactory.generate([
-        ts.factory.createStringLiteral(`{`),
-        ...filtered,
-        ts.factory.createStringLiteral(`}`),
-      ]);
-    };
+    // RETURNS WITH OBJECT BRACKET
+    return TemplateFactory.generate([
+      ts.factory.createStringLiteral(`{`),
+      ...filtered,
+      ts.factory.createStringLiteral(`}`),
+    ]);
+  };
 
   export const array = (props: {
     input: ts.Expression;

package/src/programmers/json/JsonStringifyProgrammer.ts

@@ -174,17 +174,16 @@ export namespace JsonStringifyProgrammer {
           metadata,
           explore,
         )(
-          wrap_functional(
+          wrap_functional({
             input,
             metadata,
             explore,
-          )(
-            ts.factory.createCallExpression(
+            expression: ts.factory.createCallExpression(
               ts.factory.createIdentifier("JSON.stringify"),
               undefined,
               [input],
             ),
-          ),
+          }),
         );
 
       // ONLY NULL OR UNDEFINED
@@ -470,7 +469,12 @@ export namespace JsonStringifyProgrammer {
             [],
             undefined,
             undefined,
-            iterate(importer, input, unions, metadata.getName()),
+            iterate({
+              importer,
+              input,
+              unions,
+              expected: metadata.getName(),
+            }),
           ),
           undefined,
           undefined,
@@ -709,7 +713,7 @@ export namespace JsonStringifyProgrammer {
           empty: ts.factory.createStringLiteral("[]"),
           success: ts.factory.createTrue(),
           failure: (input, expected) =>
-            create_throw_error(importer)(expected)(input),
+            create_throw_error({ importer, expected, input }),
         }),
       )(input, elements, explore);
 
@@ -808,40 +812,40 @@ export namespace JsonStringifyProgrammer {
       );
   };
 
-  const wrap_functional = (
-    input: ts.Expression,
-    meta: Metadata,
-    explore: FeatureProgrammer.IExplore,
-  ): ((expression: ts.Expression) => ts.Expression) => {
-    if (meta.functions.length === 0) return (expression) => expression;
-    return (expression) =>
-      ts.factory.createConditionalExpression(
-        ts.factory.createStrictInequality(
-          ts.factory.createStringLiteral("function"),
-          ValueFactory.TYPEOF(input),
-        ),
-        undefined,
-        expression,
-        undefined,
-        decode_functional(explore),
-      );
+  const wrap_functional = (props: {
+    input: ts.Expression;
+    metadata: Metadata;
+    explore: FeatureProgrammer.IExplore;
+    expression: ts.Expression;
+  }): ts.Expression => {
+    if (props.metadata.functions.length === 0) return props.expression;
+    return ts.factory.createConditionalExpression(
+      ts.factory.createStrictInequality(
+        ts.factory.createStringLiteral("function"),
+        ValueFactory.TYPEOF(props.input),
+      ),
+      undefined,
+      props.expression,
+      undefined,
+      decode_functional(props.explore),
+    );
   };
 
-  const iterate = (
-    importer: FunctionImporter,
-    input: ts.Expression,
-    unions: IUnion[],
-    expected: string,
-  ) =>
+  const iterate = (props: {
+    importer: FunctionImporter;
+    input: ts.Expression;
+    unions: IUnion[];
+    expected: string;
+  }) =>
     ts.factory.createBlock(
       [
-        ...unions.map((u) =>
+        ...props.unions.map((u) =>
           ts.factory.createIfStatement(
             u.is(),
             ts.factory.createReturnStatement(u.value()),
           ),
         ),
-        create_throw_error(importer)(expected)(input),
+        create_throw_error(props),
       ],
       true,
     );
@@ -854,7 +858,7 @@ export namespace JsonStringifyProgrammer {
   const configure =
     (project: ITypiaContext) =>
     (importer: FunctionImporter): FeatureProgrammer.IConfig => {
-      const config: FeatureProgrammer.IConfig = {
+      const config: FeatureProgrammer.IConfig<ts.Expression> = {
         types: {
           input: (type, name) =>
             ts.factory.createTypeReferenceNode(
@@ -870,14 +874,18 @@ export namespace JsonStringifyProgrammer {
         objector: {
           checker: () => IsProgrammer.decode(project)(importer),
           decoder: () => decode_object(importer),
-          joiner: StringifyJoiner.object(importer),
+          joiner: (props) =>
+            StringifyJoiner.object({
+              ...props,
+              importer,
+            }),
           unionizer: decode_union_object(
             IsProgrammer.decode_object(project)(importer),
-          )(decode_object(importer))((exp) => exp)((value, expected) =>
-            create_throw_error(importer)(expected)(value),
+          )(decode_object(importer))((exp) => exp)((input, expected) =>
+            create_throw_error({ importer, expected, input }),
           ),
           failure: (input, expected) =>
-            create_throw_error(importer)(expected)(input),
+            create_throw_error({ importer, expected, input }),
         },
         generator: {
           arrays: () => write_array_functions(config)(importer),
@@ -896,28 +904,29 @@ export namespace JsonStringifyProgrammer {
         type,
       });
 
-  const create_throw_error =
-    (importer: FunctionImporter) =>
-    (expected: string) =>
-    (value: ts.Expression) =>
-      ts.factory.createExpressionStatement(
-        ts.factory.createCallExpression(
-          importer.use("throws"),
-          [],
-          [
-            ts.factory.createObjectLiteralExpression(
-              [
-                ts.factory.createPropertyAssignment(
-                  "expected",
-                  ts.factory.createStringLiteral(expected),
-                ),
-                ts.factory.createPropertyAssignment("value", value),
-              ],
-              true,
-            ),
-          ],
-        ),
-      );
+  const create_throw_error = (props: {
+    importer: FunctionImporter;
+    expected: string;
+    input: ts.Expression;
+  }) =>
+    ts.factory.createExpressionStatement(
+      ts.factory.createCallExpression(
+        props.importer.use("throws"),
+        [],
+        [
+          ts.factory.createObjectLiteralExpression(
+            [
+              ts.factory.createPropertyAssignment(
+                "expected",
+                ts.factory.createStringLiteral(props.expected),
+              ),
+              ts.factory.createPropertyAssignment("value", props.input),
+            ],
+            true,
+          ),
+        ],
+      ),
+    );
 }
 
 interface IUnion {