typia 5.0.0-dev.20230711 → 5.0.0-dev.20230715

package/src/factories/ProtocolFactory.ts

@@ -1,80 +1,80 @@
-import ts from "typescript";
-
-import { Metadata } from "../metadata/Metadata";
-
-import { IProtocolMessage } from "../messages/IProtocolMessage";
-import { MetadataCollection } from "./MetadataCollection";
-import { MetadataFactory } from "./MetadataFactory";
-import { emplace_protocol_object } from "./internal/protocols/emplace_protocol_object";
-import { iterate_protocol_main } from "./internal/protocols/iterate_protocol_main";
-
-export namespace ProtocolFactory {
-    export const metadata =
-        (checker: ts.TypeChecker) =>
-        (collection: MetadataCollection) =>
-        (type: ts.Type) =>
-            MetadataFactory.analyze(checker)({
-                resolve: false,
-                constant: true,
-                absorb: true,
-                validate: (meta) => {
-                    if (meta.any) throw new Error(ErrorMessages.NO_ANY);
-                    else if (meta.functional && meta.size() !== 1)
-                        throw new Error(ErrorMessages.NO_FUNCTIONAL);
-                    else if (meta.objects.find((o) => o.name === "__Main"))
-                        throw new Error(ErrorMessages.NO_MAIN);
-                    else if (meta.objects.find((o) => o.name === "__Timestamp"))
-                        throw new Error(ErrorMessages.NO_TIMESTAMP);
-                    else if (
-                        meta.objects.some((o) =>
-                            o.properties.some((p) => !is_atomic_key(p.key)),
-                        ) ||
-                        meta.maps.some((m) => !is_atomic_key(m.key))
-                    )
-                        throw new Error(ErrorMessages.NOT_ALLOWED_KEY);
-                },
-            })(collection)(type);
-
-    export const generate =
-        (collection: MetadataCollection) =>
-        (dict: Map<string, IProtocolMessage>) =>
-        (meta: Metadata) => {
-            // EMPLACE OBJECTS
-            for (const obj of collection.objects())
-                emplace_protocol_object(dict)(obj);
-
-            // WHEN NOT OBJECT, WRAP IT INTO A FAKE MAIN OBJECT
-            iterate_protocol_main(dict)(meta);
-        };
-
-    const is_atomic_key = (key: Metadata) => {
-        if (
-            key.required &&
-            key.nullable === false &&
-            key.functional === false &&
-            key.resolved === null &&
-            key.size() ===
-                key.atomics.length +
-                    key.constants
-                        .map((c) => c.values.length)
-                        .reduce((a, b) => a + b, 0) +
-                    key.templates.length
-        ) {
-            const set: Set<string> = new Set();
-            for (const atomic of key.atomics) set.add(atomic);
-            for (const constant of key.constants) set.add(constant.type);
-            if (key.templates.length) set.add("string");
-
-            return set.size === 1;
-        }
-        return false;
-    };
-}
-
-const enum ErrorMessages {
-    NO_ANY = `Error on typia.message(): any type is not supported in protocol buffer.`,
-    NO_FUNCTIONAL = `Error on typia.message(): functional type is not supported in protocol buffer.`,
-    NO_MAIN = `Error on typia.message(): reserved type "__Main" has been detected.`,
-    NO_TIMESTAMP = `Error on typia.message(): reserved type "__Timestamp" has been detected.`,
-    NOT_ALLOWED_KEY = `Error on typia.message(): only atomic key type is supported in protocol buffer.`,
-}
+import ts from "typescript";
+
+import { Metadata } from "../metadata/Metadata";
+
+import { IProtocolMessage } from "../messages/IProtocolMessage";
+import { MetadataCollection } from "./MetadataCollection";
+import { MetadataFactory } from "./MetadataFactory";
+import { emplace_protocol_object } from "./internal/protocols/emplace_protocol_object";
+import { iterate_protocol_main } from "./internal/protocols/iterate_protocol_main";
+
+export namespace ProtocolFactory {
+    export const metadata =
+        (checker: ts.TypeChecker) =>
+        (collection: MetadataCollection) =>
+        (type: ts.Type) =>
+            MetadataFactory.analyze(checker)({
+                resolve: false,
+                constant: true,
+                absorb: true,
+                validate: (meta) => {
+                    if (meta.any) throw new Error(ErrorMessages.NO_ANY);
+                    else if (meta.functional && meta.size() !== 1)
+                        throw new Error(ErrorMessages.NO_FUNCTIONAL);
+                    else if (meta.objects.find((o) => o.name === "__Main"))
+                        throw new Error(ErrorMessages.NO_MAIN);
+                    else if (meta.objects.find((o) => o.name === "__Timestamp"))
+                        throw new Error(ErrorMessages.NO_TIMESTAMP);
+                    else if (
+                        meta.objects.some((o) =>
+                            o.properties.some((p) => !is_atomic_key(p.key)),
+                        ) ||
+                        meta.maps.some((m) => !is_atomic_key(m.key))
+                    )
+                        throw new Error(ErrorMessages.NOT_ALLOWED_KEY);
+                },
+            })(collection)(type);
+
+    export const generate =
+        (collection: MetadataCollection) =>
+        (dict: Map<string, IProtocolMessage>) =>
+        (meta: Metadata) => {
+            // EMPLACE OBJECTS
+            for (const obj of collection.objects())
+                emplace_protocol_object(dict)(obj);
+
+            // WHEN NOT OBJECT, WRAP IT INTO A FAKE MAIN OBJECT
+            iterate_protocol_main(dict)(meta);
+        };
+
+    const is_atomic_key = (key: Metadata) => {
+        if (
+            key.required &&
+            key.nullable === false &&
+            key.functional === false &&
+            key.resolved === null &&
+            key.size() ===
+                key.atomics.length +
+                    key.constants
+                        .map((c) => c.values.length)
+                        .reduce((a, b) => a + b, 0) +
+                    key.templates.length
+        ) {
+            const set: Set<string> = new Set();
+            for (const atomic of key.atomics) set.add(atomic);
+            for (const constant of key.constants) set.add(constant.type);
+            if (key.templates.length) set.add("string");
+
+            return set.size === 1;
+        }
+        return false;
+    };
+}
+
+const enum ErrorMessages {
+    NO_ANY = `Error on typia.message(): any type is not supported in protocol buffer.`,
+    NO_FUNCTIONAL = `Error on typia.message(): functional type is not supported in protocol buffer.`,
+    NO_MAIN = `Error on typia.message(): reserved type "__Main" has been detected.`,
+    NO_TIMESTAMP = `Error on typia.message(): reserved type "__Timestamp" has been detected.`,
+    NOT_ALLOWED_KEY = `Error on typia.message(): only atomic key type is supported in protocol buffer.`,
+}

package/src/factories/internal/metadata/{emplace_metadata_definition.ts → emplace_metadata_alias.ts}

@@ -7,9 +7,10 @@ import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
+import { MetadataTagFactory } from "../../MetadataTagFactory";
 import { explore_metadata } from "./explore_metadata";
 
-export const emplace_metadata_definition =
+export const emplace_metadata_alias =
     (checker: ts.TypeChecker) =>
     (options: MetadataFactory.IOptions) =>
     (collection: MetadataCollection) =>
@@ -30,6 +31,10 @@ export const emplace_metadata_definition =
             true,
         );
         closure(value);
-
+        alias.tags.push(
+            ...MetadataTagFactory.generate(value)(alias.jsDocTags)(
+                () => alias.name,
+            ),
+        );
         return alias;
     };

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

@@ -7,7 +7,7 @@ import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
-import { emplace_metadata_definition } from "./emplace_metadata_definition";
+import { emplace_metadata_alias } from "./emplace_metadata_alias";
 
 export const iterate_metadata_alias =
     (checker: ts.TypeChecker) =>
@@ -22,9 +22,9 @@ export const iterate_metadata_alias =
         if (node === undefined) return false;
 
         // CONSTRUCT DEFINITION
-        const alias: MetadataAlias = emplace_metadata_definition(checker)(
-            options,
-        )(collection)(type, meta.nullable);
+        const alias: MetadataAlias = emplace_metadata_alias(checker)(options)(
+            collection,
+        )(type, meta.nullable);
         ArrayUtil.add(meta.aliases, alias, (elem) => elem.name === alias.name);
         return true;
     };

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

@@ -48,8 +48,8 @@ const isArrayRecursive =
             meta.arrays.some(
                 (a) => a === array || isArrayRecursive(visited)(array)(a.value),
             ) ||
-            meta.aliases.some((d) =>
-                isArrayRecursive(visited)(array)(d.value),
+            meta.aliases.some((alias) =>
+                isArrayRecursive(visited)(array)(alias.value),
             ) ||
             meta.tuples.some(
                 (t) =>
@@ -83,8 +83,8 @@ const isTupleRecursive =
             ) ||
             meta.maps.some((m) => isTupleRecursive(visited)(tuple)(m.value)) ||
             meta.sets.some((s) => isTupleRecursive(visited)(tuple)(s)) ||
-            meta.aliases.some((d) =>
-                isTupleRecursive(visited)(tuple)(d.value),
+            meta.aliases.some((alias) =>
+                isTupleRecursive(visited)(tuple)(alias.value),
             ) ||
             (meta.resolved !== null &&
                 isTupleRecursive(visited)(tuple)(meta.resolved.returns)) ||

package/src/factories/internal/protocols/ProtocolMetadataUtil.ts

@@ -1,180 +1,180 @@
-import { IMetadataTag } from "../../../metadata/IMetadataTag";
-import { Metadata } from "../../../metadata/Metadata";
-import { MetadataArray } from "../../../metadata/MetadataArray";
-import { MetadataObject } from "../../../metadata/MetadataObject";
-import { MetadataProperty } from "../../../metadata/MetadataProperty";
-
-import { Atomic } from "../../../typings/Atomic";
-
-export namespace ProtocolMetadataUtil {
-    export function size(meta: Metadata): number {
-        return (
-            meta.atomics.length +
-            meta.constants.filter(
-                (c) =>
-                    meta.atomics.find((type) => c.type === type) === undefined,
-            ).length +
-            (meta.templates.length !== 0 &&
-            meta.atomics.find((type) => type === "string") === undefined &&
-            meta.constants.find((c) => c.type === "string") === undefined
-                ? 1
-                : 0) +
-            meta.tuples.length +
-            meta.arrays.length +
-            meta.sets.length +
-            meta.maps.length +
-            meta.objects.length +
-            meta.natives.filter((n) => n === "Date").length +
-            (meta.natives.filter((n) => n !== "Date").length ? 1 : 0)
-        );
-    }
-
-    export function standalone(meta: Metadata): boolean {
-        return (
-            size(meta) === 1 &&
-            meta.required === true &&
-            meta.nullable === false &&
-            meta.tuples.length === 0 &&
-            meta.arrays.length === 0 &&
-            meta.sets.length === 0 &&
-            meta.maps.length === 0 &&
-            meta.objects.every((obj) =>
-                obj.properties.every((p) => p.key.isSoleLiteral()),
-            )
-        );
-    }
-
-    export function regular(obj: MetadataObject): boolean {
-        return obj.properties.every((p) => p.key.isSoleLiteral());
-    }
-
-    export function object(name: string, index: number): MetadataObject {
-        return MetadataObject.create({
-            name,
-            index,
-            properties: [],
-            description: undefined,
-            jsDocTags: [],
-            validated: false,
-            recursive: false,
-            nullables: [false],
-        });
-    }
-
-    export function property(
-        key: string,
-        value: Metadata,
-        tags: IMetadataTag[],
-    ): MetadataProperty {
-        return MetadataProperty.create({
-            key: (() => {
-                const meta: Metadata = Metadata.initialize();
-                meta.constants.push({
-                    type: "string",
-                    values: [key],
-                });
-                return meta;
-            })(),
-            value: value,
-            description: null,
-            tags,
-            jsDocTags: [],
-        });
-    }
-
-    export function array(meta: Metadata): Metadata {
-        return Metadata.create({
-            any: false,
-            required: true,
-            optional: false,
-            nullable: false,
-            functional: false,
-            resolved: null,
-            aliases: [],
-            atomics: [],
-            constants: [],
-            templates: [],
-            rest: null,
-            arrays: [
-                MetadataArray.create({
-                    name: meta.getName(),
-                    value: meta,
-                    nullables: [false],
-                    recursive: false,
-                    index: null,
-                }),
-            ],
-            tuples: [],
-            objects: [],
-            natives: [],
-            sets: [],
-            maps: [],
-        });
-    }
-
-    export function atomic(type: Atomic.Literal): Metadata {
-        return Metadata.create({
-            any: false,
-            required: true,
-            optional: false,
-            nullable: false,
-            functional: false,
-            resolved: null,
-            aliases: [],
-            atomics: [type],
-            constants: [],
-            templates: [],
-            rest: null,
-            arrays: [],
-            tuples: [],
-            objects: [],
-            natives: [],
-            sets: [],
-            maps: [],
-        });
-    }
-
-    export function reference(obj: MetadataObject): Metadata {
-        return Metadata.create({
-            any: false,
-            required: true,
-            optional: false,
-            nullable: false,
-            functional: false,
-            resolved: null,
-            aliases: [],
-            atomics: [],
-            constants: [],
-            templates: [],
-            rest: null,
-            arrays: [],
-            tuples: [],
-            objects: [obj],
-            natives: [],
-            sets: [],
-            maps: [],
-        });
-    }
-
-    export function map(elem: Metadata.Entry): Metadata {
-        return Metadata.create({
-            any: false,
-            required: true,
-            optional: false,
-            nullable: false,
-            functional: false,
-            resolved: null,
-            aliases: [],
-            atomics: [],
-            constants: [],
-            templates: [],
-            rest: null,
-            arrays: [],
-            tuples: [],
-            objects: [],
-            natives: [],
-            sets: [],
-            maps: [elem],
-        });
-    }
-}
+import { IMetadataTag } from "../../../metadata/IMetadataTag";
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataArray } from "../../../metadata/MetadataArray";
+import { MetadataObject } from "../../../metadata/MetadataObject";
+import { MetadataProperty } from "../../../metadata/MetadataProperty";
+
+import { Atomic } from "../../../typings/Atomic";
+
+export namespace ProtocolMetadataUtil {
+    export function size(meta: Metadata): number {
+        return (
+            meta.atomics.length +
+            meta.constants.filter(
+                (c) =>
+                    meta.atomics.find((type) => c.type === type) === undefined,
+            ).length +
+            (meta.templates.length !== 0 &&
+            meta.atomics.find((type) => type === "string") === undefined &&
+            meta.constants.find((c) => c.type === "string") === undefined
+                ? 1
+                : 0) +
+            meta.tuples.length +
+            meta.arrays.length +
+            meta.sets.length +
+            meta.maps.length +
+            meta.objects.length +
+            meta.natives.filter((n) => n === "Date").length +
+            (meta.natives.filter((n) => n !== "Date").length ? 1 : 0)
+        );
+    }
+
+    export function standalone(meta: Metadata): boolean {
+        return (
+            size(meta) === 1 &&
+            meta.required === true &&
+            meta.nullable === false &&
+            meta.tuples.length === 0 &&
+            meta.arrays.length === 0 &&
+            meta.sets.length === 0 &&
+            meta.maps.length === 0 &&
+            meta.objects.every((obj) =>
+                obj.properties.every((p) => p.key.isSoleLiteral()),
+            )
+        );
+    }
+
+    export function regular(obj: MetadataObject): boolean {
+        return obj.properties.every((p) => p.key.isSoleLiteral());
+    }
+
+    export function object(name: string, index: number): MetadataObject {
+        return MetadataObject.create({
+            name,
+            index,
+            properties: [],
+            description: undefined,
+            jsDocTags: [],
+            validated: false,
+            recursive: false,
+            nullables: [false],
+        });
+    }
+
+    export function property(
+        key: string,
+        value: Metadata,
+        tags: IMetadataTag[],
+    ): MetadataProperty {
+        return MetadataProperty.create({
+            key: (() => {
+                const meta: Metadata = Metadata.initialize();
+                meta.constants.push({
+                    type: "string",
+                    values: [key],
+                });
+                return meta;
+            })(),
+            value: value,
+            description: null,
+            tags,
+            jsDocTags: [],
+        });
+    }
+
+    export function array(meta: Metadata): Metadata {
+        return Metadata.create({
+            any: false,
+            required: true,
+            optional: false,
+            nullable: false,
+            functional: false,
+            resolved: null,
+            aliases: [],
+            atomics: [],
+            constants: [],
+            templates: [],
+            rest: null,
+            arrays: [
+                MetadataArray.create({
+                    name: meta.getName(),
+                    value: meta,
+                    nullables: [false],
+                    recursive: false,
+                    index: null,
+                }),
+            ],
+            tuples: [],
+            objects: [],
+            natives: [],
+            sets: [],
+            maps: [],
+        });
+    }
+
+    export function atomic(type: Atomic.Literal): Metadata {
+        return Metadata.create({
+            any: false,
+            required: true,
+            optional: false,
+            nullable: false,
+            functional: false,
+            resolved: null,
+            aliases: [],
+            atomics: [type],
+            constants: [],
+            templates: [],
+            rest: null,
+            arrays: [],
+            tuples: [],
+            objects: [],
+            natives: [],
+            sets: [],
+            maps: [],
+        });
+    }
+
+    export function reference(obj: MetadataObject): Metadata {
+        return Metadata.create({
+            any: false,
+            required: true,
+            optional: false,
+            nullable: false,
+            functional: false,
+            resolved: null,
+            aliases: [],
+            atomics: [],
+            constants: [],
+            templates: [],
+            rest: null,
+            arrays: [],
+            tuples: [],
+            objects: [obj],
+            natives: [],
+            sets: [],
+            maps: [],
+        });
+    }
+
+    export function map(elem: Metadata.Entry): Metadata {
+        return Metadata.create({
+            any: false,
+            required: true,
+            optional: false,
+            nullable: false,
+            functional: false,
+            resolved: null,
+            aliases: [],
+            atomics: [],
+            constants: [],
+            templates: [],
+            rest: null,
+            arrays: [],
+            tuples: [],
+            objects: [],
+            natives: [],
+            sets: [],
+            maps: [elem],
+        });
+    }
+}

package/src/factories/internal/protocols/emplace_protocol_object.ts

@@ -1,25 +1,25 @@
-import { MetadataObject } from "../../../metadata/MetadataObject";
-
-import { IProtocolMessage } from "../../../messages/IProtocolMessage";
-import { emplace_protocol_property } from "./emplace_protocol_property";
-
-export const emplace_protocol_object =
-    (dict: Map<string, IProtocolMessage>) => (object: MetadataObject) => {
-        if (dict.has(object.name)) return;
-
-        const regular = object.properties.filter((p) => p.key.isSoleLiteral());
-        const dynamic = object.properties.filter((p) => !p.key.isSoleLiteral());
-
-        if (dynamic.length) return;
-
-        const output: IProtocolMessage = {
-            name: object.name,
-            properties: [],
-        };
-        dict.set(object.name, output);
-
-        output.properties.push(
-            ...regular.map((prop) => emplace_protocol_property(dict)(prop)),
-        );
-        return output;
-    };
+import { MetadataObject } from "../../../metadata/MetadataObject";
+
+import { IProtocolMessage } from "../../../messages/IProtocolMessage";
+import { emplace_protocol_property } from "./emplace_protocol_property";
+
+export const emplace_protocol_object =
+    (dict: Map<string, IProtocolMessage>) => (object: MetadataObject) => {
+        if (dict.has(object.name)) return;
+
+        const regular = object.properties.filter((p) => p.key.isSoleLiteral());
+        const dynamic = object.properties.filter((p) => !p.key.isSoleLiteral());
+
+        if (dynamic.length) return;
+
+        const output: IProtocolMessage = {
+            name: object.name,
+            properties: [],
+        };
+        dict.set(object.name, output);
+
+        output.properties.push(
+            ...regular.map((prop) => emplace_protocol_property(dict)(prop)),
+        );
+        return output;
+    };

package/src/factories/internal/protocols/emplace_protocol_property.ts

@@ -1,12 +1,12 @@
-import { MetadataProperty } from "../../../metadata/MetadataProperty";
-
-import { IProtocolMessage } from "../../../messages/IProtocolMessage";
-import { IProtocolProperty } from "../../../messages/IProtocolProperty";
-import { iterate_protocol_metadata } from "./iterate_protocol_metadata";
-
-export const emplace_protocol_property =
-    (dict: Map<string, IProtocolMessage>) =>
-    (property: MetadataProperty): IProtocolProperty => ({
-        key: property.key.getSoleLiteral()!,
-        ...iterate_protocol_metadata(dict)(property.value)(property.tags),
-    });
+import { MetadataProperty } from "../../../metadata/MetadataProperty";
+
+import { IProtocolMessage } from "../../../messages/IProtocolMessage";
+import { IProtocolProperty } from "../../../messages/IProtocolProperty";
+import { iterate_protocol_metadata } from "./iterate_protocol_metadata";
+
+export const emplace_protocol_property =
+    (dict: Map<string, IProtocolMessage>) =>
+    (property: MetadataProperty): IProtocolProperty => ({
+        key: property.key.getSoleLiteral()!,
+        ...iterate_protocol_metadata(dict)(property.value)(property.tags),
+    });