typia 6.10.0 → 7.0.0-dev.20240916

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;

package/src/programmers/functional/FunctionalIsParametersProgrammer.ts

@@ -4,98 +4,110 @@ 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 { 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()),
-                        ),
+  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;
+    declaration: ts.FunctionDeclaration;
+  }
+  export interface IDecomposeOutput {
+    functions: ts.Statement[];
+    statements: ts.Statement[];
+  }
+
+  export const write = (props: IProps): ts.CallExpression => {
+    const { async } = FunctionalGeneralProgrammer.getReturnType({
+      checker: props.context.checker,
+      declaration: props.declaration,
+    });
+    const result = decompose(props);
+    return ExpressionFactory.selfCall(
+      ts.factory.createBlock(
+        [
+          ...result.functions,
+          ts.factory.createReturnStatement(
+            ts.factory.createArrowFunction(
+              async
+                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                : undefined,
+              undefined,
+              props.declaration.parameters,
+              FunctionalIsFunctionProgrammer.getReturnTypeNode({
+                declaration: props.declaration,
+                async,
+              }),
+              undefined,
+              ts.factory.createBlock(
+                [
+                  ...result.statements,
+                  ts.factory.createReturnStatement(
+                    ts.factory.createCallExpression(
+                      props.expression,
+                      undefined,
+                      props.declaration.parameters.map((p) =>
+                        ts.factory.createIdentifier(p.name.getText()),
                       ),
                     ),
-                  ],
-                  true,
-                ),
+                  ),
+                ],
+                true,
               ),
             ),
-          ],
-          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"),
-            ),
+  export const decompose = (props: IDecomposeProps): IDecomposeOutput => ({
+    functions: props.declaration.parameters.map((p, i) =>
+      StatementFactory.constant(
+        `__is_param_${i}`,
+        IsProgrammer.write({
+          context: props.context,
+          modulo: props.modulo,
+          config: props.config,
+          type: props.context.checker.getTypeFromTypeNode(
+            p.type ?? TypeFactory.keyword("any"),
           ),
-        ),
+          init: undefined,
+          name: undefined,
+        }),
       ),
-      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())],
-              ),
+    ),
+    statements: props.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(),
-    });
+          ts.factory.createReturnStatement(ts.factory.createNull()),
+        ),
+      ])
+      .flat(),
+  });
 }

package/src/programmers/functional/FunctionalIsReturnProgrammer.ts

@@ -3,7 +3,7 @@ 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 { StringUtil } from "../../utils/StringUtil";
 
@@ -12,95 +12,104 @@ import { FunctionalIsFunctionProgrammer } from "./FunctionalIsFunctionProgrammer
 import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
 
 export namespace FunctionalIsReturnProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      expression: ts.Expression,
-      declaration: ts.FunctionDeclaration,
-    ): ts.CallExpression => {
-      const result = decompose(project)(modulo)(equals)(
-        expression,
-        declaration,
-      );
-      return ExpressionFactory.selfCall(
-        ts.factory.createBlock(
-          [
-            ...result.functions,
-            ts.factory.createReturnStatement(
-              ts.factory.createArrowFunction(
-                result.async
-                  ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
-                  : undefined,
-                undefined,
-                declaration.parameters,
-                FunctionalIsFunctionProgrammer.getReturnTypeNode(
-                  declaration,
-                  result.async,
-                ),
-                undefined,
-                ts.factory.createBlock(result.statements, true),
-              ),
-            ),
-          ],
-          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 interface IDecomposeProps {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    config: IConfig;
+    expression: ts.Expression;
+    declaration: ts.FunctionDeclaration;
+  }
+  export interface IDecomposeOutput {
+    async: boolean;
+    functions: ts.Statement[];
+    statements: ts.Statement[];
+  }
 
-  export const decompose =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      expression: ts.Expression,
-      declaration: ts.FunctionDeclaration,
-    ): {
-      async: boolean;
-      functions: ts.Statement[];
-      statements: ts.Statement[];
-    } => {
-      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()),
-        ),
-      );
-      const name: string = StringUtil.escapeDuplicate(
-        declaration.parameters.map((p) => p.name.getText()),
-      )("result");
-      return {
-        async,
-        functions: [
-          StatementFactory.constant(
-            "__is_return",
-            IsProgrammer.write(project)(modulo)(equals)(type),
-          ),
-        ],
-        statements: [
-          StatementFactory.constant(
-            name,
-            async ? ts.factory.createAwaitExpression(caller) : caller,
-          ),
+  export const write = (props: IProps): ts.CallExpression => {
+    const result = decompose(props);
+    return ExpressionFactory.selfCall(
+      ts.factory.createBlock(
+        [
+          ...result.functions,
           ts.factory.createReturnStatement(
-            ts.factory.createConditionalExpression(
-              ts.factory.createCallExpression(
-                ts.factory.createIdentifier("__is_return"),
-                undefined,
-                [ts.factory.createIdentifier(name)],
-              ),
+            ts.factory.createArrowFunction(
+              result.async
+                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                : undefined,
               undefined,
-              ts.factory.createIdentifier(name),
+              props.declaration.parameters,
+              FunctionalIsFunctionProgrammer.getReturnTypeNode({
+                declaration: props.declaration,
+                async: result.async,
+              }),
               undefined,
-              ts.factory.createNull(),
+              ts.factory.createBlock(result.statements, true),
             ),
           ),
         ],
-      };
+        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()),
+      ),
+    );
+    const name: string = StringUtil.escapeDuplicate(
+      props.declaration.parameters.map((p) => p.name.getText()),
+    )("result");
+    return {
+      async,
+      functions: [
+        StatementFactory.constant(
+          "__is_return",
+          IsProgrammer.write({
+            ...props,
+            type,
+            name: undefined,
+            init: undefined,
+          }),
+        ),
+      ],
+      statements: [
+        StatementFactory.constant(
+          name,
+          async ? ts.factory.createAwaitExpression(caller) : caller,
+        ),
+        ts.factory.createReturnStatement(
+          ts.factory.createConditionalExpression(
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("__is_return"),
+              undefined,
+              [ts.factory.createIdentifier(name)],
+            ),
+            undefined,
+            ts.factory.createIdentifier(name),
+            undefined,
+            ts.factory.createNull(),
+          ),
+        ),
+      ],
     };
+  };
 }

package/src/programmers/functional/FunctionalValidateFunctionProgrammer.ts

@@ -3,52 +3,52 @@ import ts from "typescript";
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 
-import { IProject } from "../../transformers/IProject";
+import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { FunctionalValidateParametersProgrammer } from "./FunctionalValidateParametersProgrammer";
 import { FunctionalValidateReturnProgrammer } from "./FunctionalValidateReturnProgrammer";
 
 export namespace FunctionalValidateFunctionProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      expression: ts.Expression,
-      declaration: ts.FunctionDeclaration,
-    ): ts.CallExpression => {
-      const p =
-        FunctionalValidateParametersProgrammer.decompose(project)(modulo)(
-          equals,
-        )(declaration);
-      const r = FunctionalValidateReturnProgrammer.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 = FunctionalValidateParametersProgrammer.decompose(props);
+    const r = FunctionalValidateReturnProgrammer.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 hookErrors = (props: {
     expression: ts.Expression;
@@ -90,13 +90,13 @@ export namespace FunctionalValidateFunctionProgrammer {
       ],
     );
 
-  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.createImportTypeNode(
                 ts.factory.createLiteralTypeNode(
@@ -105,7 +105,7 @@ export namespace FunctionalValidateFunctionProgrammer {
                 undefined,
                 ts.factory.createIdentifier("IValidation"),
                 [
-                  (declaration.type! as ts.TypeReferenceNode)
+                  (props.declaration.type! as ts.TypeReferenceNode)
                     .typeArguments![0]!,
                 ],
               ),
@@ -117,7 +117,7 @@ export namespace FunctionalValidateFunctionProgrammer {
             ),
             undefined,
             ts.factory.createIdentifier("IValidation"),
-            [declaration.type],
+            [props.declaration.type],
           )
       : undefined;
 }