typia 7.0.0-dev.20240930 → 7.0.0-dev.20241001

package/lib/programmers/CheckerProgrammer.js

@@ -220,28 +220,33 @@ var CheckerProgrammer;
             unionizer: props.config.equals
                 ? function (next) {
                     var _a;
-                    return (0, decode_union_object_1.decode_union_object)(function (input, object, explore) {
-                        return CheckerProgrammer.decode_object({
-                            config: props.config,
-                            importer: props.importer,
-                            object: object,
-                            input: input,
-                            explore: explore,
-                        });
-                    })(function (input, object, explore) {
-                        return CheckerProgrammer.decode_object({
-                            config: props.config,
-                            importer: props.importer,
-                            input: input,
-                            object: object,
-                            explore: __assign(__assign({}, explore), { tracable: true }),
-                        });
-                    })((_a = props.config.joiner.is) !== null && _a !== void 0 ? _a : (function (expr) { return expr; }))(function (input, expected) {
-                        return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure({
-                            input: input,
-                            expected: expected,
-                        }));
-                    })(next.input, next.objects, next.explore);
+                    return (0, decode_union_object_1.decode_union_object)({
+                        checker: function (v) {
+                            return CheckerProgrammer.decode_object({
+                                config: props.config,
+                                importer: props.importer,
+                                object: v.object,
+                                input: v.input,
+                                explore: v.explore,
+                            });
+                        },
+                        decoder: function (v) {
+                            return CheckerProgrammer.decode_object({
+                                config: props.config,
+                                importer: props.importer,
+                                input: v.input,
+                                object: v.object,
+                                explore: __assign(__assign({}, v.explore), { tracable: true }),
+                            });
+                        },
+                        success: (_a = props.config.joiner.is) !== null && _a !== void 0 ? _a : (function (expr) { return expr; }),
+                        escaper: function (v) {
+                            return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(v));
+                        },
+                        input: next.input,
+                        objects: next.objects,
+                        explore: next.explore,
+                    });
                 }
                 : function (next) {
                     return props.config.combiner({
@@ -441,7 +446,12 @@ var CheckerProgrammer;
                     binaries.push({
                         expression: props.config.atomist({
                             explore: props.explore,
-                            entry: (0, check_number_1.check_number)(props.context, props.config.numeric)(atom)(props.input),
+                            entry: (0, check_number_1.check_number)({
+                                context: props.context,
+                                numeric: props.config.numeric,
+                                atomic: atom,
+                                input: props.input,
+                            }),
                             input: props.input,
                         }),
                         combined: false,
@@ -450,7 +460,11 @@ var CheckerProgrammer;
                     binaries.push({
                         expression: props.config.atomist({
                             explore: props.explore,
-                            entry: (0, check_bigint_1.check_bigint)(props.context)(atom)(props.input),
+                            entry: (0, check_bigint_1.check_bigint)({
+                                context: props.context,
+                                atomic: atom,
+                                input: props.input,
+                            }),
                             input: props.input,
                         }),
                         combined: false,
@@ -459,7 +473,11 @@ var CheckerProgrammer;
                     binaries.push({
                         expression: props.config.atomist({
                             explore: props.explore,
-                            entry: (0, check_string_1.check_string)(props.context)(atom)(props.input),
+                            entry: (0, check_string_1.check_string)({
+                                context: props.context,
+                                atomic: atom,
+                                input: props.input,
+                            }),
                             input: props.input,
                         }),
                         combined: false,
@@ -485,7 +503,10 @@ var CheckerProgrammer;
                 binaries.push({
                     expression: props.config.atomist({
                         explore: props.explore,
-                        entry: (0, check_template_1.check_template)(props.metadata.templates)(props.input),
+                        entry: (0, check_template_1.check_template)({
+                            templates: props.metadata.templates,
+                            input: props.input,
+                        }),
                         input: props.input,
                     }),
                     combined: false,
@@ -495,7 +516,10 @@ var CheckerProgrammer;
             for (var _j = __values(props.metadata.natives), _k = _j.next(); !_k.done; _k = _j.next()) {
                 var native = _k.value;
                 binaries.push({
-                    expression: (0, check_native_1.check_native)(native)(props.input),
+                    expression: (0, check_native_1.check_native)({
+                        type: native,
+                        input: props.input,
+                    }),
                     combined: false,
                 });
             }
@@ -513,7 +537,10 @@ var CheckerProgrammer;
         if (props.metadata.sets.length) {
             var install = function (body) {
                 return prepare({
-                    knock: (0, check_native_1.check_native)("Set")(props.input),
+                    head: (0, check_native_1.check_native)({
+                        type: "Set",
+                        input: props.input,
+                    }),
                     expected: props.metadata.sets
                         .map(function (elem) { return "Set<".concat(elem.getName(), ">"); })
                         .join(" | "),
@@ -536,7 +563,10 @@ var CheckerProgrammer;
         if (props.metadata.maps.length) {
             var install = function (body) {
                 return prepare({
-                    knock: (0, check_native_1.check_native)("Map")(props.input),
+                    head: (0, check_native_1.check_native)({
+                        type: "Map",
+                        input: props.input,
+                    }),
                     expected: props.metadata.maps
                         .map(function (_a) {
                         var key = _a.key, value = _a.value;
@@ -562,7 +592,7 @@ var CheckerProgrammer;
         if (props.metadata.tuples.length + props.metadata.arrays.length > 0) {
             var install = function (body) {
                 return prepare({
-                    knock: props.config.atomist({
+                    head: props.config.atomist({
                         explore: props.explore,
                         entry: {
                             expected: __spreadArray(__spreadArray([], __read(props.metadata.tuples.map(function (t) { return t.type.name; })), false), __read(props.metadata.arrays.map(function (a) { return a.getName(); })), false).join(" | "),
@@ -631,7 +661,7 @@ var CheckerProgrammer;
         // OBJECT
         if (props.metadata.objects.length > 0)
             prepare({
-                knock: ExpressionFactory_1.ExpressionFactory.isObject({
+                head: ExpressionFactory_1.ExpressionFactory.isObject({
                     checkNull: true,
                     checkArray: props.metadata.objects.some(function (obj) {
                         return obj.properties.every(function (prop) { return !prop.key.isSoleLiteral() || !prop.value.isRequired(); });
@@ -651,24 +681,24 @@ var CheckerProgrammer;
                 return function (ins) {
                     return ins.body
                         ? {
-                            expression: merger(ins.knock, ins.body),
+                            expression: merger(ins.head, ins.body),
                             combined: true,
                         }
                         : {
-                            expression: ins.knock,
+                            expression: ins.head,
                             combined: false,
                         };
                 };
             };
             if (instances.length === 1)
-                binaries.push(transformer(function (pre, body) {
+                binaries.push(transformer(function (head, body) {
                     return props.config.combiner({
                         explore: props.explore,
                         logic: "and",
                         input: props.input,
-                        binaries: [pre, body].map(function (expression) { return ({
+                        binaries: [head, body].map(function (expression) { return ({
                             expression: expression,
-                            combined: expression !== pre,
+                            combined: expression !== head,
                         }); }),
                         expected: props.metadata.getName(),
                     });
@@ -691,7 +721,10 @@ var CheckerProgrammer;
                 combined: false,
                 expression: props.metadata.escaped.original.size() === 1 &&
                     props.metadata.escaped.original.natives.length === 1
-                    ? (0, check_native_1.check_native)(props.metadata.escaped.original.natives[0])(props.input)
+                    ? (0, check_native_1.check_native)({
+                        type: props.metadata.escaped.original.natives[0],
+                        input: props.input,
+                    })
                     : typescript_1.default.factory.createLogicalAnd(CheckerProgrammer.decode({
                         context: props.context,
                         config: props.config,
@@ -763,7 +796,11 @@ var CheckerProgrammer;
         }));
     };
     var decode_array_inline = function (props) {
-        var length = (0, check_array_length_1.check_array_length)(props.context)(props.array)(props.input);
+        var length = (0, check_array_length_1.check_array_length)({
+            context: props.context,
+            array: props.array,
+            input: props.input,
+        });
         var main = FeatureProgrammer_1.FeatureProgrammer.decode_array({
             config: {
                 prefix: props.config.prefix,
@@ -877,152 +914,164 @@ var CheckerProgrammer;
       ----------------------------------------------------------- */
     var explore_sets = function (props) {
         return typescript_1.default.factory.createCallExpression(UnionExplorer_1.UnionExplorer.set({
-            checker: function (input, metadata, explore, _container) {
-                return CheckerProgrammer.decode({
-                    context: props.context,
-                    config: props.config,
-                    importer: props.importer,
-                    input: input,
-                    metadata: metadata,
-                    explore: explore,
-                });
-            },
-            decoder: function (input, array, explore) {
-                return decode_array({
-                    config: props.config,
-                    context: props.context,
-                    importer: props.importer,
-                    array: array,
-                    input: input,
-                    explore: explore,
-                });
-            },
-            empty: props.config.success,
-            success: props.config.success,
-            failure: function (input, expected, explore) {
-                return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure({
-                    input: input,
-                    expected: expected,
-                    explore: explore,
-                }));
-            },
-        })([])(props.input, props.sets, props.explore), undefined, undefined);
-    };
-    var explore_maps = function (props) {
-        return typescript_1.default.factory.createCallExpression(UnionExplorer_1.UnionExplorer.map({
-            checker: function (input, entry, explore) {
-                return typescript_1.default.factory.createLogicalAnd(CheckerProgrammer.decode({
-                    config: props.config,
-                    context: props.context,
-                    importer: props.importer,
-                    input: typescript_1.default.factory.createElementAccessExpression(input, 0),
-                    metadata: entry[0],
-                    explore: __assign(__assign({}, explore), { postfix: "".concat(explore.postfix, "[0]") }),
-                }), CheckerProgrammer.decode({
-                    config: props.config,
-                    context: props.context,
-                    importer: props.importer,
-                    input: typescript_1.default.factory.createElementAccessExpression(input, 1),
-                    metadata: entry[1],
-                    explore: __assign(__assign({}, explore), { postfix: "".concat(explore.postfix, "[1]") }),
-                }));
-            },
-            decoder: function (input, array, explore) {
-                return decode_array({
-                    context: props.context,
-                    config: props.config,
-                    importer: props.importer,
-                    array: array,
-                    input: input,
-                    explore: explore,
-                });
-            },
-            empty: props.config.success,
-            success: props.config.success,
-            failure: function (input, expected, explore) {
-                return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure({
-                    input: input,
-                    expected: expected,
-                    explore: explore,
-                }));
-            },
-        })([])(props.input, props.maps, props.explore), undefined, undefined);
-    };
-    var explore_tuples = function (props) {
-        return explore_array_like_union_types({
-            config: props.config,
-            importer: props.importer,
-            factory: UnionExplorer_1.UnionExplorer.tuple({
-                checker: function (input, tuple, explore) {
-                    return decode_tuple({
+            config: {
+                checker: function (v) {
+                    return CheckerProgrammer.decode({
                         context: props.context,
                         config: props.config,
                         importer: props.importer,
-                        input: input,
-                        tuple: tuple,
-                        explore: explore,
+                        input: v.input,
+                        metadata: v.definition,
+                        explore: v.explore,
                     });
                 },
-                decoder: function (input, tuple, explore) {
-                    return decode_tuple({
-                        context: props.context,
+                decoder: function (v) {
+                    return decode_array({
                         config: props.config,
+                        context: props.context,
                         importer: props.importer,
-                        tuple: tuple,
-                        input: input,
-                        explore: explore,
+                        array: v.definition,
+                        input: v.input,
+                        explore: v.explore,
                     });
                 },
                 empty: props.config.success,
                 success: props.config.success,
-                failure: function (input, expected, explore) {
-                    return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure({
-                        input: input,
-                        expected: expected,
-                        explore: explore,
-                    }));
+                failure: function (v) {
+                    return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(v));
                 },
-            }),
-            definitions: props.tuples,
+            },
+            parameters: [],
             input: props.input,
+            sets: props.sets,
             explore: props.explore,
-        });
+        }), undefined, undefined);
     };
-    var explore_arrays = function (props) {
-        return explore_array_like_union_types({
-            config: props.config,
-            importer: props.importer,
-            factory: UnionExplorer_1.UnionExplorer.array({
-                checker: function (input, metadata, explore) {
-                    return CheckerProgrammer.decode({
+    var explore_maps = function (props) {
+        return typescript_1.default.factory.createCallExpression(UnionExplorer_1.UnionExplorer.map({
+            config: {
+                checker: function (v) {
+                    return typescript_1.default.factory.createLogicalAnd(CheckerProgrammer.decode({
+                        config: props.config,
                         context: props.context,
+                        importer: props.importer,
+                        input: typescript_1.default.factory.createElementAccessExpression(v.input, 0),
+                        metadata: v.definition[0],
+                        explore: __assign(__assign({}, v.explore), { postfix: "".concat(v.explore.postfix, "[0]") }),
+                    }), CheckerProgrammer.decode({
                         config: props.config,
+                        context: props.context,
                         importer: props.importer,
-                        metadata: metadata,
-                        input: input,
-                        explore: explore,
-                    });
+                        input: typescript_1.default.factory.createElementAccessExpression(v.input, 1),
+                        metadata: v.definition[1],
+                        explore: __assign(__assign({}, v.explore), { postfix: "".concat(v.explore.postfix, "[1]") }),
+                    }));
                 },
-                decoder: function (input, array, explore) {
+                decoder: function (v) {
                     return decode_array({
                         context: props.context,
                         config: props.config,
                         importer: props.importer,
-                        array: array,
-                        input: input,
-                        explore: explore,
+                        array: v.definition,
+                        input: v.input,
+                        explore: v.explore,
                     });
                 },
                 empty: props.config.success,
                 success: props.config.success,
-                failure: function (input, expected, explore) {
-                    return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure({
-                        input: input,
-                        expected: expected,
-                        explore: explore,
-                    }));
+                failure: function (v) {
+                    return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(v));
                 },
-            }),
+            },
+            parameters: [],
+            input: props.input,
+            maps: props.maps,
+            explore: props.explore,
+        }), undefined, undefined);
+    };
+    var explore_tuples = function (props) {
+        return explore_array_like_union_types({
+            config: props.config,
+            importer: props.importer,
+            factory: function (next) {
+                return UnionExplorer_1.UnionExplorer.tuple({
+                    config: {
+                        checker: function (v) {
+                            return decode_tuple({
+                                context: props.context,
+                                config: props.config,
+                                importer: props.importer,
+                                input: v.input,
+                                tuple: v.definition,
+                                explore: v.explore,
+                            });
+                        },
+                        decoder: function (v) {
+                            return decode_tuple({
+                                context: props.context,
+                                config: props.config,
+                                importer: props.importer,
+                                tuple: v.definition,
+                                input: v.input,
+                                explore: v.explore,
+                            });
+                        },
+                        empty: props.config.success,
+                        success: props.config.success,
+                        failure: function (v) {
+                            return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(v));
+                        },
+                    },
+                    parameters: next.parameters,
+                    tuples: next.definitions,
+                    input: next.input,
+                    explore: next.explore,
+                });
+            },
+            definitions: props.tuples,
+            input: props.input,
+            explore: props.explore,
+        });
+    };
+    var explore_arrays = function (props) {
+        return explore_array_like_union_types({
+            config: props.config,
+            importer: props.importer,
+            factory: function (next) {
+                return UnionExplorer_1.UnionExplorer.array({
+                    config: {
+                        checker: function (v) {
+                            return CheckerProgrammer.decode({
+                                context: props.context,
+                                config: props.config,
+                                importer: props.importer,
+                                metadata: v.definition,
+                                input: v.input,
+                                explore: v.explore,
+                            });
+                        },
+                        decoder: function (v) {
+                            return decode_array({
+                                context: props.context,
+                                config: props.config,
+                                importer: props.importer,
+                                array: v.definition,
+                                input: v.input,
+                                explore: v.explore,
+                            });
+                        },
+                        empty: props.config.success,
+                        success: props.config.success,
+                        failure: function (v) {
+                            return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(v));
+                        },
+                    },
+                    parameters: next.parameters,
+                    arrays: next.definitions,
+                    input: next.input,
+                    explore: next.explore,
+                });
+            },
             definitions: props.arrays,
             input: props.input,
             explore: props.explore,
@@ -1032,69 +1081,73 @@ var CheckerProgrammer;
         return explore_array_like_union_types({
             config: props.config,
             importer: props.importer,
-            factory: UnionExplorer_1.UnionExplorer.array_or_tuple({
-                checker: function (input, definition, explore, array) {
-                    return definition instanceof MetadataTuple_1.MetadataTuple
-                        ? decode_tuple({
-                            config: props.config,
-                            context: props.context,
-                            importer: props.importer,
-                            input: input,
-                            tuple: definition,
-                            explore: explore,
-                        })
-                        : props.config.atomist({
-                            explore: explore,
-                            entry: {
-                                expected: props.definitions
-                                    .map(function (elem) {
-                                    return elem instanceof MetadataArray_1.MetadataArray
-                                        ? elem.getName()
-                                        : elem.type.name;
+            factory: function (next) {
+                return UnionExplorer_1.UnionExplorer.array_or_tuple({
+                    config: {
+                        checker: function (v) {
+                            return v.definition instanceof MetadataTuple_1.MetadataTuple
+                                ? decode_tuple({
+                                    config: props.config,
+                                    context: props.context,
+                                    importer: props.importer,
+                                    input: v.input,
+                                    tuple: v.definition,
+                                    explore: v.explore,
                                 })
-                                    .join(" | "),
-                                expression: CheckerProgrammer.decode({
+                                : props.config.atomist({
+                                    explore: v.explore,
+                                    entry: {
+                                        expected: props.definitions
+                                            .map(function (elem) {
+                                            return elem instanceof MetadataArray_1.MetadataArray
+                                                ? elem.getName()
+                                                : elem.type.name;
+                                        })
+                                            .join(" | "),
+                                        expression: CheckerProgrammer.decode({
+                                            importer: props.importer,
+                                            context: props.context,
+                                            config: props.config,
+                                            metadata: v.definition,
+                                            input: v.input,
+                                            explore: v.explore,
+                                        }),
+                                        conditions: [],
+                                    },
+                                    input: v.container,
+                                });
+                        },
+                        decoder: function (v) {
+                            return v.definition instanceof MetadataTuple_1.MetadataTuple
+                                ? decode_tuple({
+                                    context: props.context,
+                                    config: props.config,
                                     importer: props.importer,
+                                    input: v.input,
+                                    tuple: v.definition,
+                                    explore: v.explore,
+                                })
+                                : decode_array({
                                     context: props.context,
                                     config: props.config,
-                                    input: input,
-                                    metadata: definition,
-                                    explore: explore,
-                                }),
-                                conditions: [],
-                            },
-                            input: array,
-                        });
-                },
-                decoder: function (input, definition, explore) {
-                    return definition instanceof MetadataTuple_1.MetadataTuple
-                        ? decode_tuple({
-                            context: props.context,
-                            config: props.config,
-                            importer: props.importer,
-                            input: input,
-                            tuple: definition,
-                            explore: explore,
-                        })
-                        : decode_array({
-                            context: props.context,
-                            config: props.config,
-                            importer: props.importer,
-                            input: input,
-                            array: definition,
-                            explore: explore,
-                        });
-                },
-                empty: props.config.success,
-                success: props.config.success,
-                failure: function (input, expected, explore) {
-                    return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure({
-                        input: input,
-                        expected: expected,
-                        explore: explore,
-                    }));
-                },
-            }),
+                                    importer: props.importer,
+                                    input: v.input,
+                                    array: v.definition,
+                                    explore: v.explore,
+                                });
+                        },
+                        empty: props.config.success,
+                        success: props.config.success,
+                        failure: function (v) {
+                            return typescript_1.default.factory.createReturnStatement(props.config.joiner.failure(v));
+                        },
+                    },
+                    parameters: next.parameters,
+                    definitions: next.definitions,
+                    input: next.input,
+                    explore: next.explore,
+                });
+            },
             input: props.input,
             definitions: props.definitions,
             explore: props.explore,
@@ -1102,7 +1155,12 @@ var CheckerProgrammer;
     };
     var explore_array_like_union_types = function (props) {
         var arrow = function (next) {
-            return props.factory(next.parameters)(next.input, props.definitions, next.explore);
+            return props.factory({
+                parameters: next.parameters,
+                definitions: props.definitions,
+                input: next.input,
+                explore: next.explore,
+            });
         };
         if (props.definitions.every(function (e) { return e.type.recursive === false; }))
             typescript_1.default.factory.createCallExpression(arrow({