typia 3.5.0-dev.20221222 → 3.5.0-dev.20230124

package/src/programmers/CheckerProgrammer.ts

@@ -18,11 +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 {
@@ -222,7 +224,6 @@ export namespace CheckerProgrammer {
         project: IProject,
         config: IConfig,
         importer: FunctionImporter,
-        checkTupleLength: boolean = true,
     ) {
         return function (
             input: ts.Expression,
@@ -328,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,
@@ -560,7 +548,7 @@ export namespace CheckerProgrammer {
         };
     }
 
-    function decode_tuple(
+    export function decode_tuple(
         project: IProject,
         config: IConfig,
         importer: FunctionImporter,
@@ -688,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,
@@ -720,7 +692,7 @@ export namespace CheckerProgrammer {
                 ),
         });
 
-    const explore_map = (
+    const explore_maps = (
         project: IProject,
         config: IConfig,
         importer: FunctionImporter,
@@ -774,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);