typia 3.4.11 → 3.5.0-dev.20221219

package/lib/transformers/features/protocols/MessageTransformer.d.ts

@@ -0,0 +1,5 @@
+import ts from "typescript";
+import { IProject } from "../../IProject";
+export declare namespace MessageTransformer {
+    function transform(project: IProject, _modulo: ts.LeftHandSideExpression, expression: ts.CallExpression): ts.Expression;
+}

package/lib/transformers/features/protocols/MessageTransformer.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageTransformer = void 0;
+var MessageProgrammer_1 = require("../../../programmers/MessageProgrammer");
+var MessageTransformer;
+(function (MessageTransformer) {
+    function transform(project, _modulo, expression) {
+        if (!expression.typeArguments || !expression.typeArguments[0])
+            throw new Error("Error on typia.message(): generic argument is not specified.");
+        var type = project.checker.getTypeFromTypeNode(expression.typeArguments[0]);
+        if (type.isTypeParameter())
+            throw new Error("Error on typia.message(): non-specified generic argument.");
+        return MessageProgrammer_1.MessageProgrammer.generate(project)(type);
+    }
+    MessageTransformer.transform = transform;
+})(MessageTransformer = exports.MessageTransformer || (exports.MessageTransformer = {}));
+//# sourceMappingURL=MessageTransformer.js.map

package/lib/transformers/features/protocols/MessageTransformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"MessageTransformer.js","sourceRoot":"","sources":["../../../../src/transformers/features/protocols/MessageTransformer.ts"],"names":[],"mappings":";;;AAEA,4EAA2E;AAI3E,IAAiB,kBAAkB,CAoBlC;AApBD,WAAiB,kBAAkB;IAC/B,SAAgB,SAAS,CACrB,OAAiB,EACjB,OAAkC,EAClC,UAA6B;QAG7B,IAAI,CAAC,UAAU,CAAC,aAAa,IAAI,CAAC,UAAU,CAAC,aAAa,CAAC,CAAC,CAAC;YACzD,MAAM,IAAI,KAAK,gEAA6B,CAAC;QAGjD,IAAM,IAAI,GAAY,OAAO,CAAC,OAAO,CAAC,mBAAmB,CACrD,UAAU,CAAC,aAAa,CAAC,CAAC,CAAC,CAC9B,CAAC;QACF,IAAI,IAAI,CAAC,eAAe,EAAE;YACtB,MAAM,IAAI,KAAK,6DAAgC,CAAC;QAGpD,OAAO,qCAAiB,CAAC,QAAQ,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC;IACrD,CAAC;IAlBe,4BAAS,YAkBxB,CAAA;AACL,CAAC,EApBgB,kBAAkB,GAAlB,0BAAkB,KAAlB,0BAAkB,QAoBlC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "3.4.11",
+  "version": "3.5.0-dev.20221219",
   "description": "Runtime type checkers and 5x faster JSON.stringify() function",
   "main": "lib/index.js",
   "typings": "lib/index.d.ts",
@@ -18,12 +18,12 @@
     "eslint:fix": "eslint ./**/*.ts --fix",
     "issue": "node test/issue",
     "prettier": "prettier  --write ./**/*.ts",
-    "publish:latest": "ts-node build/publish.ts latest && npm deprecate typescript-json \"Renamed to typia\"",
+    "publish:latest": "ts-node build/publish.ts latest",
     "publish:next": "ts-node build/publish.ts next",
+    "publish:deprecate": "npm deprecate typescript-json \"Renamed to typia\"",
     "test": "node bin/test",
     "test:generate": "ts-node -P tsconfig.test.json build/test.ts",
-    "test:manual": "node test/manual",
-    "test:application:replace": "node test/features/application/replace && npm run prettier"
+    "test:manual": "node test/manual"
   },
   "repository": {
     "type": "git",

package/src/factories/MetadataCollection.ts

@@ -112,6 +112,8 @@ const REPLACERS: [string, string][] = [
     ["}", "_bgt_"],
     ["<", "_lt_"],
     [">", "_gt_"],
+    ["(", "_lp_"],
+    [")", "_rp_"],
     ["[", "_alt_"],
     ["]", "_agt_"],
     [",", "_comma_"],

package/src/factories/MetadataFactory.ts

@@ -1,16 +1,17 @@
 import ts from "typescript";
 
 import { Metadata } from "../metadata/Metadata";
+import { explore_metadata } from "./internal/metadata/explore_metadata";
 
 import { ArrayUtil } from "../utils/ArrayUtil";
 
 import { MetadataCollection } from "./MetadataCollection";
-import { explore_metadata } from "./internal/explore_metadata";
 
 export namespace MetadataFactory {
     export interface IOptions {
         resolve: boolean;
         constant: boolean;
+        validate?: (meta: Metadata) => void;
     }
 
     export function generate(

package/src/factories/ProtocolFactory.ts

@@ -0,0 +1,97 @@
+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 collection = () =>
+        new MetadataCollection({
+            replace: MetadataCollection.replace,
+        });
+
+    export const metadata =
+        (checker: ts.TypeChecker) =>
+        (collection: MetadataCollection) =>
+        (type: ts.Type) =>
+            MetadataFactory.generate(checker, collection, type, {
+                resolve: false,
+                constant: 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.filter((p) =>
+                                    p.key.isSoleLiteral(),
+                                ).length &&
+                                o.properties.filter(
+                                    (p) => !p.key.isSoleLiteral(),
+                                ).length,
+                        )
+                    )
+                        throw new Error(ErrorMessages.NO_SIMULATENOUS);
+                    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);
+                },
+            });
+
+    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.`,
+    NO_SIMULATENOUS = `Error on typia.message(): object can't have both regular and dynamic properties in protocol buffer.`,
+}

package/src/factories/internal/{MetadataHelper.ts → metadata/MetadataHelper.ts}

@@ -1,4 +1,4 @@
-import { Metadata } from "../../metadata/Metadata";
+import { Metadata } from "../../../metadata/Metadata";
 
 export namespace MetadataHelper {
     export function literal_to_metadata(key: string): Metadata {

package/src/factories/internal/{emplace_metadata_object.ts → metadata/emplace_metadata_object.ts}

@@ -1,17 +1,17 @@
 import ts from "typescript";
 
-import { Metadata } from "../../metadata/Metadata";
-import { MetadataObject } from "../../metadata/MetadataObject";
-import { MetadataProperty } from "../../metadata/MetadataProperty";
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataObject } from "../../../metadata/MetadataObject";
+import { MetadataProperty } from "../../../metadata/MetadataProperty";
 
-import { Writable } from "../../typings/Writable";
+import { Writable } from "../../../typings/Writable";
 
-import { ArrayUtil } from "../../utils/ArrayUtil";
+import { ArrayUtil } from "../../../utils/ArrayUtil";
 
-import { CommentFactory } from "../CommentFactory";
-import { MetadataCollection } from "../MetadataCollection";
-import { MetadataFactory } from "../MetadataFactory";
-import { MetadataTagFactory } from "../MetadataTagFactory";
+import { CommentFactory } from "../../CommentFactory";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { MetadataTagFactory } from "../../MetadataTagFactory";
 import { MetadataHelper } from "./MetadataHelper";
 import { explore_metadata } from "./explore_metadata";
 

package/src/factories/internal/{explore_metadata.ts → metadata/explore_metadata.ts}

@@ -1,12 +1,12 @@
 import ts from "typescript";
 
-import { Metadata } from "../../metadata/Metadata";
-import { MetadataObject } from "../../metadata/MetadataObject";
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataObject } from "../../../metadata/MetadataObject";
 
-import { ArrayUtil } from "../../utils/ArrayUtil";
+import { ArrayUtil } from "../../../utils/ArrayUtil";
 
-import { MetadataCollection } from "../MetadataCollection";
-import { MetadataFactory } from "../MetadataFactory";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
 import { iterate_metadata } from "./iterate_metadata";
 
 export const explore_metadata =
@@ -86,6 +86,7 @@ export const explore_metadata =
         )
             meta.templates.splice(0, meta.templates.length);
 
-        // RETURNS
+        // RETURNS WITH VALIDATION
+        if (options.validate) options.validate(meta);
         return meta;
     };

package/src/factories/internal/{iterate_metadata.ts → metadata/iterate_metadata.ts}

@@ -1,11 +1,11 @@
 import ts from "typescript";
 
-import { Metadata } from "../../metadata/Metadata";
+import { Metadata } from "../../../metadata/Metadata";
 
-import { ArrayUtil } from "../../utils/ArrayUtil";
+import { ArrayUtil } from "../../../utils/ArrayUtil";
 
-import { MetadataCollection } from "../MetadataCollection";
-import { MetadataFactory } from "../MetadataFactory";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
 import { iterate_metadata_array } from "./iterate_metadata_array";
 import { iterate_metadata_atomic } from "./iterate_metadata_atomic";
 import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";

package/src/factories/internal/{iterate_metadata_array.ts → metadata/iterate_metadata_array.ts}

@@ -1,11 +1,11 @@
 import ts from "typescript";
 
-import { Metadata } from "../../metadata/Metadata";
+import { Metadata } from "../../../metadata/Metadata";
 
-import { ArrayUtil } from "../../utils/ArrayUtil";
+import { ArrayUtil } from "../../../utils/ArrayUtil";
 
-import { MetadataCollection } from "../MetadataCollection";
-import { MetadataFactory } from "../MetadataFactory";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
 import { explore_metadata } from "./explore_metadata";
 
 export const iterate_metadata_array =

package/src/factories/internal/{iterate_metadata_atomic.ts → metadata/iterate_metadata_atomic.ts}

@@ -1,10 +1,10 @@
 import ts from "typescript";
 
-import { Metadata } from "../../metadata/Metadata";
+import { Metadata } from "../../../metadata/Metadata";
 
-import { Atomic } from "../../typings/Atomic";
+import { Atomic } from "../../../typings/Atomic";
 
-import { ArrayUtil } from "../../utils/ArrayUtil";
+import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 const same = (type: ts.Type | null) => {
     if (type === null) return () => false;

package/src/factories/internal/{iterate_metadata_coalesce.ts → metadata/iterate_metadata_coalesce.ts}

@@ -1,10 +1,10 @@
 import ts from "typescript";
 
-import { Metadata } from "../../metadata/Metadata";
+import { Metadata } from "../../../metadata/Metadata";
 
-import { Writable } from "../../typings/Writable";
+import { Writable } from "../../../typings/Writable";
 
-import { TypeFactory } from "../TypeFactory";
+import { TypeFactory } from "../../TypeFactory";
 
 export const iterate_metadata_coalesce = (
     meta: Metadata,

package/src/factories/internal/{iterate_metadata_constant.ts → metadata/iterate_metadata_constant.ts}

@@ -1,11 +1,11 @@
 import ts from "typescript";
 
-import { Metadata } from "../../metadata/Metadata";
-import { MetadataConstant } from "../../metadata/MetadataConstant";
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataConstant } from "../../../metadata/MetadataConstant";
 
-import { ArrayUtil } from "../../utils/ArrayUtil";
+import { ArrayUtil } from "../../../utils/ArrayUtil";
 
-import { MetadataFactory } from "../MetadataFactory";
+import { MetadataFactory } from "../../MetadataFactory";
 
 export const iterate_metadata_constant =
     (checker: ts.TypeChecker) =>

package/src/factories/internal/{iterate_metadata_map.ts → metadata/iterate_metadata_map.ts}

@@ -1,12 +1,12 @@
 import ts from "typescript";
 
-import { Metadata } from "../../metadata/Metadata";
+import { Metadata } from "../../../metadata/Metadata";
 
-import { ArrayUtil } from "../../utils/ArrayUtil";
+import { ArrayUtil } from "../../../utils/ArrayUtil";
 
-import { MetadataCollection } from "../MetadataCollection";
-import { MetadataFactory } from "../MetadataFactory";
-import { TypeFactory } from "../TypeFactory";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { TypeFactory } from "../../TypeFactory";
 import { explore_metadata } from "./explore_metadata";
 
 export const iterate_metadata_map =

package/src/factories/internal/{iterate_metadata_native.ts → metadata/iterate_metadata_native.ts}

@@ -1,10 +1,10 @@
 import ts from "typescript";
 
-import { Metadata } from "../../metadata/Metadata";
+import { Metadata } from "../../../metadata/Metadata";
 
-import { ArrayUtil } from "../../utils/ArrayUtil";
+import { ArrayUtil } from "../../../utils/ArrayUtil";
 
-import { TypeFactory } from "../TypeFactory";
+import { TypeFactory } from "../../TypeFactory";
 
 export const iterate_metadata_native =
     (checker: ts.TypeChecker) =>

package/src/factories/internal/{iterate_metadata_object.ts → metadata/iterate_metadata_object.ts}

@@ -1,12 +1,12 @@
 import ts from "typescript";
 
-import { Metadata } from "../../metadata/Metadata";
-import { MetadataObject } from "../../metadata/MetadataObject";
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataObject } from "../../../metadata/MetadataObject";
 
-import { ArrayUtil } from "../../utils/ArrayUtil";
+import { ArrayUtil } from "../../../utils/ArrayUtil";
 
-import { MetadataCollection } from "../MetadataCollection";
-import { MetadataFactory } from "../MetadataFactory";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
 import { emplace_metadata_object } from "./emplace_metadata_object";
 import { iterate_metadata } from "./iterate_metadata";
 

package/src/factories/internal/{iterate_metadata_resolve.ts → metadata/iterate_metadata_resolve.ts}

@@ -1,12 +1,12 @@
 import ts from "typescript";
 
-import { Metadata } from "../../metadata/Metadata";
+import { Metadata } from "../../../metadata/Metadata";
 
-import { Writable } from "../../typings/Writable";
+import { Writable } from "../../../typings/Writable";
 
-import { MetadataCollection } from "../MetadataCollection";
-import { MetadataFactory } from "../MetadataFactory";
-import { TypeFactory } from "../TypeFactory";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { TypeFactory } from "../../TypeFactory";
 import { explore_metadata } from "./explore_metadata";
 
 export const iterate_metadata_resolve =

package/src/factories/internal/{iterate_metadata_set.ts → metadata/iterate_metadata_set.ts}

@@ -1,12 +1,12 @@
 import ts from "typescript";
 
-import { Metadata } from "../../metadata/Metadata";
+import { Metadata } from "../../../metadata/Metadata";
 
-import { ArrayUtil } from "../../utils/ArrayUtil";
+import { ArrayUtil } from "../../../utils/ArrayUtil";
 
-import { MetadataCollection } from "../MetadataCollection";
-import { MetadataFactory } from "../MetadataFactory";
-import { TypeFactory } from "../TypeFactory";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { TypeFactory } from "../../TypeFactory";
 import { explore_metadata } from "./explore_metadata";
 
 export const iterate_metadata_set =

package/src/factories/internal/{iterate_metadata_template.ts → metadata/iterate_metadata_template.ts}

@@ -1,9 +1,9 @@
 import ts from "typescript";
 
-import { Metadata } from "../../metadata/Metadata";
+import { Metadata } from "../../../metadata/Metadata";
 
-import { MetadataCollection } from "../MetadataCollection";
-import { MetadataFactory } from "../MetadataFactory";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
 import { MetadataHelper } from "./MetadataHelper";
 import { explore_metadata } from "./explore_metadata";
 

package/src/factories/internal/{iterate_metadata_tuple.ts → metadata/iterate_metadata_tuple.ts}

@@ -1,13 +1,13 @@
 import ts from "typescript";
 
-import { Metadata } from "../../metadata/Metadata";
+import { Metadata } from "../../../metadata/Metadata";
 
-import { Writable } from "../../typings/Writable";
+import { Writable } from "../../../typings/Writable";
 
-import { ArrayUtil } from "../../utils/ArrayUtil";
+import { ArrayUtil } from "../../../utils/ArrayUtil";
 
-import { MetadataCollection } from "../MetadataCollection";
-import { MetadataFactory } from "../MetadataFactory";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
 import { explore_metadata } from "./explore_metadata";
 
 export const iterate_metadata_tuple =

package/src/factories/internal/{iterate_metadata_union.ts → metadata/iterate_metadata_union.ts}

@@ -1,12 +1,12 @@
 import ts from "typescript";
 
-import { Metadata } from "../../metadata/Metadata";
+import { Metadata } from "../../../metadata/Metadata";
 
-import { Writable } from "../../typings/Writable";
+import { Writable } from "../../../typings/Writable";
 
-import { MetadataCollection } from "../MetadataCollection";
-import { MetadataFactory } from "../MetadataFactory";
-import { TypeFactory } from "../TypeFactory";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { TypeFactory } from "../../TypeFactory";
 import { iterate_metadata } from "./iterate_metadata";
 
 export const iterate_metadata_union =

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

@@ -0,0 +1,81 @@
+import { IMetadataTag } from "../../../metadata/IMetadataTag";
+import { Metadata } from "../../../metadata/Metadata";
+import { MetadataObject } from "../../../metadata/MetadataObject";
+import { MetadataProperty } from "../../../metadata/MetadataProperty";
+
+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: undefined,
+            tags,
+            jsDocTags: [],
+        });
+    }
+}

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

@@ -0,0 +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 (!regular.length || 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

@@ -0,0 +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),
+    });

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

@@ -0,0 +1,34 @@
+import { IMetadataTag } from "../../../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.IBigintType[] = tagList.filter(
+        (tag) =>
+            tag.kind === "type" &&
+            (tag.value === "int64" || tag.value === "uint64"),
+    ) as IMetadataTag.IBigintType[];
+
+    for (const { value } of filtered)
+        if (value === "int64" || value === "uint64") return value;
+    return "int64";
+};