typia 5.0.0-dev.20230823-2 → 5.0.0-dev.20230827

package/src/programmers/internal/application_tuple.ts

@@ -18,37 +18,38 @@ export const application_tuple =
     ): IJsonSchema.ITuple | IJsonSchema.IArray => {
         const schema: IJsonSchema.ITuple = {
             type: "array",
-            items: tuple.elements.map((meta, i) =>
+            items: tuple.type.elements.map((meta, i) =>
                 application_schema(options)(false)(components)(
                     meta.rest ?? meta,
                 )({
                     ...attribute,
                     "x-typia-rest":
-                        i === tuple.elements.length - 1 && meta.rest !== null,
+                        i === tuple.type.elements.length - 1 &&
+                        meta.rest !== null,
                     "x-typia-required": meta.required,
                     "x-typia-optional": meta.optional,
                 }),
             ),
             ...attribute,
-            minItems: !!tuple.elements.at(-1)?.rest
-                ? tuple.elements.length - 1
-                : tuple.elements.filter((x) => !x.optional).length,
-            maxItems: !!tuple.elements.at(-1)?.rest
+            minItems: !!tuple.type.elements.at(-1)?.rest
+                ? tuple.type.elements.length - 1
+                : tuple.type.elements.filter((x) => !x.optional).length,
+            maxItems: !!tuple.type.elements.at(-1)?.rest
                 ? undefined
-                : tuple.elements.length,
+                : tuple.type.elements.length,
         };
         if (options.purpose === "ajv")
-            if (tuple.elements.length === 0) return schema;
-            else if (!tuple.elements.at(-1)?.rest) return schema;
+            if (tuple.type.elements.length === 0) return schema;
+            else if (!tuple.type.elements.at(-1)?.rest) return schema;
 
         const wrapper: IJsonSchema.IArray = {
             ...schema,
             items: application_schema(options)(false)(components)(
-                tuple.elements.reduce(
+                tuple.type.elements.reduce(
                     (x, y) => Metadata.merge(x.rest ?? x, y.rest ?? y),
                     Metadata.initialize(),
                 ),
-            )(tuple.recursive ? {} : attribute),
+            )(tuple.type.recursive ? {} : attribute),
             "x-typia-tuple": schema,
             minItems: schema.minItems,
             maxItems: schema.maxItems,

package/src/programmers/internal/check_array_length.ts

@@ -1,35 +1,41 @@
 import ts from "typescript";
 
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+
+import { IProject } from "../../transformers/IProject";
+
+import { ICheckEntry } from "../helpers/ICheckEntry";
 
 /**
  * @internal
  */
 export const check_array_length =
-    (metaTags: IMetadataTag[]) => (input: ts.Expression) =>
-        metaTags
-            .map((tag) => ({
-                tag,
-                expression:
-                    tag.kind === "items"
-                        ? ts.factory.createStrictEquality(
-                              ts.factory.createNumericLiteral(tag.value),
-                              input,
-                          )
-                        : tag.kind === "minItems"
-                        ? ts.factory.createLessThanEquals(
-                              ts.factory.createNumericLiteral(tag.value),
-                              input,
-                          )
-                        : tag.kind === "maxItems"
-                        ? ts.factory.createGreaterThanEquals(
-                              ts.factory.createNumericLiteral(tag.value),
-                              input,
-                          )
-                        : null!,
-            }))
-            .filter((tuple) => tuple.expression !== null)
-            .map(({ tag, expression }) => ({
-                expected: `Array.length (@${tag.kind} ${tag.value})`,
-                expression,
-            }));
+    (project: IProject) =>
+    (array: MetadataArray) =>
+    (input: ts.Expression): ICheckEntry => {
+        const conditions: ICheckEntry.ICondition[][] = check_string_type_tags(
+            project,
+        )(array.tags)(input);
+
+        return {
+            expected: array.getName(),
+            expression: null,
+            conditions,
+        };
+    };
+
+const check_string_type_tags =
+    (project: IProject) =>
+    (matrix: IMetadataTypeTag[][]) =>
+    (input: ts.Expression): ICheckEntry.ICondition[][] =>
+        matrix.map((row) =>
+            row.map((tag) => ({
+                expected: `Array<> & ${tag.name}`,
+                expression: ExpressionFactory.transpile(project.context)(
+                    tag.validate,
+                )(input),
+            })),
+        );

package/src/programmers/internal/check_bigint.ts

@@ -2,109 +2,44 @@ import ts from "typescript";
 
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 
-import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+
+import { IProject } from "../../transformers/IProject";
 
-import { FunctionImporter } from "../helpers/FunctionImporeter";
 import { ICheckEntry } from "../helpers/ICheckEntry";
-import { check_custom } from "./check_custom";
 
 /**
  * @internal
  */
 export const check_bigint =
-    (importer: FunctionImporter) =>
-    (metaTags: IMetadataTag[]) =>
-    (jsDocTag: IJsDocTagInfo[]) =>
+    (project: IProject) =>
+    (atomic: MetadataAtomic) =>
     (input: ts.Expression): ICheckEntry => {
-        const entries: [IMetadataTag, 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,
-                    ),
-                ]);
-        }
+        const conditions: ICheckEntry.ICondition[][] =
+            check_bigint_type_tags(project)(atomic)(input);
+
         return {
+            expected: atomic.getName(),
             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),
-            ],
+            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

@@ -1,258 +1,105 @@
 import ts from "typescript";
 
-import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
 
 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[]) =>
+    (atomic: MetadataAtomic) =>
     (input: ts.Expression): ICheckEntry => {
-        const entries: [IMetadataTag, ts.Expression][] = [];
-        for (const tag of metaTags)
-            if (tag.kind === "type") {
-                // MUST BE INTEGER
-                if (
-                    tag.value === "int" ||
-                    tag.value === "uint" ||
-                    tag.value === "int32" ||
-                    tag.value === "uint32" ||
-                    tag.value === "int64" ||
-                    tag.value === "uint64"
-                )
-                    entries.push([
-                        tag,
-                        ts.factory.createStrictEquality(
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("Math.floor"),
-                                undefined,
-                                [input],
-                            ),
-                            input,
-                        ),
-                    ]);
-                // GREATER THAN OR EQUAL TO ZERO
-                if (
-                    tag.value === "uint" ||
-                    tag.value === "uint32" ||
-                    tag.value === "uint64"
-                )
-                    entries.push([
-                        tag,
-                        ts.factory.createLessThanEquals(
-                            ts.factory.createNumericLiteral(0),
-                            input,
-                        ),
-                    ]);
-                // RANGE LIMIT
-                if (tag.value === "uint" || tag.value === "uint32")
-                    entries.push([
-                        tag,
-                        ts.factory.createLessThanEquals(
-                            input,
-                            ts.factory.createNumericLiteral(4294967295),
-                        ),
-                    ]);
-                else if (tag.value === "uint64")
-                    entries.push([
-                        tag,
-                        ts.factory.createLessThanEquals(
-                            input,
-                            ts.factory.createNumericLiteral(
-                                18446744073709551615,
-                            ),
-                        ),
-                    ]);
-                else if (tag.value === "int64")
-                    entries.push([
-                        tag,
-                        ts.factory.createLogicalAnd(
-                            ts.factory.createLessThanEquals(
-                                ts.factory.createNumericLiteral(
-                                    -9223372036854775808,
-                                ),
-                                input,
-                            ),
-                            ts.factory.createLessThanEquals(
-                                input,
-                                ts.factory.createNumericLiteral(
-                                    9223372036854775807,
-                                ),
-                            ),
-                        ),
-                    ]);
-                else if (tag.value === "int" || tag.value === "int32")
-                    entries.push([
-                        tag,
-                        ts.factory.createLogicalAnd(
-                            ts.factory.createLessThanEquals(
-                                ts.factory.createNumericLiteral(-2147483648),
-                                input,
-                            ),
-                            ts.factory.createLessThanEquals(
-                                input,
-                                ts.factory.createNumericLiteral(2147483647),
-                            ),
-                        ),
-                    ]);
-                else if (tag.value === "float")
-                    entries.push([
-                        tag,
-                        ts.factory.createLogicalAnd(
-                            ts.factory.createLessThanEquals(
-                                ts.factory.createNumericLiteral(
-                                    -1.175494351e38,
-                                ),
-                                input,
-                            ),
-                            ts.factory.createLessThanEquals(
-                                input,
-                                ts.factory.createNumericLiteral(3.4028235e38),
-                            ),
-                        ),
-                    ]);
-            } else if (tag.kind === "multipleOf")
-                entries.push([
-                    tag,
-                    ts.factory.createStrictEquality(
-                        ts.factory.createNumericLiteral(0),
-                        ts.factory.createModulo(
-                            input,
-                            ts.factory.createNumericLiteral(tag.value),
-                        ),
-                    ),
-                ]);
-            else if (tag.kind === "step") {
-                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,
-                                  ts.factory.createNumericLiteral(minimum),
-                              )
-                            : modulo,
-                    ),
-                ]);
-            } else if (tag.kind === "minimum")
-                entries.push([
-                    tag,
-                    ts.factory.createLessThanEquals(
-                        ts.factory.createNumericLiteral(tag.value),
-                        input,
-                    ),
-                ]);
-            else if (tag.kind === "maximum")
-                entries.push([
-                    tag,
-                    ts.factory.createGreaterThanEquals(
-                        ts.factory.createNumericLiteral(tag.value),
-                        input,
-                    ),
-                ]);
-            else if (tag.kind === "exclusiveMinimum")
-                entries.push([
-                    tag,
-                    ts.factory.createLessThan(
-                        ts.factory.createNumericLiteral(tag.value),
-                        input,
-                    ),
-                ]);
-            else if (tag.kind === "exclusiveMaximum")
-                entries.push([
-                    tag,
-                    ts.factory.createGreaterThan(
-                        ts.factory.createNumericLiteral(tag.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)(metaTags)(input),
-            tags: [
-                ...entries.map(([tag, expression]) => ({
-                    expected: `number (@${tag.kind} ${tag.value})`,
-                    expression,
-                })),
-                ...check_custom("number")(importer)(jsDocTag)(input),
-            ],
+            expected: atomic.getName(),
+            expression:
+                addition !== null && conditions.length === 0
+                    ? ts.factory.createLogicalAnd(base, addition)
+                    : base,
+            conditions,
         };
     };
 
 /**
  * @internal
  */
-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],
-                        ),
-                    ),
-                );
-
-        // 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),
+            })),
+        ]);