typia 6.7.0 → 6.7.1

package/src/programmers/functional/FunctionalAssertReturnProgrammer.ts

@@ -1,98 +1,98 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-
-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.CallExpression => {
-      const wrapper = FunctionalAssertFunctionProgrammer.errorFactoryWrapper(
-        modulo,
-      )(declaration.parameters)(init);
-      const result = decompose(project)(modulo)(equals)(
-        expression,
-        declaration,
-        wrapper.name,
-      );
-      return ExpressionFactory.selfCall(
-        ts.factory.createBlock(
-          [
-            wrapper.variable,
-            ...result.functions,
-            ts.factory.createReturnStatement(
-              ts.factory.createArrowFunction(
-                result.async
-                  ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
-                  : undefined,
-                undefined,
-                declaration.parameters,
-                declaration.type,
-                undefined,
-                result.value,
-              ),
-            ),
-          ],
-          true,
-        ),
-      );
-    };
-
-  export const decompose =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      expression: ts.Expression,
-      declaration: ts.FunctionDeclaration,
-      wrapper: string,
-    ): {
-      async: boolean;
-      functions: ts.Statement[];
-      value: ts.Expression;
-    } => {
-      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,
-        functions: [
-          StatementFactory.constant(
-            "__assert_return",
-            AssertProgrammer.write(project)(modulo)(equals)(
-              type,
-              undefined,
-              FunctionalAssertFunctionProgrammer.hookPath({
-                wrapper,
-                replacer: "$input.return",
-              }),
-            ),
-          ),
-        ],
-        value: ts.factory.createCallExpression(
-          ts.factory.createIdentifier("__assert_return"),
-          undefined,
-          [async ? ts.factory.createAwaitExpression(caller) : caller],
-        ),
-      };
-    };
-}
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+
+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.CallExpression => {
+      const wrapper = FunctionalAssertFunctionProgrammer.errorFactoryWrapper(
+        modulo,
+      )(declaration.parameters)(init);
+      const result = decompose(project)(modulo)(equals)(
+        expression,
+        declaration,
+        wrapper.name,
+      );
+      return ExpressionFactory.selfCall(
+        ts.factory.createBlock(
+          [
+            wrapper.variable,
+            ...result.functions,
+            ts.factory.createReturnStatement(
+              ts.factory.createArrowFunction(
+                result.async
+                  ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                  : undefined,
+                undefined,
+                declaration.parameters,
+                declaration.type,
+                undefined,
+                result.value,
+              ),
+            ),
+          ],
+          true,
+        ),
+      );
+    };
+
+  export const decompose =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+      wrapper: string,
+    ): {
+      async: boolean;
+      functions: ts.Statement[];
+      value: ts.Expression;
+    } => {
+      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,
+        functions: [
+          StatementFactory.constant(
+            "__assert_return",
+            AssertProgrammer.write(project)(modulo)(equals)(
+              type,
+              undefined,
+              FunctionalAssertFunctionProgrammer.hookPath({
+                wrapper,
+                replacer: "$input.return",
+              }),
+            ),
+          ),
+        ],
+        value: ts.factory.createCallExpression(
+          ts.factory.createIdentifier("__assert_return"),
+          undefined,
+          [async ? ts.factory.createAwaitExpression(caller) : caller],
+        ),
+      };
+    };
+}

package/src/programmers/functional/FunctionalIsFunctionProgrammer.ts

@@ -1,72 +1,72 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-
-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.CallExpression => {
-      const p =
-        FunctionalIsParametersProgrammer.decompose(project)(modulo)(equals)(
-          declaration,
-        );
-      const r = FunctionalIsReturnProgrammer.decompose(project)(modulo)(equals)(
-        expression,
-        declaration,
-      );
-      return ExpressionFactory.selfCall(
-        ts.factory.createBlock(
-          [
-            ...p.functions,
-            ...r.functions,
-            ts.factory.createReturnStatement(
-              ts.factory.createArrowFunction(
-                r.async
-                  ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
-                  : undefined,
-                undefined,
-                declaration.parameters,
-                getReturnTypeNode(declaration, r.async),
-                undefined,
-                ts.factory.createBlock(
-                  [...p.statements, ...r.statements],
-                  true,
-                ),
-              ),
-            ),
-          ],
-          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 { ExpressionFactory } from "../../factories/ExpressionFactory";
+
+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.CallExpression => {
+      const p =
+        FunctionalIsParametersProgrammer.decompose(project)(modulo)(equals)(
+          declaration,
+        );
+      const r = FunctionalIsReturnProgrammer.decompose(project)(modulo)(equals)(
+        expression,
+        declaration,
+      );
+      return ExpressionFactory.selfCall(
+        ts.factory.createBlock(
+          [
+            ...p.functions,
+            ...r.functions,
+            ts.factory.createReturnStatement(
+              ts.factory.createArrowFunction(
+                r.async
+                  ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                  : undefined,
+                undefined,
+                declaration.parameters,
+                getReturnTypeNode(declaration, r.async),
+                undefined,
+                ts.factory.createBlock(
+                  [...p.statements, ...r.statements],
+                  true,
+                ),
+              ),
+            ),
+          ],
+          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,101 +1,101 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProject } from "../../transformers/IProject";
-
-import { IsProgrammer } from "../IsProgrammer";
-import { FunctionalIsFunctionProgrammer } from "./FunctionalIsFunctionProgrammer";
-import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
-
-export namespace FunctionalIsParametersProgrammer {
-  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);
-      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,
-                FunctionalIsFunctionProgrammer.getReturnTypeNode(
-                  declaration,
-                  async,
-                ),
-                undefined,
-                ts.factory.createBlock(
-                  [
-                    ...result.statements,
-                    ts.factory.createReturnStatement(
-                      ts.factory.createCallExpression(
-                        expression,
-                        undefined,
-                        declaration.parameters.map((p) =>
-                          ts.factory.createIdentifier(p.name.getText()),
-                        ),
-                      ),
-                    ),
-                  ],
-                  true,
-                ),
-              ),
-            ),
-          ],
-          true,
-        ),
-      );
-    };
-
-  export const decompose =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      declaration: ts.FunctionDeclaration,
-    ): {
-      functions: ts.Statement[];
-      statements: ts.Statement[];
-    } => ({
-      functions: declaration.parameters.map((p, i) =>
-        StatementFactory.constant(
-          `__is_param_${i}`,
-          IsProgrammer.write(project)(modulo)(equals)(
-            project.checker.getTypeFromTypeNode(
-              p.type ?? TypeFactory.keyword("any"),
-            ),
-          ),
-        ),
-      ),
-      statements: declaration.parameters
-        .map((p, i) => [
-          ts.factory.createIfStatement(
-            ts.factory.createStrictEquality(
-              ts.factory.createFalse(),
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier(`__is_param_${i}`),
-                undefined,
-                [ts.factory.createIdentifier(p.name.getText())],
-              ),
-            ),
-            ts.factory.createReturnStatement(ts.factory.createNull()),
-          ),
-        ])
-        .flat(),
-    });
-}
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { IsProgrammer } from "../IsProgrammer";
+import { FunctionalIsFunctionProgrammer } from "./FunctionalIsFunctionProgrammer";
+import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
+
+export namespace FunctionalIsParametersProgrammer {
+  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);
+      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,
+                FunctionalIsFunctionProgrammer.getReturnTypeNode(
+                  declaration,
+                  async,
+                ),
+                undefined,
+                ts.factory.createBlock(
+                  [
+                    ...result.statements,
+                    ts.factory.createReturnStatement(
+                      ts.factory.createCallExpression(
+                        expression,
+                        undefined,
+                        declaration.parameters.map((p) =>
+                          ts.factory.createIdentifier(p.name.getText()),
+                        ),
+                      ),
+                    ),
+                  ],
+                  true,
+                ),
+              ),
+            ),
+          ],
+          true,
+        ),
+      );
+    };
+
+  export const decompose =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      declaration: ts.FunctionDeclaration,
+    ): {
+      functions: ts.Statement[];
+      statements: ts.Statement[];
+    } => ({
+      functions: declaration.parameters.map((p, i) =>
+        StatementFactory.constant(
+          `__is_param_${i}`,
+          IsProgrammer.write(project)(modulo)(equals)(
+            project.checker.getTypeFromTypeNode(
+              p.type ?? TypeFactory.keyword("any"),
+            ),
+          ),
+        ),
+      ),
+      statements: declaration.parameters
+        .map((p, i) => [
+          ts.factory.createIfStatement(
+            ts.factory.createStrictEquality(
+              ts.factory.createFalse(),
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier(`__is_param_${i}`),
+                undefined,
+                [ts.factory.createIdentifier(p.name.getText())],
+              ),
+            ),
+            ts.factory.createReturnStatement(ts.factory.createNull()),
+          ),
+        ])
+        .flat(),
+    });
+}