typia 5.0.0-dev.20230810 → 5.0.0-dev.20230814

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

@@ -1,58 +0,0 @@
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
-import { IProtocolMap } from "../../../schemas/protobuf/IProtocolMap";
-import { IProtocolMessage } from "../../../schemas/protobuf/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 +0,0 @@
-import { IMetadataTag } from "../../../schemas/metadata/IMetadataTag";
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { IProtocolMap } from "../../../schemas/protobuf/IProtocolMap";
-import { IProtocolMessage } from "../../../schemas/protobuf/IProtocolMessage";
-import { IProtocolProperty } from "../../../schemas/protobuf/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 +0,0 @@
-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_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 +0,0 @@
-export const iterate_protocol_never = () => "uint32";

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

@@ -1,110 +0,0 @@
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
-import { MetadataProperty } from "../../../schemas/metadata/MetadataProperty";
-import { IProtocolMap } from "../../../schemas/protobuf/IProtocolMap";
-import { IProtocolMessage } from "../../../schemas/protobuf/IProtocolMessage";
-
-import { Atomic } from "../../../typings/Atomic";
-
-import { MapUtil } from "../../../utils/MapUtil";
-
-import { ProtocolMetadataUtil } from "./ProtocolMetadataUtil";
-import { emplace_protocol_object } from "./emplace_protocol_object";
-import { iterate_protocol_metadata } from "./iterate_protocol_metadata";
-
-export const iterate_protocol_object =
-    (sole: boolean) =>
-    (dict: Map<string, IProtocolMessage>) =>
-    (obj: MetadataObject): string | IProtocolMap => {
-        // ONLY REGULAR PROPERTIES
-        const statics: MetadataProperty[] = obj.properties.filter(filter(true));
-        const dynamics: Metadata.Entry[] = aggregate(
-            obj.properties.filter(filter(false)),
-        );
-        if (dynamics.length === 0) return obj.name;
-
-        const regular: MetadataObject | undefined = statics.length
-            ? (() => {
-                  const r: MetadataObject = ProtocolMetadataUtil.object(
-                      `${obj.name}.__Regular`,
-                      dict.size,
-                  );
-                  r.properties.push(...statics);
-                  emplace_protocol_object(dict)(r);
-                  return r;
-              })()
-            : undefined;
-
-        // ONLY ONE TYPED DYNAMIC PROPERTY EXISTS
-        if (regular === undefined && dynamics.length === 1 && sole === true) {
-            const { key, value } = dynamics[0]!;
-            return {
-                type: "map",
-                key: key.getName(),
-                value: ProtocolMetadataUtil.standalone(value)
-                    ? iterate_protocol_metadata(dict)(value)([]).oneOf[0]!.type
-                    : (() => {
-                          const wrapper = ProtocolMetadataUtil.object(
-                              `${obj.name}.__Wrapper`,
-                              dict.size,
-                          );
-                          wrapper.properties.push(
-                              ProtocolMetadataUtil.property("value", value, []),
-                          );
-                          emplace_protocol_object(dict)(wrapper);
-                          return wrapper.name;
-                      })(),
-            };
-        }
-
-        // DO WRAP
-        const wrapper: MetadataObject = ProtocolMetadataUtil.object(
-            `${obj.name}.__Wrapper`,
-            dict.size,
-        );
-        if (regular !== undefined)
-            wrapper.properties.push(
-                ProtocolMetadataUtil.property(
-                    "regular",
-                    ProtocolMetadataUtil.reference(regular),
-                    [],
-                ),
-            );
-        wrapper.properties.push(
-            ...dynamics.map((map, i) =>
-                ProtocolMetadataUtil.property(
-                    `__map_${i}`,
-                    ProtocolMetadataUtil.map(map),
-                    [],
-                ),
-            ),
-        );
-        emplace_protocol_object(dict)(wrapper);
-        return wrapper.name;
-    };
-
-const filter = (regular: boolean) => (prop: MetadataProperty) =>
-    regular === prop.key.isSoleLiteral();
-
-const aggregate = (properties: MetadataProperty[]): Metadata.Entry[] => {
-    const unique: Map<Atomic.Literal, MetadataProperty[]> = new Map();
-    for (const prop of properties) {
-        if (prop.key.templates)
-            MapUtil.take(unique)("string", () => []).push(prop);
-        for (const type of prop.key.atomics)
-            MapUtil.take(unique)(type, () => []).push(prop);
-        for (const { type } of prop.key.constants)
-            MapUtil.take(unique)(type, () => []).push(prop);
-    }
-    const output: Metadata.Entry[] = [];
-    for (const [key, properties] of unique) {
-        const value: Metadata = properties
-            .map((x) => x.value)
-            .reduce((x, y) => Metadata.merge(x, y));
-        output.push({
-            key: ProtocolMetadataUtil.atomic(key),
-            value,
-        });
-    }
-    return output;
-};

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

@@ -1,34 +0,0 @@
-import { IMetadataTag } from "../../../schemas/metadata/IMetadataTag";
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
-import { IProtocolMap } from "../../../schemas/protobuf/IProtocolMap";
-import { IProtocolMessage } from "../../../schemas/protobuf/IProtocolMessage";
-
-import { ProtocolMetadataUtil } from "./ProtocolMetadataUtil";
-import { emplace_protocol_object } from "./emplace_protocol_object";
-import { iterate_protocol_metadata } from "./iterate_protocol_metadata";
-
-export const iterate_protocol_repeated =
-    (container: "Array" | "Set") =>
-    (sole: boolean, bucket: boolean) =>
-    (dict: Map<string, IProtocolMessage>) =>
-    (meta: Metadata) =>
-    (tags: IMetadataTag[]): string | IProtocolMap => {
-        sole &&= ProtocolMetadataUtil.standalone(meta);
-        if (sole === true)
-            return iterate_protocol_metadata(dict)(meta)(tags).oneOf[0]!.type;
-
-        const obj: MetadataObject = ProtocolMetadataUtil.object(
-            `${container}.${bucket ? "Element" : "Wrapper"}<${meta.getName()}>`,
-            dict.size,
-        );
-        obj.properties.push(
-            ProtocolMetadataUtil.property(
-                "value",
-                bucket ? meta : ProtocolMetadataUtil.array(meta),
-                tags,
-            ),
-        );
-        emplace_protocol_object(dict)(obj);
-        return obj.name;
-    };

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

@@ -1,29 +0,0 @@
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
-import { IProtocolMessage } from "../../../schemas/protobuf/IProtocolMessage";
-
-import { ProtocolMetadataUtil } from "./ProtocolMetadataUtil";
-import { emplace_protocol_object } from "./emplace_protocol_object";
-
-export const iterate_protocol_tuple =
-    (dict: Map<string, IProtocolMessage>) =>
-    (tuple: Metadata[]): string => {
-        const name: string = `[${tuple.map((m) => m.getName()).join(", ")}]`;
-        if (dict.has(name)) return name;
-
-        const obj: MetadataObject = ProtocolMetadataUtil.object(
-            name,
-            dict.size,
-        );
-        obj.properties.push(
-            ...tuple.map((value, i) =>
-                ProtocolMetadataUtil.property(
-                    `v${i}`,
-                    value.rest ? ProtocolMetadataUtil.array(value.rest) : value,
-                    [],
-                ),
-            ),
-        );
-        emplace_protocol_object(dict)(obj);
-        return obj.name;
-    };

package/src/schemas/protobuf/IProtocolMap.ts

@@ -1,5 +0,0 @@
-export interface IProtocolMap {
-    type: "map";
-    key: string;
-    value: string | IProtocolMap;
-}

package/src/schemas/protobuf/IProtocolMessage.ts

@@ -1,6 +0,0 @@
-import { IProtocolProperty } from "./IProtocolProperty";
-
-export interface IProtocolMessage {
-    name: string;
-    properties: IProtocolProperty[];
-}

package/src/schemas/protobuf/IProtocolProperty.ts

@@ -1,13 +0,0 @@
-import { IProtocolMap } from "./IProtocolMap";
-
-export interface IProtocolProperty {
-    key: string;
-    oneOf: IProtocolProperty.IOneOf[];
-    required: boolean;
-    repeated: boolean;
-}
-export namespace IProtocolProperty {
-    export interface IOneOf {
-        type: string | IProtocolMap;
-    }
-}