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

package/src/programmers/helpers/RandomRanger.ts

@@ -1,6 +1,6 @@
 import ts from "typescript";
 
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
+import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
 
 export namespace RandomRanger {
     export interface IDefaults {
@@ -13,7 +13,7 @@ export namespace RandomRanger {
         (coalesce: (method: string) => ts.Expression) =>
         (defs: IDefaults) =>
         (acc: length.IAccessors) =>
-        (tags: IMetadataTag[]): ts.Expression | undefined => {
+        (tags: IMetadataCommentTag[]): ts.Expression | undefined => {
             const props = {
                 fixed: getter(tags)(acc.fixed),
                 minimum: getter(tags)(acc.minimum),
@@ -40,16 +40,16 @@ export namespace RandomRanger {
         };
     export namespace length {
         export interface IAccessors {
-            minimum: IMetadataTag["kind"];
-            maximum: IMetadataTag["kind"];
-            fixed: IMetadataTag["kind"];
+            minimum: IMetadataCommentTag["kind"];
+            maximum: IMetadataCommentTag["kind"];
+            fixed: IMetadataCommentTag["kind"];
         }
     }
 
     export const number =
         (config: number.IConfig) =>
         (defs: IDefaults) =>
-        (tags: IMetadataTag[]): ts.Expression => {
+        (tags: IMetadataCommentTag[]): ts.Expression => {
             const range = {
                 minimum: {
                     value:
@@ -151,8 +151,8 @@ export namespace RandomRanger {
 }
 
 const getter =
-    (tags: IMetadataTag[]) =>
-    (kind: IMetadataTag["kind"]): number | undefined =>
+    (tags: IMetadataCommentTag[]) =>
+    (kind: IMetadataCommentTag["kind"]): number | undefined =>
         tags.find((t) => t.kind === kind)?.value as number | undefined;
 
 const stepper = (gap: number) => (range: IRange) => (s: number) => {

package/src/programmers/helpers/StringifyPredicator.ts

@@ -6,8 +6,7 @@ export namespace StringifyPredicator {
 
     export const undefindable = (meta: Metadata): boolean =>
         meta.isRequired() === false ||
-        (meta.resolved !== null &&
-            meta.resolved.returns.isRequired() === false);
+        (meta.escaped !== null && meta.escaped.returns.isRequired() === false);
 
     const ESCAPED = ['"', "\\", "\b", "\f", "\n", "\n", "\r", "\t"];
 }

package/src/programmers/helpers/UnionExplorer.ts

@@ -3,11 +3,13 @@ import ts from "typescript";
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
+import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../schemas/metadata/MetadataArrayType";
 import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
+import { MetadataTupleType } from "../../schemas/metadata/MetadataTupleType";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { check_union_array_like } from "../internal/check_union_array_like";
@@ -19,7 +21,7 @@ export namespace UnionExplorer {
             input: ts.Expression,
             target: T,
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
             jsDocTags: ts.JSDocTagInfo[],
         ): ts.Expression;
     }
@@ -34,7 +36,7 @@ export namespace UnionExplorer {
             input: ts.Expression,
             targets: MetadataObject[],
             explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
+            tags: IMetadataCommentTag[],
             jsDocTags: ts.JSDocTagInfo[],
         ): ts.Expression => {
             // BREAKER
@@ -160,7 +162,7 @@ export namespace UnionExplorer {
             size: null!,
             front: (input) => input,
             array: (input) => input,
-            name: (t) => t.name,
+            name: (t) => t.type.name,
         })(props);
     export namespace tuple {
         export type IProps = check_union_array_like.IProps<
@@ -172,12 +174,12 @@ export namespace UnionExplorer {
     export const array = (props: array.IProps) =>
         check_union_array_like<MetadataArray, MetadataArray, Metadata>({
             transform: (x) => x,
-            element: (x) => x.value,
+            element: (x) => x.type.value,
             size: (input) => IdentifierFactory.access(input)("length"),
             front: (input) =>
                 ts.factory.createElementAccessExpression(input, 0),
             array: (input) => input,
-            name: (t) => t.name,
+            name: (t) => t.type.name,
         })(props);
     export namespace array {
         export type IProps = check_union_array_like.IProps<
@@ -193,12 +195,12 @@ export namespace UnionExplorer {
             Metadata | MetadataTuple
         >({
             transform: (x) => x,
-            element: (x) => (x instanceof MetadataArray ? x.value : x),
+            element: (x) => (x instanceof MetadataArray ? x.type.value : x),
             size: (input) => IdentifierFactory.access(input)("length"),
             front: (input) =>
                 ts.factory.createElementAccessExpression(input, 0),
             array: (input) => input,
-            name: (m) => m.name,
+            name: (m) => m.type.name,
         })(props);
     export namespace array_or_tuple {
         export type IProps = check_union_array_like.IProps<
@@ -211,13 +213,16 @@ export namespace UnionExplorer {
         check_union_array_like<Metadata, MetadataArray, Metadata>({
             transform: (value: Metadata) =>
                 MetadataArray.create({
-                    name: `Set<${value.getName()}>`,
-                    index: null,
-                    recursive: false,
-                    nullables: [],
-                    value,
+                    tags: [],
+                    type: MetadataArrayType.create({
+                        name: `Set<${value.getName()}>`,
+                        index: null,
+                        recursive: false,
+                        nullables: [],
+                        value,
+                    }),
                 }),
-            element: (array) => array.value,
+            element: (array) => array.type.value,
             size: (input) => IdentifierFactory.access(input)("size"),
             front: (input) =>
                 IdentifierFactory.access(
@@ -254,7 +259,10 @@ export namespace UnionExplorer {
             [Metadata, Metadata]
         >({
             element: (array) =>
-                array.value.tuples[0]!.elements as [Metadata, Metadata],
+                array.type.value.tuples[0]!.type.elements as [
+                    Metadata,
+                    Metadata,
+                ],
             size: (input) => IdentifierFactory.access(input)("size"),
             front: (input) =>
                 IdentifierFactory.access(
@@ -278,25 +286,31 @@ export namespace UnionExplorer {
             name: (_m, [k, v]) => `Map<${k.getName()}, ${v.getName()}>`,
             transform: (m: Metadata.Entry) =>
                 MetadataArray.create({
-                    name: `Map<${m.key.getName()}, ${m.value.getName()}>`,
-                    index: null,
-                    recursive: false,
-                    nullables: [],
-                    value: Metadata.create({
-                        ...Metadata.initialize(),
-                        tuples: [
-                            (() => {
-                                const tuple = MetadataTuple.create({
-                                    name: `[${m.key.getName()}, ${m.value.getName()}]`,
-                                    index: null,
-                                    recursive: false,
-                                    nullables: [],
-                                    elements: [m.key, m.value],
-                                });
-                                tuple.of_map = true;
-                                return tuple;
-                            })(),
-                        ],
+                    tags: [],
+                    type: MetadataArrayType.create({
+                        name: `Map<${m.key.getName()}, ${m.value.getName()}>`,
+                        index: null,
+                        recursive: false,
+                        nullables: [],
+                        value: Metadata.create({
+                            ...Metadata.initialize(),
+                            tuples: [
+                                (() => {
+                                    const tuple = MetadataTuple.create({
+                                        tags: [],
+                                        type: MetadataTupleType.create({
+                                            name: `[${m.key.getName()}, ${m.value.getName()}]`,
+                                            index: null,
+                                            recursive: false,
+                                            nullables: [],
+                                            elements: [m.key, m.value],
+                                        }),
+                                    });
+                                    tuple.type.of_map = true;
+                                    return tuple;
+                                })(),
+                            ],
+                        }),
                     }),
                 }),
         })(props);

package/src/programmers/helpers/disable_function_importer_declare.ts

@@ -7,6 +7,7 @@ export const disable_function_importer_declare = (
 ): FunctionImporter => disable(importer) as FunctionImporter;
 
 const disable = (importer: FunctionImporter): MethodOnly<FunctionImporter> => ({
+    method: importer.method,
     empty: (): boolean => importer.empty(),
     use: (name: string): ts.Identifier => importer.use(name),
     useLocal: (name: string): string => importer.useLocal(name),
@@ -23,5 +24,9 @@ const disable = (importer: FunctionImporter): MethodOnly<FunctionImporter> => ({
 });
 
 type MethodOnly<T> = {
-    [P in keyof T]: T[P] extends Function ? T[P] : never;
+    [P in keyof T]: T[P] extends Function
+        ? T[P]
+        : P extends "method"
+        ? T[P]
+        : never;
 };

package/src/programmers/internal/application_array.ts

@@ -17,14 +17,15 @@ export const application_array =
         const schema: IJsonSchema.IArray = {
             ...attribute,
             type: "array",
-            items: application_schema(options)(false)(components)(array.value)(
-                attribute,
-            ),
+            items: application_schema(options)(false)(components)(
+                array.type.value,
+            )(attribute),
         };
 
-        // RANGE
+        // COMMENT TAGS
         for (const tag of attribute["x-typia-metaTags"] ?? [])
             if (tag.kind === "minItems") schema.minItems = tag.value;
             else if (tag.kind === "maxItems") schema.maxItems = tag.value;
+
         return schema;
     };

package/src/programmers/internal/application_default_string.ts

@@ -14,9 +14,13 @@ export const application_default_string =
             const conditions: boolean[] = [];
 
             // OTHER ATOMIC TYPES
-            if (meta.atomics.find((t) => t === "number" || t === "bigint"))
+            if (
+                meta.atomics.find(
+                    (a) => a.type === "number" || a.type === "bigint",
+                )
+            )
                 conditions.push(Number.isNaN(Number(str)));
-            if (meta.atomics.find((t) => t === "boolean"))
+            if (meta.atomics.find((a) => a.type === "boolean"))
                 conditions.push(str !== "true" && str !== "false");
             for (const constant of meta.constants)
                 for (const value of constant.values)

package/src/programmers/internal/application_resolved.ts

@@ -1,5 +1,5 @@
 import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataResolved } from "../../schemas/metadata/MetadataResolved";
+import { MetadataEscaped } from "../../schemas/metadata/MetadataEscaped";
 
 import { IJsonComponents, IJsonSchema } from "../../module";
 import { JsonApplicationProgrammer } from "../json/JsonApplicationProgrammer";
@@ -9,7 +9,7 @@ export const application_resolved =
     (options: JsonApplicationProgrammer.IOptions) =>
     <BlockNever extends boolean>(blockNever: BlockNever) =>
     (components: IJsonComponents) =>
-    (resolved: MetadataResolved) =>
+    (resolved: MetadataEscaped) =>
     (attribute: IJsonSchema.IAttribute): IJsonSchema[] => {
         const output = application_schema(options)(blockNever)(components)(
             resolved.returns,
@@ -46,9 +46,9 @@ const is_date =
 
         return (
             meta.natives.some((name) => name === "Date") ||
-            meta.arrays.some((array) => is_date(visited)(array.value)) ||
+            meta.arrays.some((array) => is_date(visited)(array.type.value)) ||
             meta.tuples.some((tuple) =>
-                tuple.elements.some(is_date(visited)),
+                tuple.type.elements.some(is_date(visited)),
             ) ||
             meta.aliases.some((alias) => is_date(visited)(alias.value))
         );

package/src/programmers/internal/application_schema.ts

@@ -58,10 +58,10 @@ export const application_schema =
                 : (schema: IJsonSchema) => union.push(schema);
 
         // toJSON() METHOD
-        if (meta.resolved !== null)
+        if (meta.escaped !== null)
             union.push(
                 ...application_resolved(options)(blockNever)(components)(
-                    meta.resolved,
+                    meta.escaped,
                 )(attribute),
             );
 
@@ -76,14 +76,14 @@ export const application_schema =
             )
                 continue;
             else insert(application_constant(constant)(attribute));
-        for (const type of meta.atomics)
-            if (type === "bigint") throw new Error(NO_BIGINT);
-            else if (AtomicPredicator.atomic(meta)(type) === false) continue;
+        for (const a of meta.atomics)
+            if (a.type === "bigint") throw new Error(NO_BIGINT);
+            else if (AtomicPredicator.atomic(meta)(a.type) === false) continue;
             else
                 insert(
-                    type === "string"
+                    a.type === "string"
                         ? application_string(meta)(attribute)
-                        : type === "boolean"
+                        : a.type === "boolean"
                         ? application_boolean(attribute)
                         : application_number(attribute),
                 );

package/src/programmers/internal/application_string.ts

@@ -1,5 +1,5 @@
 import { IJsonSchema } from "../../schemas/json/IJsonSchema";
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
+import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
 import { Metadata } from "../../schemas/metadata/Metadata";
 
 import { application_default_string } from "./application_default_string";
@@ -40,5 +40,5 @@ export const application_string =
         return output;
     };
 
-const emendFormat = (tag: IMetadataTag.IFormat["value"]) =>
+const emendFormat = (tag: IMetadataCommentTag.IFormat["value"]) =>
     tag === "datetime" ? "date-time" : tag;

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,12 +1,12 @@
 import ts from "typescript";
 
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
+import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
 
 /**
  * @internal
  */
 export const check_array_length =
-    (metaTags: IMetadataTag[]) => (input: ts.Expression) =>
+    (metaTags: IMetadataCommentTag[]) => (input: ts.Expression) =>
         metaTags
             .map((tag) => ({
                 tag,

package/src/programmers/internal/check_array_tags.ts

@@ -0,0 +1,45 @@
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+
+import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+
+import { IProject } from "../../transformers/IProject";
+
+import { ICheckEntry } from "../helpers/ICheckEntry";
+import { check_array_length } from "./check_array_length";
+
+/**
+ * @internal
+ */
+export const check_array_tags =
+    (project: IProject) =>
+    (matrix: IMetadataTypeTag[][], metaTags: IMetadataCommentTag[]) =>
+    (input: ts.Expression): ICheckEntry => ({
+        expression: is_array(project)(matrix)(input),
+        tags: matrix.length
+            ? []
+            : check_array_length(metaTags)(
+                  IdentifierFactory.access(input)("length"),
+              ),
+    });
+
+const is_array =
+    (project: IProject) =>
+    (matrix: IMetadataTypeTag[][]) =>
+    (input: ts.Expression) =>
+        matrix.length === 0
+            ? null
+            : 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));

package/src/programmers/internal/check_bigint.ts

@@ -2,22 +2,21 @@ import ts from "typescript";
 
 import { ExpressionFactory } from "../../factories/ExpressionFactory";
 
-import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
-import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
+import { IMetadataCommentTag } from "../../schemas/metadata/IMetadataCommentTag";
+import { IMetadataTypeTag } from "../../schemas/metadata/IMetadataTypeTag";
+
+import { IProject } from "../../transformers/IProject";
 
-import { FunctionImporter } from "../helpers/FunctionImporeter";
 import { ICheckEntry } from "../helpers/ICheckEntry";
-import { check_custom } from "./check_custom";
 
 /**
  * @internal
  */
 export const check_bigint =
-    (importer: FunctionImporter) =>
-    (metaTags: IMetadataTag[]) =>
-    (jsDocTag: IJsDocTagInfo[]) =>
+    (project: IProject) =>
+    (matrix: IMetadataTypeTag[][], metaTags: IMetadataCommentTag[]) =>
     (input: ts.Expression): ICheckEntry => {
-        const entries: [IMetadataTag, ts.Expression][] = [];
+        const entries: [IMetadataCommentTag, ts.Expression][] = [];
         for (const tag of metaTags) {
             if (tag.kind === "type" && tag.value === "uint64")
                 entries.push([
@@ -95,16 +94,45 @@ export const check_bigint =
                 ]);
         }
         return {
-            expression: ts.factory.createStrictEquality(
+            expression: is_bigint(project)(matrix)(input),
+            tags: matrix.length
+                ? []
+                : entries.map(([tag, expression]) => ({
+                      expected: `bigint (@${tag.kind} ${tag.value})`,
+                      expression,
+                  })),
+        };
+    };
+
+const is_bigint =
+    (project: IProject) =>
+    (matrix: IMetadataTypeTag[][]) =>
+    (input: ts.Expression) => {
+        // BASIC TYPEOF EXPRESSION
+        const conditions: ts.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),
-            ],
-        };
+        ];
+
+        // 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));
     };