typia 5.0.0-dev.20230730 → 5.0.0-dev.20230808

package/src/factories/ProtocolFactory.ts

@@ -1,80 +1,80 @@
-import ts from "typescript";
-
-import { Metadata } from "../schemas/metadata/Metadata";
-import { IProtocolMessage } from "../schemas/protobuf/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 analyze =
-        (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 "../schemas/metadata/Metadata";
+import { IProtocolMessage } from "../schemas/protobuf/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 analyze =
+        (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/MetadataHelper.ts

@@ -1,12 +1,12 @@
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-export namespace MetadataHelper {
-    export const literal_to_metadata = (key: string): Metadata => {
-        const metadata: Metadata = Metadata.initialize();
-        metadata.constants.push({
-            type: "string",
-            values: [key],
-        });
-        return metadata;
-    };
-}
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+export namespace MetadataHelper {
+    export const literal_to_metadata = (key: string): Metadata => {
+        const metadata: Metadata = Metadata.initialize();
+        metadata.constants.push({
+            type: "string",
+            values: [key],
+        });
+        return metadata;
+    };
+}

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

@@ -1,33 +1,33 @@
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-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);
-        if (index !== -1) meta.constants.splice(index, 1);
-    }
-
-    // BOOLEAN
-    {
-        const index: number = meta.constants.findIndex(
-            (c) => c.type === "boolean",
-        );
-        if (index !== -1 && meta.constants[index]!.values.length === 2) {
-            meta.constants.splice(index, 1);
-            ArrayUtil.take(
-                meta.atomics,
-                (type) => type === "boolean",
-                () => "boolean",
-            );
-        }
-    }
-
-    // TEMPLATE
-    if (
-        meta.templates.length &&
-        meta.atomics.find((type) => type === "string") !== undefined
-    )
-        meta.templates.splice(0, meta.templates.length);
-};
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+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);
+        if (index !== -1) meta.constants.splice(index, 1);
+    }
+
+    // BOOLEAN
+    {
+        const index: number = meta.constants.findIndex(
+            (c) => c.type === "boolean",
+        );
+        if (index !== -1 && meta.constants[index]!.values.length === 2) {
+            meta.constants.splice(index, 1);
+            ArrayUtil.take(
+                meta.atomics,
+                (type) => type === "boolean",
+                () => "boolean",
+            );
+        }
+    }
+
+    // TEMPLATE
+    if (
+        meta.templates.length &&
+        meta.atomics.find((type) => type === "string") !== undefined
+    )
+        meta.templates.splice(0, meta.templates.length);
+};

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

@@ -1,40 +1,40 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataAlias } from "../../../schemas/metadata/MetadataAlias";
-
-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_alias =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (type: ts.Type, nullable: boolean): MetadataAlias => {
-        // CHECK EXISTENCE
-        const [alias, newbie, closure] = collection.emplaceAlias(
-            checker,
-            type,
-            type.aliasSymbol!,
-        );
-        ArrayUtil.add(alias.nullables, nullable);
-        if (newbie === false) return alias;
-
-        // CONSTRUCT VALUE TYPE
-        const value: Metadata = explore_metadata(checker)(options)(collection)(
-            type,
-            false,
-            true,
-        );
-        closure(value);
-        alias.tags.push(
-            ...MetadataTagFactory.generate(value)(alias.jsDocTags)(
-                () => alias.name,
-            ),
-        );
-        return alias;
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataAlias } from "../../../schemas/metadata/MetadataAlias";
+
+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_alias =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (type: ts.Type, nullable: boolean): MetadataAlias => {
+        // CHECK EXISTENCE
+        const [alias, newbie, closure] = collection.emplaceAlias(
+            checker,
+            type,
+            type.aliasSymbol!,
+        );
+        ArrayUtil.add(alias.nullables, nullable);
+        if (newbie === false) return alias;
+
+        // CONSTRUCT VALUE TYPE
+        const value: Metadata = explore_metadata(checker)(options)(collection)(
+            type,
+            false,
+            true,
+        );
+        closure(value);
+        alias.tags.push(
+            ...MetadataTagFactory.generate(value)(alias.jsDocTags)(
+                () => alias.name,
+            ),
+        );
+        return alias;
+    };

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

@@ -1,34 +1,34 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataArray } from "../../../schemas/metadata/MetadataArray";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { explore_metadata } from "./explore_metadata";
-
-export const emplace_metadata_array =
-    (checker: ts.TypeChecker) =>
-    (options: MetadataFactory.IOptions) =>
-    (collection: MetadataCollection) =>
-    (type: ts.Type, nullable: boolean): MetadataArray => {
-        // CHECK EXISTENCE
-        const [array, newbie, setValue] = collection.emplaceArray(
-            checker,
-            type,
-        );
-        ArrayUtil.add(array.nullables, nullable);
-        if (newbie === false) return array;
-
-        // CONSTRUCT VALUE TYPE
-        const value: Metadata = explore_metadata(checker)(options)(collection)(
-            type.getNumberIndexType()!,
-            false,
-            false,
-        );
-        setValue(value);
-
-        return array;
-    };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataArray } from "../../../schemas/metadata/MetadataArray";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { explore_metadata } from "./explore_metadata";
+
+export const emplace_metadata_array =
+    (checker: ts.TypeChecker) =>
+    (options: MetadataFactory.IOptions) =>
+    (collection: MetadataCollection) =>
+    (type: ts.Type, nullable: boolean): MetadataArray => {
+        // CHECK EXISTENCE
+        const [array, newbie, setValue] = collection.emplaceArray(
+            checker,
+            type,
+        );
+        ArrayUtil.add(array.nullables, nullable);
+        if (newbie === false) return array;
+
+        // CONSTRUCT VALUE TYPE
+        const value: Metadata = explore_metadata(checker)(options)(collection)(
+            type.getNumberIndexType()!,
+            false,
+            false,
+        );
+        setValue(value);
+
+        return array;
+    };