typia 5.0.0-dev.20230711 → 5.0.0-dev.20230713

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

@@ -1,27 +1,27 @@
-import { MetadataConstant } from "../../../metadata/MetadataConstant";
-
-export const iterate_protocol_constant = ({
-    type,
-    values,
-}: MetadataConstant) => {
-    if (type === "boolean") return "bool";
-    else if (type === "number") return number(values);
-    else if (type === "bigint") return bigint(values);
-    else return "string";
-};
-
-const bigint = (values: bigint[]): string => {
-    return values.every((v) => v >= BigInt(0)) ? "uint64" : "int64";
-};
-
-const number = (values: number[]): string => {
-    return values.some((v) => Math.floor(v) !== v)
-        ? "double"
-        : values.every((v) => v >= 0)
-        ? values.every((v) => v <= 2 ** 64 - 1)
-            ? "uint32"
-            : "uint64"
-        : values.every((v) => -(2 ** 31) <= v && v <= 2 ** 31 - 1)
-        ? "int32"
-        : "int64";
-};
+import { MetadataConstant } from "../../../metadata/MetadataConstant";
+
+export const iterate_protocol_constant = ({
+    type,
+    values,
+}: MetadataConstant) => {
+    if (type === "boolean") return "bool";
+    else if (type === "number") return number(values);
+    else if (type === "bigint") return bigint(values);
+    else return "string";
+};
+
+const bigint = (values: bigint[]): string => {
+    return values.every((v) => v >= BigInt(0)) ? "uint64" : "int64";
+};
+
+const number = (values: number[]): string => {
+    return values.some((v) => Math.floor(v) !== v)
+        ? "double"
+        : values.every((v) => v >= 0)
+        ? values.every((v) => v <= 2 ** 64 - 1)
+            ? "uint32"
+            : "uint64"
+        : values.every((v) => -(2 ** 31) <= v && v <= 2 ** 31 - 1)
+        ? "int32"
+        : "int64";
+};

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

@@ -1,19 +1,19 @@
-import { Metadata } from "../../../metadata/Metadata";
-
-import { IProtocolMessage } from "../../../messages/IProtocolMessage";
-import { ProtocolMetadataUtil } from "./ProtocolMetadataUtil";
-import { emplace_protocol_object } from "./emplace_protocol_object";
-
-export const iterate_protocol_main =
-    (dict: Map<string, IProtocolMessage>) =>
-    (meta: Metadata): string => {
-        // ONLY ONE OBJECT TYPE
-        if (ProtocolMetadataUtil.standalone(meta) && meta.objects.length === 1)
-            return meta.getName();
-
-        const obj = ProtocolMetadataUtil.object("__Main", dict.size);
-        obj.properties.push(ProtocolMetadataUtil.property("value", meta, []));
-        emplace_protocol_object(dict)(obj);
-
-        return obj.name;
-    };
+import { Metadata } from "../../../metadata/Metadata";
+
+import { IProtocolMessage } from "../../../messages/IProtocolMessage";
+import { ProtocolMetadataUtil } from "./ProtocolMetadataUtil";
+import { emplace_protocol_object } from "./emplace_protocol_object";
+
+export const iterate_protocol_main =
+    (dict: Map<string, IProtocolMessage>) =>
+    (meta: Metadata): string => {
+        // ONLY ONE OBJECT TYPE
+        if (ProtocolMetadataUtil.standalone(meta) && meta.objects.length === 1)
+            return meta.getName();
+
+        const obj = ProtocolMetadataUtil.object("__Main", dict.size);
+        obj.properties.push(ProtocolMetadataUtil.property("value", meta, []));
+        emplace_protocol_object(dict)(obj);
+
+        return obj.name;
+    };

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

@@ -1,58 +1,58 @@
-import { Metadata } from "../../../metadata/Metadata";
-import { MetadataObject } from "../../../metadata/MetadataObject";
-
-import { IProtocolMap } from "../../../messages/IProtocolMap";
-import { IProtocolMessage } from "../../../messages/IProtocolMessage";
-import { ProtocolMetadataUtil } from "./ProtocolMetadataUtil";
-import { emplace_protocol_object } from "./emplace_protocol_object";
-import { iterate_protocol_atomic } from "./iterate_protocol_atomic";
-import { iterate_protocol_constant } from "./iterate_protocol_constant";
-import { iterate_protocol_metadata } from "./iterate_protocol_metadata";
-
-export const iterate_protocol_map =
-    (sole: boolean) =>
-    (dict: Map<string, IProtocolMessage>) =>
-    (prop: Metadata.Entry): string | IProtocolMap => {
-        if (sole === true)
-            return {
-                type: "map",
-                key: getKeyName(prop.key),
-                value: getValueName(dict)(prop.value),
-            };
-
-        const obj: MetadataObject = ProtocolMetadataUtil.object(
-            `Map.Wrapper<${prop.key.getName()}, ${prop.value.getName()}>`,
-            dict.size,
-        );
-        obj.properties.push(
-            ProtocolMetadataUtil.property(
-                "value",
-                ProtocolMetadataUtil.map(prop),
-                [],
-            ),
-        );
-        emplace_protocol_object(dict)(obj);
-        return obj.name;
-    };
-
-const getKeyName = (meta: Metadata) => {
-    for (const atomic of meta.atomics)
-        return iterate_protocol_atomic([])(atomic);
-    for (const constant of meta.constants)
-        return iterate_protocol_constant(constant);
-    return "string";
-};
-
-const getValueName =
-    (dict: Map<string, IProtocolMessage>) => (meta: Metadata) => {
-        if (ProtocolMetadataUtil.standalone(meta))
-            return iterate_protocol_metadata(dict)(meta)([]).oneOf[0]!.type;
-
-        const obj: MetadataObject = ProtocolMetadataUtil.object(
-            `Map.Value<${meta.getName()}>`,
-            dict.size,
-        );
-        obj.properties.push(ProtocolMetadataUtil.property("value", meta, []));
-        emplace_protocol_object(dict)(obj);
-        return obj.name;
-    };
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataObject } from "../../../metadata/MetadataObject";
+
+import { IProtocolMap } from "../../../messages/IProtocolMap";
+import { IProtocolMessage } from "../../../messages/IProtocolMessage";
+import { ProtocolMetadataUtil } from "./ProtocolMetadataUtil";
+import { emplace_protocol_object } from "./emplace_protocol_object";
+import { iterate_protocol_atomic } from "./iterate_protocol_atomic";
+import { iterate_protocol_constant } from "./iterate_protocol_constant";
+import { iterate_protocol_metadata } from "./iterate_protocol_metadata";
+
+export const iterate_protocol_map =
+    (sole: boolean) =>
+    (dict: Map<string, IProtocolMessage>) =>
+    (prop: Metadata.Entry): string | IProtocolMap => {
+        if (sole === true)
+            return {
+                type: "map",
+                key: getKeyName(prop.key),
+                value: getValueName(dict)(prop.value),
+            };
+
+        const obj: MetadataObject = ProtocolMetadataUtil.object(
+            `Map.Wrapper<${prop.key.getName()}, ${prop.value.getName()}>`,
+            dict.size,
+        );
+        obj.properties.push(
+            ProtocolMetadataUtil.property(
+                "value",
+                ProtocolMetadataUtil.map(prop),
+                [],
+            ),
+        );
+        emplace_protocol_object(dict)(obj);
+        return obj.name;
+    };
+
+const getKeyName = (meta: Metadata) => {
+    for (const atomic of meta.atomics)
+        return iterate_protocol_atomic([])(atomic);
+    for (const constant of meta.constants)
+        return iterate_protocol_constant(constant);
+    return "string";
+};
+
+const getValueName =
+    (dict: Map<string, IProtocolMessage>) => (meta: Metadata) => {
+        if (ProtocolMetadataUtil.standalone(meta))
+            return iterate_protocol_metadata(dict)(meta)([]).oneOf[0]!.type;
+
+        const obj: MetadataObject = ProtocolMetadataUtil.object(
+            `Map.Value<${meta.getName()}>`,
+            dict.size,
+        );
+        obj.properties.push(ProtocolMetadataUtil.property("value", meta, []));
+        emplace_protocol_object(dict)(obj);
+        return obj.name;
+    };

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

@@ -1,96 +1,96 @@
-import { IMetadataTag } from "../../../metadata/IMetadataTag";
-import { Metadata } from "../../../metadata/Metadata";
-
-import { IProtocolMap } from "../../../messages/IProtocolMap";
-import { IProtocolMessage } from "../../../messages/IProtocolMessage";
-import { IProtocolProperty } from "../../../messages/IProtocolProperty";
-import { iterate_protocol_atomic } from "./iterate_protocol_atomic";
-import { iterate_protocol_constant } from "./iterate_protocol_constant";
-import { iterate_protocol_map } from "./iterate_protocol_map";
-import { iterate_protocol_native } from "./iterate_protocol_native";
-import { iterate_protocol_never } from "./iterate_protocol_never";
-import { iterate_protocol_object } from "./iterate_protocol_object";
-import { iterate_protocol_repeated } from "./iterate_protocol_repeated";
-import { iterate_protocol_tuple } from "./iterate_protocol_tuple";
-
-export const iterate_protocol_metadata =
-    (dict: Map<string, IProtocolMessage>) =>
-    (meta: Metadata) =>
-    (tags: IMetadataTag[]): Omit<IProtocolProperty, "key"> => {
-        // PREPARE ASSETS
-        const sole: boolean = meta.size() === 1;
-        const bucket: boolean = sole && meta.bucket() === 1;
-        const required: boolean =
-            (meta.required && !meta.nullable) ||
-            (sole &&
-                (meta.arrays.length === 1 ||
-                    meta.sets.length === 1 ||
-                    meta.maps.length === 1 ||
-                    (meta.objects.length === 1 &&
-                        meta.objects[0]!.properties.length === 1 &&
-                        !meta.objects[0]!.properties[0]?.key.isSoleLiteral())));
-
-        const oneOf: IProtocolProperty.IOneOf[] = [];
-        const add = (type: string | IProtocolMap) => {
-            if (oneOf.some((one) => one.type === type)) return;
-            oneOf.push({
-                type,
-            });
-        };
-
-        // WHEN SINGULAR ARRAY TYPE
-        if (sole && meta.arrays.length + meta.sets.length === 1) {
-            const [container, child] =
-                meta.arrays.length === 1
-                    ? (["Array", meta.arrays[0]!.value] as const)
-                    : (["Set", meta.sets[0]!] as const);
-            add(
-                iterate_protocol_repeated(container)(true, true)(dict)(child)(
-                    tags,
-                ),
-            );
-            return {
-                required,
-                oneOf,
-                repeated: true,
-            };
-        }
-
-        // ATOMIC TYPES
-        for (const type of meta.atomics)
-            add(iterate_protocol_atomic(tags)(type));
-        for (const constant of meta.constants)
-            add(iterate_protocol_constant(constant));
-        if (meta.templates.length) add("string");
-        if (meta.size() === 0) add(iterate_protocol_never());
-
-        // OBJECT TYPES
-        for (const obj of meta.objects)
-            add(iterate_protocol_object(sole)(dict)(obj));
-        for (const map of meta.maps) add(iterate_protocol_map(sole)(dict)(map));
-        for (const native of meta.natives)
-            add(iterate_protocol_native(dict)(native));
-
-        // ARRAY TYPES
-        for (const tuple of meta.tuples)
-            add(iterate_protocol_tuple(dict)(tuple.elements));
-        for (const array of meta.arrays)
-            add(
-                iterate_protocol_repeated("Array")(false, bucket)(dict)(
-                    array.value,
-                )(tags),
-            );
-        for (const set of meta.sets)
-            add(
-                iterate_protocol_repeated("Set")(false, bucket)(dict)(set)(
-                    tags,
-                ),
-            );
-
-        // RETURNS
-        return {
-            required,
-            oneOf,
-            repeated: false,
-        };
-    };
+import { IMetadataTag } from "../../../metadata/IMetadataTag";
+import { Metadata } from "../../../metadata/Metadata";
+
+import { IProtocolMap } from "../../../messages/IProtocolMap";
+import { IProtocolMessage } from "../../../messages/IProtocolMessage";
+import { IProtocolProperty } from "../../../messages/IProtocolProperty";
+import { iterate_protocol_atomic } from "./iterate_protocol_atomic";
+import { iterate_protocol_constant } from "./iterate_protocol_constant";
+import { iterate_protocol_map } from "./iterate_protocol_map";
+import { iterate_protocol_native } from "./iterate_protocol_native";
+import { iterate_protocol_never } from "./iterate_protocol_never";
+import { iterate_protocol_object } from "./iterate_protocol_object";
+import { iterate_protocol_repeated } from "./iterate_protocol_repeated";
+import { iterate_protocol_tuple } from "./iterate_protocol_tuple";
+
+export const iterate_protocol_metadata =
+    (dict: Map<string, IProtocolMessage>) =>
+    (meta: Metadata) =>
+    (tags: IMetadataTag[]): Omit<IProtocolProperty, "key"> => {
+        // PREPARE ASSETS
+        const sole: boolean = meta.size() === 1;
+        const bucket: boolean = sole && meta.bucket() === 1;
+        const required: boolean =
+            (meta.required && !meta.nullable) ||
+            (sole &&
+                (meta.arrays.length === 1 ||
+                    meta.sets.length === 1 ||
+                    meta.maps.length === 1 ||
+                    (meta.objects.length === 1 &&
+                        meta.objects[0]!.properties.length === 1 &&
+                        !meta.objects[0]!.properties[0]?.key.isSoleLiteral())));
+
+        const oneOf: IProtocolProperty.IOneOf[] = [];
+        const add = (type: string | IProtocolMap) => {
+            if (oneOf.some((one) => one.type === type)) return;
+            oneOf.push({
+                type,
+            });
+        };
+
+        // WHEN SINGULAR ARRAY TYPE
+        if (sole && meta.arrays.length + meta.sets.length === 1) {
+            const [container, child] =
+                meta.arrays.length === 1
+                    ? (["Array", meta.arrays[0]!.value] as const)
+                    : (["Set", meta.sets[0]!] as const);
+            add(
+                iterate_protocol_repeated(container)(true, true)(dict)(child)(
+                    tags,
+                ),
+            );
+            return {
+                required,
+                oneOf,
+                repeated: true,
+            };
+        }
+
+        // ATOMIC TYPES
+        for (const type of meta.atomics)
+            add(iterate_protocol_atomic(tags)(type));
+        for (const constant of meta.constants)
+            add(iterate_protocol_constant(constant));
+        if (meta.templates.length) add("string");
+        if (meta.size() === 0) add(iterate_protocol_never());
+
+        // OBJECT TYPES
+        for (const obj of meta.objects)
+            add(iterate_protocol_object(sole)(dict)(obj));
+        for (const map of meta.maps) add(iterate_protocol_map(sole)(dict)(map));
+        for (const native of meta.natives)
+            add(iterate_protocol_native(dict)(native));
+
+        // ARRAY TYPES
+        for (const tuple of meta.tuples)
+            add(iterate_protocol_tuple(dict)(tuple.elements));
+        for (const array of meta.arrays)
+            add(
+                iterate_protocol_repeated("Array")(false, bucket)(dict)(
+                    array.value,
+                )(tags),
+            );
+        for (const set of meta.sets)
+            add(
+                iterate_protocol_repeated("Set")(false, bucket)(dict)(set)(
+                    tags,
+                ),
+            );
+
+        // RETURNS
+        return {
+            required,
+            oneOf,
+            repeated: false,
+        };
+    };

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

@@ -1,34 +1,34 @@
-import { Metadata } from "../../../metadata/Metadata";
-
-import { IProtocolMessage } from "../../../messages/IProtocolMessage";
-import { ProtocolMetadataUtil } from "./ProtocolMetadataUtil";
-import { emplace_protocol_object } from "./emplace_protocol_object";
-
-export const iterate_protocol_native =
-    (dict: Map<string, IProtocolMessage>) => (native: string) => {
-        if (native === "Date") {
-            const obj = ProtocolMetadataUtil.object("__Timestamp", dict.size);
-            obj.properties.push(
-                ProtocolMetadataUtil.property("seconds", integer("bigint"), [
-                    {
-                        kind: "type",
-                        value: "int64",
-                    },
-                ]),
-                ProtocolMetadataUtil.property("nanos", integer("number"), [
-                    {
-                        kind: "type",
-                        value: "int",
-                    },
-                ]),
-            );
-            emplace_protocol_object(dict)(obj);
-            return "__Timestamp";
-        } else return "bytes";
-    };
-
-const integer = (type: "number" | "bigint") => {
-    const meta = Metadata.initialize();
-    meta.atomics.push(type);
-    return meta;
-};
+import { Metadata } from "../../../metadata/Metadata";
+
+import { IProtocolMessage } from "../../../messages/IProtocolMessage";
+import { ProtocolMetadataUtil } from "./ProtocolMetadataUtil";
+import { emplace_protocol_object } from "./emplace_protocol_object";
+
+export const iterate_protocol_native =
+    (dict: Map<string, IProtocolMessage>) => (native: string) => {
+        if (native === "Date") {
+            const obj = ProtocolMetadataUtil.object("__Timestamp", dict.size);
+            obj.properties.push(
+                ProtocolMetadataUtil.property("seconds", integer("bigint"), [
+                    {
+                        kind: "type",
+                        value: "int64",
+                    },
+                ]),
+                ProtocolMetadataUtil.property("nanos", integer("number"), [
+                    {
+                        kind: "type",
+                        value: "int",
+                    },
+                ]),
+            );
+            emplace_protocol_object(dict)(obj);
+            return "__Timestamp";
+        } else return "bytes";
+    };
+
+const integer = (type: "number" | "bigint") => {
+    const meta = Metadata.initialize();
+    meta.atomics.push(type);
+    return meta;
+};

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

@@ -1 +1 @@
-export const iterate_protocol_never = () => "uint32";
+export const iterate_protocol_never = () => "uint32";