typia 5.0.0-dev.20230823 → 5.0.0-dev.20230824

package/src/programmers/internal/check_number.ts

@@ -1,38 +1,36 @@
 import ts from "typescript";
 
-import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+
+import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
 
 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";
 
 /**
  * @internal
  */
 export const check_number =
     (project: IProject, numeric: boolean) =>
-    (importer: FunctionImporter) =>
-    (metaTags: IMetadataTag[]) =>
-    (jsDocTag: IJsDocTagInfo[]) =>
+    (matrix: IMetadataTypeTag[][], metaTags: IMetadataCommentTag[]) =>
     (input: ts.Expression): ICheckEntry => {
-        const entries: [IMetadataTag, ts.Expression][] = [];
-        for (const tag of metaTags)
-            if (tag.kind === "type") {
+        const entries: [IMetadataCommentTag, ts.Expression][] = [];
+        for (const mt of metaTags)
+            if (mt.kind === "type") {
                 // MUST BE INTEGER
                 if (
-                    tag.value === "int" ||
-                    tag.value === "uint" ||
-                    tag.value === "int32" ||
-                    tag.value === "uint32" ||
-                    tag.value === "int64" ||
-                    tag.value === "uint64"
+                    mt.value === "int" ||
+                    mt.value === "uint" ||
+                    mt.value === "int32" ||
+                    mt.value === "uint32" ||
+                    mt.value === "int64" ||
+                    mt.value === "uint64"
                 )
                     entries.push([
-                        tag,
+                        mt,
                         ts.factory.createStrictEquality(
                             ts.factory.createCallExpression(
                                 ts.factory.createIdentifier("Math.floor"),
@@ -44,29 +42,29 @@ export const check_number =
                     ]);
                 // GREATER THAN OR EQUAL TO ZERO
                 if (
-                    tag.value === "uint" ||
-                    tag.value === "uint32" ||
-                    tag.value === "uint64"
+                    mt.value === "uint" ||
+                    mt.value === "uint32" ||
+                    mt.value === "uint64"
                 )
                     entries.push([
-                        tag,
+                        mt,
                         ts.factory.createLessThanEquals(
                             ts.factory.createNumericLiteral(0),
                             input,
                         ),
                     ]);
                 // RANGE LIMIT
-                if (tag.value === "uint" || tag.value === "uint32")
+                if (mt.value === "uint" || mt.value === "uint32")
                     entries.push([
-                        tag,
+                        mt,
                         ts.factory.createLessThanEquals(
                             input,
                             ts.factory.createNumericLiteral(4294967295),
                         ),
                     ]);
-                else if (tag.value === "uint64")
+                else if (mt.value === "uint64")
                     entries.push([
-                        tag,
+                        mt,
                         ts.factory.createLessThanEquals(
                             input,
                             ts.factory.createNumericLiteral(
@@ -74,9 +72,9 @@ export const check_number =
                             ),
                         ),
                     ]);
-                else if (tag.value === "int64")
+                else if (mt.value === "int64")
                     entries.push([
-                        tag,
+                        mt,
                         ts.factory.createLogicalAnd(
                             ts.factory.createLessThanEquals(
                                 ts.factory.createNumericLiteral(
@@ -92,9 +90,9 @@ export const check_number =
                             ),
                         ),
                     ]);
-                else if (tag.value === "int" || tag.value === "int32")
+                else if (mt.value === "int" || mt.value === "int32")
                     entries.push([
-                        tag,
+                        mt,
                         ts.factory.createLogicalAnd(
                             ts.factory.createLessThanEquals(
                                 ts.factory.createNumericLiteral(-2147483648),
@@ -106,9 +104,9 @@ export const check_number =
                             ),
                         ),
                     ]);
-                else if (tag.value === "float")
+                else if (mt.value === "float")
                     entries.push([
-                        tag,
+                        mt,
                         ts.factory.createLogicalAnd(
                             ts.factory.createLessThanEquals(
                                 ts.factory.createNumericLiteral(
@@ -122,21 +120,21 @@ export const check_number =
                             ),
                         ),
                     ]);
-            } else if (tag.kind === "multipleOf")
+            } else if (mt.kind === "multipleOf")
                 entries.push([
-                    tag,
+                    mt,
                     ts.factory.createStrictEquality(
                         ts.factory.createNumericLiteral(0),
                         ts.factory.createModulo(
                             input,
-                            ts.factory.createNumericLiteral(tag.value),
+                            ts.factory.createNumericLiteral(mt.value),
                         ),
                     ),
                 ]);
-            else if (tag.kind === "step") {
+            else if (mt.kind === "step") {
                 const modulo = ts.factory.createModulo(
                     input,
-                    ts.factory.createNumericLiteral(tag.value),
+                    ts.factory.createNumericLiteral(mt.value),
                 );
                 const minimum =
                     (metaTags.find(
@@ -145,7 +143,7 @@ export const check_number =
                             tag.kind === "exclusiveMinimum",
                     )?.value as number | undefined) ?? undefined;
                 entries.push([
-                    tag,
+                    mt,
                     ts.factory.createStrictEquality(
                         ts.factory.createNumericLiteral(0),
                         minimum !== undefined
@@ -156,48 +154,47 @@ export const check_number =
                             : modulo,
                     ),
                 ]);
-            } else if (tag.kind === "minimum")
+            } else if (mt.kind === "minimum")
                 entries.push([
-                    tag,
+                    mt,
                     ts.factory.createLessThanEquals(
-                        ts.factory.createNumericLiteral(tag.value),
+                        ts.factory.createNumericLiteral(mt.value),
                         input,
                     ),
                 ]);
-            else if (tag.kind === "maximum")
+            else if (mt.kind === "maximum")
                 entries.push([
-                    tag,
+                    mt,
                     ts.factory.createGreaterThanEquals(
-                        ts.factory.createNumericLiteral(tag.value),
+                        ts.factory.createNumericLiteral(mt.value),
                         input,
                     ),
                 ]);
-            else if (tag.kind === "exclusiveMinimum")
+            else if (mt.kind === "exclusiveMinimum")
                 entries.push([
-                    tag,
+                    mt,
                     ts.factory.createLessThan(
-                        ts.factory.createNumericLiteral(tag.value),
+                        ts.factory.createNumericLiteral(mt.value),
                         input,
                     ),
                 ]);
-            else if (tag.kind === "exclusiveMaximum")
+            else if (mt.kind === "exclusiveMaximum")
                 entries.push([
-                    tag,
+                    mt,
                     ts.factory.createGreaterThan(
-                        ts.factory.createNumericLiteral(tag.value),
+                        ts.factory.createNumericLiteral(mt.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),
-            ],
+            expression: is_number(project, numeric)(matrix, metaTags)(input),
+            tags: matrix.length
+                ? []
+                : entries.map(([tag, expression]) => ({
+                      expected: `number (@${tag.kind} ${tag.value})`,
+                      expression,
+                  })),
         };
     };
 
@@ -205,8 +202,8 @@ export const check_number =
  * @internal
  */
 const is_number =
-    ({ options }: IProject, numeric: boolean) =>
-    (metaTags: IMetadataTag[]) =>
+    (project: IProject, numeric: boolean) =>
+    (matrix: IMetadataTypeTag[][], metaTags: IMetadataCommentTag[]) =>
     (input: ts.Expression) => {
         // TYPEOF STATEMENT
         const conditions: ts.Expression[] = [
@@ -217,22 +214,33 @@ const is_number =
         ];
 
         // CHECK FINITE AND NAN
-        const finite: boolean =
-            (!!metaTags.find(
+        const ranged: 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",
+                (tag) =>
+                    tag.kind === "maximum" || tag.kind === "exclusiveMaximum",
+            ) &&
+            !!metaTags.find((tag) => tag.kind === "type") &&
+            !matrix.every((row) => row.some((tag) => tag.kind === "type")) &&
+            !matrix.every(
+                (row) =>
+                    row.some(
+                        (tag) =>
+                            tag.kind === "minimum" ||
+                            tag.kind === "exclusiveMinimum",
+                    ) &&
+                    row.some(
+                        (tag) =>
+                            tag.kind === "maximum" ||
+                            tag.kind === "exclusiveMaximum",
+                    ),
             );
 
-        if (numeric === true && finite === false)
-            if (OptionPredicator.finite(options))
+        if (numeric === true && ranged === false)
+            if (OptionPredicator.finite(project.options))
                 conditions.push(
                     ts.factory.createCallExpression(
                         ts.factory.createIdentifier("Number.isFinite"),
@@ -240,7 +248,10 @@ const is_number =
                         [input],
                     ),
                 );
-            else if (OptionPredicator.numeric(options))
+            else if (
+                OptionPredicator.numeric(project.options) &&
+                ranged === false
+            )
                 conditions.push(
                     ts.factory.createLogicalNot(
                         ts.factory.createCallExpression(
@@ -251,6 +262,22 @@ const is_number =
                     ),
                 );
 
+        // ADJUST TYPED TAGS
+        if (matrix.length) {
+            const logic: ts.Expression = matrix
+                .map((row) =>
+                    row
+                        .map((tag) =>
+                            ExpressionFactory.transpile(project.context)(
+                                tag.validate,
+                            )(input),
+                        )
+                        .reduce((a, b) => ts.factory.createLogicalAnd(a, b)),
+                )
+                .reduce((a, b) => ts.factory.createLogicalOr(a, b));
+            conditions.push(logic);
+        }
+
         // COMBINATE
         return conditions.length === 1
             ? conditions[0]!

package/src/programmers/internal/check_string.ts

@@ -1,25 +1,56 @@
 import ts from "typescript";
 
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+
+import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+
+import { IProject } from "../../transformers/IProject";
 
 import { FunctionImporter } from "../helpers/FunctionImporeter";
-import { check_custom } from "./check_custom";
 import { check_string_tags } from "./check_string_tags";
 
 /**
  * @internal
  */
 export const check_string =
+    (project: IProject) =>
     (importer: FunctionImporter) =>
-    (metaTags: IMetadataTag[]) =>
-    (jsDocTags: ts.JSDocTagInfo[]) =>
+    (tags: IMetadataTypeTag[][], metaTags: IMetadataCommentTag[]) =>
     (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),
-        ],
+        expression: is_string(project)(tags)(input),
+        tags: [...check_string_tags(importer)(metaTags)(input)],
     });
+
+const is_string =
+    (project: IProject) =>
+    (matrix: IMetadataTypeTag[][]) =>
+    (input: ts.Expression) => {
+        // BASIC TYPEOF EXPRESSION
+        const conditions: ts.Expression[] = [
+            ts.factory.createStrictEquality(
+                ts.factory.createStringLiteral("string"),
+                ts.factory.createTypeOfExpression(input),
+            ),
+        ];
+
+        // ADJUST TYPED TAGS
+        if (matrix.length) {
+            const logic: ts.Expression = matrix
+                .map((row) =>
+                    row
+                        .map((tag) =>
+                            ExpressionFactory.transpile(project.context)(
+                                tag.validate,
+                            )(input),
+                        )
+                        .reduce((a, b) => ts.factory.createLogicalAnd(a, b)),
+                )
+                .reduce((a, b) => ts.factory.createLogicalOr(a, b));
+            conditions.push(logic);
+        }
+
+        return conditions.length === 1
+            ? conditions[0]!
+            : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+    };

package/src/programmers/internal/check_string_tags.ts

@@ -2,7 +2,7 @@ import ts from "typescript";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
+import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
 
 import { FunctionImporter } from "../helpers/FunctionImporeter";
 import { ICheckEntry } from "../helpers/ICheckEntry";
@@ -12,9 +12,9 @@ import { ICheckEntry } from "../helpers/ICheckEntry";
  */
 export const check_string_tags =
     (importer: FunctionImporter) =>
-    (tagList: IMetadataTag[]) =>
+    (tagList: IMetadataCommentTag[]) =>
     (input: ts.Expression): ICheckEntry.ITag[] => {
-        const conditions: [IMetadataTag, ts.Expression][] = [];
+        const conditions: [IMetadataCommentTag, ts.Expression][] = [];
         for (const tag of tagList)
             if (tag.kind === "format")
                 conditions.push([

package/src/programmers/internal/check_template.ts

@@ -1,22 +1,14 @@
 import ts from "typescript";
 
-import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
 import { Metadata } from "../../schemas/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";
 
 /**
  * @internal
  */
 export const check_template =
-    (importer: FunctionImporter) =>
-    (metaTags: IMetadataTag[]) =>
-    (jsDocTags: IJsDocTagInfo[]) =>
     (templates: Metadata[][]) =>
     (input: ts.Expression): ICheckEntry => {
         // TYPEOF STRING & TAGS
@@ -48,9 +40,6 @@ export const check_template =
             expression: conditions.reduce((x, y) =>
                 ts.factory.createLogicalAnd(x, y),
             ),
-            tags: [
-                ...check_string_tags(importer)(metaTags)(input),
-                ...check_custom("string")(importer)(jsDocTags)(input),
-            ],
+            tags: [],
         };
     };

package/src/programmers/internal/check_union_array_like.ts

@@ -4,8 +4,9 @@ import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
+import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 
 import { CheckerProgrammer } from "../CheckerProgrammer";
@@ -25,7 +26,7 @@ export const check_union_array_like =
         input: ts.Expression,
         origins: Origin[],
         explore: FeatureProgrammer.IExplore,
-        tags: IMetadataTag[],
+        tags: IMetadataCommentTag[],
         jsDocTags: ts.JSDocTagInfo[],
     ): ts.ArrowFunction => {
         // ONLY ONE TYPE
@@ -66,7 +67,7 @@ export const check_union_array_like =
                         [
                             IdentifierFactory.parameter(
                                 "top",
-                                meta instanceof MetadataArray
+                                meta instanceof MetadataArrayType
                                     ? TypeFactory.keyword("any")
                                     : ts.factory.createTypeReferenceNode(
                                           "any[]",
@@ -82,7 +83,7 @@ export const check_union_array_like =
                                 ...explore,
                                 tracable: false,
                                 postfix:
-                                    meta instanceof MetadataArray
+                                    meta instanceof MetadataArrayType
                                         ? `"[0]"`
                                         : "",
                             },
@@ -300,7 +301,7 @@ export namespace check_union_array_like {
             front: ts.Expression,
             target: Element,
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
             jsDocTags: ts.JSDocTagInfo[],
             container: ts.Expression,
         ): ts.Expression;

package/src/programmers/internal/metadata_to_pattern.ts

@@ -11,7 +11,7 @@ import { template_to_pattern } from "./template_to_pattern";
 export const metadata_to_pattern =
     (top: boolean) =>
     (meta: Metadata): string => {
-        if (meta.atomics.find((type) => type === "string") !== undefined)
+        if (meta.atomics.find((a) => a.type === "string") !== undefined)
             return "(.*)";
 
         const values: string[] = ArrayUtil.flat(
@@ -21,10 +21,10 @@ export const metadata_to_pattern =
                 return c.values.map((str) => PatternUtil.escape(str));
             }),
         );
-        for (const type of meta.atomics)
-            if (type === "number" || type === "bigint")
+        for (const a of meta.atomics)
+            if (a.type === "number" || a.type === "bigint")
                 values.push(PatternUtil.NUMBER);
-            else if (type === "boolean") values.push(PatternUtil.BOOLEAN);
+            else if (a.type === "boolean") values.push(PatternUtil.BOOLEAN);
         for (const childTpl of meta.templates)
             values.push("(" + template_to_pattern(false)(childTpl) + ")");
 

package/src/programmers/internal/stringify_dynamic_properties.ts

@@ -125,7 +125,7 @@ export const stringify_dynamic_properties = (
     const simple: boolean =
         dynamic.length === 1 &&
         dynamic[0]!.key.size() === 1 &&
-        dynamic[0]!.key.atomics[0] === "string";
+        dynamic[0]!.key.atomics[0]?.type === "string";
     if (simple === true) {
         statements.push(stringify(dynamic[0]!));
         return output();

package/src/programmers/internal/wrap_metadata_rest_tuple.ts

@@ -1,15 +1,19 @@
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
 
 export const wrap_metadata_rest_tuple = (rest: Metadata) => {
     const wrapper: Metadata = Metadata.initialize();
     wrapper.arrays.push(
         MetadataArray.create({
-            name: `...${rest.getName()}`,
-            value: rest,
-            nullables: [],
-            recursive: false,
-            index: null,
+            type: MetadataArrayType.create({
+                name: `...${rest.getName()}`,
+                value: rest,
+                nullables: [],
+                recursive: false,
+                index: null,
+            }),
+            tags: [],
         }),
     );
     return wrapper;