@typia/core 12.0.0-dev.20260225

package/src/programmers/functional/FunctionalAssertParametersProgrammer.ts

@@ -0,0 +1,123 @@
+import ts from "typescript";
+
+import { ITypiaContext } from "../../context/ITypiaContext";
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+import { AssertProgrammer } from "../AssertProgrammer";
+import { FunctionalAssertFunctionProgrammer } from "./FunctionalAssertFunctionProgrammer";
+import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
+
+export namespace FunctionalAssertParametersProgrammer {
+  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({
+      context: props.context,
+      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,
+      ),
+    );
+  };
+
+  export const decompose = (props: IDecomposeProps): IDecomposeOutput => ({
+    functions: props.parameters.map((p, i) =>
+      StatementFactory.constant({
+        name: `__assert_param_${i}`,
+        value: 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}]`,
+          }),
+        }),
+      }),
+    ),
+    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

@@ -0,0 +1,113 @@
+import ts from "typescript";
+
+import { ITypiaContext } from "../../context/ITypiaContext";
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { AssertProgrammer } from "../AssertProgrammer";
+import { FunctionalAssertFunctionProgrammer } from "./FunctionalAssertFunctionProgrammer";
+import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
+
+export namespace FunctionAssertReturnProgrammer {
+  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 write = (props: IProps): ts.CallExpression => {
+    const wrapper = FunctionalAssertFunctionProgrammer.errorFactoryWrapper({
+      context: props.context,
+      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,
+              result.value,
+            ),
+          ),
+        ],
+        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({
+          name: "__assert_return",
+          value: 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

@@ -0,0 +1,70 @@
+import ts from "typescript";
+
+import { ITypiaContext } from "../../context/ITypiaContext";
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { FunctionalIsParametersProgrammer } from "./FunctionalIsParametersProgrammer";
+import { FunctionalIsReturnProgrammer } from "./FunctionalIsReturnProgrammer";
+
+export namespace FunctionalIsFunctionProgrammer {
+  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,
+      ),
+    );
+  };
+
+  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([
+                (props.declaration.type! as ts.TypeReferenceNode)
+                  .typeArguments![0]!,
+                ts.factory.createTypeReferenceNode("null"),
+              ]),
+            ])
+          : undefined
+        : ts.factory.createUnionTypeNode([
+            props.declaration.type,
+            ts.factory.createTypeReferenceNode("null"),
+          ])
+      : undefined;
+}

package/src/programmers/functional/FunctionalIsParametersProgrammer.ts

@@ -0,0 +1,111 @@
+import ts from "typescript";
+
+import { ITypiaContext } from "../../context/ITypiaContext";
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+import { IsProgrammer } from "../IsProgrammer";
+import { FunctionalIsFunctionProgrammer } from "./FunctionalIsFunctionProgrammer";
+import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
+
+export namespace FunctionalIsParametersProgrammer {
+  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,
+      ),
+    );
+  };
+
+  export const decompose = (props: IDecomposeProps): IDecomposeOutput => ({
+    functions: props.declaration.parameters.map((p, i) =>
+      StatementFactory.constant({
+        name: `__is_param_${i}`,
+        value: 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: 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(),
+  });
+}

package/src/programmers/functional/FunctionalIsReturnProgrammer.ts

@@ -0,0 +1,113 @@
+import { StringUtil } from "@typia/utils";
+import ts from "typescript";
+
+import { ITypiaContext } from "../../context/ITypiaContext";
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { IsProgrammer } from "../IsProgrammer";
+import { FunctionalIsFunctionProgrammer } from "./FunctionalIsFunctionProgrammer";
+import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
+
+export namespace FunctionalIsReturnProgrammer {
+  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 write = (props: IProps): ts.CallExpression => {
+    const result = decompose(props);
+    return ExpressionFactory.selfCall(
+      ts.factory.createBlock(
+        [
+          ...result.functions,
+          ts.factory.createReturnStatement(
+            ts.factory.createArrowFunction(
+              result.async
+                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                : undefined,
+              undefined,
+              props.declaration.parameters,
+              FunctionalIsFunctionProgrammer.getReturnTypeNode({
+                declaration: props.declaration,
+                async: result.async,
+              }),
+              undefined,
+              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({
+      keep: props.declaration.parameters.map((p) => p.name.getText()),
+      input: "result",
+    });
+    return {
+      async,
+      functions: [
+        StatementFactory.constant({
+          name: "__is_return",
+          value: IsProgrammer.write({
+            ...props,
+            type,
+            name: undefined,
+            init: undefined,
+          }),
+        }),
+      ],
+      statements: [
+        StatementFactory.constant({
+          name,
+          value: 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

@@ -0,0 +1,117 @@
+import ts from "typescript";
+
+import { ITypiaContext } from "../../context/ITypiaContext";
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { FunctionalValidateParametersProgrammer } from "./FunctionalValidateParametersProgrammer";
+import { FunctionalValidateReturnProgrammer } from "./FunctionalValidateReturnProgrammer";
+
+export namespace FunctionalValidateFunctionProgrammer {
+  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({
+                context: props.context,
+                declaration: props.declaration,
+                async: r.async,
+              }),
+              undefined,
+              ts.factory.createBlock([...p.statements, ...r.statements], true),
+            ),
+          ),
+        ],
+        true,
+      ),
+    );
+  };
+
+  export const hookErrors = (props: {
+    expression: ts.Expression;
+    replacer: ts.Expression;
+  }): ts.CallExpression =>
+    ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(props.expression, "map"),
+      undefined,
+      [
+        ts.factory.createArrowFunction(
+          undefined,
+          undefined,
+          [IdentifierFactory.parameter("error")],
+          undefined,
+          undefined,
+          ts.factory.createObjectLiteralExpression(
+            [
+              ts.factory.createSpreadAssignment(
+                ts.factory.createIdentifier("error"),
+              ),
+              ts.factory.createPropertyAssignment(
+                "path",
+                ts.factory.createCallExpression(
+                  ts.factory.createPropertyAccessExpression(
+                    ts.factory.createPropertyAccessExpression(
+                      ts.factory.createIdentifier("error"),
+                      "path",
+                    ),
+                    "replace",
+                  ),
+                  undefined,
+                  [ts.factory.createStringLiteral("$input"), props.replacer],
+                ),
+              ),
+            ],
+            true,
+          ),
+        ),
+      ],
+    );
+
+  export const getReturnTypeNode = (props: {
+    context: ITypiaContext;
+    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", [
+              props.context.importer.type({
+                file: "typia",
+                name: "IValidation",
+                arguments: [
+                  (props.declaration.type! as ts.TypeReferenceNode)
+                    .typeArguments![0]!,
+                ],
+              }),
+            ])
+          : undefined
+        : props.context.importer.type({
+            file: "typia",
+            name: "IValidation",
+            arguments: [props.declaration.type],
+          })
+      : undefined;
+}