typia 7.0.0-dev.20240930 → 7.0.0-dev.20241002

package/lib/factories/MetadataTypeTagFactory.js

@@ -40,284 +40,329 @@ exports.MetadataTypeTagFactory = void 0;
 var MetadataTypeTagSchemaFactory_1 = require("./MetadataTypeTagSchemaFactory");
 var MetadataTypeTagFactory;
 (function (MetadataTypeTagFactory) {
-    MetadataTypeTagFactory.analyze = function (errors) {
-        return function (type) {
-            return function (objects, explore) {
-                var e_1, _a;
-                var messages = [];
-                var report = function (property) {
-                    return function (msg) {
-                        messages.push("the property ".concat(property === null ? "[\"typia.tag\"]" : "[\"typia.tag.".concat(property, "\"]"), " ").concat(msg, "."));
-                        return false;
-                    };
-                };
-                //----
-                // VALIDATION PROCESS
-                //----
-                var filtered = objects.filter(function (obj) {
-                    // ONLY ONE PROPERTY
-                    if (obj.properties.length !== 1)
-                        return false;
-                    // THE TAG.TYPE PROPERTY MUST BE
-                    var top = obj.properties[0];
-                    if (top.key.getSoleLiteral() !== "typia.tag" ||
-                        top.value.size() !== 1 ||
-                        top.value.objects.length !== 1)
-                        return false;
-                    else if (top.value.optional === false)
-                        return report(null)("must be optional object");
-                    // CHECK LIST OF PROPERTIES
-                    var tag = top.value.objects[0];
-                    var statics = tag.properties
-                        .map(function (p) { return p.key.getSoleLiteral(); })
-                        .filter(function (str) { return str !== null; });
-                    if (ESSENTIAL_FIELDS.some(function (f) { return !statics.includes(f); }))
-                        return report(null)("must have at least three properties - ".concat(ESSENTIAL_FIELDS.map(function (str) { return "'".concat(str, "'"); }).join(", ")));
-                    var each = tag.properties.map(function (p) {
-                        var key = p.key.getSoleLiteral();
-                        if (key === null)
-                            return true;
-                        else if (FIELDS.includes(key) === false)
-                            return true;
-                        return validate_property(report)(key, p.value);
-                    });
-                    return each.every(function (v) { return v === true; });
-                });
-                if (filtered.length === 0)
-                    return [];
-                //----
-                // CONSTRUCT TYPE TAGS
-                //----
-                // CREATE 1ST
-                var tagList = filtered.map(create_metadata_type_tag(report));
-                var output = [];
-                try {
-                    for (var tagList_1 = __values(tagList), tagList_1_1 = tagList_1.next(); !tagList_1_1.done; tagList_1_1 = tagList_1.next()) {
-                        var tag = tagList_1_1.value;
-                        if (tag !== null)
-                            output.push({
-                                target: tag.target.some(function (str) { return str === type; }) ? type : null,
-                                name: tag.name,
-                                kind: tag.kind,
-                                value: tag.value,
-                                validate: tag.validate[type],
-                                exclusive: tag.exclusive,
-                                schema: tag.schema,
-                            });
-                    }
-                }
-                catch (e_1_1) { e_1 = { error: e_1_1 }; }
-                finally {
-                    try {
-                        if (tagList_1_1 && !tagList_1_1.done && (_a = tagList_1.return)) _a.call(tagList_1);
-                    }
-                    finally { if (e_1) throw e_1.error; }
-                }
-                MetadataTypeTagFactory.validate(report)(type)(output);
-                if (messages.length > 0) {
-                    errors.push({
-                        name: __spreadArray([type], __read(objects.map(function (o) { return o.name; })), false).join(" & "),
-                        explore: explore,
-                        messages: messages,
-                    });
-                    return [];
-                }
-                return output;
-            };
+    MetadataTypeTagFactory.analyze = function (props) {
+        var e_1, _a;
+        var messages = [];
+        var report = function (next) {
+            messages.push("the property ".concat(next.property === null
+                ? "[\"typia.tag\"]"
+                : "[\"typia.tag.".concat(next.property, "\"]"), " ").concat(next.message, "."));
+            return false;
         };
-    };
-    MetadataTypeTagFactory.validate = function (report) {
-        return function (type) {
-            return function (tagList) {
-                var e_2, _a;
-                var success = true;
-                try {
-                    for (var tagList_2 = __values(tagList), tagList_2_1 = tagList_2.next(); !tagList_2_1.done; tagList_2_1 = tagList_2.next()) {
-                        var tag = tagList_2_1.value;
-                        if (tag.target !== type) {
-                            success && (success = report(null)("target must constains ".concat(type, " type")));
-                        }
-                    }
-                }
-                catch (e_2_1) { e_2 = { error: e_2_1 }; }
-                finally {
-                    try {
-                        if (tagList_2_1 && !tagList_2_1.done && (_a = tagList_2.return)) _a.call(tagList_2);
-                    }
-                    finally { if (e_2) throw e_2.error; }
-                }
-                tagList.forEach(function (tag, i) {
-                    if (tag.exclusive === false)
-                        return;
-                    else if (tag.exclusive === true) {
-                        var some = tagList.some(function (opposite, j) { return i !== j && opposite.kind === tag.kind; });
-                        if (some === true)
-                            success && (success = report(null)("kind '".concat(tag.kind, "' can't be duplicated")));
-                    }
-                    else if (Array.isArray(tag.exclusive)) {
-                        var some = tagList.find(function (opposite, j) {
-                            return i !== j &&
-                                opposite.kind === tag.kind &&
-                                tag.exclusive.includes(opposite.name);
-                        });
-                        if (some !== undefined)
-                            success !== null && success !== void 0 ? success : (success = report(null)("kind '".concat(tag.kind, "' can't be used with '").concat(some.name, "'")));
-                    }
+        //----
+        // VALIDATION PROCESS
+        //----
+        var filtered = props.objects.filter(function (obj) {
+            // ONLY ONE PROPERTY
+            if (obj.properties.length !== 1)
+                return false;
+            // THE TAG.TYPE PROPERTY MUST BE
+            var top = obj.properties[0];
+            if (top.key.getSoleLiteral() !== "typia.tag" ||
+                top.value.size() !== 1 ||
+                top.value.objects.length !== 1)
+                return false;
+            else if (top.value.optional === false)
+                return report({
+                    property: null,
+                    message: "must be optional object",
                 });
-                return success;
-            };
-        };
-    };
-    var validate_property = function (report) {
-        return function (key, value) {
-            var _a;
-            if (
-            // TARGET
-            key === "target" &&
-                (value.constants.length !== 1 ||
-                    value.constants[0].values.length !== value.size() ||
-                    value.constants[0].values.some(function (v) {
-                        return v.value !== "boolean" &&
-                            v.value !== "bigint" &&
-                            v.value !== "number" &&
-                            v.value !== "string" &&
-                            v.value !== "array";
-                    })))
-                return report(key)("must be one of 'boolean', 'bigint', 'number', 'string', 'array'");
-            else if (
-            // KIND
-            key === "kind" &&
-                (value.size() !== 1 ||
-                    value.constants.length !== 1 ||
-                    value.constants[0].type !== "string" ||
-                    value.constants[0].values.length !== 1))
-                return report(key)("must be a string literal type");
-            else if (
-            // VALUE
-            key === "value" &&
-                (value.size() > 1 ||
-                    (value.size() !== 0 &&
-                        (value.constants.length !== 1 ||
-                            value.constants[0].values.length !== 1))))
-                return report(key)("must be a constant literal type or undefined value");
-            else if (key === "exclusive")
-                return get_exclusive(report)(key)(value) !== null;
-            else if (key === "validate") {
-                //----
-                // VALIDATE
-                //----
-                // UNDEFINED CASE
-                if (value.size() === 0 &&
-                    value.isRequired() === false &&
-                    value.nullable === false)
+            // CHECK LIST OF PROPERTIES
+            var tag = top.value.objects[0];
+            var statics = tag.properties
+                .map(function (p) { return p.key.getSoleLiteral(); })
+                .filter(function (str) { return str !== null; });
+            if (ESSENTIAL_FIELDS.some(function (f) { return !statics.includes(f); }))
+                return report({
+                    property: null,
+                    message: "must have at least three properties - ".concat(ESSENTIAL_FIELDS.map(function (str) { return "'".concat(str, "'"); }).join(", ")),
+                });
+            var each = tag.properties.map(function (p) {
+                var key = p.key.getSoleLiteral();
+                if (key === null)
                     return true;
-                // STRING CASE
-                if (value.size() === 1 &&
-                    value.constants.length === 1 &&
-                    value.constants[0].type === "string" &&
-                    (value.constants[0].values.length === 1) === true)
+                else if (FIELDS.includes(key) === false)
                     return true;
-                // RECORD<TARGET, STRING>
-                var target_1 = (_a = value.objects[0]) === null || _a === void 0 ? void 0 : _a.properties.map(function (p) { return p.key.getSoleLiteral(); }).filter(function (str) { return str !== null; });
-                if (target_1 === undefined)
-                    return report("target")("must be one of 'boolean', 'bigint', 'number', 'string', 'array'");
-                var variadic = value.size() === 1 &&
-                    value.objects.length === 1 &&
-                    value.objects[0].properties.every(function (vp) {
-                        return vp.value.size() === 1 &&
-                            vp.value.isRequired() &&
-                            vp.value.nullable === false &&
-                            vp.value.constants.length === 1 &&
-                            vp.value.constants[0].type === "string" &&
-                            vp.value.constants[0].values.length === 1 &&
-                            target_1.includes(vp.key.getSoleLiteral());
+                return validate_property({
+                    report: report,
+                    key: key,
+                    value: p.value,
+                });
+            });
+            return each.every(function (v) { return v === true; });
+        });
+        if (filtered.length === 0)
+            return [];
+        //----
+        // CONSTRUCT TYPE TAGS
+        //----
+        // CREATE 1ST
+        var tagList = filtered.map(function (object) {
+            return create_metadata_type_tag({
+                report: report,
+                object: object,
+            });
+        });
+        var output = [];
+        try {
+            for (var tagList_1 = __values(tagList), tagList_1_1 = tagList_1.next(); !tagList_1_1.done; tagList_1_1 = tagList_1.next()) {
+                var tag = tagList_1_1.value;
+                if (tag !== null)
+                    output.push({
+                        target: tag.target.some(function (str) { return str === props.type; })
+                            ? props.type
+                            : null,
+                        name: tag.name,
+                        kind: tag.kind,
+                        value: tag.value,
+                        validate: tag.validate[props.type],
+                        exclusive: tag.exclusive,
+                        schema: tag.schema,
                     });
-                if (variadic === false)
-                    return report(key)("must be a string literal type or Record<Target, string> type.");
             }
-            return true;
-        };
+        }
+        catch (e_1_1) { e_1 = { error: e_1_1 }; }
+        finally {
+            try {
+                if (tagList_1_1 && !tagList_1_1.done && (_a = tagList_1.return)) _a.call(tagList_1);
+            }
+            finally { if (e_1) throw e_1.error; }
+        }
+        MetadataTypeTagFactory.validate({
+            report: report,
+            type: props.type,
+            tags: output,
+        });
+        if (messages.length > 0) {
+            props.errors.push({
+                name: __spreadArray([props.type], __read(props.objects.map(function (o) { return o.name; })), false).join(" & "),
+                explore: props.explore,
+                messages: messages,
+            });
+            return [];
+        }
+        return output;
     };
-    var create_metadata_type_tag = function (report) {
-        return function (obj) {
-            var _a, _b, _c;
-            var find = function (key) {
-                var _a, _b;
-                return (_b = (_a = obj.properties[0]) === null || _a === void 0 ? void 0 : _a.value.objects[0]) === null || _b === void 0 ? void 0 : _b.properties.find(function (p) { return p.key.getSoleLiteral() === key; });
-            };
-            var target = find("target").value.constants[0].values.map(function (v) { return v.value; });
-            var kind = find("kind").value.constants[0].values[0]
-                .value;
-            var value = (_b = (_a = find("value")) === null || _a === void 0 ? void 0 : _a.value.constants[0]) === null || _b === void 0 ? void 0 : _b.values[0].value;
-            var exclusive = get_exclusive(report)("exclusive")((_c = find("exclusive")) === null || _c === void 0 ? void 0 : _c.value);
-            if (exclusive === null)
-                return null;
-            var validate = (function () {
-                var _a;
-                var validate = (_a = find("validate")) === null || _a === void 0 ? void 0 : _a.value;
-                if (!validate || validate.size() === 0)
-                    return {};
-                else if (validate.constants.length)
-                    return Object.fromEntries(target.map(function (t) { return [
-                        t,
-                        validate.constants[0].values[0].value,
-                    ]; }));
-                return Object.fromEntries(validate.objects[0].properties.map(function (p) { return [
-                    p.key.getSoleLiteral(),
-                    p.value.constants[0].values[0].value,
+    MetadataTypeTagFactory.validate = function (props) {
+        var e_2, _a;
+        var success = true;
+        try {
+            for (var _b = __values(props.tags), _c = _b.next(); !_c.done; _c = _b.next()) {
+                var tag = _c.value;
+                if (tag.target !== props.type) {
+                    success && (success = props.report({
+                        property: null,
+                        message: "target must constains ".concat(props.type, " type"),
+                    }));
+                }
+            }
+        }
+        catch (e_2_1) { e_2 = { error: e_2_1 }; }
+        finally {
+            try {
+                if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
+            }
+            finally { if (e_2) throw e_2.error; }
+        }
+        props.tags.forEach(function (tag, i) {
+            if (tag.exclusive === false)
+                return;
+            else if (tag.exclusive === true) {
+                var some = props.tags.some(function (opposite, j) { return i !== j && opposite.kind === tag.kind; });
+                if (some === true)
+                    success && (success = props.report({
+                        property: null,
+                        message: "kind '".concat(tag.kind, "' can't be duplicated"),
+                    }));
+            }
+            else if (Array.isArray(tag.exclusive)) {
+                var some = props.tags.find(function (opposite, j) {
+                    return i !== j &&
+                        opposite.kind === tag.kind &&
+                        tag.exclusive.includes(opposite.name);
+                });
+                if (some !== undefined)
+                    success !== null && success !== void 0 ? success : (success = props.report({
+                        property: null,
+                        message: "kind '".concat(tag.kind, "' can't be used with '").concat(some.name, "'"),
+                    }));
+            }
+        });
+        return success;
+    };
+    var validate_property = function (props) {
+        var _a;
+        if (
+        // TARGET
+        props.key === "target" &&
+            (props.value.constants.length !== 1 ||
+                props.value.constants[0].values.length !== props.value.size() ||
+                props.value.constants[0].values.some(function (v) {
+                    return v.value !== "boolean" &&
+                        v.value !== "bigint" &&
+                        v.value !== "number" &&
+                        v.value !== "string" &&
+                        v.value !== "array";
+                })))
+            return props.report({
+                property: props.key,
+                message: "must be one of 'boolean', 'bigint', 'number', 'string', 'array'",
+            });
+        else if (
+        // KIND
+        props.key === "kind" &&
+            (props.value.size() !== 1 ||
+                props.value.constants.length !== 1 ||
+                props.value.constants[0].type !== "string" ||
+                props.value.constants[0].values.length !== 1))
+            return props.report({
+                property: props.key,
+                message: "must be a string literal type",
+            });
+        else if (
+        // VALUE
+        props.key === "value" &&
+            (props.value.size() > 1 ||
+                (props.value.size() !== 0 &&
+                    (props.value.constants.length !== 1 ||
+                        props.value.constants[0].values.length !== 1))))
+            return props.report({
+                property: props.key,
+                message: "must be a constant literal type or undefined value",
+            });
+        else if (props.key === "exclusive")
+            return get_exclusive(props) !== null;
+        else if (props.key === "validate") {
+            //----
+            // VALIDATE
+            //----
+            // UNDEFINED CASE
+            if (props.value.size() === 0 &&
+                props.value.isRequired() === false &&
+                props.value.nullable === false)
+                return true;
+            // STRING CASE
+            if (props.value.size() === 1 &&
+                props.value.constants.length === 1 &&
+                props.value.constants[0].type === "string" &&
+                (props.value.constants[0].values.length === 1) === true)
+                return true;
+            // RECORD<TARGET, STRING>
+            var target_1 = (_a = props.value.objects[0]) === null || _a === void 0 ? void 0 : _a.properties.map(function (p) { return p.key.getSoleLiteral(); }).filter(function (str) { return str !== null; });
+            if (target_1 === undefined)
+                return props.report({
+                    property: "target",
+                    message: "must be one of 'boolean', 'bigint', 'number', 'string', 'array'",
+                });
+            var variadic = props.value.size() === 1 &&
+                props.value.objects.length === 1 &&
+                props.value.objects[0].properties.every(function (vp) {
+                    return vp.value.size() === 1 &&
+                        vp.value.isRequired() &&
+                        vp.value.nullable === false &&
+                        vp.value.constants.length === 1 &&
+                        vp.value.constants[0].type === "string" &&
+                        vp.value.constants[0].values.length === 1 &&
+                        target_1.includes(vp.key.getSoleLiteral());
+                });
+            if (variadic === false)
+                return props.report({
+                    property: props.key,
+                    message: "must be a string literal type or Record<Target, string> type.",
+                });
+        }
+        return true;
+    };
+    var create_metadata_type_tag = function (props) {
+        var _a, _b, _c;
+        var find = function (key) {
+            var _a, _b;
+            return (_b = (_a = props.object.properties[0]) === null || _a === void 0 ? void 0 : _a.value.objects[0]) === null || _b === void 0 ? void 0 : _b.properties.find(function (p) { return p.key.getSoleLiteral() === key; });
+        };
+        var target = find("target").value.constants[0].values.map(function (v) { return v.value; });
+        var kind = find("kind").value.constants[0].values[0]
+            .value;
+        var value = (_b = (_a = find("value")) === null || _a === void 0 ? void 0 : _a.value.constants[0]) === null || _b === void 0 ? void 0 : _b.values[0].value;
+        var exclusive = get_exclusive({
+            report: props.report,
+            key: "exclusive",
+            value: (_c = find("exclusive")) === null || _c === void 0 ? void 0 : _c.value,
+        });
+        if (exclusive === null)
+            return null;
+        var validate = (function () {
+            var _a;
+            var validate = (_a = find("validate")) === null || _a === void 0 ? void 0 : _a.value;
+            if (!validate || validate.size() === 0)
+                return {};
+            else if (validate.constants.length)
+                return Object.fromEntries(target.map(function (t) { return [
+                    t,
+                    validate.constants[0].values[0].value,
                 ]; }));
-            })();
-            var schema = (function () {
-                var _a;
-                var p = (_a = find("schema")) === null || _a === void 0 ? void 0 : _a.value;
-                if (p === undefined)
-                    return undefined;
-                else if (p.size() === 0 && p.isRequired() === false)
-                    return undefined;
-                else if (p.size() === 1 &&
-                    p.nullable === false &&
-                    p.isRequired() === true &&
-                    p.any === false)
-                    return MetadataTypeTagSchemaFactory_1.MetadataTypeTagSchemaFactory.object(function (msg) {
-                        return report("schema")(msg);
-                    })(p.objects[0]);
-                report("schema")("must be an object type");
+            return Object.fromEntries(validate.objects[0].properties.map(function (p) { return [
+                p.key.getSoleLiteral(),
+                p.value.constants[0].values[0].value,
+            ]; }));
+        })();
+        var schema = (function () {
+            var _a;
+            var p = (_a = find("schema")) === null || _a === void 0 ? void 0 : _a.value;
+            if (p === undefined)
+                return undefined;
+            else if (p.size() === 0 && p.isRequired() === false)
                 return undefined;
-            })();
-            return {
-                name: obj.name,
-                target: target,
-                kind: kind,
-                value: value,
-                validate: validate,
-                exclusive: exclusive !== null && exclusive !== void 0 ? exclusive : false,
-                schema: schema,
-            };
+            else if (p.size() === 1 &&
+                p.nullable === false &&
+                p.isRequired() === true &&
+                p.any === false)
+                return MetadataTypeTagSchemaFactory_1.MetadataTypeTagSchemaFactory.object({
+                    report: function (message) {
+                        return props.report({
+                            property: "schema",
+                            message: message,
+                        });
+                    },
+                    object: p.objects[0],
+                });
+            props.report({
+                property: "schema",
+                message: "must be an object type",
+            });
+            return undefined;
+        })();
+        return {
+            name: props.object.name,
+            target: target,
+            kind: kind,
+            value: value,
+            validate: validate,
+            exclusive: exclusive !== null && exclusive !== void 0 ? exclusive : false,
+            schema: schema,
         };
     };
-    var get_exclusive = function (report) {
-        return function (key) {
-            return function (value) {
-                if (value === undefined)
-                    return false;
-                else if (value.size() === 1 &&
-                    value.constants.length === 1 &&
-                    value.constants[0].type === "boolean" &&
-                    value.constants[0].values.length === 1)
-                    return value.constants[0].values[0].value;
-                else if (value.size() === 1 &&
-                    value.tuples.length === 1 &&
-                    value.tuples[0].type.elements.every(function (elem) {
-                        return elem.size() === 1 &&
-                            elem.constants.length === 1 &&
-                            elem.constants[0].type === "string" &&
-                            elem.constants[0].values.length === 1;
-                    }))
-                    return value.tuples[0].type.elements.map(function (elem) { return elem.constants[0].values[0].value; });
-                report(key)("must a boolean literal type or a tuple of string literal types.");
-                return null;
-            };
-        };
+    var get_exclusive = function (props) {
+        if (props.value === undefined)
+            return false;
+        else if (props.value.size() === 1 &&
+            props.value.constants.length === 1 &&
+            props.value.constants[0].type === "boolean" &&
+            props.value.constants[0].values.length === 1)
+            return props.value.constants[0].values[0].value;
+        else if (props.value.size() === 1 &&
+            props.value.tuples.length === 1 &&
+            props.value.tuples[0].type.elements.every(function (elem) {
+                return elem.size() === 1 &&
+                    elem.constants.length === 1 &&
+                    elem.constants[0].type === "string" &&
+                    elem.constants[0].values.length === 1;
+            }))
+            return props.value.tuples[0].type.elements.map(function (elem) { return elem.constants[0].values[0].value; });
+        props.report({
+            property: props.key,
+            message: "must a boolean literal type or a tuple of string literal types.",
+        });
+        return null;
     };
 })(MetadataTypeTagFactory || (exports.MetadataTypeTagFactory = MetadataTypeTagFactory = {}));
 var ESSENTIAL_FIELDS = ["target", "kind", "value"];