typia 6.10.1-dev.20240914 → 7.0.0-dev.20240918

package/src/programmers/functional/FunctionalAssertParametersProgrammer.ts

@@ -4,105 +4,134 @@ import { ExpressionFactory } from "../../factories/ExpressionFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { IProject } from "../../transformers/IProject";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 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.CallExpression => {
-      const wrapper = FunctionalAssertFunctionProgrammer.errorFactoryWrapper(
-        modulo,
-      )(declaration.parameters)(init);
-      const { async } = FunctionalGeneralProgrammer.getReturnType(
-        project.checker,
-      )(declaration);
-      const result = decompose(project)(modulo)(equals)(
-        declaration.parameters,
-        wrapper.name,
-      );
-      return ExpressionFactory.selfCall(
-        ts.factory.createBlock(
-          [
-            wrapper.variable,
-            ...result.functions,
-            ts.factory.createReturnStatement(
-              ts.factory.createArrowFunction(
-                async
-                  ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
-                  : undefined,
-                undefined,
-                declaration.parameters,
-                declaration.type,
-                undefined,
-                ts.factory.createBlock(
-                  [
-                    ...result.expressions.map(
-                      ts.factory.createExpressionStatement,
-                    ),
-                    ts.factory.createReturnStatement(
-                      ts.factory.createCallExpression(
-                        expression,
-                        undefined,
-                        declaration.parameters.map((p) =>
-                          ts.factory.createIdentifier(p.name.getText()),
-                        ),
+  export interface IConfig {
+    equals: boolean;
+  }
+  export interface IProps {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    config: IConfig;
+    declaration: ts.FunctionDeclaration;
+    expression: ts.Expression;
+    init?: ts.Expression | undefined;
+  }
+  export interface IDecomposeProps {
+    context: ITypiaContext;
+    config: IConfig;
+    modulo: ts.LeftHandSideExpression;
+    parameters: readonly ts.ParameterDeclaration[];
+    wrapper: string;
+  }
+  export interface IDecomposeOutput {
+    functions: ts.Statement[];
+    expressions: ts.Expression[];
+  }
+
+  export const write = (props: IProps): ts.CallExpression => {
+    const wrapper = FunctionalAssertFunctionProgrammer.errorFactoryWrapper({
+      modulo: props.modulo,
+      parameters: props.declaration.parameters,
+      init: props.init,
+    });
+    const { async } = FunctionalGeneralProgrammer.getReturnType({
+      checker: props.context.checker,
+      declaration: props.declaration,
+    });
+    const result = decompose({
+      context: props.context,
+      modulo: props.modulo,
+      config: props.config,
+      parameters: props.declaration.parameters,
+      wrapper: wrapper.name,
+    });
+    return ExpressionFactory.selfCall(
+      ts.factory.createBlock(
+        [
+          wrapper.variable,
+          ...result.functions,
+          ts.factory.createReturnStatement(
+            ts.factory.createArrowFunction(
+              async
+                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                : undefined,
+              undefined,
+              props.declaration.parameters,
+              props.declaration.type,
+              undefined,
+              ts.factory.createBlock(
+                [
+                  ...result.expressions.map(
+                    ts.factory.createExpressionStatement,
+                  ),
+                  ts.factory.createReturnStatement(
+                    ts.factory.createCallExpression(
+                      props.expression,
+                      undefined,
+                      props.declaration.parameters.map((p) =>
+                        ts.factory.createIdentifier(p.name.getText()),
                       ),
                     ),
-                  ],
-                  true,
-                ),
+                  ),
+                ],
+                true,
               ),
             ),
-          ],
-          true,
-        ),
-      );
-    };
-
-  export const decompose =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      parameters: readonly ts.ParameterDeclaration[],
-      wrapper: string,
-    ): {
-      functions: ts.Statement[];
-      expressions: ts.Expression[];
-    } => ({
-      functions: parameters.map((p, i) =>
-        StatementFactory.constant(
-          `__assert_param_${i}`,
-          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())],
-        ),
+        ],
+        true,
       ),
-      expressions: parameters.map((p, i) =>
-        ts.factory.createCallExpression(
-          ts.factory.createIdentifier(`__assert_param_${i}`),
-          undefined,
-          [ts.factory.createIdentifier(p.name.getText())],
-        ),
+    );
+  };
+
+  export const decompose = (props: IDecomposeProps): IDecomposeOutput => ({
+    functions: props.parameters.map((p, i) =>
+      StatementFactory.constant(
+        `__assert_param_${i}`,
+        AssertProgrammer.write({
+          context: props.context,
+          modulo: props.modulo,
+          config: {
+            equals: props.config.equals,
+            guard: false,
+          },
+          type: p.type
+            ? props.context.checker.getTypeFromTypeNode(p.type)
+            : props.context.checker.getTypeFromTypeNode(
+                TypeFactory.keyword("any"),
+              ),
+          name: undefined,
+          init: FunctionalAssertFunctionProgrammer.hookPath({
+            wrapper: props.wrapper,
+            replacer: `$input.parameters[${i}]`,
+          }),
+        }),
+        //   project)(modulo)(equals)(
+        //   p.type
+        //     ? project.checker.getTypeFromTypeNode(p.type)
+        //     : project.checker.getTypeFromTypeNode(TypeFactory.keyword("any")),
+        //   undefined,
+        //   FunctionalAssertFunctionProgrammer.hookPath({
+        //     wrapper: props.wrapper,
+        //     replacer: `$input.parameters[${i}]`,
+        //   }),
+        // ),
+        // undefined,
+        // [ts.factory.createIdentifier(p.name.getText())],
       ),
-    });
+    ),
+    expressions: props.parameters.map((p, i) =>
+      ts.factory.createCallExpression(
+        ts.factory.createIdentifier(`__assert_param_${i}`),
+        undefined,
+        [ts.factory.createIdentifier(p.name.getText())],
+      ),
+    ),
+  });
 }

package/src/programmers/functional/FunctionalAssertReturnProgrammer.ts

@@ -3,96 +3,113 @@ import ts from "typescript";
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 
-import { IProject } from "../../transformers/IProject";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 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 interface IConfig {
+    equals: boolean;
+  }
+  export interface IProps {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    config: IConfig;
+    expression: ts.Expression;
+    declaration: ts.FunctionDeclaration;
+    init?: ts.Expression | undefined;
+  }
+  export interface IDecomposeProps {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    config: IConfig;
+    expression: ts.Expression;
+    declaration: ts.FunctionDeclaration;
+    wrapper: string;
+  }
+  export interface IDecomposeOutput {
+    async: boolean;
+    functions: ts.Statement[];
+    value: ts.Expression;
+  }
 
-  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,
+  export const write = (props: IProps): ts.CallExpression => {
+    const wrapper = FunctionalAssertFunctionProgrammer.errorFactoryWrapper({
+      modulo: props.modulo,
+      parameters: props.declaration.parameters,
+      init: props.init,
+    });
+    const result = decompose({
+      context: props.context,
+      modulo: props.modulo,
+      config: props.config,
+      expression: props.expression,
+      declaration: props.declaration,
+      wrapper: 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,
+              props.declaration.parameters,
+              props.declaration.type,
               undefined,
-              FunctionalAssertFunctionProgrammer.hookPath({
-                wrapper,
-                replacer: "$input.return",
-              }),
+              result.value,
             ),
           ),
         ],
-        value: ts.factory.createCallExpression(
-          ts.factory.createIdentifier("__assert_return"),
-          undefined,
-          [async ? ts.factory.createAwaitExpression(caller) : caller],
+        true,
+      ),
+    );
+  };
+
+  export const decompose = (props: IDecomposeProps): IDecomposeOutput => {
+    const { type, async } = FunctionalGeneralProgrammer.getReturnType({
+      checker: props.context.checker,
+      declaration: props.declaration,
+    });
+    const caller: ts.CallExpression = ts.factory.createCallExpression(
+      props.expression,
+      undefined,
+      props.declaration.parameters.map((p) =>
+        ts.factory.createIdentifier(p.name.getText()),
+      ),
+    );
+    return {
+      async,
+      functions: [
+        StatementFactory.constant(
+          "__assert_return",
+          AssertProgrammer.write({
+            context: props.context,
+            modulo: props.modulo,
+            config: {
+              equals: props.config.equals,
+              guard: false,
+            },
+            type,
+            name: undefined,
+            init: FunctionalAssertFunctionProgrammer.hookPath({
+              wrapper: props.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

@@ -2,70 +2,70 @@ import ts from "typescript";
 
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 
-import { IProject } from "../../transformers/IProject";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 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,
-                ),
-              ),
+  export interface IConfig {
+    equals: boolean;
+  }
+  export interface IProps {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    config: IConfig;
+    declaration: ts.FunctionDeclaration;
+    expression: ts.Expression;
+    init?: ts.Expression | undefined;
+  }
+
+  export const write = (props: IProps): ts.CallExpression => {
+    const p = FunctionalIsParametersProgrammer.decompose(props);
+    const r = FunctionalIsReturnProgrammer.decompose(props);
+    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,
+              props.declaration.parameters,
+              getReturnTypeNode({
+                declaration: props.declaration,
+                async: r.async,
+              }),
+              undefined,
+              ts.factory.createBlock([...p.statements, ...r.statements], true),
             ),
-          ],
-          true,
-        ),
-      );
-    };
+          ),
+        ],
+        true,
+      ),
+    );
+  };
 
-  export const getReturnTypeNode = (
-    declaration: ts.FunctionDeclaration,
-    async: boolean,
-  ): ts.TypeNode | undefined =>
-    declaration.type
-      ? async
-        ? !!(declaration.type! as ts.TypeReferenceNode).typeArguments?.[0]
+  export const getReturnTypeNode = (props: {
+    declaration: ts.FunctionDeclaration;
+    async: boolean;
+  }): ts.TypeNode | undefined =>
+    props.declaration.type
+      ? props.async
+        ? !!(props.declaration.type! as ts.TypeReferenceNode).typeArguments?.[0]
           ? ts.factory.createTypeReferenceNode("Promise", [
               ts.factory.createUnionTypeNode([
-                (declaration.type! as ts.TypeReferenceNode).typeArguments![0]!,
+                (props.declaration.type! as ts.TypeReferenceNode)
+                  .typeArguments![0]!,
                 ts.factory.createTypeReferenceNode("null"),
               ]),
             ])
           : undefined
         : ts.factory.createUnionTypeNode([
-            declaration.type,
+            props.declaration.type,
             ts.factory.createTypeReferenceNode("null"),
           ])
       : undefined;