typia 3.7.0-dev.20230310 → 3.7.0-dev.20230331

package/src/programmers/MessageProgrammer.ts

@@ -1,126 +0,0 @@
-import ts from "typescript";
-
-import { MetadataCollection } from "../factories/MetadataCollection";
-import { ProtocolFactory } from "../factories/ProtocolFactory";
-
-import { Metadata } from "../metadata/Metadata";
-
-import { IProject } from "../transformers/IProject";
-
-import { Escaper } from "../utils/Escaper";
-import { MapUtil } from "../utils/MapUtil";
-import { NameEncoder } from "../utils/NameEncoder";
-
-import { IProtocolMap } from "../messages/IProtocolMap";
-import { IProtocolMessage } from "../messages/IProtocolMessage";
-
-export namespace MessageProgrammer {
-    export const generate =
-        ({ checker }: IProject) =>
-        (type: ts.Type) => {
-            // PARSE TARGET TYPE
-            const collection: MetadataCollection = new MetadataCollection();
-            const metadata: Metadata =
-                ProtocolFactory.metadata(checker)(collection)(type);
-
-            // CONVERT TO PROTOCOL MESSAGES
-            const dict: Map<string, IProtocolMessage> = new Map();
-            ProtocolFactory.generate(collection)(dict)(metadata);
-
-            // STRINGIFY
-            const hierarchies: Map<string, Hierarchy> = new Map();
-            for (const msg of dict.values()) emplace(hierarchies)(msg);
-
-            const content: string =
-                `syntax = "proto3";\n\n` +
-                [...hierarchies.values()]
-                    .map((hier) => stringify(hier))
-                    .join("\n\n");
-
-            // RETURNS
-            return ts.factory.createStringLiteral(content);
-        };
-
-    const stringify = (hierarchy: Hierarchy): string => {
-        const { key, message, children } = hierarchy;
-        let index: number = 1;
-
-        const elements: string[] = [`message ${NameEncoder.encode(key)} {`];
-        if (message !== null)
-            elements.push(
-                ...message.properties.map((property) => {
-                    const key: string =
-                        Escaper.variable(property.key) &&
-                        property.key.indexOf("$") === -1
-                            ? property.key
-                            : `v${index + 1}`;
-                    if (property.oneOf.length === 1)
-                        return [
-                            TAB,
-                            property.required ? "" : "optional ",
-                            property.repeated ? "repeated " : "",
-                            getTypeName(property.oneOf[0]!.type) + " ",
-                            key,
-                            " = ",
-                            `${index++};`,
-                        ].join("");
-                    return (
-                        `${TAB}oneof ${key} {\n` +
-                        property.oneOf
-                            .map(
-                                (o, i) =>
-                                    `${TAB}${TAB}${getTypeName(
-                                        o.type,
-                                    )} ${key}_o${i} = ${index++};`,
-                            )
-                            .join("\n") +
-                        `\n${TAB}}`
-                    );
-                }),
-            );
-        if (message !== null && children.size) elements.push("\n");
-        if (children.size)
-            elements.push(
-                [...children.values()]
-                    .map((child) => stringify(child))
-                    .map((body) =>
-                        body
-                            .split("\n")
-                            .map((line) => `${TAB}${line}`)
-                            .join("\n"),
-                    )
-                    .join("\n\n"),
-            );
-        elements.push("}");
-
-        return elements.join("\n");
-    };
-
-    const emplace =
-        (dict: Map<string, Hierarchy>) => (message: IProtocolMessage) => {
-            const accessors: string[] = message.name.split(".");
-            accessors.forEach((access, i) => {
-                const hierarchy: Hierarchy = MapUtil.take(dict, access, () => ({
-                    key: access,
-                    message: null!,
-                    children: new Map(),
-                }));
-                dict = hierarchy.children;
-                if (i === accessors.length - 1) hierarchy.message = message;
-            });
-        };
-
-    function getTypeName(type: string | IProtocolMap): string {
-        return typeof type === "string"
-            ? NameEncoder.encode(type)
-            : `map<${type.key}, ${getTypeName(type.value)}>`;
-    }
-}
-
-interface Hierarchy {
-    key: string;
-    message: IProtocolMessage | null;
-    children: Map<string, Hierarchy>;
-}
-
-const TAB = " ".repeat(4);

package/src/transformers/features/protocols/MessageTransformer.ts

@@ -1,32 +0,0 @@
-import ts from "typescript";
-
-import { MessageProgrammer } from "../../../programmers/MessageProgrammer";
-
-import { IProject } from "../../IProject";
-
-export namespace MessageTransformer {
-    export function transform(
-        project: IProject,
-        _modulo: ts.LeftHandSideExpression,
-        expression: ts.CallExpression,
-    ): ts.Expression {
-        // CHECK GENERIC ARGUMENT EXISTENCE
-        if (!expression.typeArguments || !expression.typeArguments[0])
-            throw new Error(ErrorMessages.NOT_SPECIFIED);
-
-        // GET TYPE INFO
-        const type: ts.Type = project.checker.getTypeFromTypeNode(
-            expression.typeArguments[0],
-        );
-        if (type.isTypeParameter())
-            throw new Error(ErrorMessages.GENERIC_ARGUMENT);
-
-        // DO TRANSFORM
-        return MessageProgrammer.generate(project)(type);
-    }
-}
-
-const enum ErrorMessages {
-    NOT_SPECIFIED = "Error on typia.message(): generic argument is not specified.",
-    GENERIC_ARGUMENT = "Error on typia.message(): non-specified generic argument.",
-}

package/src/utils/NameEncoder.ts

@@ -1,32 +0,0 @@
-export namespace NameEncoder {
-    export function encode(str: string): string {
-        for (const [before, after] of REPLACERS)
-            str = str.split(before).join(after);
-        return str;
-    }
-
-    export function decode(str: string): string {
-        for (const [before, after] of REPLACERS)
-            if (after !== "") str = str.split(after).join(before);
-        return str;
-    }
-}
-
-const REPLACERS: [string, string][] = [
-    ["$", "_dollar_"],
-    ["&", "_and_"],
-    ["|", "_or_"],
-    ["{", "_blt_"],
-    ["}", "_bgt_"],
-    ["<", "_lt_"],
-    [">", "_gt_"],
-    ["(", "_lp_"],
-    [")", "_rp_"],
-    ["[", "_alt_"],
-    ["]", "_agt_"],
-    [",", "_comma_"],
-    ["`", "_backquote_"],
-    ["'", "_singlequote_"],
-    ['"', "_doublequote_"],
-    [" ", "_space_"],
-];