typia 5.5.0-dev.20240304 → 5.5.0-dev.20240305

package/src/programmers/AssertProgrammer.ts

@@ -299,35 +299,37 @@ export namespace AssertProgrammer {
     export const parameter = (init: ts.Expression | undefined) =>
       IdentifierFactory.parameter(
         "errorFactory",
-        ts.factory.createFunctionTypeNode(
-          undefined,
-          [
-            ts.factory.createParameterDeclaration(
-              undefined,
-              undefined,
-              ts.factory.createIdentifier("p"),
+        type(),
+        init ?? ts.factory.createToken(ts.SyntaxKind.QuestionToken),
+      );
+    export const type = () =>
+      ts.factory.createFunctionTypeNode(
+        undefined,
+        [
+          ts.factory.createParameterDeclaration(
+            undefined,
+            undefined,
+            ts.factory.createIdentifier("p"),
+            undefined,
+            ts.factory.createImportTypeNode(
+              ts.factory.createLiteralTypeNode(
+                ts.factory.createStringLiteral("typia"),
+              ),
               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,
+              ts.factory.createQualifiedName(
+                ts.factory.createIdentifier("TypeGuardError"),
+                ts.factory.createIdentifier("IProps"),
               ),
               undefined,
+              false,
             ),
-          ],
-          ts.factory.createTypeReferenceNode(
-            ts.factory.createIdentifier("Error"),
             undefined,
           ),
+        ],
+        ts.factory.createTypeReferenceNode(
+          ts.factory.createIdentifier("Error"),
+          undefined,
         ),
-        init ?? ts.factory.createToken(ts.SyntaxKind.QuestionToken),
       );
   }
 }

package/src/programmers/RandomProgrammer.ts

@@ -81,10 +81,18 @@ export namespace RandomProgrammer {
               init ?? ts.factory.createToken(ts.SyntaxKind.QuestionToken),
             ),
           ],
-          ts.factory.createTypeReferenceNode(
-            `typia.Resolved<${
-              name ?? TypeFactory.getFullName(project.checker)(type)
-            }>`,
+          ts.factory.createImportTypeNode(
+            ts.factory.createLiteralTypeNode(
+              ts.factory.createStringLiteral("typia"),
+            ),
+            undefined,
+            ts.factory.createIdentifier("Resolved"),
+            [
+              ts.factory.createTypeReferenceNode(
+                name ?? TypeFactory.getFullName(project.checker)(type),
+              ),
+            ],
+            false,
           ),
           undefined,
           ts.factory.createBlock(

package/src/programmers/TypiaProgrammer.ts

@@ -120,20 +120,10 @@ export namespace TypiaProgrammer {
         .replace(props.input, props.output);
 
       const content: string = printer.printFile(file);
-      await fs.promises.writeFile(to, emend(content), "utf8");
+      await fs.promises.writeFile(to, content, "utf8");
     }
   };
 
-  const emend = (content: string): string => {
-    if (
-      content.indexOf("typia.") === -1 ||
-      content.indexOf("import typia") !== -1 ||
-      content.indexOf("import * as typia") !== -1
-    )
-      return content;
-    return `import typia from "typia";\n\n${content}`;
-  };
-
   const is_directory = async (current: string): Promise<boolean> => {
     const stat: fs.Stats = await fs.promises.stat(current);
     return stat.isDirectory();

package/src/programmers/functional/FunctionalAssertFunctionProgrammer.ts

@@ -1,11 +1,13 @@
 import ts from "typescript";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
 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";
 
@@ -19,6 +21,7 @@ export namespace FunctionalAssertFunctionProgrammer {
       declaration: ts.FunctionDeclaration,
       init?: ts.Expression,
     ): ts.ArrowFunction => {
+      const wrapper = errorFactoryWrapper(modulo)(declaration.parameters)(init);
       const { async, returns } = FunctionAssertReturnProgrammer.returnStatement(
         project,
       )(modulo)(equals)(
@@ -27,6 +30,7 @@ export namespace FunctionalAssertFunctionProgrammer {
         declaration.parameters.map((p) =>
           ts.factory.createIdentifier(p.name.getText()),
         ),
+        wrapper.name,
       );
       return ts.factory.createArrowFunction(
         async
@@ -37,10 +41,10 @@ export namespace FunctionalAssertFunctionProgrammer {
         declaration.type,
         undefined,
         ts.factory.createBlock([
-          errorFactory(modulo)(init),
+          wrapper.variable,
           ...FunctionalAssertParametersProgrammer.argumentExpressions(project)(
             modulo,
-          )(equals)(declaration.parameters).map(
+          )(equals)(declaration.parameters, wrapper.name).map(
             ts.factory.createExpressionStatement,
           ),
           returns,
@@ -48,77 +52,82 @@ export namespace FunctionalAssertFunctionProgrammer {
       );
     };
 
-  export const errorFactory =
-    (modulo: ts.LeftHandSideExpression) => (init: ts.Expression | undefined) =>
-      StatementFactory.constant(
-        "errorFactoryWrapper",
-        init ??
-          ts.factory.createPropertyAccessExpression(
-            ts.factory.createAsExpression(modulo, TypeFactory.keyword("any")),
-            "errorFactory",
-          ),
+  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 = (replacer: string): ts.ArrowFunction =>
+  export const hookPath = (props: {
+    wrapper: string;
+    replacer: string;
+  }): ts.ArrowFunction =>
     ts.factory.createArrowFunction(
       undefined,
       undefined,
-      [
-        IdentifierFactory.parameter(
-          "p",
-          ts.factory.createFunctionTypeNode(
-            undefined,
-            [
-              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,
-            ),
-          ),
-        ),
-      ],
+      [IdentifierFactory.parameter("p")],
       undefined,
       undefined,
       ts.factory.createCallExpression(
-        ts.factory.createIdentifier("errorFactoryWrapper"),
+        ts.factory.createIdentifier(props.wrapper),
         undefined,
         [
           ts.factory.createObjectLiteralExpression([
             ts.factory.createSpreadAssignment(ts.factory.createIdentifier("p")),
             ts.factory.createPropertyAssignment(
               "path",
-              ts.factory.createCallExpression(
+              ts.factory.createConditionalExpression(
                 ts.factory.createPropertyAccessExpression(
+                  ts.factory.createIdentifier("p"),
+                  "path",
+                ),
+                undefined,
+                ts.factory.createCallExpression(
                   ts.factory.createPropertyAccessExpression(
-                    ts.factory.createIdentifier("p"),
-                    "path",
+                    ts.factory.createPropertyAccessExpression(
+                      ts.factory.createIdentifier("p"),
+                      "path",
+                    ),
+                    "replace",
                   ),
-                  "replace",
+                  undefined,
+                  [
+                    ts.factory.createStringLiteral("$input"),
+                    ts.factory.createStringLiteral(props.replacer),
+                  ],
                 ),
                 undefined,
-                [
-                  ts.factory.createStringLiteral("$input"),
-                  ts.factory.createStringLiteral(replacer),
-                ],
+                ts.factory.createIdentifier("undefined"),
               ),
             ),
           ]),

package/src/programmers/functional/FunctionalAssertParametersProgrammer.ts

@@ -17,6 +17,9 @@ export namespace FunctionalAssertParametersProgrammer {
       declaration: ts.FunctionDeclaration,
       init?: ts.Expression,
     ): ts.ArrowFunction => {
+      const wrapper = FunctionalAssertFunctionProgrammer.errorFactoryWrapper(
+        modulo,
+      )(declaration.parameters)(init);
       const async: boolean = (() => {
         if (declaration.type === undefined) return false;
         const type: ts.Type = project.checker.getTypeFromTypeNode(
@@ -34,9 +37,10 @@ export namespace FunctionalAssertParametersProgrammer {
         undefined,
         ts.factory.createBlock(
           [
-            FunctionalAssertFunctionProgrammer.errorFactory(modulo)(init),
+            wrapper.variable,
             ...argumentExpressions(project)(modulo)(equals)(
               declaration.parameters,
+              wrapper.name,
             ).map(ts.factory.createExpressionStatement),
             ts.factory.createReturnStatement(
               ts.factory.createCallExpression(
@@ -57,7 +61,10 @@ export namespace FunctionalAssertParametersProgrammer {
     (project: IProject) =>
     (modulo: ts.LeftHandSideExpression) =>
     (equals: boolean) =>
-    (parameters: readonly ts.ParameterDeclaration[]): ts.CallExpression[] =>
+    (
+      parameters: readonly ts.ParameterDeclaration[],
+      wrapper: string,
+    ): ts.CallExpression[] =>
       parameters.map((p, i) =>
         ts.factory.createCallExpression(
           AssertProgrammer.write(project)(modulo)(equals)(
@@ -65,9 +72,10 @@ export namespace FunctionalAssertParametersProgrammer {
               ? project.checker.getTypeFromTypeNode(p.type)
               : project.checker.getTypeFromTypeNode(TypeFactory.keyword("any")),
             undefined,
-            FunctionalAssertFunctionProgrammer.hookPath(
-              `$input.parameters[${i}]`,
-            ),
+            FunctionalAssertFunctionProgrammer.hookPath({
+              wrapper,
+              replacer: `$input.parameters[${i}]`,
+            }),
           ),
           undefined,
           [ts.factory.createIdentifier(p.name.getText())],

package/src/programmers/functional/FunctionalAssertReturnProgrammer.ts

@@ -17,6 +17,9 @@ export namespace FunctionAssertReturnProgrammer {
       declaration: ts.FunctionDeclaration,
       init?: ts.Expression,
     ): ts.ArrowFunction => {
+      const wrapper = FunctionalAssertFunctionProgrammer.errorFactoryWrapper(
+        modulo,
+      )(declaration.parameters)(init);
       const { async, returns: statement } = returnStatement(project)(modulo)(
         equals,
       )(
@@ -25,6 +28,7 @@ export namespace FunctionAssertReturnProgrammer {
         declaration.parameters.map((p) =>
           ts.factory.createIdentifier(p.name.getText()),
         ),
+        wrapper.name,
       );
       return ts.factory.createArrowFunction(
         async
@@ -34,13 +38,7 @@ export namespace FunctionAssertReturnProgrammer {
         declaration.parameters,
         declaration.type,
         undefined,
-        ts.factory.createBlock(
-          [
-            FunctionalAssertFunctionProgrammer.errorFactory(modulo)(init),
-            statement,
-          ],
-          true,
-        ),
+        ts.factory.createBlock([wrapper.variable, statement], true),
       );
     };
 
@@ -52,6 +50,7 @@ export namespace FunctionAssertReturnProgrammer {
       expression: ts.Expression,
       typeNode: ts.TypeNode | undefined,
       argumentExpressions: ts.Expression[],
+      wrapper: string,
     ): {
       async: boolean;
       returns: ts.ReturnStatement;
@@ -76,7 +75,10 @@ export namespace FunctionAssertReturnProgrammer {
             AssertProgrammer.write(project)(modulo)(equals)(
               type,
               undefined,
-              FunctionalAssertFunctionProgrammer.hookPath("$input.return"),
+              FunctionalAssertFunctionProgrammer.hookPath({
+                wrapper,
+                replacer: "$input.return",
+              }),
             ),
             undefined,
             [async ? ts.factory.createAwaitExpression(caller) : caller],

package/src/programmers/functional/FunctionalIsFunctionProgrammer.ts

@@ -0,0 +1,45 @@
+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,
+        ts.factory.createUnionTypeNode([
+          declaration.type ??
+            ts.factory.createKeywordTypeNode(ts.SyntaxKind.AnyKeyword),
+          ts.factory.createTypeReferenceNode("null"),
+        ]),
+        undefined,
+        ts.factory.createBlock(
+          [
+            ...FunctionalIsParametersProgrammer.writeStatements(project)(
+              modulo,
+            )(equals)(declaration),
+            ...statements,
+          ],
+          true,
+        ),
+      );
+    };
+}

package/src/programmers/functional/FunctionalIsParametersProgrammer.ts

@@ -0,0 +1,78 @@
+import ts from "typescript";
+
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { IsProgrammer } from "../IsProgrammer";
+
+export namespace FunctionalIsParametersProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+    ): ts.ArrowFunction => {
+      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.createArrowFunction(
+        async
+          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+          : undefined,
+        undefined,
+        declaration.parameters,
+        ts.factory.createUnionTypeNode([
+          declaration.type ?? TypeFactory.keyword("any"),
+          ts.factory.createTypeReferenceNode("null"),
+        ]),
+        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,91 @@
+import ts from "typescript";
+
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { StringUtil } from "../../utils/StringUtil";
+
+import { IsProgrammer } from "../IsProgrammer";
+
+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,
+        ts.factory.createUnionTypeNode([
+          declaration.type ?? TypeFactory.keyword("any"),
+          ts.factory.createTypeReferenceNode("null"),
+        ]),
+        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]: [ts.Type, boolean] = (() => {
+        const type: ts.Type = project.checker.getTypeFromTypeNode(
+          declaration.type ?? TypeFactory.keyword("any"),
+        );
+        return type.isTypeParameter() && type.symbol.name === "Promise"
+          ? [type.aliasTypeArguments![0]!, true]
+          : [type, false];
+      })();
+      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 };
+    };
+}

package/src/programmers/functional/FunctionalValidateFunctionProgrammer.ts

@@ -0,0 +1,91 @@
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+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.ArrowFunction => {
+      const { async, statements } =
+        FunctionalValidateReturnProgrammer.writeStatements(project)(modulo)(
+          equals,
+        )(expression, declaration);
+      return ts.factory.createArrowFunction(
+        async
+          ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+          : undefined,
+        undefined,
+        declaration.parameters,
+        declaration.type
+          ? ts.factory.createImportTypeNode(
+              ts.factory.createLiteralTypeNode(
+                ts.factory.createStringLiteral("typia"),
+              ),
+              undefined,
+              ts.factory.createIdentifier("IValidation"),
+              [declaration.type],
+            )
+          : undefined,
+        undefined,
+        ts.factory.createBlock(
+          [
+            ...FunctionalValidateParametersProgrammer.writeStatements(project)(
+              modulo,
+            )(equals)(declaration),
+            ...statements,
+          ],
+          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,
+          ),
+        ),
+      ],
+    );
+}