typia 7.0.0-dev.20241002 → 7.0.0-dev.20241003

package/lib/factories/MetadataCommentTagFactory.js

@@ -41,8 +41,6 @@ var Writable_1 = require("../typings/Writable");
 var FormatCheatSheet_1 = require("../tags/internal/FormatCheatSheet");
 var MetadataTypeTagFactory_1 = require("./MetadataTypeTagFactory");
 /**
- * Extremely hard coded, but no reason to maintain.
- *
  * @internal
  */
 var MetadataCommentTagFactory;
@@ -193,73 +191,120 @@ var MetadataCommentTagFactory;
         var next = PARSER[props.tag.name];
         if (next === undefined)
             return {};
-        var text = (_a = (props.tag.text || [])[0]) === null || _a === void 0 ? void 0 : _a.text;
-        if (text === undefined && props.tag.name !== "uniqueItems")
+        var value = (_a = (props.tag.text || [])[0]) === null || _a === void 0 ? void 0 : _a.text;
+        if (value === undefined && props.tag.name !== "uniqueItems")
             return props.report("no comment tag value");
-        return next(props.report)(text);
+        return next({
+            report: props.report,
+            value: value,
+        });
     };
 })(MetadataCommentTagFactory || (exports.MetadataCommentTagFactory = MetadataCommentTagFactory = {}));
+/**
+ * @internal
+ */
 var PARSER = {
     /* -----------------------------------------------------------
           ARRAY
       ----------------------------------------------------------- */
-    items: function (report) { return function (Value) { return ({
-        array: [
-            {
-                name: "MinItems<".concat(Value, ">"),
-                target: "array",
-                kind: "minItems",
-                value: parse_integer(report)(true)(Value),
-                validate: "".concat(Value, " <= $input.length"),
-                exclusive: true,
-                schema: {
-                    minItems: parse_integer(report)(true)(Value),
+    items: function (_a) {
+        var report = _a.report, value = _a.value;
+        return ({
+            array: [
+                {
+                    name: "MinItems<".concat(value, ">"),
+                    target: "array",
+                    kind: "minItems",
+                    value: parse_integer({
+                        report: report,
+                        value: value,
+                        unsigned: true,
+                    }),
+                    validate: "".concat(value, " <= $input.length"),
+                    exclusive: true,
+                    schema: {
+                        minItems: parse_integer({
+                            report: report,
+                            value: value,
+                            unsigned: true,
+                        }),
+                    },
                 },
-            },
-            {
-                name: "MaxItems<".concat(Value, ">"),
-                target: "array",
-                kind: "maxItems",
-                value: parse_integer(report)(true)(Value),
-                validate: "$input.length <= ".concat(Value),
-                exclusive: true,
-                schema: {
-                    maxItems: parse_integer(report)(true)(Value),
+                {
+                    name: "MaxItems<".concat(value, ">"),
+                    target: "array",
+                    kind: "maxItems",
+                    value: parse_integer({
+                        report: report,
+                        value: value,
+                        unsigned: true,
+                    }),
+                    validate: "$input.length <= ".concat(value),
+                    exclusive: true,
+                    schema: {
+                        maxItems: parse_integer({
+                            report: report,
+                            unsigned: true,
+                            value: value,
+                        }),
+                    },
                 },
-            },
-        ],
-    }); }; },
-    minItems: function (report) { return function (Value) { return ({
-        array: [
-            {
-                name: "MinItems<".concat(Value, ">"),
-                target: "array",
-                kind: "minItems",
-                value: parse_integer(report)(true)(Value),
-                validate: "".concat(Value, " <= $input.length"),
-                exclusive: true,
-                schema: {
-                    minItems: parse_integer(report)(true)(Value),
+            ],
+        });
+    },
+    minItems: function (_a) {
+        var report = _a.report, value = _a.value;
+        return ({
+            array: [
+                {
+                    name: "MinItems<".concat(value, ">"),
+                    target: "array",
+                    kind: "minItems",
+                    value: parse_integer({
+                        report: report,
+                        value: value,
+                        unsigned: true,
+                    }),
+                    validate: "".concat(value, " <= $input.length"),
+                    exclusive: true,
+                    schema: {
+                        minItems: parse_integer({
+                            report: report,
+                            value: value,
+                            unsigned: true,
+                        }),
+                    },
                 },
-            },
-        ],
-    }); }; },
-    maxItems: function (report) { return function (Value) { return ({
-        array: [
-            {
-                name: "MaxItems<".concat(Value, ">"),
-                target: "array",
-                kind: "maxItems",
-                value: parse_integer(report)(true)(Value),
-                validate: "$input.length <= ".concat(Value),
-                exclusive: true,
-                schema: {
-                    maxItems: parse_integer(report)(true)(Value),
+            ],
+        });
+    },
+    maxItems: function (_a) {
+        var report = _a.report, value = _a.value;
+        return ({
+            array: [
+                {
+                    name: "MaxItems<".concat(value, ">"),
+                    target: "array",
+                    kind: "maxItems",
+                    value: parse_integer({
+                        report: report,
+                        value: value,
+                        unsigned: true,
+                    }),
+                    validate: "$input.length <= ".concat(value),
+                    exclusive: true,
+                    schema: {
+                        maxItems: parse_integer({
+                            report: report,
+                            value: value,
+                            unsigned: true,
+                        }),
+                    },
                 },
-            },
-        ],
-    }); }; },
-    uniqueItems: function () { return function () { return ({
+            ],
+        });
+    },
+    uniqueItems: function () { return ({
         array: [
             {
                 name: "UniqueItems",
@@ -273,212 +318,234 @@ var PARSER = {
                 },
             },
         ],
-    }); }; },
+    }); },
     /* -----------------------------------------------------------
           NUMBER
       ----------------------------------------------------------- */
-    type: function () { return function (Value) {
+    type: function (_a) {
+        var value = _a.value;
         // EMENDATIONS
-        if (Value.startsWith("{") && Value.endsWith("}"))
-            Value = Value.substring(1, Value.length - 1);
-        if (Value === "int")
-            Value = "int32";
-        else if (Value === "uint")
-            Value = "uint32";
+        if (value.startsWith("{") && value.endsWith("}"))
+            value = value.substring(1, value.length - 1);
+        if (value === "int")
+            value = "int32";
+        else if (value === "uint")
+            value = "uint32";
         // MUST BE ONE OF THEM
-        if (["int32", "uint32", "int64", "uint64", "float", "double"].includes(Value) === false)
+        if (["int32", "uint32", "int64", "uint64", "float", "double"].includes(value) === false)
             return {};
         return {
             number: [
                 {
-                    name: "Type<".concat(JSON.stringify(Value), ">"),
+                    name: "Type<".concat(JSON.stringify(value), ">"),
                     target: "number",
                     kind: "type",
-                    value: Value,
-                    validate: Value === "int32"
+                    value: value,
+                    validate: value === "int32"
                         ? "Math.floor($input) === $input && -2147483648 <= $input && $input <= 2147483647"
-                        : Value === "uint32"
+                        : value === "uint32"
                             ? "Math.floor($input) === $input && 0 <= $input && $input <= 4294967295"
-                            : Value === "int64"
+                            : value === "int64"
                                 ? "Math.floor($input) === $input && -9223372036854775808 <= $input && $input <= 9223372036854775807"
-                                : Value === "uint64"
+                                : value === "uint64"
                                     ? "Math.floor($input) === $input && 0 <= $input && $input <= 18446744073709551615"
-                                    : Value === "float"
+                                    : value === "float"
                                         ? "-1.175494351e38 <= $input && $input <= 3.4028235e38"
                                         : "true",
                     exclusive: true,
-                    schema: ["int32", "uint32", "int64", "uint64"].includes(Value)
+                    schema: ["int32", "uint32", "int64", "uint64"].includes(value)
                         ? { type: "integer" }
                         : undefined,
                 },
             ],
-            bigint: Value === "int64" || "uint64"
+            bigint: value === "int64" || "uint64"
                 ? [
                     {
-                        name: "Type<".concat(JSON.stringify(Value), ">"),
+                        name: "Type<".concat(JSON.stringify(value), ">"),
                         target: "bigint",
                         kind: "type",
-                        value: Value,
-                        validate: Value === "int64" ? "true" : "BigInt(0) <= $input",
+                        value: value,
+                        validate: value === "int64" ? "true" : "BigInt(0) <= $input",
                         exclusive: true,
                         schema: undefined,
                     },
                 ]
                 : [],
         };
-    }; },
-    minimum: function (report) { return function (Value) { return ({
+    },
+    minimum: function (props) { return ({
         number: [
             {
-                name: "Minimum<".concat(Value, ">"),
+                name: "Minimum<".concat(props.value, ">"),
                 target: "number",
                 kind: "minimum",
-                value: parse_number(report)(Value),
-                validate: "".concat(Value, " <= $input"),
+                value: parse_number(props),
+                validate: "".concat(props.value, " <= $input"),
                 exclusive: ["minimum", "exclusiveMinimum"],
                 schema: {
-                    minimum: parse_number(report)(Value),
+                    minimum: parse_number(props),
                 },
             },
         ],
         bigint: [
             {
-                name: "Minimum<".concat(Value, "n>"),
+                name: "Minimum<".concat(props.value, "n>"),
                 target: "bigint",
                 kind: "minimum",
                 value: (function () {
-                    var value = parse_integer(report)(false)(Value);
-                    return value === null ? null : BigInt(value);
+                    var parsed = parse_integer({
+                        report: props.report,
+                        value: props.value,
+                        unsigned: false,
+                    });
+                    return parsed === null ? null : BigInt(parsed);
                 })(),
-                validate: "".concat(Value, " <= $input"),
+                validate: "".concat(props.value, " <= $input"),
                 exclusive: ["minimum", "exclusiveMinimum"],
                 schema: undefined,
             },
         ],
-    }); }; },
-    maximum: function (report) { return function (Value) { return ({
+    }); },
+    maximum: function (props) { return ({
         number: [
             {
-                name: "Maximum<".concat(Value, ">"),
+                name: "Maximum<".concat(props.value, ">"),
                 target: "number",
                 kind: "maximum",
-                value: parse_number(report)(Value),
-                validate: "$input <= ".concat(Value),
+                value: parse_number(props),
+                validate: "$input <= ".concat(props.value),
                 exclusive: ["maximum", "exclusiveMaximum"],
                 schema: {
-                    maximum: parse_number(report)(Value),
+                    maximum: parse_number(props),
                 },
             },
         ],
         bigint: [
             {
-                name: "Maximum<".concat(Value, "n>"),
+                name: "Maximum<".concat(props.value, "n>"),
                 target: "bigint",
                 kind: "maximum",
                 value: (function () {
-                    var value = parse_integer(report)(false)(Value);
-                    return value === null ? null : BigInt(value);
+                    var parsed = parse_integer({
+                        report: props.report,
+                        value: props.value,
+                        unsigned: false,
+                    });
+                    return parsed === null ? null : BigInt(parsed);
                 })(),
-                validate: "$input <= ".concat(Value),
+                validate: "$input <= ".concat(props.value),
                 exclusive: ["maximum", "exclusiveMaximum"],
                 schema: undefined,
             },
         ],
-    }); }; },
-    exclusiveMinimum: function (report) { return function (Value) { return ({
+    }); },
+    exclusiveMinimum: function (props) { return ({
         number: [
             {
-                name: "ExclusiveMinimum<".concat(Value, ">"),
+                name: "ExclusiveMinimum<".concat(props.value, ">"),
                 target: "number",
                 kind: "exclusiveMinimum",
-                value: parse_number(report)(Value),
-                validate: "".concat(Value, " < $input"),
+                value: parse_number(props),
+                validate: "".concat(props.value, " < $input"),
                 exclusive: ["minimum", "exclusiveMinimum"],
                 schema: {
                     exclusiveMinimum: true,
-                    minimum: parse_number(report)(Value),
+                    minimum: parse_number(props),
                 },
             },
         ],
         bigint: [
             {
-                name: "ExclusiveMinimum<".concat(Value, "n>"),
+                name: "ExclusiveMinimum<".concat(props.value, "n>"),
                 target: "bigint",
                 kind: "exclusiveMinimum",
                 value: (function () {
-                    var value = parse_integer(report)(false)(Value);
-                    return value === null ? null : BigInt(value);
+                    var parsed = parse_integer({
+                        report: props.report,
+                        value: props.value,
+                        unsigned: false,
+                    });
+                    return parsed === null ? null : BigInt(parsed);
                 })(),
-                validate: "".concat(Value, " < $input"),
+                validate: "".concat(props.value, " < $input"),
                 exclusive: ["minimum", "exclusiveMinimum"],
                 schema: undefined,
             },
         ],
-    }); }; },
-    exclusiveMaximum: function (report) { return function (Value) { return ({
+    }); },
+    exclusiveMaximum: function (props) { return ({
         number: [
             {
-                name: "ExclusiveMaximum<".concat(Value, ">"),
+                name: "ExclusiveMaximum<".concat(props.value, ">"),
                 target: "number",
                 kind: "exclusiveMaximum",
-                value: parse_number(report)(Value),
-                validate: "$input < ".concat(Value),
+                value: parse_number(props),
+                validate: "$input < ".concat(props.value),
                 exclusive: ["maximum", "exclusiveMaximum"],
                 schema: {
                     exclusiveMaximum: true,
-                    maximum: parse_number(report)(Value),
+                    maximum: parse_number(props),
                 },
             },
         ],
         bigint: [
             {
-                name: "ExclusiveMaximum<".concat(Value, "n>"),
+                name: "ExclusiveMaximum<".concat(props.value, "n>"),
                 target: "bigint",
                 kind: "exclusiveMaximum",
                 value: (function () {
-                    var value = parse_integer(report)(false)(Value);
-                    return value === null ? null : BigInt(value);
+                    var parsed = parse_integer({
+                        report: props.report,
+                        value: props.value,
+                        unsigned: false,
+                    });
+                    return parsed === null ? null : BigInt(parsed);
                 })(),
-                validate: "$input < ".concat(Value),
+                validate: "$input < ".concat(props.value),
                 exclusive: ["maximum", "exclusiveMaximum"],
                 schema: undefined,
             },
         ],
-    }); }; },
-    multipleOf: function (report) { return function (Value) { return ({
+    }); },
+    multipleOf: function (props) { return ({
         number: [
             {
-                name: "MultipleOf<".concat(Value, ">"),
+                name: "MultipleOf<".concat(props.value, ">"),
                 target: "number",
                 kind: "multipleOf",
-                value: parse_number(report)(Value),
-                validate: "$input % ".concat(Value, " === 0"),
+                value: parse_number(props),
+                validate: "$input % ".concat(props.value, " === 0"),
                 exclusive: true,
                 schema: {
-                    multipleOf: parse_number(report)(Value),
+                    multipleOf: parse_number(props),
                 },
             },
         ],
         bigint: [
             {
-                name: "MultipleOf<".concat(Value, "n>"),
+                name: "MultipleOf<".concat(props.value, "n>"),
                 target: "bigint",
                 kind: "multipleOf",
                 value: (function () {
-                    var value = parse_integer(report)(false)(Value);
-                    return value === null ? null : BigInt(value);
+                    var parsed = parse_integer({
+                        report: props.report,
+                        value: props.value,
+                        unsigned: false,
+                    });
+                    return parsed === null ? null : BigInt(parsed);
                 })(),
-                validate: "$input % ".concat(Value, "n === 0n"),
+                validate: "$input % ".concat(props.value, "n === 0n"),
                 exclusive: true,
                 schema: undefined,
             },
         ],
-    }); }; },
+    }); },
     /* -----------------------------------------------------------
           STRING
       ----------------------------------------------------------- */
-    format: function () { return function (Value) {
-        var matched = FORMATS.get(Value);
+    format: function (_a) {
+        var value = _a.value;
+        var matched = FORMATS.get(value);
         if (matched === undefined)
             return {};
         return {
@@ -496,101 +563,113 @@ var PARSER = {
                 },
             ],
         };
-    }; },
-    pattern: function () { return function (Value) { return ({
-        string: [
-            {
-                name: "Pattern<".concat(JSON.stringify(Value), ">"),
-                target: "string",
-                kind: "pattern",
-                value: Value,
-                validate: "RegExp(".concat(JSON.stringify(Value), ").test($input)"),
-                exclusive: ["format"],
-                schema: {
-                    pattern: Value,
+    },
+    pattern: function (_a) {
+        var value = _a.value;
+        return ({
+            string: [
+                {
+                    name: "Pattern<".concat(JSON.stringify(value), ">"),
+                    target: "string",
+                    kind: "pattern",
+                    value: value,
+                    validate: "RegExp(".concat(JSON.stringify(value), ").test($input)"),
+                    exclusive: ["format"],
+                    schema: {
+                        pattern: value,
+                    },
                 },
-            },
-        ],
-    }); }; },
-    length: function (report) { return function (Value) { return ({
+            ],
+        });
+    },
+    length: function (props) { return ({
         string: [
             {
-                name: "MinLength<".concat(Value, ">"),
+                name: "MinLength<".concat(props.value, ">"),
                 target: "string",
                 kind: "minLength",
-                value: parse_number(report)(Value),
-                validate: "".concat(Value, " <= $input.length"),
+                value: parse_number(props),
+                validate: "".concat(props.value, " <= $input.length"),
                 exclusive: true,
                 schema: {
-                    minLength: parse_number(report)(Value),
+                    minLength: parse_number(props),
                 },
             },
             {
-                name: "MaxLength<".concat(Value, ">"),
+                name: "MaxLength<".concat(props.value, ">"),
                 target: "string",
                 kind: "maxLength",
-                value: parse_number(report)(Value),
-                validate: "$input.length <= ".concat(Value),
+                value: parse_number(props),
+                validate: "$input.length <= ".concat(props.value),
                 exclusive: true,
                 schema: {
-                    maxLength: parse_number(report)(Value),
+                    maxLength: parse_number(props),
                 },
             },
         ],
-    }); }; },
-    minLength: function (report) { return function (Value) { return ({
-        string: [
-            {
-                name: "MinLength<".concat(Value, ">"),
-                target: "string",
-                kind: "minLength",
-                value: parse_number(report)(Value),
-                validate: "".concat(Value, " <= $input.length"),
-                exclusive: true,
-                schema: {
-                    minLength: parse_number(report)(Value),
+    }); },
+    minLength: function (_a) {
+        var report = _a.report, value = _a.value;
+        return ({
+            string: [
+                {
+                    name: "MinLength<".concat(value, ">"),
+                    target: "string",
+                    kind: "minLength",
+                    value: parse_number({ report: report, value: value }),
+                    validate: "".concat(value, " <= $input.length"),
+                    exclusive: true,
+                    schema: {
+                        minLength: parse_number({ report: report, value: value }),
+                    },
                 },
-            },
-        ],
-    }); }; },
-    maxLength: function (report) { return function (Value) { return ({
-        string: [
-            {
-                name: "MaxLength<".concat(Value, ">"),
-                target: "string",
-                kind: "maxLength",
-                value: parse_number(report)(Value),
-                validate: "$input.length <= ".concat(Value),
-                exclusive: true,
-                schema: {
-                    maxLength: parse_number(report)(Value),
+            ],
+        });
+    },
+    maxLength: function (_a) {
+        var report = _a.report, value = _a.value;
+        return ({
+            string: [
+                {
+                    name: "MaxLength<".concat(value, ">"),
+                    target: "string",
+                    kind: "maxLength",
+                    value: parse_number({ report: report, value: value }),
+                    validate: "$input.length <= ".concat(value),
+                    exclusive: true,
+                    schema: {
+                        maxLength: parse_number({ report: report, value: value }),
+                    },
                 },
-            },
-        ],
-    }); }; },
+            ],
+        });
+    },
 };
-var parse_number = function (report) {
-    return function (str) {
-        var value = Number(str);
-        if (isNaN(value) === true)
-            return report("invalid number");
-        return value;
-    };
+/**
+ * @internal
+ */
+var parse_number = function (props) {
+    var parsed = Number(props.value);
+    if (isNaN(parsed) === true)
+        return props.report("invalid number");
+    return parsed;
 };
-var parse_integer = function (report) {
-    return function (unsigned) {
-        return function (str) {
-            var value = parse_number(report)(str);
-            if (value === null)
-                return null;
-            else if (Math.floor(value) !== value)
-                return report("invalid integer");
-            else if (unsigned === true && value < 0)
-                return report("invalid unsigned integer");
-            return value;
-        };
-    };
+/**
+ * @internal
+ */
+var parse_integer = function (props) {
+    var parsed = parse_number(props);
+    if (parsed === null)
+        return null;
+    else if (Math.floor(parsed) !== parsed)
+        return props.report("invalid integer");
+    else if (props.unsigned === true && parsed < 0)
+        return props.report("invalid unsigned integer");
+    return parsed;
 };
+/**
+ * @internal
+ */
 var FORMATS = new Map(__spreadArray(__spreadArray([], __read(Object.entries(FormatCheatSheet_1.FormatCheatSheet).map(function (_a) {
     var _b = __read(_a, 2), key = _b[0], value = _b[1];
     return [key, [key, value]];