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

package/src/factories/MetadataFactory.ts

@@ -9,7 +9,7 @@ import { MetadataCollection } from "./MetadataCollection";
 
 export namespace MetadataFactory {
     export interface IOptions {
-        resolve: boolean;
+        escape: boolean;
         constant: boolean;
         absorb: boolean;
         validate?: (meta: Metadata) => void;

package/src/factories/MetadataTagFactory.ts

@@ -1,16 +1,17 @@
 import ts from "typescript";
 
-import { IMetadataTag } from "../schemas/metadata/IMetadataTag";
+import { IMetadataAtomic } from "../schemas/metadata/IMetadataAtomic";
+import { IMetadataCommentTag } from "../schemas/metadata/IMetadataCommentTag";
 import { Metadata } from "../schemas/metadata/Metadata";
 
 export namespace MetadataTagFactory {
     export const generate =
         (metadata: Metadata) =>
         (tagList: ts.JSDocTagInfo[]) =>
-        (identifier: () => string): IMetadataTag[] => {
-            const output: IMetadataTag[] = [];
+        (identifier: () => string): IMetadataCommentTag[] => {
+            const output: IMetadataCommentTag[] = [];
             for (const tag of tagList) {
-                const elem: IMetadataTag | null = parse(
+                const elem: IMetadataCommentTag | null = parse(
                     identifier,
                     metadata,
                     tag,
@@ -25,8 +26,8 @@ export namespace MetadataTagFactory {
         identifier: () => string,
         metadata: Metadata,
         tag: ts.JSDocTagInfo,
-        output: IMetadataTag[],
-    ): IMetadataTag | null => {
+        output: IMetadataCommentTag[],
+    ): IMetadataCommentTag | null => {
         const closure = _PARSER[tag.name];
         if (closure === undefined) return null;
 
@@ -46,8 +47,8 @@ export namespace MetadataTagFactory {
             identifier: () => string,
             metadata: Metadata,
             text: string,
-            output: IMetadataTag[],
-        ) => IMetadataTag | null
+            output: IMetadataCommentTag[],
+        ) => IMetadataCommentTag | null
     > = {
         /* -----------------------------------------------------------
             ARRAY
@@ -178,7 +179,7 @@ export namespace MetadataTagFactory {
         // Ignore arbitrary @format values in the internal metadata,
         // these are currently only supported on the typia.application() API.
         format: (identifier, metadata, str, output) => {
-            const value: IMetadataTag.IFormat["value"] | undefined =
+            const value: IMetadataCommentTag.IFormat["value"] | undefined =
                 FORMATS.get(str);
             validate(
                 identifier,
@@ -242,7 +243,7 @@ const parse_number = (identifier: () => string, str: string): number => {
 };
 
 const LABEL = "Error on typia.MetadataTagFactory.generate()";
-const FORMATS: Map<string, IMetadataTag.IFormat["value"]> = new Map([
+const FORMATS: Map<string, IMetadataCommentTag.IFormat["value"]> = new Map([
     ["uuid", "uuid"],
     ["email", "email"],
     ["url", "url"],
@@ -263,10 +264,10 @@ const WRONG_TYPE = (
 const validate = (
     identifier: () => string,
     metadata: Metadata,
-    output: IMetadataTag[],
-    kind: IMetadataTag["kind"],
+    output: IMetadataCommentTag[],
+    kind: IMetadataCommentTag["kind"],
     type: "array" | "string" | "number" | "Date",
-    neighbors: IMetadataTag["kind"][],
+    neighbors: IMetadataCommentTag["kind"][],
 ): void => {
     // TYPE CHECKING
     if (type === "array") {
@@ -295,7 +296,6 @@ const validate = (
             );
 };
 
-// @todo: must block repeated array and tuple type
 const has_atomic =
     (type: "string" | "number" | "bigint") =>
     (visited: Set<Metadata>) =>
@@ -305,21 +305,22 @@ const has_atomic =
         return (
             metadata.atomics.find(
                 type === "number"
-                    ? (atom: string) => atom === type || atom === "bigint"
-                    : (atom: string) => atom === type,
+                    ? (atom: IMetadataAtomic) =>
+                          atom.type === type || atom.type === "bigint"
+                    : (atom: IMetadataAtomic) => atom.type === type,
             ) !== undefined ||
             metadata.arrays.some((array) =>
-                has_atomic(type)(visited)(array.value),
+                has_atomic(type)(visited)(array.type.value),
             ) ||
             metadata.tuples.some((tuple) =>
-                tuple.elements.some(has_atomic(type)(visited)),
+                tuple.type.elements.some(has_atomic(type)(visited)),
             ) ||
             metadata.maps.some((map) => has_atomic(type)(visited)(map.value)) ||
             metadata.aliases.some((alias) =>
                 has_atomic(type)(visited)(alias.value),
             ) ||
-            (metadata.resolved !== null &&
-                has_atomic(type)(visited)(metadata.resolved.returns))
+            (metadata.escaped !== null &&
+                has_atomic(type)(visited)(metadata.escaped.returns))
         );
     };
 
@@ -332,17 +333,17 @@ const has_native =
         return (
             metadata.natives.find((native) => native === type) !== undefined ||
             metadata.arrays.some((child) =>
-                has_native(type)(visited)(child.value),
+                has_native(type)(visited)(child.type.value),
             ) ||
             metadata.tuples.some((tuple) =>
-                tuple.elements.some(has_native(type)(visited)),
+                tuple.type.elements.some(has_native(type)(visited)),
             ) ||
             metadata.maps.some((map) => has_native(type)(visited)(map.value)) ||
             metadata.aliases.some((alias) =>
                 has_native(type)(visited)(alias.value),
             ) ||
-            (metadata.resolved !== null &&
-                has_native(type)(visited)(metadata.resolved.returns))
+            (metadata.escaped !== null &&
+                has_native(type)(visited)(metadata.escaped.returns))
         );
     };
 
@@ -354,11 +355,11 @@ const has_array =
         return (
             metadata.arrays.length !== 0 ||
             metadata.tuples.some((tuple) =>
-                tuple.elements.some(has_array(visited)),
+                tuple.type.elements.some(has_array(visited)),
             ) ||
             metadata.maps.some((map) => has_array(visited)(map.value)) ||
             metadata.aliases.some((alias) => has_array(visited)(alias.value)) ||
-            (metadata.resolved !== null &&
-                has_array(visited)(metadata.resolved.returns))
+            (metadata.escaped !== null &&
+                has_array(visited)(metadata.escaped.returns))
         );
     };

package/src/factories/ProtobufFactory.ts

@@ -18,7 +18,7 @@ export namespace ProtobufFactory {
         (type: ts.Type) => {
             // COMPOSE METADATA WITH INDIVIDUAL VALIDATIONS
             const top: Metadata = MetadataFactory.analyze(checker)({
-                resolve: false,
+                escape: false,
                 constant: true,
                 absorb: true,
                 validate: validate(method),
@@ -76,7 +76,7 @@ export namespace ProtobufFactory {
         // DO NOT ALLOW MULTI-DIMENTIONAL ARRAY
         else if (
             meta.arrays.length &&
-            meta.arrays.some((array) => !!array.value.arrays.length)
+            meta.arrays.some((array) => !!array.type.value.arrays.length)
         )
             throw notSupportedError({ method })("two dimenstional array type");
         // CHILD OF ARRAY TYPE MUST BE REQUIRED
@@ -84,15 +84,15 @@ export namespace ProtobufFactory {
             meta.arrays.length &&
             meta.arrays.some(
                 (array) =>
-                    array.value.isRequired() === false ||
-                    array.value.nullable === true,
+                    array.type.value.isRequired() === false ||
+                    array.type.value.nullable === true,
             )
         )
             throw notSupportedError({ method })("optional type in array");
         // UNION IN ARRAY
         else if (
             meta.arrays.length &&
-            meta.arrays.some((a) => a.value.size() > 1)
+            meta.arrays.some((a) => a.type.value.size() > 1)
         )
             throw notSupportedError({ method })("union type in array");
         // DO DYNAMIC OBJECT IN ARRAY
@@ -100,9 +100,9 @@ export namespace ProtobufFactory {
             meta.arrays.length &&
             meta.arrays.some(
                 (a) =>
-                    a.value.maps.length ||
-                    (a.value.objects.length &&
-                        a.value.objects.some(
+                    a.type.value.maps.length ||
+                    (a.type.value.objects.length &&
+                        a.type.value.objects.some(
                             (o) => ProtobufUtil.isStaticObject(o) === false,
                         )),
             )
@@ -192,12 +192,14 @@ export namespace ProtobufFactory {
         // MAP CASES
         //----
         // MAP TYPE, BUT PROPERTY KEY TYPE IS NOT STRING
+        // @todo -> need to allow other typed keys
         else if (
             meta.maps.length &&
             meta.maps.some(
                 (m) =>
                     m.key.isBinaryUnion() ||
-                    (m.key.atomics.find((v) => v === "string") === undefined &&
+                    (m.key.atomics.find((v) => v.type === "string") ===
+                        undefined &&
                         m.key.constants.find((c) => c.type === "string") ===
                             undefined),
             )
@@ -231,7 +233,7 @@ export namespace ProtobufFactory {
     };
 }
 
-const prefix = (method: string) => `Error on typia.protobuf.${method}():`;
+const prefix = (method: string) => `Error on ${method}():`;
 
 const notSupportedError = (p: { method: string }) => (title: string) =>
     new Error(

package/src/factories/internal/metadata/emend_metadata_atomics.ts

@@ -4,8 +4,10 @@ import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 export const emend_metadata_atomics = (meta: Metadata) => {
     // ATOMICS
-    for (const type of meta.atomics) {
-        const index: number = meta.constants.findIndex((c) => c.type === type);
+    for (const a of meta.atomics) {
+        const index: number = meta.constants.findIndex(
+            (c) => c.type === a.type,
+        );
         if (index !== -1) meta.constants.splice(index, 1);
     }
 
@@ -18,8 +20,8 @@ export const emend_metadata_atomics = (meta: Metadata) => {
             meta.constants.splice(index, 1);
             ArrayUtil.take(
                 meta.atomics,
-                (type) => type === "boolean",
-                () => "boolean",
+                (a) => a.type === "boolean",
+                () => ({ type: "boolean" as const, tags: [] }),
             );
         }
     }
@@ -27,7 +29,7 @@ export const emend_metadata_atomics = (meta: Metadata) => {
     // TEMPLATE
     if (
         meta.templates.length &&
-        meta.atomics.find((type) => type === "string") !== undefined
+        meta.atomics.find((a) => a.type === "string") !== undefined
     )
         meta.templates.splice(0, meta.templates.length);
 };

package/src/factories/internal/metadata/{emplace_metadata_array.ts → emplace_metadata_array_type.ts}

@@ -1,7 +1,7 @@
 import ts from "typescript";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataArray } from "../../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
@@ -9,11 +9,11 @@ import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
 import { explore_metadata } from "./explore_metadata";
 
-export const emplace_metadata_array =
+export const emplace_metadata_array_type =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (type: ts.Type, nullable: boolean): MetadataArray => {
+    (type: ts.Type, nullable: boolean): MetadataArrayType => {
         // CHECK EXISTENCE
         const [array, newbie, setValue] = collection.emplaceArray(
             checker,

package/src/factories/internal/metadata/emplace_metadata_tuple.ts

@@ -1,7 +1,7 @@
 import ts from "typescript";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataTuple } from "../../../schemas/metadata/MetadataTuple";
+import { MetadataTupleType } from "../../../schemas/metadata/MetadataTupleType";
 
 import { Writable } from "../../../typings/Writable";
 
@@ -15,7 +15,7 @@ export const emplace_metadata_tuple =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
-    (type: ts.TupleType, nullable: boolean): MetadataTuple => {
+    (type: ts.TupleType, nullable: boolean): MetadataTupleType => {
         // CHECK EXISTENCE
         const [tuple, newbie, closure] = collection.emplaceTuple(checker, type);
         ArrayUtil.add(tuple.nullables, nullable);

package/src/factories/internal/metadata/explore_metadata.ts

@@ -30,9 +30,9 @@ export const explore_metadata =
             aliased,
         );
         emend_metadata_atomics(meta);
-        if (meta.resolved) {
-            emend_metadata_atomics(meta.resolved.original);
-            emend_metadata_atomics(meta.resolved.returns);
+        if (meta.escaped) {
+            emend_metadata_atomics(meta.escaped.original);
+            emend_metadata_atomics(meta.escaped.returns);
         }
         return meta;
     };

package/src/factories/internal/metadata/iterate_metadata_array.ts

@@ -2,12 +2,13 @@ import ts from "typescript";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
-import { emplace_metadata_array } from "./emplace_metadata_array";
+import { emplace_metadata_array_type } from "./emplace_metadata_array_type";
 
 export const iterate_metadata_array =
     (checker: ts.TypeChecker) =>
@@ -16,9 +17,16 @@ export const iterate_metadata_array =
     (meta: Metadata, type: ts.Type): boolean => {
         if (!checker.isArrayType(type)) return false;
 
-        const array: MetadataArray = emplace_metadata_array(checker)(options)(
-            collection,
-        )(type, meta.nullable);
-        ArrayUtil.add(meta.arrays, array, (elem) => elem.name === array.name);
+        const arrayType: MetadataArrayType = emplace_metadata_array_type(
+            checker,
+        )(options)(collection)(type, meta.nullable);
+        ArrayUtil.add(
+            meta.arrays,
+            MetadataArray.create({
+                type: arrayType,
+                tags: [],
+            }),
+            (elem) => elem.type.name === arrayType.name,
+        );
         return true;
     };

package/src/factories/internal/metadata/iterate_metadata_atomic.ts

@@ -2,8 +2,6 @@ import ts from "typescript";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
 
-import { Atomic } from "../../../typings/Atomic";
-
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 const same = (type: ts.Type | null) => {
@@ -19,7 +17,11 @@ export const iterate_metadata_atomic = (
     const filter = same(type);
     const check = (info: IAtomicInfo) => {
         if (filter(info.atomic) || filter(info.literal)) {
-            ArrayUtil.add(meta.atomics, info.name);
+            ArrayUtil.add(
+                meta.atomics,
+                { type: info.name, tags: [] },
+                (x, y) => x.type === y.type,
+            );
             return true;
         }
         return false;
@@ -53,7 +55,7 @@ const ATOMICS: IAtomicInfo[] = [
 ];
 
 interface IAtomicInfo {
-    name: Atomic.Literal;
+    name: "boolean" | "number" | "bigint" | "string";
     atomic: ts.TypeFlags;
     literal: ts.TypeFlags;
 }

package/src/factories/internal/metadata/iterate_metadata_collection.ts

@@ -1,10 +1,10 @@
 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 { MetadataCollection } from "../../MetadataCollection";
-import { iterate_metadata_tag } from "./iterate_metadata_tag";
+import { iterate_metadata_comment_tags } from "./iterate_metadata_comment_tags";
 
 export const iterate_metadata_collection = (
     collection: MetadataCollection,
@@ -24,7 +24,7 @@ export const iterate_metadata_collection = (
             );
         }
     for (const obj of collection.objects()) {
-        iterate_metadata_tag(obj);
+        iterate_metadata_comment_tags(obj);
         if (obj.recursive === null) {
             const visited: Set<Metadata> = new Set();
             collection.setObjectRecursive(
@@ -39,34 +39,38 @@ export const iterate_metadata_collection = (
 
 const isArrayRecursive =
     (visited: Set<Metadata>) =>
-    (array: MetadataArray) =>
+    (array: MetadataArrayType) =>
     (meta: Metadata): boolean => {
         if (visited.has(meta)) return false;
         visited.add(meta);
 
         return (
             meta.arrays.some(
-                (a) => a === array || isArrayRecursive(visited)(array)(a.value),
+                (a) =>
+                    a.type === array ||
+                    isArrayRecursive(visited)(array)(a.type.value),
             ) ||
             meta.aliases.some((alias) =>
                 isArrayRecursive(visited)(array)(alias.value),
             ) ||
             meta.tuples.some(
                 (t) =>
-                    !t.recursive &&
-                    t.elements.some((e) => isArrayRecursive(visited)(array)(e)),
+                    !t.type.recursive &&
+                    t.type.elements.some((e) =>
+                        isArrayRecursive(visited)(array)(e),
+                    ),
             ) ||
             meta.maps.some((m) => isArrayRecursive(visited)(array)(m.value)) ||
             meta.sets.some((s) => isArrayRecursive(visited)(array)(s)) ||
-            (meta.resolved !== null &&
-                isArrayRecursive(visited)(array)(meta.resolved.returns)) ||
+            (meta.escaped !== null &&
+                isArrayRecursive(visited)(array)(meta.escaped.returns)) ||
             (meta.rest !== null && isArrayRecursive(visited)(array)(meta.rest))
         );
     };
 
 const isTupleRecursive =
     (visited: Set<Metadata>) =>
-    (tuple: MetadataTuple) =>
+    (tuple: MetadataTupleType) =>
     (meta: Metadata): boolean => {
         if (visited.has(meta)) return false;
         visited.add(meta);
@@ -74,20 +78,23 @@ const isTupleRecursive =
         return (
             meta.tuples.some(
                 (t) =>
-                    t === tuple ||
-                    t.elements.some((e) => isTupleRecursive(visited)(tuple)(e)),
+                    t.type === tuple ||
+                    t.type.elements.some((e) =>
+                        isTupleRecursive(visited)(tuple)(e),
+                    ),
             ) ||
             meta.arrays.some(
                 (a) =>
-                    !a.recursive && isTupleRecursive(visited)(tuple)(a.value),
+                    !a.type.recursive &&
+                    isTupleRecursive(visited)(tuple)(a.type.value),
             ) ||
             meta.maps.some((m) => isTupleRecursive(visited)(tuple)(m.value)) ||
             meta.sets.some((s) => isTupleRecursive(visited)(tuple)(s)) ||
             meta.aliases.some((alias) =>
                 isTupleRecursive(visited)(tuple)(alias.value),
             ) ||
-            (meta.resolved !== null &&
-                isTupleRecursive(visited)(tuple)(meta.resolved.returns)) ||
+            (meta.escaped !== null &&
+                isTupleRecursive(visited)(tuple)(meta.escaped.returns)) ||
             (meta.rest !== null && isTupleRecursive(visited)(tuple)(meta.rest))
         );
     };
@@ -112,13 +119,13 @@ const isObjectRecursive =
             ) ||
             meta.arrays.some(
                 (array) =>
-                    !array.recursive &&
-                    isObjectRecursive(visited)(obj)(array.value),
+                    !array.type.recursive &&
+                    isObjectRecursive(visited)(obj)(array.type.value),
             ) ||
             meta.tuples.some(
                 (tuple) =>
-                    !tuple.recursive &&
-                    tuple.elements.some((elem) =>
+                    !tuple.type.recursive &&
+                    tuple.type.elements.some((elem) =>
                         isObjectRecursive(visited)(obj)(elem),
                     ),
             ) ||
@@ -126,8 +133,8 @@ const isObjectRecursive =
                 isObjectRecursive(visited)(obj)(map.value),
             ) ||
             meta.sets.some((value) => isObjectRecursive(visited)(obj)(value)) ||
-            (meta.resolved !== null &&
-                isObjectRecursive(visited)(obj)(meta.resolved.returns)) ||
+            (meta.escaped !== null &&
+                isObjectRecursive(visited)(obj)(meta.escaped.returns)) ||
             (meta.rest !== null && isObjectRecursive(visited)(obj)(meta.rest))
         );
     };

package/src/factories/internal/metadata/{iterate_metadata_tag.ts → iterate_metadata_comment_tags.ts}

@@ -6,7 +6,7 @@ import { Escaper } from "../../../utils/Escaper";
 
 import { MetadataTagFactory } from "../../MetadataTagFactory";
 
-export const iterate_metadata_tag = (obj: MetadataObject) => {
+export const iterate_metadata_comment_tags = (obj: MetadataObject) => {
     if (obj.tagged_ === true) return;
     obj.tagged_ = true;