typia 5.0.0-dev.20230726 → 5.0.0-dev.20230805

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

@@ -1,180 +1,180 @@
-import { IMetadataTag } from "../../../schemas/metadata/IMetadataTag";
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataArray } from "../../../schemas/metadata/MetadataArray";
-import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
-import { MetadataProperty } from "../../../schemas/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 "../../../schemas/metadata/IMetadataTag";
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataArray } from "../../../schemas/metadata/MetadataArray";
+import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
+import { MetadataProperty } from "../../../schemas/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 "../../../schemas/metadata/MetadataObject";
-import { IProtocolMessage } from "../../../schemas/protobuf/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 "../../../schemas/metadata/MetadataObject";
+import { IProtocolMessage } from "../../../schemas/protobuf/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 "../../../schemas/metadata/MetadataProperty";
-import { IProtocolMessage } from "../../../schemas/protobuf/IProtocolMessage";
-import { IProtocolProperty } from "../../../schemas/protobuf/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 "../../../schemas/metadata/MetadataProperty";
+import { IProtocolMessage } from "../../../schemas/protobuf/IProtocolMessage";
+import { IProtocolProperty } from "../../../schemas/protobuf/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),
+    });

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

@@ -1,34 +1,34 @@
-import { IMetadataTag } from "../../../schemas/metadata/IMetadataTag";
-
-import { Atomic } from "../../../typings/Atomic";
-
-export const iterate_protocol_atomic =
-    (tags: IMetadataTag[]) => (type: Atomic.Literal) => {
-        if (type === "boolean") return "bool";
-        else if (type === "number") return number(tags);
-        else if (type === "bigint") return bigint(tags);
-        else return "string";
-    };
-
-const number = (tagList: IMetadataTag[]) => {
-    const filtered: IMetadataTag.INumberType[] = tagList.filter(
-        (tag) => tag.kind === "type",
-    ) as IMetadataTag.INumberType[];
-
-    for (const { value } of filtered)
-        if (value === "int") return "int32";
-        else if (value === "uint") return "uint32";
-    return "double";
-};
-
-const bigint = (tagList: IMetadataTag[]) => {
-    const filtered: IMetadataTag.INumberType[] = tagList.filter(
-        (tag) =>
-            tag.kind === "type" &&
-            (tag.value === "int64" || tag.value === "uint64"),
-    ) as IMetadataTag.INumberType[];
-
-    for (const { value } of filtered)
-        if (value === "int64" || value === "uint64") return value;
-    return "int64";
-};
+import { IMetadataTag } from "../../../schemas/metadata/IMetadataTag";
+
+import { Atomic } from "../../../typings/Atomic";
+
+export const iterate_protocol_atomic =
+    (tags: IMetadataTag[]) => (type: Atomic.Literal) => {
+        if (type === "boolean") return "bool";
+        else if (type === "number") return number(tags);
+        else if (type === "bigint") return bigint(tags);
+        else return "string";
+    };
+
+const number = (tagList: IMetadataTag[]) => {
+    const filtered: IMetadataTag.INumberType[] = tagList.filter(
+        (tag) => tag.kind === "type",
+    ) as IMetadataTag.INumberType[];
+
+    for (const { value } of filtered)
+        if (value === "int") return "int32";
+        else if (value === "uint") return "uint32";
+    return "double";
+};
+
+const bigint = (tagList: IMetadataTag[]) => {
+    const filtered: IMetadataTag.INumberType[] = tagList.filter(
+        (tag) =>
+            tag.kind === "type" &&
+            (tag.value === "int64" || tag.value === "uint64"),
+    ) as IMetadataTag.INumberType[];
+
+    for (const { value } of filtered)
+        if (value === "int64" || value === "uint64") return value;
+    return "int64";
+};

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

@@ -1,27 +1,27 @@
-import { MetadataConstant } from "../../../schemas/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 "../../../schemas/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 "../../../schemas/metadata/Metadata";
-import { IProtocolMessage } from "../../../schemas/protobuf/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 "../../../schemas/metadata/Metadata";
+import { IProtocolMessage } from "../../../schemas/protobuf/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;
+    };