typia 5.0.0-dev.20230824 → 5.0.0-dev.20230828

package/src/programmers/internal/check_bigint.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";
 
@@ -14,125 +13,33 @@ import { ICheckEntry } from "../helpers/ICheckEntry";
  */
 export const check_bigint =
     (project: IProject) =>
-    (matrix: IMetadataTypeTag[][], metaTags: IMetadataCommentTag[]) =>
+    (atomic: MetadataAtomic) =>
     (input: ts.Expression): ICheckEntry => {
-        const entries: [IMetadataCommentTag, ts.Expression][] = [];
-        for (const tag of metaTags) {
-            if (tag.kind === "type" && tag.value === "uint64")
-                entries.push([
-                    tag,
-                    ts.factory.createLessThanEquals(
-                        ExpressionFactory.bigint(0),
-                        input,
-                    ),
-                ]);
-            else if (tag.kind === "multipleOf")
-                entries.push([
-                    tag,
-                    ts.factory.createStrictEquality(
-                        ExpressionFactory.bigint(0),
-                        ts.factory.createModulo(
-                            input,
-                            ExpressionFactory.bigint(tag.value),
-                        ),
-                    ),
-                ]);
-            else if (tag.kind === "step") {
-                const modulo = ts.factory.createModulo(
-                    input,
-                    ExpressionFactory.bigint(tag.value),
-                );
-                const minimum =
-                    (metaTags.find(
-                        (tag) =>
-                            tag.kind === "minimum" ||
-                            tag.kind === "exclusiveMinimum",
-                    )?.value as number | undefined) ?? undefined;
-                entries.push([
-                    tag,
-                    ts.factory.createStrictEquality(
-                        ExpressionFactory.bigint(0),
-                        minimum !== undefined
-                            ? ts.factory.createSubtract(
-                                  modulo,
-                                  ExpressionFactory.bigint(minimum),
-                              )
-                            : modulo,
-                    ),
-                ]);
-            } else if (tag.kind === "minimum")
-                entries.push([
-                    tag,
-                    ts.factory.createLessThanEquals(
-                        ExpressionFactory.bigint(tag.value),
-                        input,
-                    ),
-                ]);
-            else if (tag.kind === "maximum")
-                entries.push([
-                    tag,
-                    ts.factory.createGreaterThanEquals(
-                        ExpressionFactory.bigint(tag.value),
-                        input,
-                    ),
-                ]);
-            else if (tag.kind === "exclusiveMinimum")
-                entries.push([
-                    tag,
-                    ts.factory.createLessThan(
-                        ExpressionFactory.bigint(tag.value),
-                        input,
-                    ),
-                ]);
-            else if (tag.kind === "exclusiveMaximum")
-                entries.push([
-                    tag,
-                    ts.factory.createGreaterThan(
-                        ExpressionFactory.bigint(tag.value),
-                        input,
-                    ),
-                ]);
-        }
-        return {
-            expression: is_bigint(project)(matrix)(input),
-            tags: matrix.length
-                ? []
-                : entries.map(([tag, expression]) => ({
-                      expected: `bigint (@${tag.kind} ${tag.value})`,
-                      expression,
-                  })),
-        };
-    };
+        const conditions: ICheckEntry.ICondition[][] =
+            check_bigint_type_tags(project)(atomic)(input);
 
-const is_bigint =
-    (project: IProject) =>
-    (matrix: IMetadataTypeTag[][]) =>
-    (input: ts.Expression) => {
-        // BASIC TYPEOF EXPRESSION
-        const conditions: ts.Expression[] = [
-            ts.factory.createStrictEquality(
+        return {
+            expected: atomic.getName(),
+            expression: ts.factory.createStrictEquality(
                 ts.factory.createStringLiteral("bigint"),
                 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_bigint_type_tags =
+    (project: IProject) =>
+    (atomic: MetadataAtomic) =>
+    (input: ts.Expression): ICheckEntry.ICondition[][] =>
+        atomic.tags.map((row) =>
+            row.map((tag) => ({
+                expected: `bigint & ${tag.name}`,
+                expression: ExpressionFactory.transpile(project.context)(
+                    tag.validate,
+                )(input),
+            })),
+        );

package/src/programmers/internal/check_dynamic_properties.ts

@@ -111,8 +111,7 @@ const check_dynamic_property =
             );
 
         // GATHER CONDITIONS
-        if (props.equals === true && regular.length)
-            add(is_regular_property(regular), props.positive);
+        if (regular.length) add(is_regular_property(regular), props.positive);
         statements.push(
             StatementFactory.constant(
                 "value",

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(" | "),
         };
     };