typia 6.10.0 → 7.0.0-dev.20240916

package/src/programmers/functional/FunctionalAssertFunctionProgrammer.ts

@@ -4,7 +4,7 @@ import { ExpressionFactory } from "../../factories/ExpressionFactory";
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { IProject } from "../../transformers/IProject";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { StringUtil } from "../../utils/StringUtil";
 
@@ -13,84 +13,100 @@ import { FunctionalAssertParametersProgrammer } from "./FunctionalAssertParamete
 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.CallExpression => {
-      const wrapper = errorFactoryWrapper(modulo)(declaration.parameters)(init);
-      const p = FunctionalAssertParametersProgrammer.decompose(project)(modulo)(
-        equals,
-      )(declaration.parameters, wrapper.name);
-      const r = FunctionAssertReturnProgrammer.decompose(project)(modulo)(
-        equals,
-      )(expression, declaration, wrapper.name);
-      return ExpressionFactory.selfCall(
-        ts.factory.createBlock(
-          [
-            wrapper.variable,
-            ...p.functions,
-            ...r.functions,
-            ts.factory.createReturnStatement(
-              ts.factory.createArrowFunction(
-                r.async
-                  ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
-                  : undefined,
-                undefined,
-                declaration.parameters,
-                declaration.type,
-                undefined,
-                ts.factory.createBlock([
-                  ...p.expressions.map(ts.factory.createExpressionStatement),
-                  ts.factory.createReturnStatement(r.value),
-                ]),
-              ),
-            ),
-          ],
-          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 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,
+  export const write = (props: IProps): ts.CallExpression => {
+    const wrapper = errorFactoryWrapper({
+      modulo: props.modulo,
+      parameters: props.declaration.parameters,
+      init: props.init,
+    });
+    const p = FunctionalAssertParametersProgrammer.decompose({
+      context: props.context,
+      modulo: props.modulo,
+      config: props.config,
+      parameters: props.declaration.parameters,
+      wrapper: wrapper.name,
+    });
+    const r = FunctionAssertReturnProgrammer.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,
+          ...p.functions,
+          ...r.functions,
+          ts.factory.createReturnStatement(
+            ts.factory.createArrowFunction(
+              r.async
+                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                : undefined,
               undefined,
-              AssertProgrammer.Guardian.type(),
-              init ??
-                ts.factory.createPropertyAccessExpression(
-                  ts.factory.createAsExpression(
-                    modulo,
-                    TypeFactory.keyword("any"),
-                  ),
-                  "errorFactory",
-                ),
+              props.declaration.parameters,
+              props.declaration.type,
+              undefined,
+              ts.factory.createBlock([
+                ...p.expressions.map(ts.factory.createExpressionStatement),
+                ts.factory.createReturnStatement(r.value),
+              ]),
             ),
-          ],
-          ts.NodeFlags.Const,
-        ),
-      );
-      return { name, variable };
-    };
+          ),
+        ],
+        true,
+      ),
+    );
+  };
+
+  export const errorFactoryWrapper = (props: {
+    modulo: ts.LeftHandSideExpression;
+    parameters: readonly ts.ParameterDeclaration[];
+    init: ts.Expression | undefined;
+  }): {
+    name: string;
+    variable: ts.VariableStatement;
+  } => {
+    const name: string = StringUtil.escapeDuplicate(
+      props.parameters.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(),
+            props.init ??
+              ts.factory.createPropertyAccessExpression(
+                ts.factory.createAsExpression(
+                  props.modulo,
+                  TypeFactory.keyword("any"),
+                ),
+                "errorFactory",
+              ),
+          ),
+        ],
+        ts.NodeFlags.Const,
+      ),
+    );
+    return { name, variable };
+  };
 
   export const hookPath = (props: {
     wrapper: string;

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