typia 6.0.0-dev.20240122 → 6.0.0

package/src/programmers/ValidateProgrammer.ts

@@ -38,53 +38,55 @@ export namespace ValidateProgrammer {
             ...(entry.conditions.length === 0
               ? []
               : entry.conditions.length === 1
-              ? entry.conditions[0]!.map((cond) =>
-                  ts.factory.createLogicalOr(
-                    cond.expression,
-                    create_report_call(
-                      explore.from === "top"
-                        ? ts.factory.createTrue()
-                        : ts.factory.createIdentifier("_exceptionable"),
-                    )(
-                      ts.factory.createIdentifier(
-                        explore.postfix
-                          ? `_path + ${explore.postfix}`
-                          : "_path",
+                ? entry.conditions[0]!.map((cond) =>
+                    ts.factory.createLogicalOr(
+                      cond.expression,
+                      create_report_call(
+                        explore.from === "top"
+                          ? ts.factory.createTrue()
+                          : ts.factory.createIdentifier("_exceptionable"),
+                      )(
+                        ts.factory.createIdentifier(
+                          explore.postfix
+                            ? `_path + ${explore.postfix}`
+                            : "_path",
+                        ),
+                        cond.expected,
+                        input,
                       ),
-                      cond.expected,
-                      input,
                     ),
-                  ),
-                )
-              : [
-                  ts.factory.createLogicalOr(
-                    entry.conditions
-                      .map((set) =>
-                        set
-                          .map((s) => s.expression)
-                          .reduce((a, b) => ts.factory.createLogicalAnd(a, b)),
-                      )
-                      .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
-                    create_report_call(
-                      explore.from === "top"
-                        ? ts.factory.createTrue()
-                        : ts.factory.createIdentifier("_exceptionable"),
-                    )(
-                      ts.factory.createIdentifier(
-                        explore.postfix
-                          ? `_path + ${explore.postfix}`
-                          : "_path",
+                  )
+                : [
+                    ts.factory.createLogicalOr(
+                      entry.conditions
+                        .map((set) =>
+                          set
+                            .map((s) => s.expression)
+                            .reduce((a, b) =>
+                              ts.factory.createLogicalAnd(a, b),
+                            ),
+                        )
+                        .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
+                      create_report_call(
+                        explore.from === "top"
+                          ? ts.factory.createTrue()
+                          : ts.factory.createIdentifier("_exceptionable"),
+                      )(
+                        ts.factory.createIdentifier(
+                          explore.postfix
+                            ? `_path + ${explore.postfix}`
+                            : "_path",
+                        ),
+                        entry.expected,
+                        input,
                       ),
-                      entry.expected,
-                      input,
                     ),
-                  ),
-                ]),
+                  ]),
           ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
         combiner: combine(equals)(project)(importer),
         joiner: joiner(equals)(project)(importer),
         success: ts.factory.createTrue(),
-        addition: () => importer.declare(),
+        addition: () => importer.declare(modulo),
       })(importer)(type, name);
 
       return ts.factory.createArrowFunction(
@@ -121,16 +123,13 @@ export namespace ValidateProgrammer {
                   "$report",
                   ts.factory.createCallExpression(
                     IdentifierFactory.access(
-                      ts.factory.createCallExpression(
-                        ts.factory.createIdentifier("require"),
-                        [],
-                        [
-                          ts.factory.createStringLiteral(
-                            "typia/lib/functional/$report",
-                          ),
-                        ],
+                      ts.factory.createParenthesizedExpression(
+                        ts.factory.createAsExpression(
+                          modulo,
+                          TypeFactory.keyword("any"),
+                        ),
                       ),
-                    )("$report"),
+                    )("report"),
                     [],
                     [ts.factory.createIdentifier("errors")],
                   ),

package/src/programmers/functional/FunctionalAssertFunctionProgrammer.ts

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

package/src/programmers/functional/FunctionalAssertParametersProgrammer.ts

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

package/src/programmers/functional/FunctionalAssertReturnProgrammer.ts

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

package/src/programmers/functional/FunctionalIsFunctionProgrammer.ts

@@ -0,0 +1,61 @@
+import ts from "typescript";
+
+import { IProject } from "../../transformers/IProject";
+
+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.ArrowFunction => {
+      const { async, statements } =
+        FunctionalIsReturnProgrammer.writeStatements(project)(modulo)(equals)(
+          expression,
+          declaration,
+        );
+      return ts.factory.createArrowFunction(
+        async
+          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+          : undefined,
+        undefined,
+        declaration.parameters,
+        getReturnTypeNode(declaration, async),
+        undefined,
+        ts.factory.createBlock(
+          [
+            ...FunctionalIsParametersProgrammer.writeStatements(project)(
+              modulo,
+            )(equals)(declaration),
+            ...statements,
+          ],
+          true,
+        ),
+      );
+    };
+
+  export const getReturnTypeNode = (
+    declaration: ts.FunctionDeclaration,
+    async: boolean,
+  ): ts.TypeNode | undefined =>
+    declaration.type
+      ? async
+        ? !!(declaration.type! as ts.TypeReferenceNode).typeArguments?.[0]
+          ? ts.factory.createTypeReferenceNode("Promise", [
+              ts.factory.createUnionTypeNode([
+                (declaration.type! as ts.TypeReferenceNode).typeArguments![0]!,
+                ts.factory.createTypeReferenceNode("null"),
+              ]),
+            ])
+          : undefined
+        : ts.factory.createUnionTypeNode([
+            declaration.type,
+            ts.factory.createTypeReferenceNode("null"),
+          ])
+      : undefined;
+}

package/src/programmers/functional/FunctionalIsParametersProgrammer.ts

@@ -0,0 +1,73 @@
+import ts from "typescript";
+
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+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.ArrowFunction => {
+      const { async } = FunctionalGeneralProgrammer.getReturnType(
+        project.checker,
+      )(declaration);
+      return ts.factory.createArrowFunction(
+        async
+          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+          : undefined,
+        undefined,
+        declaration.parameters,
+        FunctionalIsFunctionProgrammer.getReturnTypeNode(declaration, async),
+        undefined,
+        ts.factory.createBlock(
+          [
+            ...writeStatements(project)(modulo)(equals)(declaration),
+            ts.factory.createReturnStatement(
+              ts.factory.createCallExpression(
+                expression,
+                undefined,
+                declaration.parameters.map((p) =>
+                  ts.factory.createIdentifier(p.name.getText()),
+                ),
+              ),
+            ),
+          ],
+          true,
+        ),
+      );
+    };
+
+  export const writeStatements =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (declaration: ts.FunctionDeclaration): ts.Statement[] =>
+      declaration.parameters
+        .map((p) => [
+          ts.factory.createIfStatement(
+            ts.factory.createStrictEquality(
+              ts.factory.createFalse(),
+              ts.factory.createCallExpression(
+                IsProgrammer.write(project)(modulo)(equals)(
+                  project.checker.getTypeFromTypeNode(
+                    p.type ?? TypeFactory.keyword("any"),
+                  ),
+                ),
+                undefined,
+                [ts.factory.createIdentifier(p.name.getText())],
+              ),
+            ),
+            ts.factory.createReturnStatement(ts.factory.createNull()),
+          ),
+        ])
+        .flat();
+}

package/src/programmers/functional/FunctionalIsReturnProgrammer.ts

@@ -0,0 +1,84 @@
+import ts from "typescript";
+
+import { StatementFactory } from "../../factories/StatementFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { StringUtil } from "../../utils/StringUtil";
+
+import { IsProgrammer } from "../IsProgrammer";
+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.ArrowFunction => {
+      const { async, statements } = writeStatements(project)(modulo)(equals)(
+        expression,
+        declaration,
+      );
+      return ts.factory.createArrowFunction(
+        async
+          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+          : undefined,
+        undefined,
+        declaration.parameters,
+        FunctionalIsFunctionProgrammer.getReturnTypeNode(declaration, async),
+        undefined,
+        ts.factory.createBlock(statements, true),
+      );
+    };
+
+  export const writeStatements =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+    ): {
+      async: boolean;
+      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");
+      const statements: ts.Statement[] = [
+        StatementFactory.constant(
+          name,
+          async ? ts.factory.createAwaitExpression(caller) : caller,
+        ),
+        ts.factory.createReturnStatement(
+          ts.factory.createConditionalExpression(
+            ts.factory.createCallExpression(
+              IsProgrammer.write(project)(modulo)(equals)(type),
+              undefined,
+              [ts.factory.createIdentifier(name)],
+            ),
+            undefined,
+            ts.factory.createIdentifier(name),
+            undefined,
+            ts.factory.createNull(),
+          ),
+        ),
+      ];
+      return { async, statements };
+    };
+}