typia 5.0.0-dev.20230824 → 5.0.0-dev.20230827

package/src/programmers/internal/check_number.ts

@@ -2,8 +2,7 @@ import ts from "typescript";
 
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 
-import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
-import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
 
 import { IProject } from "../../transformers/IProject";
 
@@ -15,271 +14,92 @@ import { OptionPredicator } from "../helpers/OptionPredicator";
  */
 export const check_number =
     (project: IProject, numeric: boolean) =>
-    (matrix: IMetadataTypeTag[][], metaTags: IMetadataCommentTag[]) =>
+    (atomic: MetadataAtomic) =>
     (input: ts.Expression): ICheckEntry => {
-        const entries: [IMetadataCommentTag, ts.Expression][] = [];
-        for (const mt of metaTags)
-            if (mt.kind === "type") {
-                // MUST BE INTEGER
-                if (
-                    mt.value === "int" ||
-                    mt.value === "uint" ||
-                    mt.value === "int32" ||
-                    mt.value === "uint32" ||
-                    mt.value === "int64" ||
-                    mt.value === "uint64"
-                )
-                    entries.push([
-                        mt,
-                        ts.factory.createStrictEquality(
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("Math.floor"),
-                                undefined,
-                                [input],
-                            ),
-                            input,
-                        ),
-                    ]);
-                // GREATER THAN OR EQUAL TO ZERO
-                if (
-                    mt.value === "uint" ||
-                    mt.value === "uint32" ||
-                    mt.value === "uint64"
-                )
-                    entries.push([
-                        mt,
-                        ts.factory.createLessThanEquals(
-                            ts.factory.createNumericLiteral(0),
-                            input,
-                        ),
-                    ]);
-                // RANGE LIMIT
-                if (mt.value === "uint" || mt.value === "uint32")
-                    entries.push([
-                        mt,
-                        ts.factory.createLessThanEquals(
-                            input,
-                            ts.factory.createNumericLiteral(4294967295),
-                        ),
-                    ]);
-                else if (mt.value === "uint64")
-                    entries.push([
-                        mt,
-                        ts.factory.createLessThanEquals(
-                            input,
-                            ts.factory.createNumericLiteral(
-                                18446744073709551615,
-                            ),
-                        ),
-                    ]);
-                else if (mt.value === "int64")
-                    entries.push([
-                        mt,
-                        ts.factory.createLogicalAnd(
-                            ts.factory.createLessThanEquals(
-                                ts.factory.createNumericLiteral(
-                                    -9223372036854775808,
-                                ),
-                                input,
-                            ),
-                            ts.factory.createLessThanEquals(
-                                input,
-                                ts.factory.createNumericLiteral(
-                                    9223372036854775807,
-                                ),
-                            ),
-                        ),
-                    ]);
-                else if (mt.value === "int" || mt.value === "int32")
-                    entries.push([
-                        mt,
-                        ts.factory.createLogicalAnd(
-                            ts.factory.createLessThanEquals(
-                                ts.factory.createNumericLiteral(-2147483648),
-                                input,
-                            ),
-                            ts.factory.createLessThanEquals(
-                                input,
-                                ts.factory.createNumericLiteral(2147483647),
-                            ),
-                        ),
-                    ]);
-                else if (mt.value === "float")
-                    entries.push([
-                        mt,
-                        ts.factory.createLogicalAnd(
-                            ts.factory.createLessThanEquals(
-                                ts.factory.createNumericLiteral(
-                                    -1.175494351e38,
-                                ),
-                                input,
-                            ),
-                            ts.factory.createLessThanEquals(
-                                input,
-                                ts.factory.createNumericLiteral(3.4028235e38),
-                            ),
-                        ),
-                    ]);
-            } else if (mt.kind === "multipleOf")
-                entries.push([
-                    mt,
-                    ts.factory.createStrictEquality(
-                        ts.factory.createNumericLiteral(0),
-                        ts.factory.createModulo(
-                            input,
-                            ts.factory.createNumericLiteral(mt.value),
-                        ),
-                    ),
-                ]);
-            else if (mt.kind === "step") {
-                const modulo = ts.factory.createModulo(
-                    input,
-                    ts.factory.createNumericLiteral(mt.value),
-                );
-                const minimum =
-                    (metaTags.find(
-                        (tag) =>
-                            tag.kind === "minimum" ||
-                            tag.kind === "exclusiveMinimum",
-                    )?.value as number | undefined) ?? undefined;
-                entries.push([
-                    mt,
-                    ts.factory.createStrictEquality(
-                        ts.factory.createNumericLiteral(0),
-                        minimum !== undefined
-                            ? ts.factory.createSubtract(
-                                  modulo,
-                                  ts.factory.createNumericLiteral(minimum),
-                              )
-                            : modulo,
-                    ),
-                ]);
-            } else if (mt.kind === "minimum")
-                entries.push([
-                    mt,
-                    ts.factory.createLessThanEquals(
-                        ts.factory.createNumericLiteral(mt.value),
-                        input,
-                    ),
-                ]);
-            else if (mt.kind === "maximum")
-                entries.push([
-                    mt,
-                    ts.factory.createGreaterThanEquals(
-                        ts.factory.createNumericLiteral(mt.value),
-                        input,
-                    ),
-                ]);
-            else if (mt.kind === "exclusiveMinimum")
-                entries.push([
-                    mt,
-                    ts.factory.createLessThan(
-                        ts.factory.createNumericLiteral(mt.value),
-                        input,
-                    ),
-                ]);
-            else if (mt.kind === "exclusiveMaximum")
-                entries.push([
-                    mt,
-                    ts.factory.createGreaterThan(
-                        ts.factory.createNumericLiteral(mt.value),
-                        input,
-                    ),
-                ]);
+        const base = ts.factory.createStrictEquality(
+            ts.factory.createStringLiteral("number"),
+            ts.factory.createTypeOfExpression(input),
+        );
+        const addition: ts.Expression | null =
+            numeric === true
+                ? OptionPredicator.finite(project.options)
+                    ? ts.factory.createCallExpression(
+                          ts.factory.createIdentifier("Number.isFinite"),
+                          undefined,
+                          [input],
+                      )
+                    : OptionPredicator.numeric(project.options)
+                    ? ts.factory.createLogicalNot(
+                          ts.factory.createCallExpression(
+                              ts.factory.createIdentifier("Number.isNaN"),
+                              undefined,
+                              [input],
+                          ),
+                      )
+                    : null
+                : null;
+
+        const conditions: ICheckEntry.ICondition[][] =
+            check_numeric_type_tags(project)(atomic)(addition)(input);
 
         return {
-            expression: is_number(project, numeric)(matrix, metaTags)(input),
-            tags: matrix.length
-                ? []
-                : entries.map(([tag, expression]) => ({
-                      expected: `number (@${tag.kind} ${tag.value})`,
-                      expression,
-                  })),
+            expected: atomic.getName(),
+            expression:
+                addition !== null && conditions.length === 0
+                    ? ts.factory.createLogicalAnd(base, addition)
+                    : base,
+            conditions,
         };
     };
 
 /**
  * @internal
  */
-const is_number =
-    (project: IProject, numeric: boolean) =>
-    (matrix: IMetadataTypeTag[][], metaTags: IMetadataCommentTag[]) =>
-    (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 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 === "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 && ranged === false)
-            if (OptionPredicator.finite(project.options))
-                conditions.push(
-                    ts.factory.createCallExpression(
-                        ts.factory.createIdentifier("Number.isFinite"),
-                        undefined,
-                        [input],
-                    ),
-                );
-            else if (
-                OptionPredicator.numeric(project.options) &&
-                ranged === false
-            )
-                conditions.push(
-                    ts.factory.createLogicalNot(
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("Number.isNaN"),
-                            undefined,
-                            [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);
-        }
-
-        // COMBINATE
-        return conditions.length === 1
-            ? conditions[0]!
-            : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
-    };
+const check_numeric_type_tags =
+    (project: IProject) =>
+    (atomic: MetadataAtomic) =>
+    (addition: ts.Expression | null) =>
+    (input: ts.Expression): ICheckEntry.ICondition[][] =>
+        atomic.tags.map((row) => [
+            ...(addition === null
+                ? []
+                : row.some(
+                      (tag) =>
+                          tag.kind === "type" &&
+                          (tag.value === "int32" ||
+                              tag.value === "uint32" ||
+                              tag.value === "int64" ||
+                              tag.value === "uint64" ||
+                              tag.value === "float"),
+                  ) ||
+                  row.some(
+                      (tag) =>
+                          tag.kind === "multipleOf" &&
+                          typeof tag.value === "number",
+                  ) ||
+                  (row.some(
+                      (tag) =>
+                          (tag.kind === "minimum" ||
+                              tag.kind === "exclusiveMinimum") &&
+                          typeof tag.value === "number",
+                  ) &&
+                      row.some(
+                          (tag) =>
+                              (tag.kind === "maximum" ||
+                                  tag.kind === "exclusiveMaximum") &&
+                              typeof tag.value === "number",
+                      ))
+                ? []
+                : [
+                      {
+                          expected: "number",
+                          expression: addition!,
+                      },
+                  ]),
+            ...row.map((tag) => ({
+                expected: `number & ${tag.name}`,
+                expression: ExpressionFactory.transpile(project.context)(
+                    tag.validate,
+                )(input),
+            })),
+        ]);

package/src/programmers/internal/check_string.ts

@@ -2,55 +2,44 @@ import ts from "typescript";
 
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 
-import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
-import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
 
 import { IProject } from "../../transformers/IProject";
 
-import { FunctionImporter } from "../helpers/FunctionImporeter";
-import { check_string_tags } from "./check_string_tags";
+import { ICheckEntry } from "../helpers/ICheckEntry";
 
 /**
  * @internal
  */
 export const check_string =
     (project: IProject) =>
-    (importer: FunctionImporter) =>
-    (tags: IMetadataTypeTag[][], metaTags: IMetadataCommentTag[]) =>
-    (input: ts.Expression) => ({
-        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(
+    (atomic: MetadataAtomic) =>
+    (input: ts.Expression): ICheckEntry => {
+        const conditions: ICheckEntry.ICondition[][] =
+            check_string_type_tags(project)(atomic)(input);
+
+        return {
+            expected: atomic.getName(),
+            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));
+            conditions,
+        };
     };
+
+/**
+ * @internal
+ */
+const check_string_type_tags =
+    (project: IProject) =>
+    (atomic: MetadataAtomic) =>
+    (input: ts.Expression): ICheckEntry.ICondition[][] =>
+        atomic.tags.map((row) =>
+            row.map((tag) => ({
+                expected: `string & ${tag.name}`,
+                expression: ExpressionFactory.transpile(project.context)(
+                    tag.validate,
+                )(input),
+            })),
+        );

package/src/programmers/internal/check_template.ts

@@ -40,6 +40,22 @@ export const check_template =
             expression: conditions.reduce((x, y) =>
                 ts.factory.createLogicalAnd(x, y),
             ),
-            tags: [],
+            conditions: [],
+            expected: templates
+                .map(
+                    (tpl) =>
+                        "`" +
+                        tpl
+                            .map((child) =>
+                                child.isConstant() && child.size() === 1
+                                    ? child.constants[0]!.values[0]!
+                                    : `$\{${child.getName()}\}`,
+                            )
+                            .join("")
+                            .split("`")
+                            .join("\\`") +
+                        "`",
+                )
+                .join(" | "),
         };
     };

package/src/programmers/internal/check_union_array_like.ts

@@ -4,7 +4,6 @@ import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
 import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
@@ -26,8 +25,6 @@ export const check_union_array_like =
         input: ts.Expression,
         origins: Origin[],
         explore: FeatureProgrammer.IExplore,
-        tags: IMetadataCommentTag[],
-        jsDocTags: ts.JSDocTagInfo[],
     ): ts.ArrowFunction => {
         // ONLY ONE TYPE
         const targets: Array<Category> = origins.map(accessor.transform);
@@ -38,13 +35,7 @@ export const check_union_array_like =
                 parameters,
                 undefined,
                 undefined,
-                props.decoder(
-                    accessor.array(input),
-                    targets[0]!,
-                    explore,
-                    tags,
-                    jsDocTags,
-                ),
+                props.decoder(accessor.array(input), targets[0]!, explore),
             );
 
         const array = ts.factory.createIdentifier("array");
@@ -87,8 +78,6 @@ export const check_union_array_like =
                                         ? `"[0]"`
                                         : "",
                             },
-                            tags,
-                            jsDocTags,
                             array,
                         ),
                     ),
@@ -110,8 +99,6 @@ export const check_union_array_like =
                                 ...explore,
                                 tracable: true,
                             },
-                            tags,
-                            jsDocTags,
                         ),
                     ),
                 ],
@@ -301,8 +288,6 @@ export namespace check_union_array_like {
             front: ts.Expression,
             target: Element,
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataCommentTag[],
-            jsDocTags: ts.JSDocTagInfo[],
             container: ts.Expression,
         ): ts.Expression;
         decoder: UnionExplorer.Decoder<Category>;

package/src/programmers/internal/feature_object_entries.ts

@@ -41,23 +41,17 @@ export const feature_object_entries =
                 input: propInput,
                 key: prop.key,
                 meta: prop.value,
-                expression: config.decoder()(
-                    propInput,
-                    prop.value,
-                    {
-                        tracable: config.path || config.trace,
-                        source: "function",
-                        from,
-                        postfix:
-                            sole !== null
-                                ? IdentifierFactory.postfix(sole)
-                                : (() => {
-                                      importer.use("join");
-                                      return `$join(key)`;
-                                  })(),
-                    },
-                    prop.tags,
-                    prop.jsDocTags,
-                ),
+                expression: config.decoder()(propInput, prop.value, {
+                    tracable: config.path || config.trace,
+                    source: "function",
+                    from,
+                    postfix:
+                        sole !== null
+                            ? IdentifierFactory.postfix(sole)
+                            : (() => {
+                                  importer.use("join");
+                                  return `$join(key)`;
+                              })(),
+                }),
             };
         });

package/src/programmers/internal/random_custom.ts

@@ -3,7 +3,7 @@ import ts from "typescript";
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 import { LiteralFactory } from "../../factories/LiteralFactory";
 
-import { ICommentTag } from "../../schemas/metadata/ICommentTag";
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
 
 import { Customizable } from "../../typings/Customizable";
 
@@ -13,7 +13,7 @@ import { Customizable } from "../../typings/Customizable";
 export const random_custom =
     (accessor: (name: string) => ts.Expression) =>
     (type: keyof Customizable) =>
-    (comments: ICommentTag[]) =>
+    (tags: IMetadataTypeTag[]) =>
     (expression: ts.Expression) =>
         ExpressionFactory.coalesce(
             ts.factory.createCallChain(
@@ -24,6 +24,6 @@ export const random_custom =
                 ),
                 ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
                 undefined,
-                [LiteralFactory.generate(comments)],
+                [LiteralFactory.generate(tags)],
             ),
         )(expression);