typia 5.5.7 → 5.5.8-dev.20240402

package/src/programmers/functional/FunctionalAssertParametersProgrammer.ts

@@ -1,81 +1,81 @@
-import ts from "typescript";
-
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProject } from "../../transformers/IProject";
-
-import { AssertProgrammer } from "../AssertProgrammer";
-import { FunctionalAssertFunctionProgrammer } from "./FunctionalAssertFunctionProgrammer";
-import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
-
-export namespace FunctionalAssertParametersProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      expression: ts.Expression,
-      declaration: ts.FunctionDeclaration,
-      init?: ts.Expression,
-    ): ts.ArrowFunction => {
-      const wrapper = FunctionalAssertFunctionProgrammer.errorFactoryWrapper(
-        modulo,
-      )(declaration.parameters)(init);
-      const { async } = FunctionalGeneralProgrammer.getReturnType(
-        project.checker,
-      )(declaration);
-      return ts.factory.createArrowFunction(
-        async
-          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
-          : undefined,
-        undefined,
-        declaration.parameters,
-        declaration.type,
-        undefined,
-        ts.factory.createBlock(
-          [
-            wrapper.variable,
-            ...argumentExpressions(project)(modulo)(equals)(
-              declaration.parameters,
-              wrapper.name,
-            ).map(ts.factory.createExpressionStatement),
-            ts.factory.createReturnStatement(
-              ts.factory.createCallExpression(
-                expression,
-                undefined,
-                declaration.parameters.map((p) =>
-                  ts.factory.createIdentifier(p.name.getText()),
-                ),
-              ),
-            ),
-          ],
-          true,
-        ),
-      );
-    };
-
-  export const argumentExpressions =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      parameters: readonly ts.ParameterDeclaration[],
-      wrapper: string,
-    ): ts.CallExpression[] =>
-      parameters.map((p, i) =>
-        ts.factory.createCallExpression(
-          AssertProgrammer.write(project)(modulo)(equals)(
-            p.type
-              ? project.checker.getTypeFromTypeNode(p.type)
-              : project.checker.getTypeFromTypeNode(TypeFactory.keyword("any")),
-            undefined,
-            FunctionalAssertFunctionProgrammer.hookPath({
-              wrapper,
-              replacer: `$input.parameters[${i}]`,
-            }),
-          ),
-          undefined,
-          [ts.factory.createIdentifier(p.name.getText())],
-        ),
-      );
-}
+import ts from "typescript";
+
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { AssertProgrammer } from "../AssertProgrammer";
+import { FunctionalAssertFunctionProgrammer } from "./FunctionalAssertFunctionProgrammer";
+import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
+
+export namespace FunctionalAssertParametersProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+      init?: ts.Expression,
+    ): ts.ArrowFunction => {
+      const wrapper = FunctionalAssertFunctionProgrammer.errorFactoryWrapper(
+        modulo,
+      )(declaration.parameters)(init);
+      const { async } = FunctionalGeneralProgrammer.getReturnType(
+        project.checker,
+      )(declaration);
+      return ts.factory.createArrowFunction(
+        async
+          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+          : undefined,
+        undefined,
+        declaration.parameters,
+        declaration.type,
+        undefined,
+        ts.factory.createBlock(
+          [
+            wrapper.variable,
+            ...argumentExpressions(project)(modulo)(equals)(
+              declaration.parameters,
+              wrapper.name,
+            ).map(ts.factory.createExpressionStatement),
+            ts.factory.createReturnStatement(
+              ts.factory.createCallExpression(
+                expression,
+                undefined,
+                declaration.parameters.map((p) =>
+                  ts.factory.createIdentifier(p.name.getText()),
+                ),
+              ),
+            ),
+          ],
+          true,
+        ),
+      );
+    };
+
+  export const argumentExpressions =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      parameters: readonly ts.ParameterDeclaration[],
+      wrapper: string,
+    ): ts.CallExpression[] =>
+      parameters.map((p, i) =>
+        ts.factory.createCallExpression(
+          AssertProgrammer.write(project)(modulo)(equals)(
+            p.type
+              ? project.checker.getTypeFromTypeNode(p.type)
+              : project.checker.getTypeFromTypeNode(TypeFactory.keyword("any")),
+            undefined,
+            FunctionalAssertFunctionProgrammer.hookPath({
+              wrapper,
+              replacer: `$input.parameters[${i}]`,
+            }),
+          ),
+          undefined,
+          [ts.factory.createIdentifier(p.name.getText())],
+        ),
+      );
+}

package/src/programmers/functional/FunctionalAssertReturnProgrammer.ts

@@ -1,77 +1,77 @@
-import ts from "typescript";
-
-import { IProject } from "../../transformers/IProject";
-
-import { AssertProgrammer } from "../AssertProgrammer";
-import { FunctionalAssertFunctionProgrammer } from "./FunctionalAssertFunctionProgrammer";
-import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
-
-export namespace FunctionAssertReturnProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      expression: ts.Expression,
-      declaration: ts.FunctionDeclaration,
-      init?: ts.Expression,
-    ): ts.ArrowFunction => {
-      const wrapper = FunctionalAssertFunctionProgrammer.errorFactoryWrapper(
-        modulo,
-      )(declaration.parameters)(init);
-      const { async, returns: statement } = returnStatement(project)(modulo)(
-        equals,
-      )(expression, declaration, wrapper.name);
-      return ts.factory.createArrowFunction(
-        async
-          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
-          : undefined,
-        undefined,
-        declaration.parameters,
-        declaration.type,
-        undefined,
-        ts.factory.createBlock([wrapper.variable, statement], true),
-      );
-    };
-
-  export const returnStatement =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      expression: ts.Expression,
-      declaration: ts.FunctionDeclaration,
-      wrapper: string,
-    ): {
-      async: boolean;
-      returns: ts.ReturnStatement;
-    } => {
-      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()),
-        ),
-      );
-      return {
-        async,
-        returns: ts.factory.createReturnStatement(
-          ts.factory.createCallExpression(
-            AssertProgrammer.write(project)(modulo)(equals)(
-              type,
-              undefined,
-              FunctionalAssertFunctionProgrammer.hookPath({
-                wrapper,
-                replacer: "$input.return",
-              }),
-            ),
-            undefined,
-            [async ? ts.factory.createAwaitExpression(caller) : caller],
-          ),
-        ),
-      };
-    };
-}
+import ts from "typescript";
+
+import { IProject } from "../../transformers/IProject";
+
+import { AssertProgrammer } from "../AssertProgrammer";
+import { FunctionalAssertFunctionProgrammer } from "./FunctionalAssertFunctionProgrammer";
+import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
+
+export namespace FunctionAssertReturnProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+      init?: ts.Expression,
+    ): ts.ArrowFunction => {
+      const wrapper = FunctionalAssertFunctionProgrammer.errorFactoryWrapper(
+        modulo,
+      )(declaration.parameters)(init);
+      const { async, returns: statement } = returnStatement(project)(modulo)(
+        equals,
+      )(expression, declaration, wrapper.name);
+      return ts.factory.createArrowFunction(
+        async
+          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+          : undefined,
+        undefined,
+        declaration.parameters,
+        declaration.type,
+        undefined,
+        ts.factory.createBlock([wrapper.variable, statement], true),
+      );
+    };
+
+  export const returnStatement =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+      wrapper: string,
+    ): {
+      async: boolean;
+      returns: ts.ReturnStatement;
+    } => {
+      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()),
+        ),
+      );
+      return {
+        async,
+        returns: ts.factory.createReturnStatement(
+          ts.factory.createCallExpression(
+            AssertProgrammer.write(project)(modulo)(equals)(
+              type,
+              undefined,
+              FunctionalAssertFunctionProgrammer.hookPath({
+                wrapper,
+                replacer: "$input.return",
+              }),
+            ),
+            undefined,
+            [async ? ts.factory.createAwaitExpression(caller) : caller],
+          ),
+        ),
+      };
+    };
+}

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

@@ -5,8 +5,8 @@ import { TypeFactory } from "../../factories/TypeFactory";
 import { IProject } from "../../transformers/IProject";
 
 import { IsProgrammer } from "../IsProgrammer";
-import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
 import { FunctionalIsFunctionProgrammer } from "./FunctionalIsFunctionProgrammer";
+import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
 
 export namespace FunctionalIsParametersProgrammer {
   export const write =

package/src/programmers/functional/FunctionalIsReturnProgrammer.ts

@@ -7,8 +7,8 @@ import { IProject } from "../../transformers/IProject";
 import { StringUtil } from "../../utils/StringUtil";
 
 import { IsProgrammer } from "../IsProgrammer";
-import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
 import { FunctionalIsFunctionProgrammer } from "./FunctionalIsFunctionProgrammer";
+import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
 
 export namespace FunctionalIsReturnProgrammer {
   export const write =