typia 7.0.0-dev.20240930 → 7.0.0-dev.20241001

package/src/programmers/http/HttpFormDataProgrammer.ts

@@ -51,7 +51,10 @@ export namespace HttpFormDataProgrammer {
 
     // DO TRANSFORM
     const object: MetadataObject = result.data.objects[0]!;
-    const statements: ts.Statement[] = decode_object(props.importer)(object);
+    const statements: ts.Statement[] = decode_object({
+      importer: props.importer,
+      object,
+    });
     return {
       functions: {},
       statements: [],
@@ -154,126 +157,144 @@ export namespace HttpFormDataProgrammer {
     return errors;
   };
 
-  const decode_object =
-    (importer: FunctionImporter) =>
-    (object: MetadataObject): ts.Statement[] => {
-      // const input: ts.Identifier = ts.factory.createIdentifier("input");
-      const output: ts.Identifier = ts.factory.createIdentifier("output");
-      return [
-        StatementFactory.constant(
-          "output",
-          ts.factory.createObjectLiteralExpression(
-            object.properties.map((prop) =>
-              decode_regular_property(importer)(prop),
-            ),
-            true,
+  const decode_object = (props: {
+    importer: FunctionImporter;
+    object: MetadataObject;
+  }): ts.Statement[] => {
+    // const input: ts.Identifier = ts.factory.createIdentifier("input");
+    const output: ts.Identifier = ts.factory.createIdentifier("output");
+    return [
+      StatementFactory.constant(
+        "output",
+        ts.factory.createObjectLiteralExpression(
+          props.object.properties.map((p) =>
+            decode_regular_property({
+              importer: props.importer,
+              property: p,
+            }),
           ),
+          true,
         ),
-        ts.factory.createReturnStatement(
-          ts.factory.createAsExpression(output, TypeFactory.keyword("any")),
-        ),
-      ];
-    };
+      ),
+      ts.factory.createReturnStatement(
+        ts.factory.createAsExpression(output, TypeFactory.keyword("any")),
+      ),
+    ];
+  };
 
-  const decode_regular_property =
-    (importer: FunctionImporter) =>
-    (property: MetadataProperty): ts.PropertyAssignment => {
-      const key: string = property.key.constants[0]!.values[0]!.value as string;
-      const value: Metadata = property.value;
+  const decode_regular_property = (props: {
+    importer: FunctionImporter;
+    property: MetadataProperty;
+  }): ts.PropertyAssignment => {
+    const key: string = props.property.key.constants[0]!.values[0]!
+      .value as string;
+    const value: Metadata = props.property.value;
 
-      const [type, isArray]: [Atomic.Literal | "blob" | "file", boolean] = value
-        .atomics.length
-        ? [value.atomics[0]!.type, false]
-        : value.constants.length
-          ? [value.constants[0]!.type, false]
-          : value.templates.length
-            ? ["string", false]
-            : value.natives.includes("Blob")
-              ? ["blob", false]
-              : value.natives.includes("File")
-                ? ["file", false]
-                : (() => {
-                    const meta =
-                      value.arrays[0]?.type.value ??
-                      value.tuples[0]!.type.elements[0]!;
-                    return meta.atomics.length
-                      ? [meta.atomics[0]!.type, true]
-                      : meta.templates.length
-                        ? ["string", true]
-                        : meta.natives.includes("Blob")
-                          ? ["blob", true]
-                          : meta.natives.includes("File")
-                            ? ["file", true]
-                            : [meta.constants[0]!.type, true];
-                  })();
-      return ts.factory.createPropertyAssignment(
-        Escaper.variable(key) ? key : ts.factory.createStringLiteral(key),
-        isArray
-          ? decode_array(importer)(value)(
-              ts.factory.createCallExpression(
-                IdentifierFactory.access(
-                  ts.factory.createCallExpression(
-                    ts.factory.createIdentifier("input.getAll"),
-                    undefined,
-                    [ts.factory.createStringLiteral(key)],
-                  ),
-                )("map"),
-                undefined,
-                [
-                  ts.factory.createArrowFunction(
-                    undefined,
-                    undefined,
-                    [IdentifierFactory.parameter("elem")],
-                    undefined,
-                    undefined,
-                    decode_value(importer)(type)(false)(
-                      ts.factory.createIdentifier("elem"),
-                    ),
-                  ),
-                ],
-              ),
-            )
-          : decode_value(importer)(type)(
-              value.nullable === false && value.isRequired() === false,
-            )(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("input.get"),
-                undefined,
-                [ts.factory.createStringLiteral(key)],
-              ),
+    const [type, isArray]: [Atomic.Literal | "blob" | "file", boolean] = value
+      .atomics.length
+      ? [value.atomics[0]!.type, false]
+      : value.constants.length
+        ? [value.constants[0]!.type, false]
+        : value.templates.length
+          ? ["string", false]
+          : value.natives.includes("Blob")
+            ? ["blob", false]
+            : value.natives.includes("File")
+              ? ["file", false]
+              : (() => {
+                  const meta =
+                    value.arrays[0]?.type.value ??
+                    value.tuples[0]!.type.elements[0]!;
+                  return meta.atomics.length
+                    ? [meta.atomics[0]!.type, true]
+                    : meta.templates.length
+                      ? ["string", true]
+                      : meta.natives.includes("Blob")
+                        ? ["blob", true]
+                        : meta.natives.includes("File")
+                          ? ["file", true]
+                          : [meta.constants[0]!.type, true];
+                })();
+    return ts.factory.createPropertyAssignment(
+      Escaper.variable(key) ? key : ts.factory.createStringLiteral(key),
+      isArray
+        ? decode_array({
+            importer: props.importer,
+            metadata: value,
+            input: ts.factory.createCallExpression(
+              IdentifierFactory.access(
+                ts.factory.createCallExpression(
+                  ts.factory.createIdentifier("input.getAll"),
+                  undefined,
+                  [ts.factory.createStringLiteral(key)],
+                ),
+              )("map"),
+              undefined,
+              [
+                ts.factory.createArrowFunction(
+                  undefined,
+                  undefined,
+                  [IdentifierFactory.parameter("elem")],
+                  undefined,
+                  undefined,
+                  decode_value({
+                    importer: props.importer,
+                    type,
+                    coalesce: false,
+                    input: ts.factory.createIdentifier("elem"),
+                  }),
+                ),
+              ],
             ),
-      );
-    };
+          })
+        : decode_value({
+            importer: props.importer,
+            type,
+            coalesce: value.nullable === false && value.isRequired() === false,
+            input: ts.factory.createCallExpression(
+              ts.factory.createIdentifier("input.get"),
+              undefined,
+              [ts.factory.createStringLiteral(key)],
+            ),
+          }),
+    );
+  };
 
-  const decode_value =
-    (importer: FunctionImporter) =>
-    (type: Atomic.Literal | "blob" | "file") =>
-    (onlyUndefindable: boolean) =>
-    (value: ts.Expression) => {
-      const call = ts.factory.createCallExpression(
-        importer.use(type),
-        undefined,
-        [value],
-      );
-      return onlyUndefindable
-        ? ts.factory.createBinaryExpression(
-            call,
-            ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken),
-            ts.factory.createIdentifier("undefined"),
-          )
-        : call;
-    };
+  const decode_value = (props: {
+    importer: FunctionImporter;
+    type: Atomic.Literal | "blob" | "file";
+    coalesce: boolean;
+    input: ts.Expression;
+  }) => {
+    const call = ts.factory.createCallExpression(
+      props.importer.use(props.type),
+      undefined,
+      [props.input],
+    );
+    return props.coalesce
+      ? ts.factory.createBinaryExpression(
+          call,
+          ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken),
+          ts.factory.createIdentifier("undefined"),
+        )
+      : call;
+  };
 
-  const decode_array =
-    (importer: FunctionImporter) =>
-    (value: Metadata) =>
-    (expression: ts.Expression): ts.Expression =>
-      value.nullable || value.isRequired() === false
-        ? ts.factory.createCallExpression(importer.use("array"), undefined, [
-            expression,
-            value.nullable
+  const decode_array = (props: {
+    importer: FunctionImporter;
+    metadata: Metadata;
+    input: ts.Expression;
+  }): ts.Expression =>
+    props.metadata.nullable || props.metadata.isRequired() === false
+      ? ts.factory.createCallExpression(
+          props.importer.use("array"),
+          undefined,
+          [
+            props.input,
+            props.metadata.nullable
               ? ts.factory.createNull()
               : ts.factory.createIdentifier("undefined"),
-          ])
-        : expression;
+          ],
+        )
+      : props.input;
 }

package/src/programmers/http/HttpHeadersProgrammer.ts

@@ -55,7 +55,10 @@ export namespace HttpHeadersProgrammer {
 
     // DO TRANSFORM
     const object: MetadataObject = result.data.objects[0]!;
-    const statements: ts.Statement[] = decode_object(props.importer)(object);
+    const statements: ts.Statement[] = decode_object({
+      importer: props.importer,
+      object,
+    });
     return {
       functions: {},
       statements: [],
@@ -195,135 +198,157 @@ export namespace HttpHeadersProgrammer {
     return errors;
   };
 
-  const decode_object =
-    (importer: FunctionImporter) =>
-    (object: MetadataObject): ts.Statement[] => {
-      const output: ts.Identifier = ts.factory.createIdentifier("output");
-      const optionals: string[] = [];
-      return [
-        StatementFactory.constant(
-          "output",
-          ts.factory.createObjectLiteralExpression(
-            object.properties.map((prop) => {
-              if (
-                !prop.value.isRequired() &&
-                prop.value.arrays.length + prop.value.tuples.length > 0
-              )
-                optionals.push(
-                  prop.key.constants[0]!.values[0]!.value as string,
-                );
-              return decode_regular_property(importer)(prop);
-            }),
-            true,
-          ),
-        ),
-        ...optionals.map((key) => {
-          const access = IdentifierFactory.access(output)(key);
-          return ts.factory.createIfStatement(
-            ts.factory.createStrictEquality(
-              ExpressionFactory.number(0),
-              IdentifierFactory.access(access)("length"),
-            ),
-            ts.factory.createExpressionStatement(
-              ts.factory.createDeleteExpression(access),
-            ),
-          );
-        }),
-        ts.factory.createReturnStatement(
-          ts.factory.createAsExpression(output, TypeFactory.keyword("any")),
+  const decode_object = (props: {
+    importer: FunctionImporter;
+    object: MetadataObject;
+  }): ts.Statement[] => {
+    const output: ts.Identifier = ts.factory.createIdentifier("output");
+    const optionals: string[] = [];
+    return [
+      StatementFactory.constant(
+        "output",
+        ts.factory.createObjectLiteralExpression(
+          props.object.properties.map((p) => {
+            if (
+              !p.value.isRequired() &&
+              p.value.arrays.length + p.value.tuples.length > 0
+            )
+              optionals.push(p.key.constants[0]!.values[0]!.value as string);
+            return decode_regular_property({
+              importer: props.importer,
+              property: p,
+            });
+          }),
+          true,
         ),
-      ];
-    };
+      ),
+      ...optionals.map((key) => {
+        const access = IdentifierFactory.access(output)(key);
+        return ts.factory.createIfStatement(
+          ts.factory.createStrictEquality(
+            ExpressionFactory.number(0),
+            IdentifierFactory.access(access)("length"),
+          ),
+          ts.factory.createExpressionStatement(
+            ts.factory.createDeleteExpression(access),
+          ),
+        );
+      }),
+      ts.factory.createReturnStatement(
+        ts.factory.createAsExpression(output, TypeFactory.keyword("any")),
+      ),
+    ];
+  };
 
-  const decode_regular_property =
-    (importer: FunctionImporter) =>
-    (property: MetadataProperty): ts.PropertyAssignment => {
-      const key: string = property.key.constants[0]!.values[0]!.value as string;
-      const value: Metadata = property.value;
+  const decode_regular_property = (props: {
+    importer: FunctionImporter;
+    property: MetadataProperty;
+  }): ts.PropertyAssignment => {
+    const key: string = props.property.key.constants[0]!.values[0]!
+      .value as string;
+    const value: Metadata = props.property.value;
 
-      const [type, isArray]: [Atomic.Literal, boolean] = value.atomics.length
-        ? [value.atomics[0]!.type, false]
-        : value.constants.length
-          ? [value.constants[0]!.type, false]
-          : value.templates.length
-            ? ["string", false]
-            : (() => {
-                const meta: Metadata =
-                  value.arrays[0]?.type.value ??
-                  value.tuples[0]!.type.elements[0]!;
-                return meta.atomics.length
-                  ? [meta.atomics[0]!.type, true]
-                  : meta.templates.length
-                    ? ["string", true]
-                    : [meta.constants[0]!.type, true];
-              })();
-      const accessor = IdentifierFactory.access(
-        ts.factory.createIdentifier("input"),
-      )(key.toLowerCase());
+    const [type, isArray]: [Atomic.Literal, boolean] = value.atomics.length
+      ? [value.atomics[0]!.type, false]
+      : value.constants.length
+        ? [value.constants[0]!.type, false]
+        : value.templates.length
+          ? ["string", false]
+          : (() => {
+              const meta: Metadata =
+                value.arrays[0]?.type.value ??
+                value.tuples[0]!.type.elements[0]!;
+              return meta.atomics.length
+                ? [meta.atomics[0]!.type, true]
+                : meta.templates.length
+                  ? ["string", true]
+                  : [meta.constants[0]!.type, true];
+            })();
+    const input = IdentifierFactory.access(
+      ts.factory.createIdentifier("input"),
+    )(key.toLowerCase());
 
-      return ts.factory.createPropertyAssignment(
-        Escaper.variable(key) ? key : ts.factory.createStringLiteral(key),
-        isArray
-          ? key === "set-cookie"
-            ? accessor
-            : decode_array(importer)(type)(key)(value)(accessor)
-          : decode_value(importer)(type)(accessor),
-      );
-    };
+    return ts.factory.createPropertyAssignment(
+      Escaper.variable(key) ? key : ts.factory.createStringLiteral(key),
+      isArray
+        ? key === "set-cookie"
+          ? input
+          : decode_array({
+              importer: props.importer,
+              type,
+              key,
+              value,
+              input,
+            })
+        : decode_value({
+            importer: props.importer,
+            type,
+            input,
+          }),
+    );
+  };
 
-  const decode_value =
-    (importer: FunctionImporter) =>
-    (type: Atomic.Literal) =>
-    (value: ts.Expression) =>
-      type === "string"
-        ? value
-        : ts.factory.createCallExpression(importer.use(type), undefined, [
-            value,
-          ]);
+  const decode_value = (props: {
+    importer: FunctionImporter;
+    type: Atomic.Literal;
+    input: ts.Expression;
+  }) =>
+    props.type === "string"
+      ? props.input
+      : ts.factory.createCallExpression(
+          props.importer.use(props.type),
+          undefined,
+          [props.input],
+        );
 
-  const decode_array =
-    (importer: FunctionImporter) =>
-    (type: Atomic.Literal) =>
-    (key: string) =>
-    (value: Metadata) =>
-    (accessor: ts.Expression) => {
-      const split: ts.CallChain = ts.factory.createCallChain(
-        ts.factory.createPropertyAccessChain(
-          ts.factory.createCallChain(
-            ts.factory.createPropertyAccessChain(
-              accessor,
-              ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
-              ts.factory.createIdentifier("split"),
-            ),
-            undefined,
-            undefined,
-            [ts.factory.createStringLiteral(key === "cookie" ? "; " : ", ")],
+  const decode_array = (props: {
+    importer: FunctionImporter;
+    type: Atomic.Literal;
+    key: string;
+    value: Metadata;
+    input: ts.Expression;
+  }) => {
+    const split: ts.CallChain = ts.factory.createCallChain(
+      ts.factory.createPropertyAccessChain(
+        ts.factory.createCallChain(
+          ts.factory.createPropertyAccessChain(
+            props.input,
+            ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
+            ts.factory.createIdentifier("split"),
           ),
-          ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
-          ts.factory.createIdentifier("map"),
-        ),
-        undefined,
-        undefined,
-        [importer.use(type)],
-      );
-      return ts.factory.createConditionalExpression(
-        ExpressionFactory.isArray(accessor),
-        undefined,
-        ts.factory.createCallExpression(
-          IdentifierFactory.access(accessor)("map"),
           undefined,
-          [importer.use(type)],
+          undefined,
+          [
+            ts.factory.createStringLiteral(
+              props.key === "cookie" ? "; " : ", ",
+            ),
+          ],
         ),
+        ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
+        ts.factory.createIdentifier("map"),
+      ),
+      undefined,
+      undefined,
+      [props.importer.use(props.type)],
+    );
+    return ts.factory.createConditionalExpression(
+      ExpressionFactory.isArray(props.input),
+      undefined,
+      ts.factory.createCallExpression(
+        IdentifierFactory.access(props.input)("map"),
         undefined,
-        value.isRequired() === false
-          ? split
-          : ts.factory.createBinaryExpression(
-              split,
-              ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken),
-              ts.factory.createArrayLiteralExpression([], false),
-            ),
-      );
-    };
+        [props.importer.use(props.type)],
+      ),
+      undefined,
+      props.value.isRequired() === false
+        ? split
+        : ts.factory.createBinaryExpression(
+            split,
+            ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken),
+            ts.factory.createArrayLiteralExpression([], false),
+          ),
+    );
+  };
 }
 
 const SINGULAR: Set<string> = new Set([