typia 7.0.0-dev.20240916 → 7.0.0-dev.20240918

package/lib/factories/MetadataFactory.js

@@ -60,37 +60,42 @@ var iterate_metadata_sort_1 = require("./internal/metadata/iterate_metadata_sort
 var ExpressionFactory_1 = require("./ExpressionFactory");
 var MetadataFactory;
 (function (MetadataFactory) {
-    MetadataFactory.analyze = function (checker, context) {
-        return function (options) {
-            return function (collection) {
-                return function (type) {
-                    var errors = [];
-                    var meta = (0, explore_metadata_1.explore_metadata)(checker)(options)(collection)(errors)(type, {
-                        top: true,
-                        object: null,
-                        property: null,
-                        parameter: null,
-                        nested: null,
-                        aliased: false,
-                        escaped: false,
-                        output: false,
-                    });
-                    (0, iterate_metadata_collection_1.iterate_metadata_collection)(errors)(collection);
-                    (0, iterate_metadata_sort_1.iterate_metadata_sort)(collection)(meta);
-                    if (options.validate)
-                        errors.push.apply(errors, __spreadArray([], __read(MetadataFactory.validate(context)(options)(options.validate)(meta)), false));
-                    return errors.length
-                        ? {
-                            success: false,
-                            errors: errors,
-                        }
-                        : {
-                            success: true,
-                            data: meta,
-                        };
-                };
+    MetadataFactory.analyze = function (props) {
+        var errors = [];
+        var metadata = (0, explore_metadata_1.explore_metadata)(__assign(__assign({}, props), { errors: errors, explore: {
+                top: true,
+                object: null,
+                property: null,
+                parameter: null,
+                nested: null,
+                aliased: false,
+                escaped: false,
+                output: false,
+            } }));
+        (0, iterate_metadata_collection_1.iterate_metadata_collection)({
+            errors: errors,
+            collection: props.collection,
+        });
+        (0, iterate_metadata_sort_1.iterate_metadata_sort)({
+            collection: props.collection,
+            metadata: metadata,
+        });
+        if (props.options.validate)
+            errors.push.apply(errors, __spreadArray([], __read(MetadataFactory.validate({
+                transformer: props.transformer,
+                options: props.options,
+                functor: props.options.validate,
+                metadata: metadata,
+            })), false));
+        return errors.length
+            ? {
+                success: false,
+                errors: errors,
+            }
+            : {
+                success: true,
+                data: metadata,
             };
-        };
     };
     /**
      * @internal
@@ -108,319 +113,277 @@ var MetadataFactory;
         }));
         return meta;
     };
-    MetadataFactory.validate = function (context) {
-        return function (options) {
-            return function (functor) {
-                return function (meta) {
-                    var visitor = {
-                        functor: functor,
-                        errors: [],
-                        objects: new Set(),
-                        arrays: new Set(),
-                        tuples: new Set(),
-                        aliases: new Set(),
-                        functions: new Set(),
-                    };
-                    validateMeta(context)(options)(visitor)(meta, {
-                        object: null,
-                        property: null,
-                        parameter: null,
-                        nested: null,
-                        top: true,
-                        aliased: false,
-                        escaped: false,
-                        output: false,
-                    });
-                    return visitor.errors;
-                };
-            };
+    MetadataFactory.validate = function (props) {
+        var visitor = {
+            functor: props.functor,
+            errors: [],
+            objects: new Set(),
+            arrays: new Set(),
+            tuples: new Set(),
+            aliases: new Set(),
+            functions: new Set(),
         };
+        validateMeta(__assign(__assign({}, props), { visitor: visitor, explore: {
+                object: null,
+                property: null,
+                parameter: null,
+                nested: null,
+                top: true,
+                aliased: false,
+                escaped: false,
+                output: false,
+            } }));
+        return visitor.errors;
     };
-    var validateMeta = function (context) {
-        return function (options) {
-            return function (visitor) {
-                return function (meta, explore) {
-                    var e_1, _a, e_2, _b, e_3, _c, e_4, _d, e_5, _e, e_6, _f, e_7, _g, e_8, _h, e_9, _j, e_10, _k;
-                    var result = [];
-                    if (context !== undefined)
-                        try {
-                            for (var _l = __values(meta.atomics), _m = _l.next(); !_m.done; _m = _l.next()) {
-                                var atomic = _m.value;
-                                try {
-                                    for (var _o = (e_2 = void 0, __values(atomic.tags)), _p = _o.next(); !_p.done; _p = _o.next()) {
-                                        var row = _p.value;
-                                        try {
-                                            for (var _q = (e_3 = void 0, __values(row.filter(function (t) { return t.validate !== undefined && t.predicate === undefined; }))), _r = _q.next(); !_r.done; _r = _q.next()) {
-                                                var tag = _r.value;
-                                                try {
-                                                    tag.predicate = ExpressionFactory_1.ExpressionFactory.transpile(context)(tag.validate);
-                                                }
-                                                catch (_s) {
-                                                    result.push("Unable to transpile type tag script: ".concat(JSON.stringify(tag.validate)));
-                                                    tag.predicate = function () { return typescript_1.default.factory.createTrue(); };
-                                                }
-                                            }
-                                        }
-                                        catch (e_3_1) { e_3 = { error: e_3_1 }; }
-                                        finally {
-                                            try {
-                                                if (_r && !_r.done && (_c = _q.return)) _c.call(_q);
-                                            }
-                                            finally { if (e_3) throw e_3.error; }
-                                        }
-                                    }
-                                }
-                                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                                finally {
+    var validateMeta = function (props) {
+        var e_1, _a, e_2, _b, e_3, _c, e_4, _d, e_5, _e, e_6, _f, e_7, _g, e_8, _h, e_9, _j, e_10, _k;
+        var result = [];
+        if (props.transformer !== undefined)
+            try {
+                for (var _l = __values(props.metadata.atomics), _m = _l.next(); !_m.done; _m = _l.next()) {
+                    var atomic = _m.value;
+                    try {
+                        for (var _o = (e_2 = void 0, __values(atomic.tags)), _p = _o.next(); !_p.done; _p = _o.next()) {
+                            var row = _p.value;
+                            try {
+                                for (var _q = (e_3 = void 0, __values(row.filter(function (t) { return t.validate !== undefined && t.predicate === undefined; }))), _r = _q.next(); !_r.done; _r = _q.next()) {
+                                    var tag = _r.value;
                                     try {
-                                        if (_p && !_p.done && (_b = _o.return)) _b.call(_o);
+                                        tag.predicate = ExpressionFactory_1.ExpressionFactory.transpile(props.transformer)(tag.validate);
+                                    }
+                                    catch (_s) {
+                                        result.push("Unable to transpile type tag script: ".concat(JSON.stringify(tag.validate)));
+                                        tag.predicate = function () { return typescript_1.default.factory.createTrue(); };
                                     }
-                                    finally { if (e_2) throw e_2.error; }
                                 }
                             }
-                        }
-                        catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                        finally {
-                            try {
-                                if (_m && !_m.done && (_a = _l.return)) _a.call(_l);
+                            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                            finally {
+                                try {
+                                    if (_r && !_r.done && (_c = _q.return)) _c.call(_q);
+                                }
+                                finally { if (e_3) throw e_3.error; }
                             }
-                            finally { if (e_1) throw e_1.error; }
-                        }
-                    result.push.apply(result, __spreadArray([], __read(visitor.functor(meta, explore)), false));
-                    if (result.length)
-                        visitor.errors.push({
-                            name: meta.getName(),
-                            explore: __assign({}, explore),
-                            messages: __spreadArray([], __read(new Set(result)), false),
-                        });
-                    try {
-                        for (var _t = __values(meta.aliases), _u = _t.next(); !_u.done; _u = _t.next()) {
-                            var alias = _u.value;
-                            validateAlias(context)(options)(visitor)(alias, explore);
                         }
                     }
-                    catch (e_4_1) { e_4 = { error: e_4_1 }; }
+                    catch (e_2_1) { e_2 = { error: e_2_1 }; }
                     finally {
                         try {
-                            if (_u && !_u.done && (_d = _t.return)) _d.call(_t);
+                            if (_p && !_p.done && (_b = _o.return)) _b.call(_o);
                         }
-                        finally { if (e_4) throw e_4.error; }
+                        finally { if (e_2) throw e_2.error; }
                     }
-                    try {
-                        for (var _v = __values(meta.arrays), _w = _v.next(); !_w.done; _w = _v.next()) {
-                            var array = _w.value;
-                            validateArray(context)(options)(visitor)(array.type, explore);
-                        }
-                    }
-                    catch (e_5_1) { e_5 = { error: e_5_1 }; }
-                    finally {
-                        try {
-                            if (_w && !_w.done && (_e = _v.return)) _e.call(_v);
-                        }
-                        finally { if (e_5) throw e_5.error; }
-                    }
-                    try {
-                        for (var _x = __values(meta.tuples), _y = _x.next(); !_y.done; _y = _x.next()) {
-                            var tuple = _y.value;
-                            validateTuple(context)(options)(visitor)(tuple.type, explore);
-                        }
-                    }
-                    catch (e_6_1) { e_6 = { error: e_6_1 }; }
-                    finally {
-                        try {
-                            if (_y && !_y.done && (_f = _x.return)) _f.call(_x);
-                        }
-                        finally { if (e_6) throw e_6.error; }
-                    }
-                    try {
-                        for (var _z = __values(meta.objects), _0 = _z.next(); !_0.done; _0 = _z.next()) {
-                            var obj = _0.value;
-                            validateObject(context)(options)(visitor)(obj);
-                        }
-                    }
-                    catch (e_7_1) { e_7 = { error: e_7_1 }; }
-                    finally {
-                        try {
-                            if (_0 && !_0.done && (_g = _z.return)) _g.call(_z);
-                        }
-                        finally { if (e_7) throw e_7.error; }
-                    }
-                    try {
-                        for (var _1 = __values(meta.functions), _2 = _1.next(); !_2.done; _2 = _1.next()) {
-                            var func = _2.value;
-                            validateFunction(context)(options)(visitor)(func, explore);
-                        }
-                    }
-                    catch (e_8_1) { e_8 = { error: e_8_1 }; }
-                    finally {
-                        try {
-                            if (_2 && !_2.done && (_h = _1.return)) _h.call(_1);
-                        }
-                        finally { if (e_8) throw e_8.error; }
-                    }
-                    try {
-                        for (var _3 = __values(meta.sets), _4 = _3.next(); !_4.done; _4 = _3.next()) {
-                            var set = _4.value;
-                            validateMeta(context)(options)(visitor)(set, explore);
-                        }
-                    }
-                    catch (e_9_1) { e_9 = { error: e_9_1 }; }
-                    finally {
-                        try {
-                            if (_4 && !_4.done && (_j = _3.return)) _j.call(_3);
-                        }
-                        finally { if (e_9) throw e_9.error; }
-                    }
-                    try {
-                        for (var _5 = __values(meta.maps), _6 = _5.next(); !_6.done; _6 = _5.next()) {
-                            var map = _6.value;
-                            validateMeta(context)(options)(visitor)(map.key, explore);
-                            validateMeta(context)(options)(visitor)(map.value, explore);
-                        }
-                    }
-                    catch (e_10_1) { e_10 = { error: e_10_1 }; }
-                    finally {
-                        try {
-                            if (_6 && !_6.done && (_k = _5.return)) _k.call(_5);
-                        }
-                        finally { if (e_10) throw e_10.error; }
-                    }
-                    if (options.escape === true && meta.escaped !== null)
-                        validateMeta(context)(options)(visitor)(meta.escaped.returns, __assign(__assign({}, explore), { escaped: true }));
-                };
-            };
-        };
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (_m && !_m.done && (_a = _l.return)) _a.call(_l);
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        result.push.apply(result, __spreadArray([], __read(props.visitor.functor(props.metadata, props.explore)), false));
+        if (result.length)
+            props.visitor.errors.push({
+                name: props.metadata.getName(),
+                explore: __assign({}, props.explore),
+                messages: __spreadArray([], __read(new Set(result)), false),
+            });
+        try {
+            for (var _t = __values(props.metadata.aliases), _u = _t.next(); !_u.done; _u = _t.next()) {
+                var alias = _u.value;
+                validateAlias(__assign(__assign({}, props), { alias: alias }));
+            }
+        }
+        catch (e_4_1) { e_4 = { error: e_4_1 }; }
+        finally {
+            try {
+                if (_u && !_u.done && (_d = _t.return)) _d.call(_t);
+            }
+            finally { if (e_4) throw e_4.error; }
+        }
+        try {
+            for (var _v = __values(props.metadata.arrays), _w = _v.next(); !_w.done; _w = _v.next()) {
+                var array = _w.value;
+                validateArray(__assign(__assign({}, props), { array: array.type }));
+            }
+        }
+        catch (e_5_1) { e_5 = { error: e_5_1 }; }
+        finally {
+            try {
+                if (_w && !_w.done && (_e = _v.return)) _e.call(_v);
+            }
+            finally { if (e_5) throw e_5.error; }
+        }
+        try {
+            for (var _x = __values(props.metadata.tuples), _y = _x.next(); !_y.done; _y = _x.next()) {
+                var tuple = _y.value;
+                validateTuple(__assign(__assign({}, props), { tuple: tuple.type }));
+            }
+        }
+        catch (e_6_1) { e_6 = { error: e_6_1 }; }
+        finally {
+            try {
+                if (_y && !_y.done && (_f = _x.return)) _f.call(_x);
+            }
+            finally { if (e_6) throw e_6.error; }
+        }
+        try {
+            for (var _z = __values(props.metadata.objects), _0 = _z.next(); !_0.done; _0 = _z.next()) {
+                var object = _0.value;
+                validateObject(__assign(__assign({}, props), { object: object }));
+            }
+        }
+        catch (e_7_1) { e_7 = { error: e_7_1 }; }
+        finally {
+            try {
+                if (_0 && !_0.done && (_g = _z.return)) _g.call(_z);
+            }
+            finally { if (e_7) throw e_7.error; }
+        }
+        try {
+            for (var _1 = __values(props.metadata.functions), _2 = _1.next(); !_2.done; _2 = _1.next()) {
+                var func = _2.value;
+                validateFunction(__assign(__assign({}, props), { function: func }));
+            }
+        }
+        catch (e_8_1) { e_8 = { error: e_8_1 }; }
+        finally {
+            try {
+                if (_2 && !_2.done && (_h = _1.return)) _h.call(_1);
+            }
+            finally { if (e_8) throw e_8.error; }
+        }
+        try {
+            for (var _3 = __values(props.metadata.sets), _4 = _3.next(); !_4.done; _4 = _3.next()) {
+                var set = _4.value;
+                validateMeta(__assign(__assign({}, props), { metadata: set }));
+            }
+        }
+        catch (e_9_1) { e_9 = { error: e_9_1 }; }
+        finally {
+            try {
+                if (_4 && !_4.done && (_j = _3.return)) _j.call(_3);
+            }
+            finally { if (e_9) throw e_9.error; }
+        }
+        try {
+            for (var _5 = __values(props.metadata.maps), _6 = _5.next(); !_6.done; _6 = _5.next()) {
+                var map = _6.value;
+                validateMeta(__assign(__assign({}, props), { metadata: map.key }));
+                validateMeta(__assign(__assign({}, props), { metadata: map.value }));
+            }
+        }
+        catch (e_10_1) { e_10 = { error: e_10_1 }; }
+        finally {
+            try {
+                if (_6 && !_6.done && (_k = _5.return)) _k.call(_5);
+            }
+            finally { if (e_10) throw e_10.error; }
+        }
+        if (props.options.escape === true && props.metadata.escaped !== null)
+            validateMeta(__assign(__assign({}, props), { metadata: props.metadata.escaped.returns, explore: __assign(__assign({}, props.explore), { escaped: true }) }));
     };
-    var validateAlias = function (context) {
-        return function (options) {
-            return function (visitor) {
-                return function (alias, explore) {
-                    if (visitor.aliases.has(alias))
-                        return;
-                    visitor.aliases.add(alias);
-                    validateMeta(context)(options)(visitor)(alias.value, __assign(__assign({}, explore), { nested: alias, aliased: true }));
-                };
-            };
-        };
+    var validateAlias = function (props) {
+        if (props.visitor.aliases.has(props.alias))
+            return;
+        props.visitor.aliases.add(props.alias);
+        validateMeta(__assign(__assign({}, props), { metadata: props.alias.value, explore: __assign(__assign({}, props.explore), { nested: props.alias, aliased: true }) }));
     };
-    var validateArray = function (context) {
-        return function (options) {
-            return function (visitor) {
-                return function (array, explore) {
-                    if (visitor.arrays.has(array))
-                        return;
-                    visitor.arrays.add(array);
-                    validateMeta(context)(options)(visitor)(array.value, __assign(__assign({}, explore), { nested: array, top: false }));
-                };
-            };
-        };
+    var validateArray = function (props) {
+        if (props.visitor.arrays.has(props.array))
+            return;
+        props.visitor.arrays.add(props.array);
+        validateMeta(__assign(__assign({}, props), { metadata: props.array.value, explore: __assign(__assign({}, props.explore), { nested: props.array, top: false }) }));
     };
-    var validateTuple = function (context) {
-        return function (options) {
-            return function (visitor) {
-                return function (tuple, explore) {
-                    var e_11, _a;
-                    if (visitor.tuples.has(tuple))
-                        return;
-                    visitor.tuples.add(tuple);
-                    try {
-                        for (var _b = __values(tuple.elements), _c = _b.next(); !_c.done; _c = _b.next()) {
-                            var elem = _c.value;
-                            validateMeta(context)(options)(visitor)(elem, __assign(__assign({}, explore), { nested: tuple, top: false }));
-                        }
-                    }
-                    catch (e_11_1) { e_11 = { error: e_11_1 }; }
-                    finally {
-                        try {
-                            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                        }
-                        finally { if (e_11) throw e_11.error; }
-                    }
-                };
-            };
-        };
+    var validateTuple = function (props) {
+        var e_11, _a;
+        if (props.visitor.tuples.has(props.tuple))
+            return;
+        props.visitor.tuples.add(props.tuple);
+        try {
+            for (var _b = __values(props.tuple.elements), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var elem = _c.value;
+                validateMeta(__assign(__assign({}, props), { metadata: elem, explore: __assign(__assign({}, props.explore), { nested: props.tuple, top: false }) }));
+            }
+        }
+        catch (e_11_1) { e_11 = { error: e_11_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_11) throw e_11.error; }
+        }
     };
-    var validateObject = function (context) {
-        return function (options) {
-            return function (visitor) {
-                return function (object) {
-                    var e_12, _a;
-                    if (visitor.objects.has(object))
-                        return;
-                    visitor.objects.add(object);
-                    if (options.validate) {
-                        var explore = {
-                            object: object,
-                            top: false,
-                            property: null,
-                            parameter: null,
-                            nested: null,
-                            aliased: false,
-                            escaped: false,
-                            output: false,
-                        };
-                        var errors = options.validate(Metadata_1.Metadata.create(__assign(__assign({}, Metadata_1.Metadata.initialize()), { objects: [object] })), explore);
-                        if (errors.length)
-                            visitor.errors.push({
-                                name: object.name,
-                                explore: explore,
-                                messages: __spreadArray([], __read(new Set(errors)), false),
-                            });
-                    }
-                    try {
-                        for (var _b = __values(object.properties), _c = _b.next(); !_c.done; _c = _b.next()) {
-                            var property = _c.value;
-                            validateMeta(context)(options)(visitor)(property.value, {
-                                object: object,
-                                property: property.key.isSoleLiteral()
-                                    ? property.key.getSoleLiteral()
-                                    : {},
-                                parameter: null,
-                                nested: null,
-                                top: false,
-                                aliased: false,
-                                escaped: false,
-                                output: false,
-                            });
-                        }
-                    }
-                    catch (e_12_1) { e_12 = { error: e_12_1 }; }
-                    finally {
-                        try {
-                            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                        }
-                        finally { if (e_12) throw e_12.error; }
-                    }
-                };
+    var validateObject = function (props) {
+        var e_12, _a;
+        if (props.visitor.objects.has(props.object))
+            return;
+        props.visitor.objects.add(props.object);
+        if (props.options.validate) {
+            var explore = {
+                object: props.object,
+                top: false,
+                property: null,
+                parameter: null,
+                nested: null,
+                aliased: false,
+                escaped: false,
+                output: false,
             };
-        };
+            var errors = props.options.validate(Metadata_1.Metadata.create(__assign(__assign({}, Metadata_1.Metadata.initialize()), { objects: [props.object] })), explore);
+            if (errors.length)
+                props.visitor.errors.push({
+                    name: props.object.name,
+                    explore: explore,
+                    messages: __spreadArray([], __read(new Set(errors)), false),
+                });
+        }
+        try {
+            for (var _b = __values(props.object.properties), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var property = _c.value;
+                validateMeta(__assign(__assign({}, props), { metadata: property.value, explore: {
+                        object: props.object,
+                        property: property.key.isSoleLiteral()
+                            ? property.key.getSoleLiteral()
+                            : {},
+                        parameter: null,
+                        nested: null,
+                        top: false,
+                        aliased: false,
+                        escaped: false,
+                        output: false,
+                    } }));
+            }
+        }
+        catch (e_12_1) { e_12 = { error: e_12_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_12) throw e_12.error; }
+        }
     };
-    var validateFunction = function (context) {
-        return function (options) {
-            return function (visitor) {
-                return function (func, explore) {
-                    var e_13, _a;
-                    if (visitor.functions.has(func))
-                        return;
-                    visitor.functions.add(func);
-                    try {
-                        for (var _b = __values(func.parameters), _c = _b.next(); !_c.done; _c = _b.next()) {
-                            var param = _c.value;
-                            validateMeta(context)(options)(visitor)(param.type, __assign(__assign({}, explore), { parameter: param.name, nested: null, top: false, output: false }));
-                        }
-                    }
-                    catch (e_13_1) { e_13 = { error: e_13_1 }; }
-                    finally {
-                        try {
-                            if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
-                        }
-                        finally { if (e_13) throw e_13.error; }
-                    }
-                    if (func.output)
-                        validateMeta(context)(options)(visitor)(func.output, __assign(__assign({}, explore), { parameter: null, nested: null, top: false, output: true }));
-                };
-            };
-        };
+    var validateFunction = function (props) {
+        var e_13, _a;
+        if (props.visitor.functions.has(props.function))
+            return;
+        props.visitor.functions.add(props.function);
+        try {
+            for (var _b = __values(props.function.parameters), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var param = _c.value;
+                validateMeta(__assign(__assign({}, props), { metadata: param.type, explore: __assign(__assign({}, props.explore), { parameter: param.name, nested: null, top: false, output: false }) }));
+            }
+        }
+        catch (e_13_1) { e_13 = { error: e_13_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_13) throw e_13.error; }
+        }
+        if (props.function.output)
+            validateMeta(__assign(__assign({}, props), { metadata: props.function.output, explore: __assign(__assign({}, props.explore), { parameter: null, nested: null, top: false, output: true }) }));
     };
 })(MetadataFactory || (exports.MetadataFactory = MetadataFactory = {}));
 //# sourceMappingURL=MetadataFactory.js.map