typia 5.5.8 → 5.5.9

package/src/programmers/functional/FunctionalAssertFunctionProgrammer.ts

@@ -1,130 +1,130 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProject } from "../../transformers/IProject";
-
-import { StringUtil } from "../../utils/StringUtil";
-
-import { AssertProgrammer } from "../AssertProgrammer";
-import { FunctionalAssertParametersProgrammer } from "./FunctionalAssertParametersProgrammer";
-import { FunctionAssertReturnProgrammer } from "./FunctionalAssertReturnProgrammer";
-
-export namespace FunctionalAssertFunctionProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      expression: ts.Expression,
-      declaration: ts.FunctionDeclaration,
-      init?: ts.Expression,
-    ): ts.ArrowFunction => {
-      const wrapper = errorFactoryWrapper(modulo)(declaration.parameters)(init);
-      const { async, returns } = FunctionAssertReturnProgrammer.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,
-          ...FunctionalAssertParametersProgrammer.argumentExpressions(project)(
-            modulo,
-          )(equals)(declaration.parameters, wrapper.name).map(
-            ts.factory.createExpressionStatement,
-          ),
-          returns,
-        ]),
-      );
-    };
-
-  export const errorFactoryWrapper =
-    (modulo: ts.LeftHandSideExpression) =>
-    (paramters: readonly ts.ParameterDeclaration[]) =>
-    (
-      init: ts.Expression | undefined,
-    ): {
-      name: string;
-      variable: ts.VariableStatement;
-    } => {
-      const name: string = StringUtil.escapeDuplicate(
-        paramters.map((p) => p.name.getText()),
-      )("errorFactoryWrapper");
-      const variable: ts.VariableStatement = ts.factory.createVariableStatement(
-        undefined,
-        ts.factory.createVariableDeclarationList(
-          [
-            ts.factory.createVariableDeclaration(
-              name,
-              undefined,
-              AssertProgrammer.Guardian.type(),
-              init ??
-                ts.factory.createPropertyAccessExpression(
-                  ts.factory.createAsExpression(
-                    modulo,
-                    TypeFactory.keyword("any"),
-                  ),
-                  "errorFactory",
-                ),
-            ),
-          ],
-          ts.NodeFlags.Const,
-        ),
-      );
-      return { name, variable };
-    };
-
-  export const hookPath = (props: {
-    wrapper: string;
-    replacer: string;
-  }): ts.ArrowFunction =>
-    ts.factory.createArrowFunction(
-      undefined,
-      undefined,
-      [IdentifierFactory.parameter("p")],
-      undefined,
-      undefined,
-      ts.factory.createCallExpression(
-        ts.factory.createIdentifier(props.wrapper),
-        undefined,
-        [
-          ts.factory.createObjectLiteralExpression([
-            ts.factory.createSpreadAssignment(ts.factory.createIdentifier("p")),
-            ts.factory.createPropertyAssignment(
-              "path",
-              ts.factory.createConditionalExpression(
-                ts.factory.createPropertyAccessExpression(
-                  ts.factory.createIdentifier("p"),
-                  "path",
-                ),
-                undefined,
-                ts.factory.createCallExpression(
-                  ts.factory.createPropertyAccessExpression(
-                    ts.factory.createPropertyAccessExpression(
-                      ts.factory.createIdentifier("p"),
-                      "path",
-                    ),
-                    "replace",
-                  ),
-                  undefined,
-                  [
-                    ts.factory.createStringLiteral("$input"),
-                    ts.factory.createStringLiteral(props.replacer),
-                  ],
-                ),
-                undefined,
-                ts.factory.createIdentifier("undefined"),
-              ),
-            ),
-          ]),
-        ],
-      ),
-    );
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { StringUtil } from "../../utils/StringUtil";
+
+import { AssertProgrammer } from "../AssertProgrammer";
+import { FunctionalAssertParametersProgrammer } from "./FunctionalAssertParametersProgrammer";
+import { FunctionAssertReturnProgrammer } from "./FunctionalAssertReturnProgrammer";
+
+export namespace FunctionalAssertFunctionProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+      init?: ts.Expression,
+    ): ts.ArrowFunction => {
+      const wrapper = errorFactoryWrapper(modulo)(declaration.parameters)(init);
+      const { async, returns } = FunctionAssertReturnProgrammer.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,
+          ...FunctionalAssertParametersProgrammer.argumentExpressions(project)(
+            modulo,
+          )(equals)(declaration.parameters, wrapper.name).map(
+            ts.factory.createExpressionStatement,
+          ),
+          returns,
+        ]),
+      );
+    };
+
+  export const errorFactoryWrapper =
+    (modulo: ts.LeftHandSideExpression) =>
+    (paramters: readonly ts.ParameterDeclaration[]) =>
+    (
+      init: ts.Expression | undefined,
+    ): {
+      name: string;
+      variable: ts.VariableStatement;
+    } => {
+      const name: string = StringUtil.escapeDuplicate(
+        paramters.map((p) => p.name.getText()),
+      )("errorFactoryWrapper");
+      const variable: ts.VariableStatement = ts.factory.createVariableStatement(
+        undefined,
+        ts.factory.createVariableDeclarationList(
+          [
+            ts.factory.createVariableDeclaration(
+              name,
+              undefined,
+              AssertProgrammer.Guardian.type(),
+              init ??
+                ts.factory.createPropertyAccessExpression(
+                  ts.factory.createAsExpression(
+                    modulo,
+                    TypeFactory.keyword("any"),
+                  ),
+                  "errorFactory",
+                ),
+            ),
+          ],
+          ts.NodeFlags.Const,
+        ),
+      );
+      return { name, variable };
+    };
+
+  export const hookPath = (props: {
+    wrapper: string;
+    replacer: string;
+  }): ts.ArrowFunction =>
+    ts.factory.createArrowFunction(
+      undefined,
+      undefined,
+      [IdentifierFactory.parameter("p")],
+      undefined,
+      undefined,
+      ts.factory.createCallExpression(
+        ts.factory.createIdentifier(props.wrapper),
+        undefined,
+        [
+          ts.factory.createObjectLiteralExpression([
+            ts.factory.createSpreadAssignment(ts.factory.createIdentifier("p")),
+            ts.factory.createPropertyAssignment(
+              "path",
+              ts.factory.createConditionalExpression(
+                ts.factory.createPropertyAccessExpression(
+                  ts.factory.createIdentifier("p"),
+                  "path",
+                ),
+                undefined,
+                ts.factory.createCallExpression(
+                  ts.factory.createPropertyAccessExpression(
+                    ts.factory.createPropertyAccessExpression(
+                      ts.factory.createIdentifier("p"),
+                      "path",
+                    ),
+                    "replace",
+                  ),
+                  undefined,
+                  [
+                    ts.factory.createStringLiteral("$input"),
+                    ts.factory.createStringLiteral(props.replacer),
+                  ],
+                ),
+                undefined,
+                ts.factory.createIdentifier("undefined"),
+              ),
+            ),
+          ]),
+        ],
+      ),
+    );
+}

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],
+          ),
+        ),
+      };
+    };
+}