typia 3.7.0-dev.20230331 → 3.7.0-dev.20230401

package/lib/programmers/internal/check_template.js

@@ -30,20 +30,32 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.check_template = void 0;
 var typescript_1 = __importDefault(require("typescript"));
+var check_custom_1 = require("./check_custom");
 var check_string_tags_1 = require("./check_string_tags");
 var template_to_pattern_1 = require("./template_to_pattern");
 var check_template = function (importer) {
-    return function (input, templates, tagList) {
-        var conditions = __spreadArray([
-            typescript_1.default.factory.createStrictEquality(typescript_1.default.factory.createStringLiteral("string"), typescript_1.default.factory.createTypeOfExpression(input))
-        ], __read((0, check_string_tags_1.check_string_tags)(importer)(input, tagList)), false);
-        var internal = templates.map(function (tpl) {
-            return typescript_1.default.factory.createStrictEquality(typescript_1.default.factory.createTrue(), typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier("RegExp(/".concat((0, template_to_pattern_1.template_to_pattern)(true)(tpl), "/).test")), undefined, [input]));
-        });
-        conditions.push(internal.length === 1
-            ? internal[0]
-            : internal.reduce(function (x, y) { return typescript_1.default.factory.createLogicalOr(x, y); }));
-        return conditions.reduce(function (x, y) { return typescript_1.default.factory.createLogicalAnd(x, y); });
+    return function (metaTags) {
+        return function (jsDocTags) {
+            return function (templates) {
+                return function (input) {
+                    var conditions = [
+                        typescript_1.default.factory.createStrictEquality(typescript_1.default.factory.createStringLiteral("string"), typescript_1.default.factory.createTypeOfExpression(input)),
+                    ];
+                    var internal = templates.map(function (tpl) {
+                        return typescript_1.default.factory.createStrictEquality(typescript_1.default.factory.createTrue(), typescript_1.default.factory.createCallExpression(typescript_1.default.factory.createIdentifier("RegExp(/".concat((0, template_to_pattern_1.template_to_pattern)(true)(tpl), "/).test")), undefined, [input]));
+                    });
+                    conditions.push(internal.length === 1
+                        ? internal[0]
+                        : internal.reduce(function (x, y) { return typescript_1.default.factory.createLogicalOr(x, y); }));
+                    return {
+                        expression: conditions.reduce(function (x, y) {
+                            return typescript_1.default.factory.createLogicalAnd(x, y);
+                        }),
+                        tags: __spreadArray(__spreadArray([], __read((0, check_string_tags_1.check_string_tags)(importer)(metaTags)(input)), false), __read((0, check_custom_1.check_custom)("string")(importer)(jsDocTags)(input)), false),
+                    };
+                };
+            };
+        };
     };
 };
 exports.check_template = check_template;

package/lib/programmers/internal/check_template.js.map

@@ -1 +1 @@
-{"version":3,"file":"check_template.js","sourceRoot":"","sources":["../../../src/programmers/internal/check_template.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,0DAA4B;AAM5B,yDAAwD;AACxD,6DAA4D;AAKrD,IAAM,cAAc,GACvB,UAAC,QAA0B;IAC3B,OAAA,UACI,KAAoB,EACpB,SAAuB,EACvB,OAAuB;QAGvB,IAAM,UAAU;YACZ,oBAAE,CAAC,OAAO,CAAC,oBAAoB,CAC3B,oBAAE,CAAC,OAAO,CAAC,mBAAmB,CAAC,QAAQ,CAAC,EACxC,oBAAE,CAAC,OAAO,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAC3C;kBACE,IAAA,qCAAiB,EAAC,QAAQ,CAAC,CAAC,KAAK,EAAE,OAAO,CAAC,SACjD,CAAC;QAGF,IAAM,QAAQ,GAAG,SAAS,CAAC,GAAG,CAAC,UAAC,GAAG;YAC/B,OAAA,oBAAE,CAAC,OAAO,CAAC,oBAAoB,CAC3B,oBAAE,CAAC,OAAO,CAAC,UAAU,EAAE,EACvB,oBAAE,CAAC,OAAO,CAAC,oBAAoB,CAC3B,oBAAE,CAAC,OAAO,CAAC,gBAAgB,CACvB,kBAAW,IAAA,yCAAmB,EAAC,IAAI,CAAC,CAAC,GAAG,CAAC,YAAS,CACrD,EACD,SAAS,EACT,CAAC,KAAK,CAAC,CACV,CACJ;QATD,CASC,CACJ,CAAC;QACF,UAAU,CAAC,IAAI,CACX,QAAQ,CAAC,MAAM,KAAK,CAAC;YACjB,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAE;YACd,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAC,CAAC,EAAE,CAAC,IAAK,OAAA,oBAAE,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,EAAhC,CAAgC,CAAC,CACpE,CAAC;QAGF,OAAO,UAAU,CAAC,MAAM,CAAC,UAAC,CAAC,EAAE,CAAC,IAAK,OAAA,oBAAE,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,EAAjC,CAAiC,CAAC,CAAC;IAC1E,CAAC;AAnCD,CAmCC,CAAC;AArCO,QAAA,cAAc,kBAqCrB"}
+{"version":3,"file":"check_template.js","sourceRoot":"","sources":["../../../src/programmers/internal/check_template.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,0DAA4B;AAQ5B,+CAA8C;AAC9C,yDAAwD;AACxD,6DAA4D;AAKrD,IAAM,cAAc,GACvB,UAAC,QAA0B;IAC3B,OAAA,UAAC,QAAwB;QACzB,OAAA,UAAC,SAA0B;YAC3B,OAAA,UAAC,SAAuB;gBACxB,OAAA,UAAC,KAAoB;oBAEjB,IAAM,UAAU,GAAoB;wBAChC,oBAAE,CAAC,OAAO,CAAC,oBAAoB,CAC3B,oBAAE,CAAC,OAAO,CAAC,mBAAmB,CAAC,QAAQ,CAAC,EACxC,oBAAE,CAAC,OAAO,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAC3C;qBACJ,CAAC;oBAGF,IAAM,QAAQ,GAAG,SAAS,CAAC,GAAG,CAAC,UAAC,GAAG;wBAC/B,OAAA,oBAAE,CAAC,OAAO,CAAC,oBAAoB,CAC3B,oBAAE,CAAC,OAAO,CAAC,UAAU,EAAE,EACvB,oBAAE,CAAC,OAAO,CAAC,oBAAoB,CAC3B,oBAAE,CAAC,OAAO,CAAC,gBAAgB,CACvB,kBAAW,IAAA,yCAAmB,EAAC,IAAI,CAAC,CAAC,GAAG,CAAC,YAAS,CACrD,EACD,SAAS,EACT,CAAC,KAAK,CAAC,CACV,CACJ;oBATD,CASC,CACJ,CAAC;oBACF,UAAU,CAAC,IAAI,CACX,QAAQ,CAAC,MAAM,KAAK,CAAC;wBACjB,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAE;wBACd,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,UAAC,CAAC,EAAE,CAAC,IAAK,OAAA,oBAAE,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC,EAAE,CAAC,CAAC,EAAhC,CAAgC,CAAC,CACpE,CAAC;oBAGF,OAAO;wBACH,UAAU,EAAE,UAAU,CAAC,MAAM,CAAC,UAAC,CAAC,EAAE,CAAC;4BAC/B,OAAA,oBAAE,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC;wBAAjC,CAAiC,CACpC;wBACD,IAAI,yCACG,IAAA,qCAAiB,EAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,kBAC5C,IAAA,2BAAY,EAAC,QAAQ,CAAC,CAAC,QAAQ,CAAC,CAAC,SAAS,CAAC,CAAC,KAAK,CAAC,SACxD;qBACJ,CAAC;gBACN,CAAC;YAtCD,CAsCC;QAvCD,CAuCC;IAxCD,CAwCC;AAzCD,CAyCC,CAAC;AA3CO,QAAA,cAAc,kBA2CrB"}

package/lib/typings/Customizable.d.ts

@@ -1,5 +1,4 @@
 export type Customizable = {
-    boolean: boolean;
     number: number;
     string: string;
     bigint: bigint;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "3.7.0-dev.20230331",
+  "version": "3.7.0-dev.20230401",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",

package/src/programmers/AssertProgrammer.ts

@@ -30,6 +30,30 @@ export namespace AssertProgrammer {
                     trace: true,
                     numeric: OptionPredicator.numeric(project.options),
                     equals,
+                    atomist: (explore) => (tuple) => (input) =>
+                        [
+                            tuple.expression,
+                            ...tuple.tags.map((tag) =>
+                                ts.factory.createLogicalOr(
+                                    tag.expression,
+                                    create_guard_call(importer)(
+                                        explore.from === "top"
+                                            ? ts.factory.createTrue()
+                                            : ts.factory.createIdentifier(
+                                                  "_exceptionable",
+                                              ),
+                                    )(
+                                        ts.factory.createIdentifier(
+                                            explore.postfix
+                                                ? `_path + ${explore.postfix}`
+                                                : "_path",
+                                        ),
+                                        tag.expected,
+                                        input,
+                                    ),
+                                ),
+                            ),
+                        ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
                     combiner: combiner(equals)(importer),
                     joiner: joiner(equals)(importer),
                     success: ts.factory.createTrue(),

package/src/programmers/CheckerProgrammer.ts

@@ -16,6 +16,7 @@ import { IProject } from "../transformers/IProject";
 import { FeatureProgrammer } from "./FeatureProgrammer";
 import { AtomicPredicator } from "./helpers/AtomicPredicator";
 import { FunctionImporter } from "./helpers/FunctionImporeter";
+import { ICheckEntry } from "./helpers/ICheckEntry";
 import { IExpressionEntry } from "./helpers/IExpressionEntry";
 import { OptionPredicator } from "./helpers/OptionPredicator";
 import { UnionExplorer } from "./helpers/UnionExplorer";
@@ -39,6 +40,9 @@ export namespace CheckerProgrammer {
         numeric: boolean;
         combiner: IConfig.Combiner;
         decoder?: FeatureProgrammer.Decoder<Metadata, ts.Expression>;
+        atomist: (
+            explore: IExplore,
+        ) => (check: ICheckEntry) => (input: ts.Expression) => ts.Expression;
         joiner: IConfig.IJoiner;
         success: ts.Expression;
     }
@@ -318,28 +322,25 @@ export namespace CheckerProgrammer {
                 if (AtomicPredicator.atomic(meta)(type) === false) continue;
                 else if (type === "number")
                     binaries.push({
-                        expression: check_number(
-                            project,
-                            config.numeric,
-                        )(importer)(input, metaTags, jsDocTags),
+                        expression: config.atomist(explore)(
+                            check_number(project, config.numeric)(importer)(
+                                metaTags,
+                            )(jsDocTags)(input),
+                        )(input),
                         combined: false,
                     });
                 else if (type === "bigint")
                     binaries.push({
-                        expression: check_bigint(importer)(
-                            input,
-                            metaTags,
-                            jsDocTags,
-                        ),
+                        expression: config.atomist(explore)(
+                            check_bigint(importer)(metaTags)(jsDocTags)(input),
+                        )(input),
                         combined: false,
                     });
                 else if (type === "string")
                     binaries.push({
-                        expression: check_string(importer)(
-                            input,
-                            metaTags,
-                            jsDocTags,
-                        ),
+                        expression: config.atomist(explore)(
+                            check_string(importer)(metaTags)(jsDocTags)(input),
+                        )(input),
                         combined: false,
                     });
                 else
@@ -353,11 +354,11 @@ export namespace CheckerProgrammer {
             if (meta.templates.length)
                 if (AtomicPredicator.template(meta))
                     binaries.push({
-                        expression: check_template(importer)(
-                            input,
-                            meta.templates,
-                            metaTags,
-                        ),
+                        expression: config.atomist(explore)(
+                            check_template(importer)(metaTags)(jsDocTags)(
+                                meta.templates,
+                            )(input),
+                        )(input),
                         combined: false,
                     });
 
@@ -438,11 +439,11 @@ export namespace CheckerProgrammer {
             // ARRAYS AND TUPLES
             if (meta.tuples.length + meta.arrays.length > 0) {
                 const install = prepare(
-                    check_array(importer)(
-                        input,
-                        meta.tuples.length === 0 ? metaTags : [],
-                        jsDocTags,
-                    ),
+                    config.atomist(explore)(
+                        check_array(importer)(
+                            meta.tuples.length === 0 ? metaTags : [],
+                        )(jsDocTags)(input),
+                    )(input),
                     [...meta.tuples, ...meta.arrays]
                         .map((elem) =>
                             Array.isArray(elem)
@@ -832,28 +833,26 @@ export namespace CheckerProgrammer {
         importer: FunctionImporter,
     ) =>
         UnionExplorer.array_or_tuple({
-            checker: (front, target, explore, tags, jsDocTags, array) => {
-                if (Array.isArray(target))
-                    return check_union_tuple(project, config, importer)(
-                        front,
-                        target,
-                        explore,
-                        tags,
-                        jsDocTags,
-                        array,
-                    );
-                const condition = decode(project, config, importer)(
-                    front,
-                    target,
-                    explore,
-                    tags,
-                    jsDocTags,
-                );
-                const length = check_array_length(array, tags);
-                return length !== null
-                    ? ts.factory.createBitwiseAnd(condition, length)
-                    : condition;
-            },
+            checker: (front, target, explore, tags, jsDocTags, array) =>
+                Array.isArray(target)
+                    ? check_union_tuple(project, config, importer)(
+                          front,
+                          target,
+                          explore,
+                          tags,
+                          jsDocTags,
+                          array,
+                      )
+                    : config.atomist(explore)({
+                          expression: decode(project, config, importer)(
+                              front,
+                              target,
+                              explore,
+                              tags,
+                              jsDocTags,
+                          ),
+                          tags: check_array_length(tags)(array),
+                      })(array),
             decoder: (input, target, explore, tags, jsDocTags) =>
                 Array.isArray(target)
                     ? decode_tuple(project, config, importer, true)(

package/src/programmers/IsProgrammer.ts

@@ -27,6 +27,11 @@ export namespace IsProgrammer {
             numeric: OptionPredicator.numeric({
                 numeric: options?.numeric,
             }),
+            atomist: () => (entry) => () =>
+                [
+                    entry.expression,
+                    ...entry.tags.map((tag) => tag.expression),
+                ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
             combiner: () => (type: "and" | "or") => {
                 const initial: ts.TrueLiteral | ts.FalseLiteral =
                     type === "and"

package/src/programmers/ValidateProgrammer.ts

@@ -31,6 +31,30 @@ export namespace ValidateProgrammer {
                     trace: true,
                     numeric: OptionPredicator.numeric(project.options),
                     equals,
+                    atomist: (explore) => (tuple) => (input) =>
+                        [
+                            tuple.expression,
+                            ...tuple.tags.map((tag) =>
+                                ts.factory.createLogicalOr(
+                                    tag.expression,
+                                    create_report_call(
+                                        explore.from === "top"
+                                            ? ts.factory.createTrue()
+                                            : ts.factory.createIdentifier(
+                                                  "_exceptionable",
+                                              ),
+                                    )(
+                                        ts.factory.createIdentifier(
+                                            explore.postfix
+                                                ? `_path + ${explore.postfix}`
+                                                : "_path",
+                                        ),
+                                        tag.expected,
+                                        input,
+                                    ),
+                                ),
+                            ),
+                        ].reduce((x, y) => ts.factory.createLogicalAnd(x, y)),
                     combiner: combine(equals)(importer),
                     joiner: joiner(equals)(importer),
                     success: ts.factory.createTrue(),

package/src/programmers/helpers/ICheckEntry.ts

@@ -0,0 +1,12 @@
+import ts from "typescript";
+
+export interface ICheckEntry {
+    expression: ts.Expression;
+    tags: ICheckEntry.ITag[];
+}
+export namespace ICheckEntry {
+    export interface ITag {
+        expected: string;
+        expression: ts.Expression;
+    }
+}

package/src/programmers/internal/check_array.ts

@@ -6,6 +6,7 @@ import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 
 import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { ICheckEntry } from "../helpers/ICheckEntry";
 import { check_array_length } from "./check_array_length";
 import { check_custom } from "./check_custom";
 
@@ -14,18 +15,12 @@ import { check_custom } from "./check_custom";
  */
 export const check_array =
     (importer: FunctionImporter) =>
-    (
-        input: ts.Expression,
-        metaTags: IMetadataTag[],
-        jsDocTags: IJsDocTagInfo[],
-    ): ts.Expression => {
-        const conditions: ts.Expression[] = [ExpressionFactory.isArray(input)];
-
-        const length: ts.Expression | null = check_array_length(
-            input,
-            metaTags,
-        );
-        if (length !== null) conditions.push(length);
-        conditions.push(...check_custom("array")(importer)(input, jsDocTags));
-        return conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
-    };
+    (metaTags: IMetadataTag[]) =>
+    (jsDocTags: IJsDocTagInfo[]) =>
+    (input: ts.Expression): ICheckEntry => ({
+        expression: ExpressionFactory.isArray(input),
+        tags: [
+            ...check_array_length(metaTags)(input),
+            ...check_custom("array", "Array")(importer)(jsDocTags)(input),
+        ],
+    });

package/src/programmers/internal/check_array_length.ts

@@ -4,41 +4,37 @@ import { IdentifierFactory } from "../../factories/IdentifierFactory";
 
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 
+import { ICheckEntry } from "../helpers/ICheckEntry";
+
 /**
  * @internal
  */
-export function check_array_length(
-    input: ts.Expression,
-    tagList: IMetadataTag[],
-): ts.Expression | null {
-    const conditions: ts.Expression[] = [];
-
-    // CHECK TAGS
-    for (const tag of tagList)
-        if (tag.kind === "items")
-            conditions.push(
-                ts.factory.createStrictEquality(
-                    ts.factory.createNumericLiteral(tag.value),
-                    IdentifierFactory.join(input, "length"),
-                ),
-            );
-        else if (tag.kind === "minItems")
-            conditions.push(
-                ts.factory.createLessThanEquals(
-                    ts.factory.createNumericLiteral(tag.value),
-                    IdentifierFactory.join(input, "length"),
-                ),
-            );
-        else if (tag.kind === "maxItems")
-            conditions.push(
-                ts.factory.createGreaterThanEquals(
-                    ts.factory.createNumericLiteral(tag.value),
-                    IdentifierFactory.join(input, "length"),
-                ),
-            );
-
-    // COMBINATION
-    return conditions.length
-        ? conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y))
-        : null;
-}
+export const check_array_length =
+    (tagList: IMetadataTag[]) =>
+    (input: ts.Expression): ICheckEntry.ITag[] =>
+        tagList
+            .map((tag) => ({
+                tag,
+                expression:
+                    tag.kind === "items"
+                        ? ts.factory.createStrictEquality(
+                              ts.factory.createNumericLiteral(tag.value),
+                              IdentifierFactory.join(input, "length"),
+                          )
+                        : tag.kind === "minItems"
+                        ? ts.factory.createLessThanEquals(
+                              ts.factory.createNumericLiteral(tag.value),
+                              IdentifierFactory.join(input, "length"),
+                          )
+                        : tag.kind === "maxItems"
+                        ? ts.factory.createGreaterThanEquals(
+                              ts.factory.createNumericLiteral(tag.value),
+                              IdentifierFactory.join(input, "length"),
+                          )
+                        : null!,
+            }))
+            .filter((tuple) => tuple.expression !== null)
+            .map(({ tag, expression }) => ({
+                expected: `Array.length (@${tag.kind} ${tag.value})`,
+                expression,
+            }));

package/src/programmers/internal/check_bigint.ts

@@ -4,81 +4,79 @@ import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 
 import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { ICheckEntry } from "../helpers/ICheckEntry";
 import { check_custom } from "./check_custom";
 
+/**
+ * @internal
+ */
 export const check_bigint =
     (importer: FunctionImporter) =>
-    (
-        input: ts.Expression,
-        metaTags: IMetadataTag[],
-        jsDocTags: IJsDocTagInfo[],
-    ): ts.Expression => {
-        const caster = (value: number) =>
-            ts.factory.createIdentifier(`${Math.floor(value)}n`);
-
-        // TYPEOF STATEMENT
-        const conditions: ts.Expression[] = [
-            ts.factory.createStrictEquality(
-                ts.factory.createStringLiteral("bigint"),
-                ts.factory.createTypeOfExpression(input),
-            ),
-        ];
-
-        // TAG (RANGE)
-        for (const tag of metaTags)
+    (metaTags: IMetadataTag[]) =>
+    (jsDocTag: IJsDocTagInfo[]) =>
+    (input: ts.Expression): ICheckEntry => {
+        const entries: [IMetadataTag, ts.Expression][] = [];
+        for (const tag of metaTags) {
             if (tag.kind === "multipleOf")
-                conditions.push(
+                entries.push([
+                    tag,
                     ts.factory.createStrictEquality(
-                        caster(0),
-                        ts.factory.createModulo(input, caster(tag.value)),
+                        cast(0),
+                        ts.factory.createModulo(input, cast(tag.value)),
                     ),
-                );
+                ]);
             else if (tag.kind === "step") {
-                const modulo = () =>
-                    ts.factory.createModulo(input, caster(tag.value));
-                const minimum = (() => {
-                    for (const tag of metaTags)
-                        if (tag.kind === "minimum") return tag.value;
-                        else if (tag.kind === "exclusiveMinimum")
-                            return tag.value;
-                    return undefined;
-                })();
-                conditions.push(
+                const modulo = ts.factory.createModulo(input, cast(tag.value));
+                const minimum =
+                    (metaTags.find(
+                        (tag) =>
+                            tag.kind === "minimum" ||
+                            tag.kind === "exclusiveMinimum",
+                    )?.value as number | undefined) ?? undefined;
+                entries.push([
+                    tag,
                     ts.factory.createStrictEquality(
-                        caster(0),
+                        cast(0),
                         minimum !== undefined
-                            ? ts.factory.createSubtract(
-                                  modulo(),
-                                  caster(minimum),
-                              )
-                            : modulo(),
+                            ? ts.factory.createSubtract(modulo, cast(minimum))
+                            : modulo,
                     ),
-                );
+                ]);
             } else if (tag.kind === "minimum")
-                conditions.push(
-                    ts.factory.createLessThanEquals(caster(tag.value), input),
-                );
+                entries.push([
+                    tag,
+                    ts.factory.createLessThanEquals(cast(tag.value), input),
+                ]);
             else if (tag.kind === "maximum")
-                conditions.push(
-                    ts.factory.createGreaterThanEquals(
-                        caster(tag.value),
-                        input,
-                    ),
-                );
+                entries.push([
+                    tag,
+                    ts.factory.createGreaterThanEquals(cast(tag.value), input),
+                ]);
             else if (tag.kind === "exclusiveMinimum")
-                conditions.push(
-                    ts.factory.createLessThan(caster(tag.value), input),
-                );
+                entries.push([
+                    tag,
+                    ts.factory.createLessThan(cast(tag.value), input),
+                ]);
             else if (tag.kind === "exclusiveMaximum")
-                conditions.push(
-                    ts.factory.createGreaterThan(caster(tag.value), input),
-                );
-
-        // CUSTOM TAGS
-        conditions.push(...check_custom("bigint")(importer)(input, jsDocTags));
-
-        // COMBINATION
-        return conditions.length === 1
-            ? conditions[0]!
-            : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+                entries.push([
+                    tag,
+                    ts.factory.createGreaterThan(cast(tag.value), input),
+                ]);
+        }
+        return {
+            expression: ts.factory.createStrictEquality(
+                ts.factory.createStringLiteral("bigint"),
+                ts.factory.createTypeOfExpression(input),
+            ),
+            tags: [
+                ...entries.map(([tag, expression]) => ({
+                    expected: `bigint (@${tag.kind} ${tag.value})`,
+                    expression,
+                })),
+                ...check_custom("bigint")(importer)(jsDocTag)(input),
+            ],
+        };
     };
+
+const cast = (value: number) =>
+    ts.factory.createIdentifier(`${Math.floor(value)}n`);

package/src/programmers/internal/check_custom.ts

@@ -5,28 +5,37 @@ import { MetadataTagFactory } from "../../factories/MetadataTagFactory";
 import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
 
 import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { ICheckEntry } from "../helpers/ICheckEntry";
 
 export const check_custom =
-    (type: string) =>
+    (type: string, alias?: string) =>
     (importer: FunctionImporter) =>
-    (input: ts.Expression, jsDocTags: IJsDocTagInfo[]) =>
+    (jsDocTags: IJsDocTagInfo[]) =>
+    (input: ts.Expression): ICheckEntry.ITag[] =>
         jsDocTags
             .filter(
                 (tag) =>
                     tag.name !== "random" &&
+                    (!tag.text?.length ||
+                        (tag.text?.length === 1 &&
+                            tag.text?.[0]?.kind === "text")) &&
                     MetadataTagFactory._PARSER[tag.name] === undefined,
             )
-            .map((tag) =>
-                ts.factory.createCallExpression(
-                    importer.use("is_custom"),
-                    undefined,
-                    [
-                        ts.factory.createStringLiteral(tag.name),
-                        ts.factory.createStringLiteral(type),
-                        ts.factory.createStringLiteral(
-                            tag.text?.[0]?.text ?? "",
-                        ),
-                        input,
-                    ],
-                ),
-            );
+            .map((tag) => {
+                const text: string | undefined = tag.text?.[0]?.text ?? "";
+                return {
+                    expected: `${alias ?? type} (@${tag.name}${
+                        text.length ? ` ${text}` : ""
+                    })`,
+                    expression: ts.factory.createCallExpression(
+                        importer.use("is_custom"),
+                        undefined,
+                        [
+                            ts.factory.createStringLiteral(tag.name),
+                            ts.factory.createStringLiteral(type),
+                            ts.factory.createStringLiteral(text),
+                            input,
+                        ],
+                    ),
+                };
+            });