typia 3.5.3 → 3.6.0-dev.20230219

package/src/programmers/AssertProgrammer.ts

@@ -1,6 +1,7 @@
 import ts from "typescript";
 
 import { IdentifierFactory } from "../factories/IdentifierFactory";
+import { TypeFactory } from "../factories/TypeFactory";
 
 // import { StatementFactory } from "../factories/StatementFactory";
 import { IProject } from "../transformers/IProject";
@@ -11,217 +12,6 @@ import { FunctionImporter } from "./helpers/FunctionImporeter";
 import { OptionPredicator } from "./helpers/OptionPredicator";
 import { check_object } from "./internal/check_object";
 
-// /* -----------------------------------------------------------
-//     ASSERT V2 -> USE (NULL OR ERROR) CONDITION
-// ----------------------------------------------------------- */
-// export namespace AssertProgrammerV2 {
-//     export const generate =
-//         (
-//             project: IProject,
-//             modulo: ts.LeftHandSideExpression,
-//             equals: boolean = false,
-//         ) =>
-//         (type: ts.Type) => {
-//             const importer: FunctionImporter = new FunctionImporter();
-//             const guardV2: ts.Expression = importer.use("guardV2");
-
-//             const program: ts.ArrowFunction = CheckerProgrammer.generate(
-//                 project,
-//                 {
-//                     functors: "$ao",
-//                     unioners: "$au",
-//                     path: true,
-//                     trace: true,
-//                     numeric: OptionPredicator.numeric(project.options),
-//                     equals,
-//                     combiner,
-//                     joiner: joiner(equals)(importer),
-//                     success: ts.factory.createNull(),
-//                 },
-//                 importer,
-//             )(type);
-
-//             return ts.factory.createArrowFunction(
-//                 undefined,
-//                 undefined,
-//                 [IdentifierFactory.parameter("input")],
-//                 undefined,
-//                 undefined,
-//                 ts.factory.createBlock(
-//                     [
-//                         ...importer.declare(modulo),
-//                         StatementFactory.constant(
-//                             "error",
-//                             ts.factory.createCallExpression(
-//                                 program,
-//                                 undefined,
-//                                 [
-//                                     ValueFactory.INPUT(),
-//                                     ts.factory.createStringLiteral("$input"),
-//                                 ],
-//                             ),
-//                         ),
-//                         ts.factory.createIfStatement(
-//                             ts.factory.createStrictInequality(
-//                                 ts.factory.createNull(),
-//                                 ts.factory.createIdentifier("error"),
-//                             ),
-//                             ts.factory.createThrowStatement(
-//                                 ts.factory.createCallExpression(
-//                                     guardV2,
-//                                     undefined,
-//                                     [ts.factory.createIdentifier("error")],
-//                                 ),
-//                             ),
-//                         ),
-//                         ts.factory.createReturnStatement(ValueFactory.INPUT()),
-//                     ],
-//                     true,
-//                 ),
-//             );
-//         };
-
-//     const combiner: CheckerProgrammer.IConfig.Combiner = (
-//         explore: CheckerProgrammer.IExplore,
-//     ) => {
-//         const path: string = explore.postfix
-//             ? `path + ${explore.postfix}`
-//             : "path";
-//         return (logic) => (input, binaries, expected) =>
-//             binaries
-//                 .map((binary) =>
-//                     binary.combined
-//                         ? binary.expression
-//                         : ts.factory.createParenthesizedExpression(
-//                               ts.factory.createConditionalExpression(
-//                                   binary.expression,
-//                                   undefined,
-//                                   ts.factory.createNull(),
-//                                   undefined,
-//                                   create_exception_props(
-//                                       ts.factory.createIdentifier(path),
-//                                       expected,
-//                                       input,
-//                                   ),
-//                               ),
-//                           ),
-//                 )
-//                 .reduce(
-//                     logic === "and"
-//                         ? ts.factory.createLogicalOr
-//                         : ts.factory.createLogicalAnd,
-//                 );
-//     };
-
-//     const assert_object = (equals: boolean) => (importer: FunctionImporter) =>
-//         check_object({
-//             equals,
-//             assert: true,
-//             reduce: ts.factory.createLogicalOr,
-//             positive: ts.factory.createNull(),
-//             superfluous: (value) =>
-//                 create_exception_props(
-//                     ts.factory.createAdd(
-//                         ts.factory.createIdentifier("path"),
-//                         ts.factory.createCallExpression(
-//                             importer.use("join"),
-//                             undefined,
-//                             [ts.factory.createIdentifier("key")],
-//                         ),
-//                     ),
-//                     "undefined",
-//                     value,
-//                 ),
-//             entries: importer.use("every"),
-//             halt: (expr) =>
-//                 ts.factory.createConditionalExpression(
-//                     ts.factory.createStrictEquality(
-//                         ts.factory.createFalse(),
-//                         ts.factory.createIdentifier("exceptionable"),
-//                     ),
-//                     undefined,
-//                     ts.factory.createNull(),
-//                     undefined,
-//                     expr,
-//                 ),
-//         });
-
-//     const joiner =
-//         (equals: boolean) =>
-//         (importer: FunctionImporter): CheckerProgrammer.IConfig.IJoiner => ({
-//             object: assert_object(equals)(importer),
-//             array: (input, arrow) =>
-//                 ts.factory.createCallExpression(
-//                     importer.use("every"),
-//                     undefined,
-//                     [input, arrow],
-//                 ),
-//             failure: (value, expected, explore) =>
-//                 create_exception_props(
-//                     ts.factory.createIdentifier(
-//                         explore?.postfix ? `path + ${explore.postfix}` : "path",
-//                     ),
-//                     expected,
-//                     value,
-//                 ),
-//             is: (exp) =>
-//                 ts.factory.createStrictEquality(
-//                     ts.factory.createNull(),
-//                     ts.factory.createParenthesizedExpression(exp),
-//                 ),
-//             required: (value) =>
-//                 ts.factory.createConditionalExpression(
-//                     value,
-//                     undefined,
-//                     ts.factory.createNull(),
-//                     undefined,
-//                     create_exception_props(
-//                         ts.factory.createStringLiteral(""),
-//                         "not undefined",
-//                         value,
-//                     ),
-//                 ),
-//             full: equals
-//                 ? undefined
-//                 : (condition) => (input, expected) =>
-//                       ts.factory.createConditionalExpression(
-//                           ts.factory.createStrictEquality(
-//                               ts.factory.createNull(),
-//                               condition,
-//                           ),
-//                           undefined,
-//                           ts.factory.createNull(),
-//                           undefined,
-//                           create_exception_props(
-//                               ts.factory.createIdentifier("path"),
-//                               expected,
-//                               input,
-//                           ),
-//                       ),
-//         });
-
-//     function create_exception_props(
-//         path: ts.Expression,
-//         expected: string,
-//         value: ts.Expression,
-//     ): ts.ObjectLiteralExpression {
-//         return ts.factory.createObjectLiteralExpression(
-//             [
-//                 ts.factory.createPropertyAssignment("path", path),
-//                 ts.factory.createPropertyAssignment(
-//                     "expected",
-//                     ts.factory.createStringLiteral(expected),
-//                 ),
-//                 ts.factory.createPropertyAssignment("value", value),
-//             ],
-//             true,
-//         );
-//     }
-// }
-
-/* -----------------------------------------------------------
-    ASSERT V3 -> (CONDITION OR THROW(exceptable): FALSE)
------------------------------------------------------------ */
 export namespace AssertProgrammer {
     export const generate =
         (
@@ -250,7 +40,12 @@ export namespace AssertProgrammer {
             return ts.factory.createArrowFunction(
                 undefined,
                 undefined,
-                [IdentifierFactory.parameter("input")],
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        TypeFactory.keyword("any"),
+                    ),
+                ],
                 undefined,
                 undefined,
                 ts.factory.createBlock(
@@ -268,7 +63,14 @@ export namespace AssertProgrammer {
                             ),
                         ),
                         ts.factory.createReturnStatement(
-                            ts.factory.createIdentifier("input"),
+                            ts.factory.createAsExpression(
+                                ts.factory.createIdentifier("input"),
+                                project.checker.typeToTypeNode(
+                                    type,
+                                    undefined,
+                                    undefined,
+                                ) ?? TypeFactory.keyword("any"),
+                            ),
                         ),
                     ],
                     true,

package/src/programmers/AssertPruneProgrammer.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,14 @@ export namespace AssertPruneProgrammer {
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
-                [IdentifierFactory.parameter("input")],
-                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        TypeFactory.keyword("any"),
+                    ),
+                ],
+                project.checker.typeToTypeNode(type, undefined, undefined) ??
+                    TypeFactory.keyword("any"),
                 undefined,
                 ts.factory.createBlock([
                     StatementFactory.constant(

package/src/programmers/AssertStringifyProgrammer.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,17 @@ export namespace AssertStringifyProgrammer {
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
-                [IdentifierFactory.parameter("input")],
-                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        project.checker.typeToTypeNode(
+                            type,
+                            undefined,
+                            undefined,
+                        ) ?? TypeFactory.keyword("any"),
+                    ),
+                ],
+                TypeFactory.keyword("string"),
                 undefined,
                 ts.factory.createBlock([
                     StatementFactory.constant(

package/src/programmers/CheckerProgrammer.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";
@@ -106,8 +107,7 @@ export namespace CheckerProgrammer {
         config: IConfig,
         importer: FunctionImporter,
     ) =>
-        FeatureProgrammer.generate_functors(
-            CONFIG(project, config, importer),
+        FeatureProgrammer.generate_functors(CONFIG(project, config, importer))(
             importer,
         );
 
@@ -126,6 +126,19 @@ export namespace CheckerProgrammer {
         importer: FunctionImporter,
     ): FeatureProgrammer.IConfig {
         const output: FeatureProgrammer.IConfig = {
+            types: {
+                input: () => TypeFactory.keyword("any"),
+                output: (type) =>
+                    ts.factory.createTypePredicateNode(
+                        undefined,
+                        "input",
+                        project.checker.typeToTypeNode(
+                            type,
+                            undefined,
+                            undefined,
+                        ),
+                    ),
+            },
             trace: config.trace,
             path: config.path,
             functors: config.functors,

package/src/programmers/CloneProgrammer.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";
 
@@ -288,6 +289,19 @@ export namespace CloneProgrammer {
         project: IProject,
         importer: FunctionImporter,
     ): FeatureProgrammer.IConfig => ({
+        types: {
+            input: (type) =>
+                project.checker.typeToTypeNode(type, undefined, undefined) ??
+                TypeFactory.keyword("any"),
+            output: (type) =>
+                ts.factory.createTypeReferenceNode("typia.Primitive", [
+                    project.checker.typeToTypeNode(
+                        type,
+                        undefined,
+                        undefined,
+                    ) ?? TypeFactory.keyword("any"),
+                ]),
+        },
         functors: FUNCTORS,
         unioners: UNIONERS,
         trace: false,

package/src/programmers/FeatureProgrammer.ts

@@ -3,6 +3,7 @@ import ts from "typescript";
 import { IdentifierFactory } from "../factories/IdentifierFactory";
 import { MetadataCollection } from "../factories/MetadataCollection";
 import { StatementFactory } from "../factories/StatementFactory";
+import { TypeFactory } from "../factories/TypeFactory";
 import { ValueFactory } from "../factories/ValueFactory";
 
 import { IMetadataTag } from "../metadata/IMetadataTag";
@@ -22,6 +23,8 @@ export namespace FeatureProgrammer {
         PARAMETERS
     ----------------------------------------------------------- */
     export interface IConfig<Output extends ts.ConciseBody = ts.ConciseBody> {
+        types: IConfig.ITypes;
+
         /**
          * Prefix name of functions for specific object types.
          */
@@ -66,6 +69,11 @@ export namespace FeatureProgrammer {
         generator?: Partial<IConfig.IGenerator>;
     }
     export namespace IConfig {
+        export interface ITypes {
+            input: (type: ts.Type) => ts.TypeNode;
+            output: (type: ts.Type) => ts.TypeNode;
+        }
+
         export interface IObjector {
             /**
              * Type checker when union object type comes.
@@ -234,7 +242,7 @@ export namespace FeatureProgrammer {
             const functors: ts.VariableStatement[] =
                 config.generator?.functors !== undefined
                     ? config.generator.functors(collection)
-                    : generate_functors(config, importer)(collection);
+                    : generate_functors(config)(importer)(collection);
             const unioners: ts.VariableStatement[] =
                 config.generator?.unioners !== undefined
                     ? config.generator.unioners(collection)
@@ -244,8 +252,10 @@ export namespace FeatureProgrammer {
             return ts.factory.createArrowFunction(
                 undefined,
                 undefined,
-                PARAMETERS(config)(ValueFactory.INPUT()),
-                undefined,
+                PARAMETERS(config)(config.types.input(type))(
+                    ValueFactory.INPUT(),
+                ),
+                config.types.output(type),
                 undefined,
                 ts.factory.createBlock(
                     [
@@ -262,14 +272,15 @@ export namespace FeatureProgrammer {
         };
 
     export const generate_functors =
-        (config: IConfig, importer: FunctionImporter) =>
+        (config: IConfig) =>
+        (importer: FunctionImporter) =>
         (collection: MetadataCollection) =>
             collection
                 .objects()
                 .map((obj, i) =>
                     StatementFactory.constant(
                         `${config.functors}${i}`,
-                        generate_object(config, importer)(obj),
+                        generate_object(config)(importer)(obj),
                     ),
                 );
 
@@ -284,24 +295,26 @@ export namespace FeatureProgrammer {
                     ),
                 );
 
-    function generate_object(config: IConfig, importer: FunctionImporter) {
-        if (config.path === true) importer.use("join");
-        return (obj: MetadataObject) =>
+    const generate_object =
+        (config: IConfig) =>
+        (importer: FunctionImporter) =>
+        (obj: MetadataObject) =>
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
-                PARAMETERS(config)(ValueFactory.INPUT()),
+                PARAMETERS(config)(TypeFactory.keyword("any"))(
+                    ValueFactory.INPUT(),
+                ),
                 undefined,
                 undefined,
                 config.objector.joiner(
                     ts.factory.createIdentifier("input"),
-                    feature_object_entries(config)(obj)(
+                    feature_object_entries(config)(importer)(obj)(
                         ts.factory.createIdentifier("input"),
                     ),
                     obj,
                 ),
             );
-    }
 
     function generate_union(config: IConfig) {
         const explorer = UnionExplorer.object(config);
@@ -311,7 +324,9 @@ export namespace FeatureProgrammer {
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
-                PARAMETERS(config)(ValueFactory.INPUT()),
+                PARAMETERS(config)(TypeFactory.keyword("any"))(
+                    ValueFactory.INPUT(),
+                ),
                 undefined,
                 undefined,
                 explorer(
@@ -343,7 +358,12 @@ export namespace FeatureProgrammer {
         const rand: string = importer.increment().toString();
         const tail =
             config.path || config.trace
-                ? [IdentifierFactory.parameter("index" + rand)]
+                ? [
+                      IdentifierFactory.parameter(
+                          "index" + rand,
+                          TypeFactory.keyword("number"),
+                      ),
+                  ]
                 : [];
 
         return (
@@ -355,7 +375,13 @@ export namespace FeatureProgrammer {
             const arrow: ts.ArrowFunction = ts.factory.createArrowFunction(
                 undefined,
                 undefined,
-                [IdentifierFactory.parameter("elem"), ...tail],
+                [
+                    IdentifierFactory.parameter(
+                        "elem",
+                        TypeFactory.keyword("any"),
+                    ),
+                    ...tail,
+                ],
                 undefined,
                 undefined,
                 config.decoder(
@@ -438,15 +464,27 @@ const INDEX_SYMBOL =
             return prev.substring(0, prev.length - 1) + tail.substring(1);
         return prev + ` + ${tail}`;
     };
-const PARAMETERS = (
-    props: Pick<CheckerProgrammer.IConfig, "path" | "trace">,
-) => {
-    const tail: ts.ParameterDeclaration[] = [];
-    if (props.path) tail.push(IdentifierFactory.parameter("path"));
-    if (props.trace) tail.push(IdentifierFactory.parameter("exceptionable"));
-
-    return (input: ts.Identifier) => [
-        IdentifierFactory.parameter(input),
-        ...tail,
-    ];
-};
+const PARAMETERS =
+    (props: Pick<CheckerProgrammer.IConfig, "path" | "trace">) =>
+    (type: ts.TypeNode) => {
+        const tail: ts.ParameterDeclaration[] = [];
+        if (props.path)
+            tail.push(
+                IdentifierFactory.parameter(
+                    "path",
+                    TypeFactory.keyword("string"),
+                ),
+            );
+        if (props.trace)
+            tail.push(
+                IdentifierFactory.parameter(
+                    "exceptionable",
+                    TypeFactory.keyword("boolean"),
+                ),
+            );
+
+        return (input: ts.Identifier) => [
+            IdentifierFactory.parameter(input, type),
+            ...tail,
+        ];
+    };

package/src/programmers/IsCloneProgrammer.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,22 @@ export namespace IsCloneProgrammer {
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
-                [IdentifierFactory.parameter("input")],
-                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        TypeFactory.keyword("any"),
+                    ),
+                ],
+                ts.factory.createUnionTypeNode([
+                    ts.factory.createTypeReferenceNode("typia.Primitive", [
+                        project.checker.typeToTypeNode(
+                            type,
+                            undefined,
+                            undefined,
+                        ) ?? TypeFactory.keyword("any"),
+                    ]),
+                    ts.factory.createLiteralTypeNode(ts.factory.createNull()),
+                ]),
                 undefined,
                 ts.factory.createBlock([
                     StatementFactory.constant(

package/src/programmers/IsParseProgrammer.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,19 @@ export namespace IsParseProgrammer {
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
-                [IdentifierFactory.parameter("input")],
-                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        TypeFactory.keyword("any"),
+                    ),
+                ],
+                ts.factory.createTypeReferenceNode("typia.Primitive", [
+                    project.checker.typeToTypeNode(
+                        type,
+                        undefined,
+                        undefined,
+                    ) ?? TypeFactory.keyword("any"),
+                ]),
                 undefined,
                 ts.factory.createBlock([
                     StatementFactory.constant(
@@ -51,7 +63,10 @@ export namespace IsParseProgrammer {
                                 [ts.factory.createIdentifier("input")],
                             ),
                             undefined,
-                            ts.factory.createIdentifier("input"),
+                            ts.factory.createAsExpression(
+                                ts.factory.createIdentifier("input"),
+                                TypeFactory.keyword("any"),
+                            ),
                             undefined,
                             ts.factory.createNull(),
                         ),

package/src/programmers/IsProgrammer.ts

@@ -126,7 +126,9 @@ export namespace IsProgrammer {
                         }),
                         config.joiner.object(
                             input,
-                            feature_object_entries(config as any)(obj)(input),
+                            feature_object_entries(config as any)(importer)(
+                                obj,
+                            )(input),
                         ),
                     );
             }

package/src/programmers/IsPruneProgrammer.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 IsPruneProgrammer {
             ts.factory.createArrowFunction(
                 undefined,
                 undefined,
-                [IdentifierFactory.parameter("input")],
-                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        TypeFactory.keyword("any"),
+                    ),
+                ],
+                ts.factory.createTypePredicateNode(
+                    undefined,
+                    "input",
+                    project.checker.typeToTypeNode(
+                        type,
+                        undefined,
+                        undefined,
+                    ) ?? TypeFactory.keyword("any"),
+                ),
                 undefined,
                 ts.factory.createBlock([
                     StatementFactory.constant(