typia 5.5.5 → 5.5.6-dev.20240319

package/src/programmers/functional/FunctionalIsFunctionProgrammer.ts

@@ -1,61 +1,61 @@
-import ts from "typescript";
-
-import { IProject } from "../../transformers/IProject";
-
-import { FunctionalIsParametersProgrammer } from "./FunctionalIsParametersProgrammer";
-import { FunctionalIsReturnProgrammer } from "./FunctionalIsReturnProgrammer";
-
-export namespace FunctionalIsFunctionProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      expression: ts.Expression,
-      declaration: ts.FunctionDeclaration,
-    ): ts.ArrowFunction => {
-      const { async, statements } =
-        FunctionalIsReturnProgrammer.writeStatements(project)(modulo)(equals)(
-          expression,
-          declaration,
-        );
-      return ts.factory.createArrowFunction(
-        async
-          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
-          : undefined,
-        undefined,
-        declaration.parameters,
-        getReturnTypeNode(declaration, async),
-        undefined,
-        ts.factory.createBlock(
-          [
-            ...FunctionalIsParametersProgrammer.writeStatements(project)(
-              modulo,
-            )(equals)(declaration),
-            ...statements,
-          ],
-          true,
-        ),
-      );
-    };
-
-  export const getReturnTypeNode = (
-    declaration: ts.FunctionDeclaration,
-    async: boolean,
-  ): ts.TypeNode | undefined =>
-    declaration.type
-      ? async
-        ? !!(declaration.type! as ts.TypeReferenceNode).typeArguments?.[0]
-          ? ts.factory.createTypeReferenceNode("Promise", [
-              ts.factory.createUnionTypeNode([
-                (declaration.type! as ts.TypeReferenceNode).typeArguments![0]!,
-                ts.factory.createTypeReferenceNode("null"),
-              ]),
-            ])
-          : undefined
-        : ts.factory.createUnionTypeNode([
-            declaration.type,
-            ts.factory.createTypeReferenceNode("null"),
-          ])
-      : undefined;
-}
+import ts from "typescript";
+
+import { IProject } from "../../transformers/IProject";
+
+import { FunctionalIsParametersProgrammer } from "./FunctionalIsParametersProgrammer";
+import { FunctionalIsReturnProgrammer } from "./FunctionalIsReturnProgrammer";
+
+export namespace FunctionalIsFunctionProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+    ): ts.ArrowFunction => {
+      const { async, statements } =
+        FunctionalIsReturnProgrammer.writeStatements(project)(modulo)(equals)(
+          expression,
+          declaration,
+        );
+      return ts.factory.createArrowFunction(
+        async
+          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+          : undefined,
+        undefined,
+        declaration.parameters,
+        getReturnTypeNode(declaration, async),
+        undefined,
+        ts.factory.createBlock(
+          [
+            ...FunctionalIsParametersProgrammer.writeStatements(project)(
+              modulo,
+            )(equals)(declaration),
+            ...statements,
+          ],
+          true,
+        ),
+      );
+    };
+
+  export const getReturnTypeNode = (
+    declaration: ts.FunctionDeclaration,
+    async: boolean,
+  ): ts.TypeNode | undefined =>
+    declaration.type
+      ? async
+        ? !!(declaration.type! as ts.TypeReferenceNode).typeArguments?.[0]
+          ? ts.factory.createTypeReferenceNode("Promise", [
+              ts.factory.createUnionTypeNode([
+                (declaration.type! as ts.TypeReferenceNode).typeArguments![0]!,
+                ts.factory.createTypeReferenceNode("null"),
+              ]),
+            ])
+          : undefined
+        : ts.factory.createUnionTypeNode([
+            declaration.type,
+            ts.factory.createTypeReferenceNode("null"),
+          ])
+      : undefined;
+}

package/src/programmers/functional/FunctionalIsParametersProgrammer.ts

@@ -1,73 +1,73 @@
-import ts from "typescript";
-
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProject } from "../../transformers/IProject";
-
-import { IsProgrammer } from "../IsProgrammer";
-import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
-import { FunctionalIsFunctionProgrammer } from "./FunctionalIsFunctionProgrammer";
-
-export namespace FunctionalIsParametersProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      expression: ts.Expression,
-      declaration: ts.FunctionDeclaration,
-    ): ts.ArrowFunction => {
-      const { async } = FunctionalGeneralProgrammer.getReturnType(
-        project.checker,
-      )(declaration);
-      return ts.factory.createArrowFunction(
-        async
-          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
-          : undefined,
-        undefined,
-        declaration.parameters,
-        FunctionalIsFunctionProgrammer.getReturnTypeNode(declaration, async),
-        undefined,
-        ts.factory.createBlock(
-          [
-            ...writeStatements(project)(modulo)(equals)(declaration),
-            ts.factory.createReturnStatement(
-              ts.factory.createCallExpression(
-                expression,
-                undefined,
-                declaration.parameters.map((p) =>
-                  ts.factory.createIdentifier(p.name.getText()),
-                ),
-              ),
-            ),
-          ],
-          true,
-        ),
-      );
-    };
-
-  export const writeStatements =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (declaration: ts.FunctionDeclaration): ts.Statement[] =>
-      declaration.parameters
-        .map((p) => [
-          ts.factory.createIfStatement(
-            ts.factory.createStrictEquality(
-              ts.factory.createFalse(),
-              ts.factory.createCallExpression(
-                IsProgrammer.write(project)(modulo)(equals)(
-                  project.checker.getTypeFromTypeNode(
-                    p.type ?? TypeFactory.keyword("any"),
-                  ),
-                ),
-                undefined,
-                [ts.factory.createIdentifier(p.name.getText())],
-              ),
-            ),
-            ts.factory.createReturnStatement(ts.factory.createNull()),
-          ),
-        ])
-        .flat();
-}
+import ts from "typescript";
+
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { IsProgrammer } from "../IsProgrammer";
+import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
+import { FunctionalIsFunctionProgrammer } from "./FunctionalIsFunctionProgrammer";
+
+export namespace FunctionalIsParametersProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+    ): ts.ArrowFunction => {
+      const { async } = FunctionalGeneralProgrammer.getReturnType(
+        project.checker,
+      )(declaration);
+      return ts.factory.createArrowFunction(
+        async
+          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+          : undefined,
+        undefined,
+        declaration.parameters,
+        FunctionalIsFunctionProgrammer.getReturnTypeNode(declaration, async),
+        undefined,
+        ts.factory.createBlock(
+          [
+            ...writeStatements(project)(modulo)(equals)(declaration),
+            ts.factory.createReturnStatement(
+              ts.factory.createCallExpression(
+                expression,
+                undefined,
+                declaration.parameters.map((p) =>
+                  ts.factory.createIdentifier(p.name.getText()),
+                ),
+              ),
+            ),
+          ],
+          true,
+        ),
+      );
+    };
+
+  export const writeStatements =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (declaration: ts.FunctionDeclaration): ts.Statement[] =>
+      declaration.parameters
+        .map((p) => [
+          ts.factory.createIfStatement(
+            ts.factory.createStrictEquality(
+              ts.factory.createFalse(),
+              ts.factory.createCallExpression(
+                IsProgrammer.write(project)(modulo)(equals)(
+                  project.checker.getTypeFromTypeNode(
+                    p.type ?? TypeFactory.keyword("any"),
+                  ),
+                ),
+                undefined,
+                [ts.factory.createIdentifier(p.name.getText())],
+              ),
+            ),
+            ts.factory.createReturnStatement(ts.factory.createNull()),
+          ),
+        ])
+        .flat();
+}

package/src/programmers/functional/FunctionalIsReturnProgrammer.ts

@@ -1,84 +1,84 @@
-import ts from "typescript";
-
-import { StatementFactory } from "../../factories/StatementFactory";
-
-import { IProject } from "../../transformers/IProject";
-
-import { StringUtil } from "../../utils/StringUtil";
-
-import { IsProgrammer } from "../IsProgrammer";
-import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
-import { FunctionalIsFunctionProgrammer } from "./FunctionalIsFunctionProgrammer";
-
-export namespace FunctionalIsReturnProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      expression: ts.Expression,
-      declaration: ts.FunctionDeclaration,
-    ): ts.ArrowFunction => {
-      const { async, statements } = writeStatements(project)(modulo)(equals)(
-        expression,
-        declaration,
-      );
-      return ts.factory.createArrowFunction(
-        async
-          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
-          : undefined,
-        undefined,
-        declaration.parameters,
-        FunctionalIsFunctionProgrammer.getReturnTypeNode(declaration, async),
-        undefined,
-        ts.factory.createBlock(statements, true),
-      );
-    };
-
-  export const writeStatements =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      expression: ts.Expression,
-      declaration: ts.FunctionDeclaration,
-    ): {
-      async: boolean;
-      statements: ts.Statement[];
-    } => {
-      const { type, async } = FunctionalGeneralProgrammer.getReturnType(
-        project.checker,
-      )(declaration);
-      const caller: ts.CallExpression = ts.factory.createCallExpression(
-        expression,
-        undefined,
-        declaration.parameters.map((p) =>
-          ts.factory.createIdentifier(p.name.getText()),
-        ),
-      );
-
-      const name: string = StringUtil.escapeDuplicate(
-        declaration.parameters.map((p) => p.name.getText()),
-      )("result");
-      const statements: ts.Statement[] = [
-        StatementFactory.constant(
-          name,
-          async ? ts.factory.createAwaitExpression(caller) : caller,
-        ),
-        ts.factory.createReturnStatement(
-          ts.factory.createConditionalExpression(
-            ts.factory.createCallExpression(
-              IsProgrammer.write(project)(modulo)(equals)(type),
-              undefined,
-              [ts.factory.createIdentifier(name)],
-            ),
-            undefined,
-            ts.factory.createIdentifier(name),
-            undefined,
-            ts.factory.createNull(),
-          ),
-        ),
-      ];
-      return { async, statements };
-    };
-}
+import ts from "typescript";
+
+import { StatementFactory } from "../../factories/StatementFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { StringUtil } from "../../utils/StringUtil";
+
+import { IsProgrammer } from "../IsProgrammer";
+import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
+import { FunctionalIsFunctionProgrammer } from "./FunctionalIsFunctionProgrammer";
+
+export namespace FunctionalIsReturnProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+    ): ts.ArrowFunction => {
+      const { async, statements } = writeStatements(project)(modulo)(equals)(
+        expression,
+        declaration,
+      );
+      return ts.factory.createArrowFunction(
+        async
+          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+          : undefined,
+        undefined,
+        declaration.parameters,
+        FunctionalIsFunctionProgrammer.getReturnTypeNode(declaration, async),
+        undefined,
+        ts.factory.createBlock(statements, true),
+      );
+    };
+
+  export const writeStatements =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+    ): {
+      async: boolean;
+      statements: ts.Statement[];
+    } => {
+      const { type, async } = FunctionalGeneralProgrammer.getReturnType(
+        project.checker,
+      )(declaration);
+      const caller: ts.CallExpression = ts.factory.createCallExpression(
+        expression,
+        undefined,
+        declaration.parameters.map((p) =>
+          ts.factory.createIdentifier(p.name.getText()),
+        ),
+      );
+
+      const name: string = StringUtil.escapeDuplicate(
+        declaration.parameters.map((p) => p.name.getText()),
+      )("result");
+      const statements: ts.Statement[] = [
+        StatementFactory.constant(
+          name,
+          async ? ts.factory.createAwaitExpression(caller) : caller,
+        ),
+        ts.factory.createReturnStatement(
+          ts.factory.createConditionalExpression(
+            ts.factory.createCallExpression(
+              IsProgrammer.write(project)(modulo)(equals)(type),
+              undefined,
+              [ts.factory.createIdentifier(name)],
+            ),
+            undefined,
+            ts.factory.createIdentifier(name),
+            undefined,
+            ts.factory.createNull(),
+          ),
+        ),
+      ];
+      return { async, statements };
+    };
+}

package/src/programmers/functional/FunctionalValidateFunctionProgrammer.ts

@@ -1,113 +1,113 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-
-import { IProject } from "../../transformers/IProject";
-
-import { FunctionalValidateParametersProgrammer } from "./FunctionalValidateParametersProgrammer";
-import { FunctionalValidateReturnProgrammer } from "./FunctionalValidateReturnProgrammer";
-
-export namespace FunctionalValidateFunctionProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      expression: ts.Expression,
-      declaration: ts.FunctionDeclaration,
-    ): ts.ArrowFunction => {
-      const { async, statements } =
-        FunctionalValidateReturnProgrammer.writeStatements(project)(modulo)(
-          equals,
-        )(expression, declaration);
-      return ts.factory.createArrowFunction(
-        async
-          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
-          : undefined,
-        undefined,
-        declaration.parameters,
-        getReturnTypeNode(declaration, async),
-        undefined,
-        ts.factory.createBlock(
-          [
-            ...FunctionalValidateParametersProgrammer.writeStatements(project)(
-              modulo,
-            )(equals)(declaration),
-            ...statements,
-          ],
-          true,
-        ),
-      );
-    };
-
-  export const hookErrors = (props: {
-    expression: ts.Expression;
-    replacer: ts.Expression;
-  }): ts.CallExpression =>
-    ts.factory.createCallExpression(
-      ts.factory.createPropertyAccessExpression(props.expression, "map"),
-      undefined,
-      [
-        ts.factory.createArrowFunction(
-          undefined,
-          undefined,
-          [IdentifierFactory.parameter("error")],
-          undefined,
-          undefined,
-          ts.factory.createObjectLiteralExpression(
-            [
-              ts.factory.createSpreadAssignment(
-                ts.factory.createIdentifier("error"),
-              ),
-              ts.factory.createPropertyAssignment(
-                "path",
-                ts.factory.createCallExpression(
-                  ts.factory.createPropertyAccessExpression(
-                    ts.factory.createPropertyAccessExpression(
-                      ts.factory.createIdentifier("error"),
-                      "path",
-                    ),
-                    "replace",
-                  ),
-                  undefined,
-                  [ts.factory.createStringLiteral("$input"), props.replacer],
-                ),
-              ),
-            ],
-            true,
-          ),
-        ),
-      ],
-    );
-
-  export const getReturnTypeNode = (
-    declaration: ts.FunctionDeclaration,
-    async: boolean,
-  ): ts.TypeNode | undefined =>
-    declaration.type
-      ? async
-        ? !!(declaration.type! as ts.TypeReferenceNode).typeArguments?.[0]
-          ? ts.factory.createTypeReferenceNode("Promise", [
-              ts.factory.createImportTypeNode(
-                ts.factory.createLiteralTypeNode(
-                  ts.factory.createStringLiteral("typia"),
-                ),
-                undefined,
-                ts.factory.createIdentifier("IValidation"),
-                [
-                  (declaration.type! as ts.TypeReferenceNode)
-                    .typeArguments![0]!,
-                ],
-              ),
-            ])
-          : undefined
-        : ts.factory.createImportTypeNode(
-            ts.factory.createLiteralTypeNode(
-              ts.factory.createStringLiteral("typia"),
-            ),
-            undefined,
-            ts.factory.createIdentifier("IValidation"),
-            [declaration.type],
-          )
-      : undefined;
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { FunctionalValidateParametersProgrammer } from "./FunctionalValidateParametersProgrammer";
+import { FunctionalValidateReturnProgrammer } from "./FunctionalValidateReturnProgrammer";
+
+export namespace FunctionalValidateFunctionProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+    ): ts.ArrowFunction => {
+      const { async, statements } =
+        FunctionalValidateReturnProgrammer.writeStatements(project)(modulo)(
+          equals,
+        )(expression, declaration);
+      return ts.factory.createArrowFunction(
+        async
+          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+          : undefined,
+        undefined,
+        declaration.parameters,
+        getReturnTypeNode(declaration, async),
+        undefined,
+        ts.factory.createBlock(
+          [
+            ...FunctionalValidateParametersProgrammer.writeStatements(project)(
+              modulo,
+            )(equals)(declaration),
+            ...statements,
+          ],
+          true,
+        ),
+      );
+    };
+
+  export const hookErrors = (props: {
+    expression: ts.Expression;
+    replacer: ts.Expression;
+  }): ts.CallExpression =>
+    ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(props.expression, "map"),
+      undefined,
+      [
+        ts.factory.createArrowFunction(
+          undefined,
+          undefined,
+          [IdentifierFactory.parameter("error")],
+          undefined,
+          undefined,
+          ts.factory.createObjectLiteralExpression(
+            [
+              ts.factory.createSpreadAssignment(
+                ts.factory.createIdentifier("error"),
+              ),
+              ts.factory.createPropertyAssignment(
+                "path",
+                ts.factory.createCallExpression(
+                  ts.factory.createPropertyAccessExpression(
+                    ts.factory.createPropertyAccessExpression(
+                      ts.factory.createIdentifier("error"),
+                      "path",
+                    ),
+                    "replace",
+                  ),
+                  undefined,
+                  [ts.factory.createStringLiteral("$input"), props.replacer],
+                ),
+              ),
+            ],
+            true,
+          ),
+        ),
+      ],
+    );
+
+  export const getReturnTypeNode = (
+    declaration: ts.FunctionDeclaration,
+    async: boolean,
+  ): ts.TypeNode | undefined =>
+    declaration.type
+      ? async
+        ? !!(declaration.type! as ts.TypeReferenceNode).typeArguments?.[0]
+          ? ts.factory.createTypeReferenceNode("Promise", [
+              ts.factory.createImportTypeNode(
+                ts.factory.createLiteralTypeNode(
+                  ts.factory.createStringLiteral("typia"),
+                ),
+                undefined,
+                ts.factory.createIdentifier("IValidation"),
+                [
+                  (declaration.type! as ts.TypeReferenceNode)
+                    .typeArguments![0]!,
+                ],
+              ),
+            ])
+          : undefined
+        : ts.factory.createImportTypeNode(
+            ts.factory.createLiteralTypeNode(
+              ts.factory.createStringLiteral("typia"),
+            ),
+            undefined,
+            ts.factory.createIdentifier("IValidation"),
+            [declaration.type],
+          )
+      : undefined;
+}