typia 3.5.0-dev.20221219 → 3.5.0-dev.20230107

package/src/programmers/CheckerProgrammer.ts

@@ -18,10 +18,13 @@ import { IExpressionEntry } from "./helpers/IExpressionEntry";
 import { OptionPredicator } from "./helpers/OptionPredicator";
 import { UnionExplorer } from "./helpers/UnionExplorer";
 import { check_array } from "./internal/check_array";
+import { check_array_length } from "./internal/check_array_length";
+import { check_bigint } from "./internal/check_bigint";
 import { check_native } from "./internal/check_native";
 import { check_number } from "./internal/check_number";
 import { check_string } from "./internal/check_string";
 import { check_template } from "./internal/check_template";
+import { check_union_tuple } from "./internal/check_union_tuple";
 import { decode_union_object } from "./internal/decode_union_object";
 
 export namespace CheckerProgrammer {
@@ -221,7 +224,6 @@ export namespace CheckerProgrammer {
         project: IProject,
         config: IConfig,
         importer: FunctionImporter,
-        checkTupleLength: boolean = true,
     ) {
         return function (
             input: ts.Expression,
@@ -299,6 +301,11 @@ export namespace CheckerProgrammer {
                         ),
                         combined: false,
                     });
+                else if (type === "bigint")
+                    binaries.push({
+                        expression: check_bigint(input, tags),
+                        combined: false,
+                    });
                 else if (type === "string")
                     binaries.push({
                         expression: check_string(importer)(input, tags),
@@ -322,212 +329,199 @@ export namespace CheckerProgrammer {
                     combined: false,
                 });
 
+            // NATIVE CLASSES
+            for (const native of meta.natives)
+                binaries.push({
+                    expression: check_native(native)(input),
+                    combined: false,
+                });
+
             //----
             // INSTANCES
             //----
-            // TUPLE
-            if (meta.tuples.length > 0) {
-                const inner: ts.Expression[] = [];
-                for (const tuple of meta.tuples)
-                    inner.push(
-                        decode_tuple(
-                            project,
-                            config,
-                            importer,
-                            checkTupleLength,
-                        )(input, tuple, explore, tags),
-                    );
+            interface IInstance {
+                pre: ts.Expression;
+                body: ts.Expression | null;
+                expected: string;
+            }
+            const instances: IInstance[] = [];
+            const prepare =
+                (pre: ts.Expression, expected: string) =>
+                (body: ts.Expression | null) =>
+                    instances.push({
+                        pre,
+                        expected,
+                        body,
+                    });
 
-                // ADD
-                binaries.push({
-                    expression: config.combiner(explore)("and")(
-                        input,
-                        [
-                            ...(checkTupleLength
-                                ? [
-                                      {
-                                          expression:
-                                              ExpressionFactory.isArray(input),
-                                          combined: false,
-                                      },
-                                  ]
-                                : []),
-                            ...inner.map((expression) => ({
-                                expression,
-                                combined: true,
-                            })),
-                        ],
-                        meta.getName(),
-                    ),
-                    combined: true,
-                });
+            // SETS
+            if (meta.sets.length) {
+                const install = prepare(
+                    check_native("Set")(input),
+                    meta.sets
+                        .map((elem) => `Set<${elem.getName()}>`)
+                        .join(" | "),
+                );
+                if (meta.sets.some((elem) => elem.any)) install(null);
+                else
+                    install(
+                        explore_sets(project, config, importer)(
+                            input,
+                            meta.sets,
+                            {
+                                ...explore,
+                                from: "array",
+                            },
+                            [],
+                        ),
+                    );
             }
 
-            // ARRAY
-            if (meta.arrays.length > 0)
-                if (meta.arrays.every((elem) => elem.any))
-                    binaries.push({
-                        expression: check_array(input, tags),
-                        combined: false,
-                    });
+            // MAPS
+            if (meta.maps.length) {
+                const install = prepare(
+                    check_native("Map")(input),
+                    meta.maps
+                        .map(({ key, value }) => `Map<${key}, ${value}>`)
+                        .join(" | "),
+                );
+                if (meta.maps.some((elem) => elem.key.any && elem.value.any))
+                    install(null);
                 else
-                    binaries.push({
-                        expression: config.combiner(explore)("and")(
+                    install(
+                        explore_maps(project, config, importer)(
                             input,
-                            [
-                                ...(checkTupleLength
-                                    ? [
-                                          {
-                                              expression: check_array(
-                                                  input,
-                                                  tags,
-                                              ),
-                                              combined: false,
-                                          },
-                                      ]
-                                    : []),
-                                {
-                                    expression: explore_array(
-                                        project,
-                                        config,
-                                        importer,
-                                    )(
-                                        input,
-                                        meta.arrays,
-                                        {
-                                            ...explore,
-                                            from: "array",
-                                        },
-                                        tags,
-                                    ),
-                                    combined: true,
-                                },
-                            ],
-                            meta.getName(),
+                            meta.maps.map((m) => [m.key, m.value]),
+                            {
+                                ...explore,
+                                from: "array",
+                            },
+                            [],
                         ),
-                        combined: true,
-                    });
+                    );
+            }
 
-            // OBJECT
-            if (meta.objects.length > 0)
-                binaries.push({
-                    expression: config.combiner(explore)("and")(
-                        input,
-                        [
+            // ARRAYS AND TUPLES
+            if (meta.tuples.length + meta.arrays.length > 0) {
+                const install = prepare(
+                    check_array(input, meta.tuples.length === 0 ? tags : []),
+                    [...meta.tuples, ...meta.arrays]
+                        .map((elem) =>
+                            Array.isArray(elem)
+                                ? `[${elem
+                                      .map((elem) => elem.getName())
+                                      .join(", ")}]`
+                                : `Array<${elem.getName()}>`,
+                        )
+                        .join(" | "),
+                );
+                if (meta.arrays.length === 0)
+                    install(
+                        explore_tuples(project, config, importer)(
+                            input,
+                            meta.tuples,
                             {
-                                expression: ExpressionFactory.isObject(input, {
-                                    checkNull: true,
-                                    checkArray: meta.objects.some((obj) =>
-                                        obj.properties.every(
-                                            (prop) =>
-                                                !prop.key.isSoleLiteral() ||
-                                                !prop.value.required,
-                                        ),
-                                    ),
-                                }),
-                                combined: false,
+                                ...explore,
+                                from: "array",
                             },
+                            tags,
+                        ),
+                    );
+                else if (meta.arrays.some((elem) => elem.any)) install(null);
+                else if (meta.tuples.length === 0)
+                    // ARRAY ONLY
+                    install(
+                        explore_arrays(project, config, importer)(
+                            input,
+                            meta.arrays,
                             {
-                                expression: explore_objects(config)(
-                                    input,
-                                    meta,
-                                    {
-                                        ...explore,
-                                        from: "object",
-                                    },
-                                ),
-                                combined: true,
+                                ...explore,
+                                from: "array",
                             },
-                        ],
-                        meta.getName(),
-                    ),
-                    combined: true,
-                });
-
-            // NATIVE CLASSES
-            for (const native of meta.natives)
-                binaries.push({
-                    expression: check_native(native)(input),
-                    combined: false,
-                });
-
-            // SETS
-            if (meta.sets.length)
-                if (meta.sets.every((elem) => elem.any))
-                    binaries.push({
-                        combined: false,
-                        expression: check_native("Set")(input),
-                    });
+                            tags,
+                        ),
+                    );
                 else
-                    binaries.push({
-                        combined: true,
-                        expression: config.combiner(explore)("and")(
+                    install(
+                        explore_arrays_and_tuples(project, config, importer)(
                             input,
-                            [
-                                {
-                                    combined: false,
-                                    expression: check_native("Set")(input),
-                                },
-                                {
-                                    combined: true,
-                                    expression: explore_set(
-                                        project,
-                                        config,
-                                        importer,
-                                    )(
-                                        input,
-                                        meta.sets,
-                                        {
-                                            ...explore,
-                                            from: "array",
-                                        },
-                                        [],
-                                    ),
-                                },
-                            ],
-                            meta.getName(),
+                            [...meta.tuples, ...meta.arrays],
+                            explore,
+                            tags,
                         ),
-                    });
+                    );
+            }
 
-            // MAPS
-            if (meta.maps.length)
-                if (meta.maps.every((elem) => elem.key.any && elem.value.any))
-                    binaries.push({
-                        expression: check_native("Map")(input),
-                        combined: false,
-                    });
+            // OBJECT
+            if (meta.objects.length > 0)
+                prepare(
+                    ExpressionFactory.isObject(input, {
+                        checkNull: true,
+                        checkArray: meta.objects.some((obj) =>
+                            obj.properties.every(
+                                (prop) =>
+                                    !prop.key.isSoleLiteral() ||
+                                    !prop.value.required,
+                            ),
+                        ),
+                    }),
+                    meta.objects
+                        .map((obj) => `Resolve<${obj.name}>`)
+                        .join(" | "),
+                )(
+                    explore_objects(config)(input, meta, {
+                        ...explore,
+                        from: "object",
+                    }),
+                );
+
+            if (instances.length) {
+                const transformer =
+                    (
+                        merger: (
+                            x: ts.Expression,
+                            y: ts.Expression,
+                        ) => ts.Expression,
+                    ) =>
+                    (ins: IInstance) =>
+                        ins.body
+                            ? {
+                                  expression: merger(ins.pre, ins.body),
+                                  combined: true,
+                              }
+                            : {
+                                  expression: ins.pre,
+                                  combined: false,
+                              };
+                if (instances.length === 1)
+                    binaries.push(
+                        transformer((pre, body) =>
+                            config.combiner(explore)("and")(
+                                input,
+                                [pre, body].map((expression) => ({
+                                    expression,
+                                    combined: expression !== pre,
+                                })),
+                                meta.getName(),
+                            ),
+                        )(instances[0]!),
+                    );
                 else
                     binaries.push({
-                        combined: true,
-                        expression: config.combiner(explore)("and")(
+                        expression: config.combiner(explore)("or")(
                             input,
-                            [
-                                {
-                                    combined: false,
-                                    expression: check_native("Map")(input),
-                                },
-                                {
-                                    combined: true,
-                                    expression: explore_map(
-                                        project,
-                                        config,
-                                        importer,
-                                    )(
-                                        input,
-                                        meta.maps.map((m) => [m.key, m.value]),
-                                        {
-                                            ...explore,
-                                            from: "array",
-                                        },
-                                        [],
-                                    ),
-                                },
-                            ],
+                            instances.map(
+                                transformer(ts.factory.createLogicalAnd),
+                            ),
                             meta.getName(),
                         ),
+                        combined: true,
                     });
+            }
 
+            //----
             // COMBINE CONDITIONS
+            //----
             return top.length && binaries.length
                 ? config.combiner(explore)("and")(
                       input,
@@ -554,7 +548,7 @@ export namespace CheckerProgrammer {
         };
     }
 
-    function decode_tuple(
+    export function decode_tuple(
         project: IProject,
         config: IConfig,
         importer: FunctionImporter,
@@ -682,23 +676,7 @@ export namespace CheckerProgrammer {
         };
     }
 
-    const explore_array = (
-        project: IProject,
-        config: IConfig,
-        importer: FunctionImporter,
-    ) =>
-        UnionExplorer.array({
-            checker: decode(project, config, importer),
-            decoder: decode_array(project, config, importer, true),
-            empty: config.success,
-            success: config.success,
-            failure: (input, expected, explore) =>
-                ts.factory.createReturnStatement(
-                    config.joiner.failure(input, expected, explore),
-                ),
-        });
-
-    const explore_set = (
+    const explore_sets = (
         project: IProject,
         config: IConfig,
         importer: FunctionImporter,
@@ -714,7 +692,7 @@ export namespace CheckerProgrammer {
                 ),
         });
 
-    const explore_map = (
+    const explore_maps = (
         project: IProject,
         config: IConfig,
         importer: FunctionImporter,
@@ -768,6 +746,86 @@ export namespace CheckerProgrammer {
                 ),
         });
 
+    const explore_tuples = (
+        project: IProject,
+        config: IConfig,
+        importer: FunctionImporter,
+    ) =>
+        UnionExplorer.tuple({
+            checker: check_union_tuple(project, config, importer),
+            decoder: decode_tuple(project, config, importer, true),
+            empty: config.success,
+            success: config.success,
+            failure: (input, expected, explore) =>
+                ts.factory.createReturnStatement(
+                    config.joiner.failure(input, expected, explore),
+                ),
+        });
+
+    const explore_arrays = (
+        project: IProject,
+        config: IConfig,
+        importer: FunctionImporter,
+    ) =>
+        UnionExplorer.array({
+            checker: decode(project, config, importer),
+            decoder: decode_array(project, config, importer, true),
+            empty: config.success,
+            success: config.success,
+            failure: (input, expected, explore) =>
+                ts.factory.createReturnStatement(
+                    config.joiner.failure(input, expected, explore),
+                ),
+        });
+
+    const explore_arrays_and_tuples = (
+        project: IProject,
+        config: IConfig,
+        importer: FunctionImporter,
+    ) =>
+        UnionExplorer.array_or_tuple({
+            checker: (front, target, explore, tags, array) => {
+                if (Array.isArray(target))
+                    return check_union_tuple(project, config, importer)(
+                        front,
+                        target,
+                        explore,
+                        tags,
+                        array,
+                    );
+                const condition = decode(project, config, importer)(
+                    front,
+                    target,
+                    explore,
+                    tags,
+                );
+                const length = check_array_length(array, tags);
+                return length !== null
+                    ? ts.factory.createBitwiseAnd(condition, length)
+                    : condition;
+            },
+            decoder: (input, target, explore, tags) =>
+                Array.isArray(target)
+                    ? decode_tuple(project, config, importer, true)(
+                          input,
+                          target,
+                          explore,
+                          tags,
+                      )
+                    : decode_array(project, config, importer, true)(
+                          input,
+                          target,
+                          explore,
+                          tags,
+                      ),
+            empty: config.success,
+            success: config.success,
+            failure: (input, expected, explore) =>
+                ts.factory.createReturnStatement(
+                    config.joiner.failure(input, expected, explore),
+                ),
+        });
+
     const explore_objects = (config: IConfig) => {
         const objector = decode_object(config);
 

package/src/programmers/IsParseProgrammer.ts

@@ -20,7 +20,17 @@ export namespace IsParseProgrammer {
                 ts.factory.createBlock([
                     StatementFactory.constant(
                         "is",
-                        IsProgrammer.generate(project, modulo)(type),
+                        IsProgrammer.generate(
+                            {
+                                ...project,
+                                options: {
+                                    ...project.options,
+                                    functional: false,
+                                    numeric: false,
+                                },
+                            },
+                            modulo,
+                        )(type),
                     ),
                     ts.factory.createExpressionStatement(
                         ts.factory.createBinaryExpression(

package/src/programmers/IsProgrammer.ts

@@ -11,6 +11,7 @@ import { IProject } from "../transformers/IProject";
 import { CheckerProgrammer } from "./CheckerProgrammer";
 import { FunctionImporter } from "./helpers/FunctionImporeter";
 import { IExpressionEntry } from "./helpers/IExpressionEntry";
+import { OptionPredicator } from "./helpers/OptionPredicator";
 import { check_object } from "./internal/check_object";
 import { feature_object_entries } from "./internal/feature_object_entries";
 
@@ -23,7 +24,9 @@ export namespace IsProgrammer {
         trace: false,
         path: false,
         equals: !!options?.object,
-        numeric: !!options?.numeric,
+        numeric: OptionPredicator.numeric({
+            numeric: options?.numeric,
+        }),
         combiner: () => (type: "and" | "or") => {
             const initial: ts.TrueLiteral | ts.FalseLiteral =
                 type === "and"
@@ -90,7 +93,7 @@ export namespace IsProgrammer {
                 positive: ts.factory.createTrue(),
                 superfluous: () => ts.factory.createFalse(),
             }),
-            numeric: !!project.options.numeric,
+            numeric: OptionPredicator.numeric(project.options),
         });
         config.trace = equals;
 

package/src/programmers/IsStringifyProgrammer.ts

@@ -21,11 +21,31 @@ export namespace IsStringifyProgrammer {
                 ts.factory.createBlock([
                     StatementFactory.constant(
                         "is",
-                        IsProgrammer.generate(project, modulo)(type),
+                        IsProgrammer.generate(
+                            {
+                                ...project,
+                                options: {
+                                    ...project.options,
+                                    functional: false,
+                                    numeric: true,
+                                },
+                            },
+                            modulo,
+                        )(type),
                     ),
                     StatementFactory.constant(
                         "stringify",
-                        StringifyProgrammer.generate(project, modulo)(type),
+                        StringifyProgrammer.generate(
+                            {
+                                ...project,
+                                options: {
+                                    ...project.options,
+                                    functional: false,
+                                    numeric: false,
+                                },
+                            },
+                            modulo,
+                        )(type),
                     ),
                     ts.factory.createReturnStatement(
                         ts.factory.createConditionalExpression(

package/src/programmers/MessageProgrammer.ts

@@ -7,7 +7,9 @@ import { Metadata } from "../metadata/Metadata";
 
 import { IProject } from "../transformers/IProject";
 
+import { Escaper } from "../utils/Escaper";
 import { MapUtil } from "../utils/MapUtil";
+import { NameEncoder } from "../utils/NameEncoder";
 
 import { IProtocolMessage } from "../messages/IProtocolMessage";
 
@@ -16,7 +18,7 @@ export namespace MessageProgrammer {
         ({ checker }: IProject) =>
         (type: ts.Type) => {
             // PARSE TARGET TYPE
-            const collection: MetadataCollection = ProtocolFactory.collection();
+            const collection: MetadataCollection = new MetadataCollection();
             const metadata: Metadata =
                 ProtocolFactory.metadata(checker)(collection)(type);
 
@@ -42,7 +44,7 @@ export namespace MessageProgrammer {
         const { key, message, children } = hierarchy;
         let index: number = 1;
 
-        const elements: string[] = [`message ${key} {`];
+        const elements: string[] = [`message ${NameEncoder.encode(key)} {`];
         if (message !== null)
             elements.push(
                 ...message.properties.map((property) => {
@@ -51,9 +53,11 @@ export namespace MessageProgrammer {
                             TAB,
                             property.required ? "" : "optional ",
                             property.repeated ? "repeated " : "",
-                            property.oneOf[0]!.type + " ",
-                            property.key + " ",
-                            "= ",
+                            NameEncoder.encode(property.oneOf[0]!.type) + " ",
+                            Escaper.variable(property.key)
+                                ? property.key
+                                : `v${index + 1}`,
+                            " = ",
                             `${index++};`,
                         ].join("");
                     return (
@@ -61,7 +65,9 @@ export namespace MessageProgrammer {
                         property.oneOf
                             .map(
                                 (o, i) =>
-                                    `${TAB}${TAB}${o.type} o${i} = ${index++};`,
+                                    `${TAB}${TAB}${NameEncoder.encode(
+                                        o.type,
+                                    )} o${i} = ${index++};`,
                             )
                             .join("\n") +
                         `\n${TAB}}`