typia 5.5.0-dev.20240301 → 5.5.0-dev.20240303

package/src/programmers/AssertProgrammer.ts

@@ -40,7 +40,7 @@ export namespace AssertProgrammer {
               ? entry.conditions[0]!.map((cond) =>
                   ts.factory.createLogicalOr(
                     cond.expression,
-                    create_guard_call(
+                    create_guard_call(importer)(
                       explore.from === "top"
                         ? ts.factory.createTrue()
                         : ts.factory.createIdentifier("_exceptionable"),
@@ -64,7 +64,7 @@ export namespace AssertProgrammer {
                           .reduce((a, b) => ts.factory.createLogicalAnd(a, b)),
                       )
                       .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
-                    create_guard_call(
+                    create_guard_call(importer)(
                       explore.from === "top"
                         ? ts.factory.createTrue()
                         : ts.factory.createIdentifier("_exceptionable"),
@@ -107,21 +107,6 @@ export namespace AssertProgrammer {
         undefined,
         ts.factory.createBlock(
           [
-            StatementFactory.constant(
-              "$guard",
-              ts.factory.createCallExpression(
-                IdentifierFactory.access(
-                  ts.factory.createParenthesizedExpression(
-                    ts.factory.createAsExpression(
-                      modulo,
-                      TypeFactory.keyword("any"),
-                    ),
-                  ),
-                )("guard"),
-                undefined,
-                [Guardian.identifier()],
-              ),
-            ),
             StatementFactory.constant("__is", is),
             ts.factory.createIfStatement(
               ts.factory.createStrictEquality(
@@ -176,7 +161,7 @@ export namespace AssertProgrammer {
                   ? binary.expression
                   : ts.factory.createLogicalOr(
                       binary.expression,
-                      create_guard_call(
+                      create_guard_call(importer)(
                         explore.source === "top"
                           ? ts.factory.createTrue()
                           : ts.factory.createIdentifier("_exceptionable"),
@@ -188,7 +173,7 @@ export namespace AssertProgrammer {
               binaries
                 .map((binary) => binary.expression)
                 .reduce(ts.factory.createLogicalOr),
-              create_guard_call(
+              create_guard_call(importer)(
                 explore.source === "top"
                   ? ts.factory.createTrue()
                   : ts.factory.createIdentifier("_exceptionable"),
@@ -201,7 +186,7 @@ export namespace AssertProgrammer {
       //       ) {
       //           addicted.push({
       //               combined: true,
-      //               expression: create_guard_call(
+      //               expression: create_guard_call(importer)(
       //                   explore.source === "top"
       //                       ? ts.factory.createTrue()
       //                       : ts.factory.createIdentifier(
@@ -229,7 +214,7 @@ export namespace AssertProgrammer {
         reduce: ts.factory.createLogicalAnd,
         positive: ts.factory.createTrue(),
         superfluous: (value) =>
-          create_guard_call()(
+          create_guard_call(importer)()(
             ts.factory.createAdd(
               ts.factory.createIdentifier("_path"),
               ts.factory.createCallExpression(importer.use("join"), undefined, [
@@ -261,7 +246,7 @@ export namespace AssertProgrammer {
           [arrow],
         ),
       failure: (value, expected, explore) =>
-        create_guard_call(
+        create_guard_call(importer)(
           explore?.from === "top"
             ? ts.factory.createTrue()
             : ts.factory.createIdentifier("_exceptionable"),
@@ -277,7 +262,7 @@ export namespace AssertProgrammer {
         : (condition) => (input, expected, explore) =>
             ts.factory.createLogicalOr(
               condition,
-              create_guard_call(
+              create_guard_call(importer)(
                 explore.from === "top"
                   ? ts.factory.createTrue()
                   : ts.factory.createIdentifier("_exceptionable"),
@@ -286,47 +271,61 @@ export namespace AssertProgrammer {
     });
 
   const create_guard_call =
+    (importer: FunctionImporter) =>
     (exceptionable?: ts.Expression) =>
     (
       path: ts.Expression,
       expected: string,
       value: ts.Expression,
     ): ts.Expression =>
-      ts.factory.createCallExpression(
-        ts.factory.createIdentifier("$guard"),
-        undefined,
-        [
-          exceptionable ?? ts.factory.createIdentifier("_exceptionable"),
-          ts.factory.createObjectLiteralExpression(
-            [
-              ts.factory.createPropertyAssignment("path", path),
-              ts.factory.createPropertyAssignment(
-                "expected",
-                ts.factory.createStringLiteral(expected),
-              ),
-              ts.factory.createPropertyAssignment("value", value),
-            ],
-            true,
-          ),
-        ],
-      );
+      ts.factory.createCallExpression(importer.use("guard"), undefined, [
+        exceptionable ?? ts.factory.createIdentifier("_exceptionable"),
+        ts.factory.createObjectLiteralExpression(
+          [
+            ts.factory.createPropertyAssignment("path", path),
+            ts.factory.createPropertyAssignment(
+              "expected",
+              ts.factory.createStringLiteral(expected),
+            ),
+            ts.factory.createPropertyAssignment("value", value),
+          ],
+          true,
+        ),
+        Guardian.identifier(),
+      ]);
 
   export namespace Guardian {
     export const identifier = () => ts.factory.createIdentifier("errorFactory");
     export const parameter = (init: ts.Expression | undefined) =>
       IdentifierFactory.parameter(
         "errorFactory",
-        ts.factory.createImportTypeNode(
-          ts.factory.createLiteralTypeNode(
-            ts.factory.createStringLiteral("typia"),
-          ),
+        ts.factory.createFunctionTypeNode(
           undefined,
-          ts.factory.createQualifiedName(
-            ts.factory.createIdentifier("TypeGuardError"),
-            ts.factory.createIdentifier("IProps"),
+          [
+            ts.factory.createParameterDeclaration(
+              undefined,
+              undefined,
+              ts.factory.createIdentifier("p"),
+              undefined,
+              ts.factory.createImportTypeNode(
+                ts.factory.createLiteralTypeNode(
+                  ts.factory.createStringLiteral("typia"),
+                ),
+                undefined,
+                ts.factory.createQualifiedName(
+                  ts.factory.createIdentifier("TypeGuardError"),
+                  ts.factory.createIdentifier("IProps"),
+                ),
+                undefined,
+                false,
+              ),
+              undefined,
+            ),
+          ],
+          ts.factory.createTypeReferenceNode(
+            ts.factory.createIdentifier("Error"),
+            undefined,
           ),
-          undefined,
-          false,
         ),
         init ?? ts.factory.createToken(ts.SyntaxKind.QuestionToken),
       );

package/src/programmers/functional/FunctionalAssertFunctionProgrammer.ts

@@ -0,0 +1,44 @@
+import ts from "typescript";
+import { IProject } from "../../transformers/IProject";
+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,
+    ) => {
+      const params = FunctionalAssertParametersProgrammer.prepare(project)(
+        modulo,
+      )(equals)(declaration, init);
+      const output = FunctionAssertReturnProgrammer.prepare(project)(modulo)(
+        equals,
+      )(expression, declaration, init);
+      return ts.factory.createFunctionDeclaration(
+        output.async
+          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+          : undefined,
+        undefined,
+        undefined,
+        undefined,
+        declaration.parameters,
+        declaration.type,
+        ts.factory.createBlock(
+          [
+            params.assert,
+            output.assert,
+            params.call,
+            output.variable,
+            output.call,
+            output.returns,
+          ],
+          true,
+        ),
+      );
+    };
+}

package/src/programmers/functional/FunctionalAssertParametersProgrammer.ts

@@ -0,0 +1,100 @@
+import ts from "typescript";
+import { IProject } from "../../transformers/IProject";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { AssertProgrammer } from "../AssertProgrammer";
+
+export namespace FunctionalAssertParametersProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+      init?: ts.Expression,
+    ) => {
+      const { assert, call } = prepare(project)(modulo)(equals)(
+        declaration,
+        init,
+      );
+      const async: boolean = (() => {
+        if (declaration.type === undefined) return false;
+        const type: ts.Type = project.checker.getTypeFromTypeNode(
+          declaration.type,
+        );
+        return type.isTypeParameter() && type.symbol.name === "Promise";
+      })();
+
+      return ts.factory.createFunctionDeclaration(
+        async
+          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+          : undefined,
+        undefined,
+        undefined,
+        undefined,
+        declaration.parameters,
+        declaration.type,
+        ts.factory.createBlock(
+          [
+            assert,
+            call,
+            ts.factory.createReturnStatement(
+              ts.factory.createCallExpression(
+                expression,
+                undefined,
+                declaration.parameters.map((p) =>
+                  ts.factory.createIdentifier(p.name.getText()),
+                ),
+              ),
+            ),
+          ],
+          true,
+        ),
+      );
+    };
+
+  export const prepare =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (declaration: ts.FunctionDeclaration, init?: ts.Expression) => {
+      const typeNode: ts.TypeNode = ts.factory.createTypeLiteralNode([
+        ts.factory.createPropertySignature(
+          undefined,
+          "parameters",
+          undefined,
+          ts.factory.createTupleTypeNode(
+            declaration.parameters.map((p) => p.type!),
+          ),
+        ),
+      ]);
+      const type: ts.Type = project.checker.getTypeFromTypeNode(typeNode);
+
+      const assert = StatementFactory.constant(
+        "assert",
+        AssertProgrammer.write(project)(modulo)(equals)(type, undefined, init),
+      );
+      const call = ts.factory.createExpressionStatement(
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier("assert"),
+          undefined,
+          [
+            ts.factory.createObjectLiteralExpression(
+              [
+                ts.factory.createPropertyAssignment(
+                  "parameters",
+                  ts.factory.createArrayLiteralExpression(
+                    declaration.parameters.map((p) =>
+                      ts.factory.createIdentifier(p.name.getText()),
+                    ),
+                  ),
+                ),
+              ],
+              true,
+            ),
+          ],
+        ),
+      );
+      return { assert, call, type };
+    };
+}

package/src/programmers/functional/FunctionalAssertReturnProgrammer.ts

@@ -0,0 +1,84 @@
+import ts from "typescript";
+import { IProject } from "../../transformers/IProject";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { AssertProgrammer } from "../AssertProgrammer";
+
+export namespace FunctionAssertReturnProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+      init?: ts.Expression,
+    ) => {
+      const { async, assert, variable, call, returns } = prepare(project)(
+        modulo,
+      )(equals)(expression, declaration, init);
+      return ts.factory.createFunctionDeclaration(
+        async
+          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+          : undefined,
+        undefined,
+        undefined,
+        undefined,
+        declaration.parameters,
+        declaration.type,
+        ts.factory.createBlock([assert, variable, call, returns], true),
+      );
+    };
+
+  export const prepare =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+      init?: ts.Expression,
+    ) => {
+      const [type, async]: [ts.Type, boolean] = (() => {
+        const type: ts.Type = project.checker.getTypeFromTypeNode(
+          declaration.type!,
+        );
+        return type.isTypeParameter() && type.symbol.name === "Promise"
+          ? [type.aliasTypeArguments![0]!, true]
+          : [type, false];
+      })();
+      const assert = StatementFactory.constant(
+        "assert",
+        AssertProgrammer.write(project)(modulo)(equals)(type, undefined, init),
+      );
+      const funcCaller = ts.factory.createCallExpression(
+        expression,
+        undefined,
+        declaration.parameters.map((p) =>
+          ts.factory.createIdentifier(p.name.getText()),
+        ),
+      );
+      const variable = StatementFactory.constant(
+        "output",
+        async ? ts.factory.createAwaitExpression(funcCaller) : funcCaller,
+      );
+
+      const call = ts.factory.createExpressionStatement(
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier("assert"),
+          undefined,
+          [
+            ts.factory.createObjectLiteralExpression([
+              ts.factory.createPropertyAssignment(
+                "return",
+                ts.factory.createIdentifier("output"),
+              ),
+            ]),
+          ],
+        ),
+      );
+      const returns = ts.factory.createReturnStatement(
+        ts.factory.createIdentifier("output"),
+      );
+      return { async, type, assert, variable, call, returns };
+    };
+}

package/src/transformers/CallExpressionTransformer.ts

@@ -96,11 +96,17 @@ import { CreateHttpAssertFormDataTransformer } from "./features/http/CreateHttpA
 import { CreateHttpFormDataTransformer } from "./features/http/CreateHttpFormDataTransformer";
 import { CreateHttpIsFormDataTransformer } from "./features/http/CreateHttpIsFormDataTransformer";
 import { CreateHttpValidateFormDataTransformer } from "./features/http/CreateHttpValidateFormDataTransformer";
+import { FunctionalGenericTransformer } from "./features/functional/FunctionalGenericTransformer";
+import { FunctionalAssertFunctionProgrammer } from "../programmers/functional/FunctionalAssertFunctionProgrammer";
+import { FunctionalAssertParametersProgrammer } from "../programmers/functional/FunctionalAssertParametersProgrammer";
+import { FunctionAssertReturnProgrammer } from "../programmers/functional/FunctionalAssertReturnProgrammer";
 
 export namespace CallExpressionTransformer {
   export const transform =
     (project: IProject) =>
-    (expression: ts.CallExpression): ts.Expression | null => {
+    (
+      expression: ts.CallExpression,
+    ): ts.Expression | ts.FunctionDeclaration | null => {
       //----
       // VALIDATIONS
       //----
@@ -127,9 +133,9 @@ export namespace CallExpressionTransformer {
       if (functor === undefined) return expression;
 
       // RETURNS WITH TRANSFORMATION
-      const result: ts.Expression | null = functor()(project)(
-        expression.expression,
-      )(expression);
+      const result: ts.Expression | ts.FunctionDeclaration | null = functor()(
+        project,
+      )(expression.expression)(expression);
       return result ?? expression;
     };
 
@@ -145,7 +151,9 @@ type Task = (
   project: IProject,
 ) => (
   modulo: ts.LeftHandSideExpression,
-) => (expression: ts.CallExpression) => ts.Expression | null;
+) => (
+  expression: ts.CallExpression,
+) => ts.Expression | ts.FunctionDeclaration | null;
 
 const FUNCTORS: Record<string, Record<string, () => Task>> = {
   module: {
@@ -187,6 +195,45 @@ const FUNCTORS: Record<string, Record<string, () => Task>> = {
     createValidateEquals: () => CreateValidateTransformer.transform(true),
     createRandom: () => CreateRandomTransformer.transform,
   },
+  functional: {
+    // ASSERTIONS
+    assertFunction: () =>
+      FunctionalGenericTransformer.transform({
+        method: "assertFunction",
+        equals: false,
+        programmer: FunctionalAssertFunctionProgrammer.write,
+      }),
+    assertParameters: () =>
+      FunctionalGenericTransformer.transform({
+        method: "assertParameters",
+        equals: false,
+        programmer: FunctionalAssertParametersProgrammer.write,
+      }),
+    assertReturn: () =>
+      FunctionalGenericTransformer.transform({
+        method: "assertReturn",
+        equals: false,
+        programmer: FunctionAssertReturnProgrammer.write,
+      }),
+    assertEqualsFunction: () =>
+      FunctionalGenericTransformer.transform({
+        method: "assertEqualsFunction",
+        equals: true,
+        programmer: FunctionalAssertFunctionProgrammer.write,
+      }),
+    assertEqualsParameters: () =>
+      FunctionalGenericTransformer.transform({
+        method: "assertEqualsParameters",
+        equals: true,
+        programmer: FunctionalAssertParametersProgrammer.write,
+      }),
+    assertEqualsReturn: () =>
+      FunctionalGenericTransformer.transform({
+        method: "assertEqualsReturn",
+        equals: true,
+        programmer: FunctionAssertReturnProgrammer.write,
+      }),
+  },
   http: {
     // FORM-DATA
     formData: () => HttpFormDataTransformer.transform,

package/src/transformers/features/functional/FunctionalGenericTransformer.ts

@@ -0,0 +1,41 @@
+import ts from "typescript";
+import { IProject } from "../../IProject";
+import { TransformerError } from "../../TransformerError";
+
+export namespace FunctionalGenericTransformer {
+  export const transform =
+    (props: {
+      method: string;
+      programmer: (
+        project: IProject,
+      ) => (
+        modulo: ts.LeftHandSideExpression,
+      ) => (
+        equals: boolean,
+      ) => (
+        expression: ts.CallExpression,
+        declaration: ts.FunctionDeclaration,
+        init?: ts.Expression,
+      ) => ts.FunctionDeclaration;
+      equals: boolean;
+    }) =>
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (expression: ts.CallExpression) => {
+      // CHECK PARAMETER
+      if (expression.arguments.length === 0)
+        throw new TransformerError({
+          code: `typia.functional.${props.method}`,
+          message: `no input value.`,
+        });
+      else if (false === ts.isFunctionDeclaration(expression.arguments[0]!))
+        throw new TransformerError({
+          code: `typia.functional.${props.method}`,
+          message: `input value is not a function.`,
+        });
+      return props.programmer(project)(modulo)(props.equals)(
+        expression,
+        expression.arguments[0]!,
+      );
+    };
+}