typia 5.2.6-dev.20231108 → 5.2.7-dev.20231109

package/src/programmers/helpers/AtomicPredicator.ts

@@ -1,31 +1,31 @@
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { Atomic } from "../../typings/Atomic";
-
-import { ArrayUtil } from "../../utils/ArrayUtil";
-
-export namespace AtomicPredicator {
-    export const constant =
-        (meta: Metadata) =>
-        (name: Atomic.Literal): boolean =>
-            !ArrayUtil.has(meta.atomics, (a) => a.type === name) &&
-            !ArrayUtil.has(
-                meta.natives,
-                (native) => native.toLowerCase() === name,
-            );
-
-    export const atomic =
-        (meta: Metadata) =>
-        (name: Atomic.Literal): boolean =>
-            !ArrayUtil.has(
-                meta.natives,
-                (native) => native.toLowerCase() === name,
-            );
-
-    export const native = (name: string) => LIKE.has(name.toLowerCase());
-
-    export const template = (meta: Metadata): boolean =>
-        !ArrayUtil.has(meta.atomics, (a) => a.type === "string");
-}
-
-const LIKE = new Set(["boolean", "bigint", "number", "string"]);
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { Atomic } from "../../typings/Atomic";
+
+import { ArrayUtil } from "../../utils/ArrayUtil";
+
+export namespace AtomicPredicator {
+    export const constant =
+        (meta: Metadata) =>
+        (name: Atomic.Literal): boolean =>
+            !ArrayUtil.has(meta.atomics, (a) => a.type === name) &&
+            !ArrayUtil.has(
+                meta.natives,
+                (native) => native.toLowerCase() === name,
+            );
+
+    export const atomic =
+        (meta: Metadata) =>
+        (name: Atomic.Literal): boolean =>
+            !ArrayUtil.has(
+                meta.natives,
+                (native) => native.toLowerCase() === name,
+            );
+
+    export const native = (name: string) => LIKE.has(name.toLowerCase());
+
+    export const template = (meta: Metadata): boolean =>
+        !ArrayUtil.has(meta.atomics, (a) => a.type === "string");
+}
+
+const LIKE = new Set(["boolean", "bigint", "number", "string"]);

package/src/programmers/http/HttpHeadersProgrammer.ts

@@ -35,7 +35,10 @@ export namespace HttpHeadersProgrammer {
                 modulo.getText(),
             );
             const collection: MetadataCollection = new MetadataCollection();
-            const result = MetadataFactory.analyze(project.checker)({
+            const result = MetadataFactory.analyze(
+                project.checker,
+                project.context,
+            )({
                 escape: false,
                 constant: true,
                 absorb: true,

package/src/programmers/http/HttpParameterProgrammer.ts

@@ -20,7 +20,10 @@ export namespace HttpParameterProgrammer {
         (project: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
         (type: ts.Type, name?: string): ts.ArrowFunction => {
-            const result = MetadataFactory.analyze(project.checker)({
+            const result = MetadataFactory.analyze(
+                project.checker,
+                project.context,
+            )({
                 escape: false,
                 constant: true,
                 absorb: true,

package/src/programmers/http/HttpQueryProgrammer.ts

@@ -33,7 +33,10 @@ export namespace HttpQueryProgrammer {
                 modulo.getText(),
             );
             const collection: MetadataCollection = new MetadataCollection();
-            const result = MetadataFactory.analyze(project.checker)({
+            const result = MetadataFactory.analyze(
+                project.checker,
+                project.context,
+            )({
                 escape: false,
                 constant: true,
                 absorb: true,

package/src/programmers/internal/application_array.ts

@@ -49,5 +49,13 @@ const application_array_tags =
                 schema.minItems = tag.value;
             else if (tag.kind === "maxItems" && typeof tag.value === "number")
                 schema.maxItems = tag.value;
+        schema["x-typia-typeTags"] = row.map((tag) => ({
+            target: tag.target,
+            name: tag.name,
+            kind: tag.kind,
+            value: tag.value,
+            validate: tag.validate,
+            exclusive: tag.exclusive,
+        }));
         return schema;
     };

package/src/programmers/internal/application_number.ts

@@ -85,6 +85,13 @@ const application_number_tags =
             else if (tag.kind === "default" && typeof tag.value === "number")
                 base.default = tag.value;
         }
-        base["x-typia-typeTags"] = row;
+        base["x-typia-typeTags"] = row.map((tag) => ({
+            target: tag.target,
+            name: tag.name,
+            kind: tag.kind,
+            value: tag.value,
+            validate: tag.validate,
+            exclusive: tag.exclusive,
+        }));
         return base;
     };

package/src/programmers/internal/application_string.ts

@@ -49,6 +49,13 @@ const application_string_tags =
             else if (tag.kind === "pattern") base.pattern = tag.value;
             else if (tag.kind === "default" && typeof tag.value === "string")
                 base.default = tag.value;
-        base["x-typia-typeTags"] = row;
+        base["x-typia-typeTags"] = row.map((tag) => ({
+            target: tag.target,
+            name: tag.name,
+            kind: tag.kind,
+            value: tag.value,
+            validate: tag.validate,
+            exclusive: tag.exclusive,
+        }));
         return base;
     };

package/src/programmers/internal/check_array_length.ts

@@ -37,8 +37,11 @@ const check_string_type_tags =
             .map((row) =>
                 row.map((tag) => ({
                     expected: `Array<> & ${tag.name}`,
-                    expression: ExpressionFactory.transpile(project.context)(
-                        tag.validate!,
+                    expression: (
+                        tag.predicate ??
+                        ExpressionFactory.transpile(project.context)(
+                            tag.validate!,
+                        )
                     )(input),
                 })),
             );

package/src/programmers/internal/check_bigint.ts

@@ -41,8 +41,11 @@ const check_bigint_type_tags =
             .map((row) =>
                 row.map((tag) => ({
                     expected: `bigint & ${tag.name}`,
-                    expression: ExpressionFactory.transpile(project.context)(
-                        tag.validate!,
+                    expression: (
+                        tag.predicate ??
+                        ExpressionFactory.transpile(project.context)(
+                            tag.validate!,
+                        )
                     )(input),
                 })),
             );

package/src/programmers/internal/check_dynamic_key.ts

@@ -1,178 +1,178 @@
-import ts from "typescript";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-
-import { IProject } from "../../transformers/IProject";
-
-import { FunctionImporter } from "../helpers/FunctionImporeter";
-import { ICheckEntry } from "../helpers/ICheckEntry";
-import { check_bigint } from "./check_bigint";
-import { check_number } from "./check_number";
-import { check_string } from "./check_string";
-import { check_template } from "./check_template";
-
-export const check_dynamic_key =
-    (project: IProject) =>
-    (importer: FunctionImporter) =>
-    (input: ts.Expression, metadata: Metadata): ts.Expression => {
-        // IF PURE STRING EXISTS, THEN SKIP VALIDATION
-        if (
-            (metadata.atomics.length !== 0 &&
-                metadata.atomics.some(
-                    (a) =>
-                        a.type === "string" &&
-                        a.tags.filter((row) =>
-                            row.every((t) => t.validate !== undefined),
-                        ).length === 0,
-                )) ||
-            (metadata.natives.length !== 0 &&
-                metadata.natives.some((type) => type === "String"))
-        )
-            return ts.factory.createTrue();
-
-        const conditions: ts.Expression[] = [];
-
-        // NULLISH COALESCING
-        if (metadata.nullable === true)
-            conditions.push(
-                ts.factory.createStrictEquality(
-                    ts.factory.createStringLiteral("null"),
-                    input,
-                ),
-            );
-        if (metadata.isRequired() === false)
-            conditions.push(
-                ts.factory.createStrictEquality(
-                    ts.factory.createStringLiteral("undefined"),
-                    input,
-                ),
-            );
-
-        // ATOMICS
-        for (const atom of metadata.atomics)
-            if (atom.type === "boolean")
-                conditions.push(
-                    ts.factory.createLogicalOr(
-                        ts.factory.createStrictEquality(
-                            ts.factory.createStringLiteral("false"),
-                            input,
-                        ),
-                        ts.factory.createStrictEquality(
-                            ts.factory.createStringLiteral("true"),
-                            input,
-                        ),
-                    ),
-                );
-            else if (atom.type === "bigint")
-                conditions.push(
-                    ts.factory.createLogicalAnd(
-                        ts.factory.createCallExpression(
-                            importer.use("is_bigint_string"),
-                            undefined,
-                            [input],
-                        ),
-                        atomist(
-                            check_bigint(project)(atom)(
-                                ts.factory.createCallExpression(
-                                    ts.factory.createIdentifier("BigInt"),
-                                    undefined,
-                                    [input],
-                                ),
-                            ),
-                        ),
-                    ),
-                );
-            else if (atom.type === "number")
-                conditions.push(
-                    atomist(
-                        check_number(project, true)(atom)(
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("Number"),
-                                undefined,
-                                [input],
-                            ),
-                        ),
-                    ),
-                );
-            else conditions.push(atomist(check_string(project)(atom)(input)));
-
-        // CONSTANTS
-        for (const constant of metadata.constants)
-            for (const value of constant.values)
-                conditions.push(
-                    ts.factory.createStrictEquality(
-                        ts.factory.createStringLiteral(String(value)),
-                        input,
-                    ),
-                );
-
-        // TEMPLATES
-        if (!!metadata.templates.length)
-            conditions.push(atomist(check_template(metadata.templates)(input)));
-
-        // NATIVES
-        for (const native of metadata.natives)
-            if (native === "Boolean")
-                conditions.push(
-                    ts.factory.createLogicalOr(
-                        ts.factory.createStrictEquality(
-                            ts.factory.createStringLiteral("false"),
-                            input,
-                        ),
-                        ts.factory.createStrictEquality(
-                            ts.factory.createStringLiteral("true"),
-                            input,
-                        ),
-                    ),
-                );
-            else if (native === "BigInt")
-                conditions.push(
-                    ts.factory.createCallExpression(
-                        importer.use("is_bigint_string"),
-                        undefined,
-                        [input],
-                    ),
-                );
-            else if (native === "Number")
-                conditions.push(
-                    ts.factory.createStrictEquality(
-                        ts.factory.createFalse(),
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("Number.isNaN"),
-                            undefined,
-                            [
-                                ts.factory.createCallExpression(
-                                    ts.factory.createIdentifier("Number"),
-                                    undefined,
-                                    [input],
-                                ),
-                            ],
-                        ),
-                    ),
-                );
-
-        return conditions.length === 0
-            ? ts.factory.createTrue()
-            : conditions.length === 1
-            ? conditions[0]!
-            : conditions.reduce(ts.factory.createLogicalOr);
-    };
-
-const atomist = (entry: ICheckEntry) => {
-    return [
-        ...(entry.expression ? [entry.expression] : []),
-        ...(entry.conditions.length === 0
-            ? []
-            : [
-                  entry.conditions
-                      .map((set) =>
-                          set
-                              .map((s) => s.expression)
-                              .reduce((a, b) =>
-                                  ts.factory.createLogicalAnd(a, b),
-                              ),
-                      )
-                      .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
-              ]),
-    ].reduce((x, y) => ts.factory.createLogicalAnd(x, y));
-};
+import ts from "typescript";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+
+import { IProject } from "../../transformers/IProject";
+
+import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { ICheckEntry } from "../helpers/ICheckEntry";
+import { check_bigint } from "./check_bigint";
+import { check_number } from "./check_number";
+import { check_string } from "./check_string";
+import { check_template } from "./check_template";
+
+export const check_dynamic_key =
+    (project: IProject) =>
+    (importer: FunctionImporter) =>
+    (input: ts.Expression, metadata: Metadata): ts.Expression => {
+        // IF PURE STRING EXISTS, THEN SKIP VALIDATION
+        if (
+            (metadata.atomics.length !== 0 &&
+                metadata.atomics.some(
+                    (a) =>
+                        a.type === "string" &&
+                        a.tags.filter((row) =>
+                            row.every((t) => t.validate !== undefined),
+                        ).length === 0,
+                )) ||
+            (metadata.natives.length !== 0 &&
+                metadata.natives.some((type) => type === "String"))
+        )
+            return ts.factory.createTrue();
+
+        const conditions: ts.Expression[] = [];
+
+        // NULLISH COALESCING
+        if (metadata.nullable === true)
+            conditions.push(
+                ts.factory.createStrictEquality(
+                    ts.factory.createStringLiteral("null"),
+                    input,
+                ),
+            );
+        if (metadata.isRequired() === false)
+            conditions.push(
+                ts.factory.createStrictEquality(
+                    ts.factory.createStringLiteral("undefined"),
+                    input,
+                ),
+            );
+
+        // ATOMICS
+        for (const atom of metadata.atomics)
+            if (atom.type === "boolean")
+                conditions.push(
+                    ts.factory.createLogicalOr(
+                        ts.factory.createStrictEquality(
+                            ts.factory.createStringLiteral("false"),
+                            input,
+                        ),
+                        ts.factory.createStrictEquality(
+                            ts.factory.createStringLiteral("true"),
+                            input,
+                        ),
+                    ),
+                );
+            else if (atom.type === "bigint")
+                conditions.push(
+                    ts.factory.createLogicalAnd(
+                        ts.factory.createCallExpression(
+                            importer.use("is_bigint_string"),
+                            undefined,
+                            [input],
+                        ),
+                        atomist(
+                            check_bigint(project)(atom)(
+                                ts.factory.createCallExpression(
+                                    ts.factory.createIdentifier("BigInt"),
+                                    undefined,
+                                    [input],
+                                ),
+                            ),
+                        ),
+                    ),
+                );
+            else if (atom.type === "number")
+                conditions.push(
+                    atomist(
+                        check_number(project, true)(atom)(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("Number"),
+                                undefined,
+                                [input],
+                            ),
+                        ),
+                    ),
+                );
+            else conditions.push(atomist(check_string(project)(atom)(input)));
+
+        // CONSTANTS
+        for (const constant of metadata.constants)
+            for (const value of constant.values)
+                conditions.push(
+                    ts.factory.createStrictEquality(
+                        ts.factory.createStringLiteral(String(value)),
+                        input,
+                    ),
+                );
+
+        // TEMPLATES
+        if (!!metadata.templates.length)
+            conditions.push(atomist(check_template(metadata.templates)(input)));
+
+        // NATIVES
+        for (const native of metadata.natives)
+            if (native === "Boolean")
+                conditions.push(
+                    ts.factory.createLogicalOr(
+                        ts.factory.createStrictEquality(
+                            ts.factory.createStringLiteral("false"),
+                            input,
+                        ),
+                        ts.factory.createStrictEquality(
+                            ts.factory.createStringLiteral("true"),
+                            input,
+                        ),
+                    ),
+                );
+            else if (native === "BigInt")
+                conditions.push(
+                    ts.factory.createCallExpression(
+                        importer.use("is_bigint_string"),
+                        undefined,
+                        [input],
+                    ),
+                );
+            else if (native === "Number")
+                conditions.push(
+                    ts.factory.createStrictEquality(
+                        ts.factory.createFalse(),
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("Number.isNaN"),
+                            undefined,
+                            [
+                                ts.factory.createCallExpression(
+                                    ts.factory.createIdentifier("Number"),
+                                    undefined,
+                                    [input],
+                                ),
+                            ],
+                        ),
+                    ),
+                );
+
+        return conditions.length === 0
+            ? ts.factory.createTrue()
+            : conditions.length === 1
+            ? conditions[0]!
+            : conditions.reduce(ts.factory.createLogicalOr);
+    };
+
+const atomist = (entry: ICheckEntry) => {
+    return [
+        ...(entry.expression ? [entry.expression] : []),
+        ...(entry.conditions.length === 0
+            ? []
+            : [
+                  entry.conditions
+                      .map((set) =>
+                          set
+                              .map((s) => s.expression)
+                              .reduce((a, b) =>
+                                  ts.factory.createLogicalAnd(a, b),
+                              ),
+                      )
+                      .reduce((a, b) => ts.factory.createLogicalOr(a, b)),
+              ]),
+    ].reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+};