typia 3.5.3 → 3.6.0-dev.20230219

package/src/programmers/IsStringifyProgrammer.ts

@@ -2,6 +2,7 @@ import ts from "typescript";
 
 import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { StatementFactory } from "../factories/StatementFactory";
+import { TypeFactory } from "../factories/TypeFactory";
 
 import { IProject } from "../transformers/IProject";
 
@@ -15,8 +16,20 @@ export namespace IsStringifyProgrammer {
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
-                [IdentifierFactory.parameter("input")],
-                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        project.checker.typeToTypeNode(
+                            type,
+                            undefined,
+                            undefined,
+                        ) ?? TypeFactory.keyword("any"),
+                    ),
+                ],
+                ts.factory.createUnionTypeNode([
+                    TypeFactory.keyword("string"),
+                    ts.factory.createLiteralTypeNode(ts.factory.createNull()),
+                ]),
                 undefined,
                 ts.factory.createBlock([
                     StatementFactory.constant(

package/src/programmers/PruneProgrammer.ts

@@ -4,6 +4,7 @@ import { ExpressionFactory } from "../factories/ExpressionFactory";
 import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { MetadataCollection } from "../factories/MetadataCollection";
 import { MetadataFactory } from "../factories/MetadataFactory";
+import { TypeFactory } from "../factories/TypeFactory";
 
 import { Metadata } from "../metadata/Metadata";
 
@@ -260,6 +261,12 @@ export namespace PruneProgrammer {
         project: IProject,
         importer: FunctionImporter,
     ): FeatureProgrammer.IConfig => ({
+        types: {
+            input: (type) =>
+                project.checker.typeToTypeNode(type, undefined, undefined) ??
+                TypeFactory.keyword("any"),
+            output: () => TypeFactory.keyword("void"),
+        },
         functors: FUNCTORS,
         unioners: UNIONERS,
         trace: false,

package/src/programmers/RandomProgrammer.ts

@@ -6,6 +6,7 @@ import { MetadataCollection } from "../factories/MetadataCollection";
 import { MetadataFactory } from "../factories/MetadataFactory";
 import { StatementFactory } from "../factories/StatementFactory";
 import { TemplateFactory } from "../factories/TemplateFactory";
+import { TypeFactory } from "../factories/TypeFactory";
 
 import { IMetadataTag } from "../metadata/IMetadataTag";
 import { Metadata } from "../metadata/Metadata";
@@ -49,7 +50,18 @@ export namespace RandomProgrammer {
                 [
                     IdentifierFactory.parameter(
                         "generator",
-                        IdentifierFactory.join(modulo, "generator"),
+                        ts.factory.createTypeReferenceNode(
+                            "typia.IRandomGenerator",
+                        ),
+                        IdentifierFactory.join(
+                            ts.factory.createParenthesizedExpression(
+                                ts.factory.createAsExpression(
+                                    modulo,
+                                    TypeFactory.keyword("any"),
+                                ),
+                            ),
+                            "generator",
+                        ),
                     ),
                 ],
                 undefined,
@@ -77,12 +89,14 @@ export namespace RandomProgrammer {
                         [
                             IdentifierFactory.parameter(
                                 "recursive",
+                                undefined,
                                 ts.factory.createIdentifier(
                                     String(obj.recursive),
                                 ),
                             ),
                             IdentifierFactory.parameter(
                                 "depth",
+                                undefined,
                                 ts.factory.createNumericLiteral(0),
                             ),
                         ],

package/src/programmers/StringifyProgrammer.ts

@@ -4,6 +4,7 @@ import { ExpressionFactory } from "../factories/ExpressionFactory";
 import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { MetadataCollection } from "../factories/MetadataCollection";
 import { MetadataFactory } from "../factories/MetadataFactory";
+import { TypeFactory } from "../factories/TypeFactory";
 import { ValueFactory } from "../factories/ValueFactory";
 
 import { IMetadataTag } from "../metadata/IMetadataTag";
@@ -374,7 +375,7 @@ export namespace StringifyProgrammer {
                                           decoder: decode(project, importer),
                                           trace: false,
                                           path: false,
-                                      })(obj)(input);
+                                      })(importer)(obj)(input);
                                   return StringifyJoiner.object(importer)(
                                       input,
                                       entries,
@@ -696,6 +697,12 @@ export namespace StringifyProgrammer {
         project: IProject,
         importer: FunctionImporter,
     ): FeatureProgrammer.IConfig => ({
+        types: {
+            input: (type) =>
+                project.checker.typeToTypeNode(type, undefined, undefined) ??
+                TypeFactory.keyword("any"),
+            output: () => TypeFactory.keyword("string"),
+        },
         functors: FUNCTORS,
         unioners: UNIONERS,
         trace: false,

package/src/programmers/ValidateCloneProgrammer.ts

@@ -2,6 +2,7 @@ import ts from "typescript";
 
 import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { StatementFactory } from "../factories/StatementFactory";
+import { TypeFactory } from "../factories/TypeFactory";
 
 import { IProject } from "../transformers/IProject";
 
@@ -15,8 +16,21 @@ export namespace ValidateCloneProgrammer {
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
-                [IdentifierFactory.parameter("input")],
-                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        TypeFactory.keyword("any"),
+                    ),
+                ],
+                ts.factory.createTypeReferenceNode("typia.IValidation", [
+                    ts.factory.createTypeReferenceNode("typia.Primitive", [
+                        project.checker.typeToTypeNode(
+                            type,
+                            undefined,
+                            undefined,
+                        ) ?? TypeFactory.keyword("any"),
+                    ]),
+                ]),
                 undefined,
                 ts.factory.createBlock([
                     StatementFactory.constant(
@@ -49,10 +63,13 @@ export namespace ValidateCloneProgrammer {
                     ),
                     StatementFactory.constant(
                         "output",
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("validate"),
-                            undefined,
-                            [ts.factory.createIdentifier("input")],
+                        ts.factory.createAsExpression(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("validate"),
+                                undefined,
+                                [ts.factory.createIdentifier("input")],
+                            ),
+                            TypeFactory.keyword("any"),
                         ),
                     ),
                     ts.factory.createIfStatement(

package/src/programmers/ValidateParseProgrammer.ts

@@ -2,6 +2,7 @@ import ts from "typescript";
 
 import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { StatementFactory } from "../factories/StatementFactory";
+import { TypeFactory } from "../factories/TypeFactory";
 
 import { IProject } from "../transformers/IProject";
 
@@ -14,8 +15,21 @@ export namespace ValidateParseProgrammer {
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
-                [IdentifierFactory.parameter("input")],
-                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        TypeFactory.keyword("string"),
+                    ),
+                ],
+                ts.factory.createTypeReferenceNode("typia.IValidation", [
+                    ts.factory.createTypeReferenceNode("typia.Primitive", [
+                        project.checker.typeToTypeNode(
+                            type,
+                            undefined,
+                            undefined,
+                        ) ?? TypeFactory.keyword("any"),
+                    ]),
+                ]),
                 undefined,
                 ts.factory.createBlock([
                     StatementFactory.constant(

package/src/programmers/ValidateProgrammer.ts

@@ -2,6 +2,7 @@ import ts from "typescript";
 
 import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { StatementFactory } from "../factories/StatementFactory";
+import { TypeFactory } from "../factories/TypeFactory";
 
 import { IProject } from "../transformers/IProject";
 
@@ -40,19 +41,43 @@ export namespace ValidateProgrammer {
             return ts.factory.createArrowFunction(
                 undefined,
                 undefined,
-                [IdentifierFactory.parameter("input")],
-                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        TypeFactory.keyword("any"),
+                    ),
+                ],
+                ts.factory.createTypeReferenceNode("typia.IValidation", [
+                    project.checker.typeToTypeNode(
+                        type,
+                        undefined,
+                        undefined,
+                    ) ?? TypeFactory.keyword("any"),
+                ]),
                 undefined,
                 ts.factory.createBlock(
                     [
                         StatementFactory.constant(
                             "errors",
-                            ts.factory.createArrayLiteralExpression([]),
+                            ts.factory.createAsExpression(
+                                ts.factory.createArrayLiteralExpression([]),
+                                ts.factory.createArrayTypeNode(
+                                    TypeFactory.keyword("any"),
+                                ),
+                            ),
                         ),
                         StatementFactory.constant(
                             "$report",
                             ts.factory.createCallExpression(
-                                IdentifierFactory.join(modulo, "report"),
+                                IdentifierFactory.join(
+                                    ts.factory.createParenthesizedExpression(
+                                        ts.factory.createAsExpression(
+                                            modulo,
+                                            TypeFactory.keyword("any"),
+                                        ),
+                                    ),
+                                    "report",
+                                ),
                                 [],
                                 [ts.factory.createIdentifier("errors")],
                             ),
@@ -76,7 +101,21 @@ export namespace ValidateProgrammer {
                                 ts.factory.createIdentifier("errors.length"),
                             ),
                         ),
-                        ts.factory.createReturnStatement(create_output()),
+                        ts.factory.createReturnStatement(
+                            ts.factory.createAsExpression(
+                                create_output(),
+                                ts.factory.createTypeReferenceNode(
+                                    "typia.IValidation",
+                                    [
+                                        project.checker.typeToTypeNode(
+                                            type,
+                                            undefined,
+                                            undefined,
+                                        ) ?? TypeFactory.keyword("any"),
+                                    ],
+                                ),
+                            ),
+                        ),
                     ],
                     true,
                 ),

package/src/programmers/ValidatePruneProgrammer.ts

@@ -2,6 +2,7 @@ import ts from "typescript";
 
 import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { StatementFactory } from "../factories/StatementFactory";
+import { TypeFactory } from "../factories/TypeFactory";
 
 import { IProject } from "../transformers/IProject";
 
@@ -15,8 +16,19 @@ export namespace ValidatePruneProgrammer {
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
-                [IdentifierFactory.parameter("input")],
-                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        TypeFactory.keyword("any"),
+                    ),
+                ],
+                ts.factory.createTypeReferenceNode("typia.IValidation", [
+                    project.checker.typeToTypeNode(
+                        type,
+                        undefined,
+                        undefined,
+                    ) ?? TypeFactory.keyword("any"),
+                ]),
                 undefined,
                 ts.factory.createBlock([
                     StatementFactory.constant(

package/src/programmers/ValidateStringifyProgrammer.ts

@@ -2,6 +2,7 @@ import ts from "typescript";
 
 import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { StatementFactory } from "../factories/StatementFactory";
+import { TypeFactory } from "../factories/TypeFactory";
 
 import { IProject } from "../transformers/IProject";
 
@@ -15,8 +16,19 @@ export namespace ValidateStringifyProgrammer {
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
-                [IdentifierFactory.parameter("input")],
-                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        project.checker.typeToTypeNode(
+                            type,
+                            undefined,
+                            undefined,
+                        ) ?? TypeFactory.keyword("any"),
+                    ),
+                ],
+                ts.factory.createTypeReferenceNode("typia.IValidation", [
+                    TypeFactory.keyword("string"),
+                ]),
                 undefined,
                 ts.factory.createBlock([
                     StatementFactory.constant(
@@ -49,10 +61,13 @@ export namespace ValidateStringifyProgrammer {
                     ),
                     StatementFactory.constant(
                         "output",
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("validate"),
-                            undefined,
-                            [ts.factory.createIdentifier("input")],
+                        ts.factory.createAsExpression(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("validate"),
+                                undefined,
+                                [ts.factory.createIdentifier("input")],
+                            ),
+                            TypeFactory.keyword("any"),
                         ),
                     ),
                     ts.factory.createIfStatement(

package/src/programmers/helpers/FunctionImporeter.ts

@@ -2,6 +2,7 @@ import ts from "typescript";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
 
 export class FunctionImporter {
     private readonly used_: Set<string> = new Set();
@@ -20,7 +21,15 @@ export class FunctionImporter {
         return [...this.used_].map((name) =>
             StatementFactory.constant(
                 "$" + name,
-                IdentifierFactory.join(modulo, name),
+                IdentifierFactory.join(
+                    ts.factory.createParenthesizedExpression(
+                        ts.factory.createAsExpression(
+                            modulo,
+                            TypeFactory.keyword("any"),
+                        ),
+                    ),
+                    name,
+                ),
             ),
         );
     }

package/src/programmers/internal/check_everything.ts

@@ -1,6 +1,7 @@
 import ts from "typescript";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
 
 /**
  * @internal
@@ -13,13 +14,15 @@ export const check_everything = (array: ts.Expression) =>
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
-                [IdentifierFactory.parameter("flag")],
+                [
+                    IdentifierFactory.parameter(
+                        "flag",
+                        TypeFactory.keyword("boolean"),
+                    ),
+                ],
                 undefined,
                 undefined,
-                ts.factory.createStrictEquality(
-                    ts.factory.createTrue(),
-                    ts.factory.createIdentifier("flag"),
-                ),
+                ts.factory.createIdentifier("flag"),
             ),
         ],
     );

package/src/programmers/internal/check_union_array_like.ts

@@ -2,6 +2,7 @@ import ts from "typescript";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
 
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 
@@ -140,7 +141,12 @@ export const check_union_array_like =
                         ts.factory.createArrowFunction(
                             undefined,
                             undefined,
-                            [IdentifierFactory.parameter("value")],
+                            [
+                                IdentifierFactory.parameter(
+                                    "value",
+                                    TypeFactory.keyword("any"),
+                                ),
+                            ],
                             undefined,
                             undefined,
                             ts.factory.createStrictEquality(

package/src/programmers/internal/feature_object_entries.ts

@@ -7,6 +7,7 @@ import { MetadataObject } from "../../metadata/MetadataObject";
 import { Escaper } from "../../utils/Escaper";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
+import { FunctionImporter } from "../helpers/FunctionImporeter";
 
 export const feature_object_entries =
     <Output extends ts.ConciseBody>(
@@ -15,6 +16,7 @@ export const feature_object_entries =
             "decoder" | "path" | "trace"
         >,
     ) =>
+    (importer: FunctionImporter) =>
     (obj: MetadataObject) =>
     (input: ts.Expression) =>
         obj.properties.map((prop) => {
@@ -46,7 +48,10 @@ export const feature_object_entries =
                         postfix:
                             sole !== null
                                 ? IdentifierFactory.postfix(sole)
-                                : `$join(key)`,
+                                : (() => {
+                                      importer.use("join");
+                                      return `$join(key)`;
+                                  })(),
                     },
                     prop.tags,
                 ),

package/src/transformers/CallExpressionTransformer.ts

@@ -58,7 +58,11 @@ export namespace CallExpressionTransformer {
 
         // FILE PATH
         const file: string = path.resolve(declaration.getSourceFile().fileName);
-        if (file.indexOf(LIB_PATH) === -1 && file !== SRC_PATH)
+        if (
+            file.indexOf(LIB_PATH) === -1 &&
+            file !== SRC_PATH &&
+            file !== CLI_PATH
+        )
             return expression;
 
         //----
@@ -84,6 +88,9 @@ type Task = (
 
 const LIB_PATH = path.join("node_modules", "typia", "lib", "module.d.ts");
 const SRC_PATH = path.resolve(path.join(__dirname, "..", "module.ts"));
+const CLI_PATH = path.resolve(
+    path.join(__dirname, "..", "..", "..", "src", "module.ts"),
+);
 
 const FUNCTORS: Record<string, () => Task> = {
     //----

package/lib/executable/internal/ArgumentParser.d.ts

@@ -1,9 +0,0 @@
-import { PackageManager } from "./PackageManager";
-export declare namespace ArgumentParser {
-    interface IArguments {
-        compiler: "ts-patch" | "ttypescript";
-        manager: "npm" | "pnpm" | "yarn";
-        project: string | null;
-    }
-    function parse(pack: PackageManager): Promise<IArguments>;
-}