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

package/src/programmers/internal/check_number.ts

@@ -1,10 +1,12 @@
 import ts from "typescript";
 
+import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 
 import { IProject } from "../../transformers/IProject";
 
 import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { ICheckEntry } from "../helpers/ICheckEntry";
 import { OptionPredicator } from "../helpers/OptionPredicator";
 import { check_custom } from "./check_custom";
 
@@ -12,60 +14,16 @@ import { check_custom } from "./check_custom";
  * @internal
  */
 export const check_number =
-    ({ options }: IProject, numeric: boolean) =>
+    (project: IProject, numeric: boolean) =>
     (importer: FunctionImporter) =>
-    (
-        input: ts.Expression,
-        metaTags: IMetadataTag[],
-        jsDocTags: ts.JSDocTagInfo[],
-    ) => {
-        // TYPEOF STATEMENT
-        const conditions: ts.Expression[] = [
-            ts.factory.createStrictEquality(
-                ts.factory.createStringLiteral("number"),
-                ts.factory.createTypeOfExpression(input),
-            ),
-        ];
-
-        // CHECK FINITE AND NAN
-        const finite: boolean =
-            (!!metaTags.find(
-                (tag) =>
-                    tag.kind === "minimum" || tag.kind === "exclusiveMinimum",
-            ) &&
-                !!metaTags.find(
-                    (tag) =>
-                        tag.kind === "maximum" ||
-                        tag.kind === "exclusiveMaximum",
-                )) ||
-            !!metaTags.find(
-                (tag) => tag.kind === "step" || tag.kind === "multipleOf",
-            );
-
-        if (numeric === true && finite === false)
-            if (OptionPredicator.finite(options))
-                conditions.push(
-                    ts.factory.createCallExpression(
-                        ts.factory.createIdentifier("Number.isFinite"),
-                        undefined,
-                        [input],
-                    ),
-                );
-            else if (OptionPredicator.numeric(options))
-                conditions.push(
-                    ts.factory.createLogicalNot(
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("Number.isNaN"),
-                            undefined,
-                            [input],
-                        ),
-                    ),
-                );
-
-        // TAG (RANGE)
+    (metaTags: IMetadataTag[]) =>
+    (jsDocTag: IJsDocTagInfo[]) =>
+    (input: ts.Expression): ICheckEntry => {
+        const entries: [IMetadataTag, ts.Expression][] = [];
         for (const tag of metaTags)
             if (tag.kind === "type") {
-                conditions.push(
+                entries.push([
+                    tag,
                     ts.factory.createStrictEquality(
                         ts.factory.createCallExpression(
                             ts.factory.createIdentifier("parseInt"),
@@ -74,16 +32,18 @@ export const check_number =
                         ),
                         input,
                     ),
-                );
+                ]);
                 if (tag.value === "uint")
-                    conditions.push(
+                    entries.push([
+                        tag,
                         ts.factory.createLessThanEquals(
                             ts.factory.createNumericLiteral(0),
                             input,
                         ),
-                    );
+                    ]);
             } else if (tag.kind === "multipleOf")
-                conditions.push(
+                entries.push([
+                    tag,
                     ts.factory.createStrictEquality(
                         ts.factory.createNumericLiteral(0),
                         ts.factory.createModulo(
@@ -91,64 +51,123 @@ export const check_number =
                             ts.factory.createNumericLiteral(tag.value),
                         ),
                     ),
-                );
+                ]);
             else if (tag.kind === "step") {
-                const modulo = () =>
-                    ts.factory.createModulo(
-                        input,
-                        ts.factory.createNumericLiteral(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,
+                    ts.factory.createNumericLiteral(tag.value),
+                );
+                const minimum =
+                    (metaTags.find(
+                        (tag) =>
+                            tag.kind === "minimum" ||
+                            tag.kind === "exclusiveMinimum",
+                    )?.value as number | undefined) ?? undefined;
+                entries.push([
+                    tag,
                     ts.factory.createStrictEquality(
                         ts.factory.createNumericLiteral(0),
                         minimum !== undefined
                             ? ts.factory.createSubtract(
-                                  modulo(),
+                                  modulo,
                                   ts.factory.createNumericLiteral(minimum),
                               )
-                            : modulo(),
+                            : modulo,
                     ),
-                );
+                ]);
             } else if (tag.kind === "minimum")
-                conditions.push(
+                entries.push([
+                    tag,
                     ts.factory.createLessThanEquals(
                         ts.factory.createNumericLiteral(tag.value),
                         input,
                     ),
-                );
+                ]);
             else if (tag.kind === "maximum")
-                conditions.push(
+                entries.push([
+                    tag,
                     ts.factory.createGreaterThanEquals(
                         ts.factory.createNumericLiteral(tag.value),
                         input,
                     ),
-                );
+                ]);
             else if (tag.kind === "exclusiveMinimum")
-                conditions.push(
+                entries.push([
+                    tag,
                     ts.factory.createLessThan(
                         ts.factory.createNumericLiteral(tag.value),
                         input,
                     ),
-                );
+                ]);
             else if (tag.kind === "exclusiveMaximum")
-                conditions.push(
+                entries.push([
+                    tag,
                     ts.factory.createGreaterThan(
                         ts.factory.createNumericLiteral(tag.value),
                         input,
                     ),
-                );
+                ]);
+
+        return {
+            expression: is_number(project, numeric)(metaTags)(input),
+            tags: [
+                ...entries.map(([tag, expression]) => ({
+                    expected: `number (@${tag.kind} ${tag.value})`,
+                    expression,
+                })),
+                ...check_custom("number")(importer)(jsDocTag)(input),
+            ],
+        };
+    };
 
-        // CUSTOM TAGS
-        conditions.push(...check_custom("number")(importer)(input, jsDocTags));
+const is_number =
+    ({ options }: IProject, numeric: boolean) =>
+    (metaTags: IMetadataTag[]) =>
+    (input: ts.Expression) => {
+        // TYPEOF STATEMENT
+        const conditions: ts.Expression[] = [
+            ts.factory.createStrictEquality(
+                ts.factory.createStringLiteral("number"),
+                ts.factory.createTypeOfExpression(input),
+            ),
+        ];
+
+        // CHECK FINITE AND NAN
+        const finite: boolean =
+            (!!metaTags.find(
+                (tag) =>
+                    tag.kind === "minimum" || tag.kind === "exclusiveMinimum",
+            ) &&
+                !!metaTags.find(
+                    (tag) =>
+                        tag.kind === "maximum" ||
+                        tag.kind === "exclusiveMaximum",
+                )) ||
+            !!metaTags.find(
+                (tag) => tag.kind === "step" || tag.kind === "multipleOf",
+            );
+
+        if (numeric === true && finite === false)
+            if (OptionPredicator.finite(options))
+                conditions.push(
+                    ts.factory.createCallExpression(
+                        ts.factory.createIdentifier("Number.isFinite"),
+                        undefined,
+                        [input],
+                    ),
+                );
+            else if (OptionPredicator.numeric(options))
+                conditions.push(
+                    ts.factory.createLogicalNot(
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("Number.isNaN"),
+                            undefined,
+                            [input],
+                        ),
+                    ),
+                );
 
-        // COMBINATION
+        // COMBINATE
         return conditions.length === 1
             ? conditions[0]!
             : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));

package/src/programmers/internal/check_string.ts

@@ -9,22 +9,17 @@ import { check_string_tags } from "./check_string_tags";
 /**
  * @internal
  */
-export function check_string(importer: FunctionImporter) {
-    return function (
-        input: ts.Expression,
-        metaTags: IMetadataTag[],
-        jsDocTags: ts.JSDocTagInfo[],
-    ) {
-        const conditions: ts.Expression[] = [
-            ts.factory.createStrictEquality(
-                ts.factory.createStringLiteral("string"),
-                ts.factory.createTypeOfExpression(input),
-            ),
-            ...check_string_tags(importer)(input, metaTags),
-            ...check_custom("string")(importer)(input, jsDocTags),
-        ];
-        return conditions.length === 1
-            ? conditions[0]!
-            : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
-    };
-}
+export const check_string =
+    (importer: FunctionImporter) =>
+    (metaTags: IMetadataTag[]) =>
+    (jsDocTags: ts.JSDocTagInfo[]) =>
+    (input: ts.Expression) => ({
+        expression: ts.factory.createStrictEquality(
+            ts.factory.createStringLiteral("string"),
+            ts.factory.createTypeOfExpression(input),
+        ),
+        tags: [
+            ...check_string_tags(importer)(metaTags)(input),
+            ...check_custom("string")(importer)(jsDocTags)(input),
+        ],
+    });

package/src/programmers/internal/check_string_tags.ts

@@ -5,17 +5,20 @@ import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 
 import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { ICheckEntry } from "../helpers/ICheckEntry";
 
 /**
  * @internal
  */
 export const check_string_tags =
     (importer: FunctionImporter) =>
-    (input: ts.Expression, tagList: IMetadataTag[]) => {
-        const conditions: ts.Expression[] = [];
+    (tagList: IMetadataTag[]) =>
+    (input: ts.Expression): ICheckEntry.ITag[] => {
+        const conditions: [IMetadataTag, ts.Expression][] = [];
         for (const tag of tagList)
             if (tag.kind === "format")
-                conditions.push(
+                conditions.push([
+                    tag,
                     ts.factory.createStrictEquality(
                         ts.factory.createTrue(),
                         ts.factory.createCallExpression(
@@ -24,9 +27,10 @@ export const check_string_tags =
                             [input],
                         ),
                     ),
-                );
+                ]);
             else if (tag.kind === "pattern")
-                conditions.push(
+                conditions.push([
+                    tag,
                     ts.factory.createStrictEquality(
                         ts.factory.createTrue(),
                         ts.factory.createCallExpression(
@@ -37,27 +41,33 @@ export const check_string_tags =
                             [input],
                         ),
                     ),
-                );
+                ]);
             else if (tag.kind === "length")
-                conditions.push(
+                conditions.push([
+                    tag,
                     ts.factory.createStrictEquality(
                         ts.factory.createNumericLiteral(tag.value),
                         IdentifierFactory.join(input, "length"),
                     ),
-                );
+                ]);
             else if (tag.kind === "minLength")
-                conditions.push(
+                conditions.push([
+                    tag,
                     ts.factory.createLessThanEquals(
                         ts.factory.createNumericLiteral(tag.value),
                         IdentifierFactory.join(input, "length"),
                     ),
-                );
+                ]);
             else if (tag.kind === "maxLength")
-                conditions.push(
+                conditions.push([
+                    tag,
                     ts.factory.createGreaterThanEquals(
                         ts.factory.createNumericLiteral(tag.value),
                         IdentifierFactory.join(input, "length"),
                     ),
-                );
-        return conditions;
+                ]);
+        return conditions.map(([tag, expression]) => ({
+            expected: `string (@${tag.kind} ${tag.value})`,
+            expression,
+        }));
     };

package/src/programmers/internal/check_template.ts

@@ -1,9 +1,12 @@
 import ts from "typescript";
 
+import { IJsDocTagInfo } from "../../metadata/IJsDocTagInfo";
 import { IMetadataTag } from "../../metadata/IMetadataTag";
 import { Metadata } from "../../metadata/Metadata";
 
 import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { ICheckEntry } from "../helpers/ICheckEntry";
+import { check_custom } from "./check_custom";
 import { check_string_tags } from "./check_string_tags";
 import { template_to_pattern } from "./template_to_pattern";
 
@@ -12,18 +15,16 @@ import { template_to_pattern } from "./template_to_pattern";
  */
 export const check_template =
     (importer: FunctionImporter) =>
-    (
-        input: ts.Expression,
-        templates: Metadata[][],
-        tagList: IMetadataTag[],
-    ) => {
+    (metaTags: IMetadataTag[]) =>
+    (jsDocTags: IJsDocTagInfo[]) =>
+    (templates: Metadata[][]) =>
+    (input: ts.Expression): ICheckEntry => {
         // TYPEOF STRING & TAGS
         const conditions: ts.Expression[] = [
             ts.factory.createStrictEquality(
                 ts.factory.createStringLiteral("string"),
                 ts.factory.createTypeOfExpression(input),
             ),
-            ...check_string_tags(importer)(input, tagList),
         ];
 
         // TEMPLATES
@@ -46,5 +47,13 @@ export const check_template =
         );
 
         // COMBINATION
-        return conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+        return {
+            expression: conditions.reduce((x, y) =>
+                ts.factory.createLogicalAnd(x, y),
+            ),
+            tags: [
+                ...check_string_tags(importer)(metaTags)(input),
+                ...check_custom("string")(importer)(jsDocTags)(input),
+            ],
+        };
     };

package/src/typings/Customizable.ts

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