typia 6.10.2 → 6.10.3-dev.20240925

package/src/programmers/functional/FunctionalValidateParametersProgrammer.ts

@@ -1,267 +1,267 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProject } from "../../transformers/IProject";
-
-import { StringUtil } from "../../utils/StringUtil";
-
-import { ValidateProgrammer } from "../ValidateProgrammer";
-import { FunctionalValidateFunctionProgrammer } from "./FunctionalValidateFunctionProgrammer";
-import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
-
-export namespace FunctionalValidateParametersProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      expression: ts.Expression,
-      declaration: ts.FunctionDeclaration,
-    ): ts.CallExpression => {
-      const { async } = FunctionalGeneralProgrammer.getReturnType(
-        project.checker,
-      )(declaration);
-      const result = decompose(project)(modulo)(equals)(declaration);
-      const caller: ts.CallExpression = ts.factory.createCallExpression(
-        expression,
-        undefined,
-        declaration.parameters.map((p) =>
-          ts.factory.createIdentifier(p.name.getText()),
-        ),
-      );
-      return ExpressionFactory.selfCall(
-        ts.factory.createBlock(
-          [
-            ...result.functions,
-            ts.factory.createReturnStatement(
-              ts.factory.createArrowFunction(
-                async
-                  ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
-                  : undefined,
-                undefined,
-                declaration.parameters,
-                FunctionalValidateFunctionProgrammer.getReturnTypeNode(
-                  declaration,
-                  async,
-                ),
-                undefined,
-                ts.factory.createBlock(
-                  [
-                    ...result.statements,
-                    ts.factory.createReturnStatement(
-                      ts.factory.createObjectLiteralExpression(
-                        [
-                          ts.factory.createPropertyAssignment(
-                            "success",
-                            ts.factory.createTrue(),
-                          ),
-                          ts.factory.createPropertyAssignment(
-                            "data",
-                            async
-                              ? ts.factory.createAwaitExpression(caller)
-                              : caller,
-                          ),
-                          ts.factory.createPropertyAssignment(
-                            "errors",
-                            ts.factory.createArrayLiteralExpression([]),
-                          ),
-                        ],
-                        true,
-                      ),
-                    ),
-                  ],
-                  true,
-                ),
-              ),
-            ),
-          ],
-          true,
-        ),
-      );
-    };
-
-  export const decompose =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      declaration: ts.FunctionDeclaration,
-    ): {
-      functions: ts.Statement[];
-      statements: ts.Statement[];
-    } => {
-      const resultName: string = StringUtil.escapeDuplicate(
-        declaration.parameters.map((p) => p.name.getText()),
-      )("paramErrorResults");
-      const validationResultArray: ts.ArrayLiteralExpression =
-        ts.factory.createArrayLiteralExpression(
-          declaration.parameters.map((p, i) =>
-            ts.factory.createAsExpression(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier(`__validate_param_${i}`),
-                undefined,
-                [ts.factory.createIdentifier(p.name.getText())],
-              ),
-              ts.factory.createImportTypeNode(
-                ts.factory.createLiteralTypeNode(
-                  ts.factory.createStringLiteral("typia"),
-                ),
-                undefined,
-                ts.factory.createQualifiedName(
-                  ts.factory.createIdentifier("IValidation"),
-                  ts.factory.createIdentifier("IFailure"),
-                ),
-                undefined,
-                false,
-              ),
-            ),
-          ),
-          true,
-        );
-      const errorMatrix = ts.factory.createCallExpression(
-        ts.factory.createPropertyAccessExpression(validationResultArray, "map"),
-        undefined,
-        [
-          ts.factory.createArrowFunction(
-            undefined,
-            undefined,
-            [
-              IdentifierFactory.parameter("r"),
-              IdentifierFactory.parameter("i"),
-            ],
-            undefined,
-            undefined,
-            ts.factory.createConditionalExpression(
-              ts.factory.createStrictEquality(
-                ts.factory.createTrue(),
-                ts.factory.createPropertyAccessExpression(
-                  ts.factory.createIdentifier("r"),
-                  "success",
-                ),
-              ),
-              undefined,
-              ts.factory.createIdentifier("r"),
-              undefined,
-              ts.factory.createObjectLiteralExpression(
-                [
-                  ts.factory.createSpreadAssignment(
-                    ts.factory.createIdentifier("r"),
-                  ),
-                  ts.factory.createPropertyAssignment(
-                    "errors",
-                    FunctionalValidateFunctionProgrammer.hookErrors({
-                      expression: ts.factory.createPropertyAccessExpression(
-                        ts.factory.createIdentifier("r"),
-                        "errors",
-                      ),
-                      replacer: ts.factory.createTemplateExpression(
-                        ts.factory.createTemplateHead("$input.parameters["),
-                        [
-                          ts.factory.createTemplateSpan(
-                            ts.factory.createIdentifier("i"),
-                            ts.factory.createTemplateTail("]"),
-                          ),
-                        ],
-                      ),
-                    }),
-                  ),
-                ],
-                true,
-              ),
-            ),
-          ),
-        ],
-      );
-      const failures = ts.factory.createCallExpression(
-        ts.factory.createPropertyAccessExpression(errorMatrix, "filter"),
-        undefined,
-        [
-          ts.factory.createArrowFunction(
-            undefined,
-            undefined,
-            [IdentifierFactory.parameter("r")],
-            undefined,
-            undefined,
-            ts.factory.createStrictEquality(
-              ts.factory.createFalse(),
-              ts.factory.createPropertyAccessExpression(
-                ts.factory.createIdentifier("r"),
-                "success",
-              ),
-            ),
-          ),
-        ],
-      );
-      return {
-        functions: declaration.parameters.map((p, i) =>
-          StatementFactory.constant(
-            `__validate_param_${i}`,
-            ValidateProgrammer.write(project)(modulo)(equals)(
-              project.checker.getTypeFromTypeNode(
-                p.type ?? TypeFactory.keyword("any"),
-              ),
-            ),
-          ),
-        ),
-        statements: [
-          StatementFactory.constant(resultName, failures),
-          ts.factory.createIfStatement(
-            ts.factory.createStrictInequality(
-              ts.factory.createNumericLiteral("0"),
-              ts.factory.createPropertyAccessExpression(
-                ts.factory.createIdentifier(resultName),
-                "length",
-              ),
-            ),
-            ts.factory.createReturnStatement(
-              ts.factory.createObjectLiteralExpression(
-                [
-                  ts.factory.createPropertyAssignment(
-                    "success",
-                    ts.factory.createFalse(),
-                  ),
-                  ts.factory.createPropertyAssignment(
-                    "errors",
-                    ts.factory.createCallExpression(
-                      IdentifierFactory.access(
-                        ts.factory.createCallExpression(
-                          IdentifierFactory.access(
-                            ts.factory.createIdentifier(resultName),
-                          )("map"),
-                          undefined,
-                          [
-                            ts.factory.createArrowFunction(
-                              undefined,
-                              undefined,
-                              [
-                                IdentifierFactory.parameter(
-                                  "r",
-                                  TypeFactory.keyword("any"),
-                                ),
-                              ],
-                              undefined,
-                              undefined,
-                              IdentifierFactory.access(
-                                ts.factory.createIdentifier("r"),
-                              )("errors"),
-                            ),
-                          ],
-                        ),
-                      )("flat"),
-                      undefined,
-                      undefined,
-                    ),
-                  ),
-                ],
-                true,
-              ),
-            ),
-          ),
-        ],
-      };
-    };
-}
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { StringUtil } from "../../utils/StringUtil";
+
+import { ValidateProgrammer } from "../ValidateProgrammer";
+import { FunctionalValidateFunctionProgrammer } from "./FunctionalValidateFunctionProgrammer";
+import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
+
+export namespace FunctionalValidateParametersProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+    ): ts.CallExpression => {
+      const { async } = FunctionalGeneralProgrammer.getReturnType(
+        project.checker,
+      )(declaration);
+      const result = decompose(project)(modulo)(equals)(declaration);
+      const caller: ts.CallExpression = ts.factory.createCallExpression(
+        expression,
+        undefined,
+        declaration.parameters.map((p) =>
+          ts.factory.createIdentifier(p.name.getText()),
+        ),
+      );
+      return ExpressionFactory.selfCall(
+        ts.factory.createBlock(
+          [
+            ...result.functions,
+            ts.factory.createReturnStatement(
+              ts.factory.createArrowFunction(
+                async
+                  ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                  : undefined,
+                undefined,
+                declaration.parameters,
+                FunctionalValidateFunctionProgrammer.getReturnTypeNode(
+                  declaration,
+                  async,
+                ),
+                undefined,
+                ts.factory.createBlock(
+                  [
+                    ...result.statements,
+                    ts.factory.createReturnStatement(
+                      ts.factory.createObjectLiteralExpression(
+                        [
+                          ts.factory.createPropertyAssignment(
+                            "success",
+                            ts.factory.createTrue(),
+                          ),
+                          ts.factory.createPropertyAssignment(
+                            "data",
+                            async
+                              ? ts.factory.createAwaitExpression(caller)
+                              : caller,
+                          ),
+                          ts.factory.createPropertyAssignment(
+                            "errors",
+                            ts.factory.createArrayLiteralExpression([]),
+                          ),
+                        ],
+                        true,
+                      ),
+                    ),
+                  ],
+                  true,
+                ),
+              ),
+            ),
+          ],
+          true,
+        ),
+      );
+    };
+
+  export const decompose =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      declaration: ts.FunctionDeclaration,
+    ): {
+      functions: ts.Statement[];
+      statements: ts.Statement[];
+    } => {
+      const resultName: string = StringUtil.escapeDuplicate(
+        declaration.parameters.map((p) => p.name.getText()),
+      )("paramErrorResults");
+      const validationResultArray: ts.ArrayLiteralExpression =
+        ts.factory.createArrayLiteralExpression(
+          declaration.parameters.map((p, i) =>
+            ts.factory.createAsExpression(
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier(`__validate_param_${i}`),
+                undefined,
+                [ts.factory.createIdentifier(p.name.getText())],
+              ),
+              ts.factory.createImportTypeNode(
+                ts.factory.createLiteralTypeNode(
+                  ts.factory.createStringLiteral("typia"),
+                ),
+                undefined,
+                ts.factory.createQualifiedName(
+                  ts.factory.createIdentifier("IValidation"),
+                  ts.factory.createIdentifier("IFailure"),
+                ),
+                undefined,
+                false,
+              ),
+            ),
+          ),
+          true,
+        );
+      const errorMatrix = ts.factory.createCallExpression(
+        ts.factory.createPropertyAccessExpression(validationResultArray, "map"),
+        undefined,
+        [
+          ts.factory.createArrowFunction(
+            undefined,
+            undefined,
+            [
+              IdentifierFactory.parameter("r"),
+              IdentifierFactory.parameter("i"),
+            ],
+            undefined,
+            undefined,
+            ts.factory.createConditionalExpression(
+              ts.factory.createStrictEquality(
+                ts.factory.createTrue(),
+                ts.factory.createPropertyAccessExpression(
+                  ts.factory.createIdentifier("r"),
+                  "success",
+                ),
+              ),
+              undefined,
+              ts.factory.createIdentifier("r"),
+              undefined,
+              ts.factory.createObjectLiteralExpression(
+                [
+                  ts.factory.createSpreadAssignment(
+                    ts.factory.createIdentifier("r"),
+                  ),
+                  ts.factory.createPropertyAssignment(
+                    "errors",
+                    FunctionalValidateFunctionProgrammer.hookErrors({
+                      expression: ts.factory.createPropertyAccessExpression(
+                        ts.factory.createIdentifier("r"),
+                        "errors",
+                      ),
+                      replacer: ts.factory.createTemplateExpression(
+                        ts.factory.createTemplateHead("$input.parameters["),
+                        [
+                          ts.factory.createTemplateSpan(
+                            ts.factory.createIdentifier("i"),
+                            ts.factory.createTemplateTail("]"),
+                          ),
+                        ],
+                      ),
+                    }),
+                  ),
+                ],
+                true,
+              ),
+            ),
+          ),
+        ],
+      );
+      const failures = ts.factory.createCallExpression(
+        ts.factory.createPropertyAccessExpression(errorMatrix, "filter"),
+        undefined,
+        [
+          ts.factory.createArrowFunction(
+            undefined,
+            undefined,
+            [IdentifierFactory.parameter("r")],
+            undefined,
+            undefined,
+            ts.factory.createStrictEquality(
+              ts.factory.createFalse(),
+              ts.factory.createPropertyAccessExpression(
+                ts.factory.createIdentifier("r"),
+                "success",
+              ),
+            ),
+          ),
+        ],
+      );
+      return {
+        functions: declaration.parameters.map((p, i) =>
+          StatementFactory.constant(
+            `__validate_param_${i}`,
+            ValidateProgrammer.write(project)(modulo)(equals)(
+              project.checker.getTypeFromTypeNode(
+                p.type ?? TypeFactory.keyword("any"),
+              ),
+            ),
+          ),
+        ),
+        statements: [
+          StatementFactory.constant(resultName, failures),
+          ts.factory.createIfStatement(
+            ts.factory.createStrictInequality(
+              ts.factory.createNumericLiteral("0"),
+              ts.factory.createPropertyAccessExpression(
+                ts.factory.createIdentifier(resultName),
+                "length",
+              ),
+            ),
+            ts.factory.createReturnStatement(
+              ts.factory.createObjectLiteralExpression(
+                [
+                  ts.factory.createPropertyAssignment(
+                    "success",
+                    ts.factory.createFalse(),
+                  ),
+                  ts.factory.createPropertyAssignment(
+                    "errors",
+                    ts.factory.createCallExpression(
+                      IdentifierFactory.access(
+                        ts.factory.createCallExpression(
+                          IdentifierFactory.access(
+                            ts.factory.createIdentifier(resultName),
+                          )("map"),
+                          undefined,
+                          [
+                            ts.factory.createArrowFunction(
+                              undefined,
+                              undefined,
+                              [
+                                IdentifierFactory.parameter(
+                                  "r",
+                                  TypeFactory.keyword("any"),
+                                ),
+                              ],
+                              undefined,
+                              undefined,
+                              IdentifierFactory.access(
+                                ts.factory.createIdentifier("r"),
+                              )("errors"),
+                            ),
+                          ],
+                        ),
+                      )("flat"),
+                      undefined,
+                      undefined,
+                    ),
+                  ),
+                ],
+                true,
+              ),
+            ),
+          ),
+        ],
+      };
+    };
+}