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

package/src/programmers/protobuf/ProtobufMessageProgrammer.ts

@@ -1,125 +1,125 @@
-import ts from "typescript";
-
-import { MetadataCollection } from "../../factories/MetadataCollection";
-import { ProtocolFactory } from "../../factories/ProtocolFactory";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { IProtocolMap } from "../../schemas/protobuf/IProtocolMap";
-import { IProtocolMessage } from "../../schemas/protobuf/IProtocolMessage";
-
-import { IProject } from "../../transformers/IProject";
-
-import { Escaper } from "../../utils/Escaper";
-import { MapUtil } from "../../utils/MapUtil";
-import { NameEncoder } from "../../utils/NameEncoder";
-
-export namespace ProtobufMessageProgrammer {
-    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.analyze(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);
+import ts from "typescript";
+
+import { MetadataCollection } from "../../factories/MetadataCollection";
+import { ProtocolFactory } from "../../factories/ProtocolFactory";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { IProtocolMap } from "../../schemas/protobuf/IProtocolMap";
+import { IProtocolMessage } from "../../schemas/protobuf/IProtocolMessage";
+
+import { IProject } from "../../transformers/IProject";
+
+import { Escaper } from "../../utils/Escaper";
+import { MapUtil } from "../../utils/MapUtil";
+import { NameEncoder } from "../../utils/NameEncoder";
+
+export namespace ProtobufMessageProgrammer {
+    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.analyze(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/programmers/protobuf/ProtobufValidateDecodeProgrammer.ts

@@ -1,83 +1,83 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProject } from "../../transformers/IProject";
-
-import { ValidateProgrammer } from "../ValidateProgrammer";
-import { ProtobufDecodeProgrammer } from "./ProtobufDecodeProgrammer";
-
-export namespace ProtobufValidateDecodeProgrammer {
-    export const write =
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
-            ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [
-                    IdentifierFactory.parameter(
-                        "input",
-                        ts.factory.createTypeReferenceNode("Uint8Array"),
-                    ),
-                ],
-                ts.factory.createTypeReferenceNode(
-                    name ?? TypeFactory.getFullName(project.checker)(type),
-                ),
-                undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
-                        "validate",
-                        ValidateProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: true,
-                            },
-                        })(modulo)(false)(type, name),
-                    ),
-                    StatementFactory.constant(
-                        "decode",
-                        ProtobufDecodeProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: false,
-                            },
-                        })(modulo)(type, name),
-                    ),
-                    StatementFactory.constant(
-                        "output",
-                        ts.factory.createAsExpression(
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("validate"),
-                                undefined,
-                                [ts.factory.createIdentifier("input")],
-                            ),
-                            TypeFactory.keyword("any"),
-                        ),
-                    ),
-                    ts.factory.createIfStatement(
-                        ts.factory.createIdentifier("output.success"),
-                        ts.factory.createExpressionStatement(
-                            ts.factory.createBinaryExpression(
-                                ts.factory.createIdentifier("output.data"),
-                                ts.SyntaxKind.EqualsToken,
-                                ts.factory.createCallExpression(
-                                    ts.factory.createIdentifier("decode"),
-                                    undefined,
-                                    [ts.factory.createIdentifier("input")],
-                                ),
-                            ),
-                        ),
-                    ),
-                    ts.factory.createReturnStatement(
-                        ts.factory.createIdentifier("output"),
-                    ),
-                ]),
-            );
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { ValidateProgrammer } from "../ValidateProgrammer";
+import { ProtobufDecodeProgrammer } from "./ProtobufDecodeProgrammer";
+
+export namespace ProtobufValidateDecodeProgrammer {
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string) =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        ts.factory.createTypeReferenceNode("Uint8Array"),
+                    ),
+                ],
+                ts.factory.createTypeReferenceNode(
+                    name ?? TypeFactory.getFullName(project.checker)(type),
+                ),
+                undefined,
+                ts.factory.createBlock([
+                    StatementFactory.constant(
+                        "validate",
+                        ValidateProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: true,
+                            },
+                        })(modulo)(false)(type, name),
+                    ),
+                    StatementFactory.constant(
+                        "decode",
+                        ProtobufDecodeProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(type, name),
+                    ),
+                    StatementFactory.constant(
+                        "output",
+                        ts.factory.createAsExpression(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("validate"),
+                                undefined,
+                                [ts.factory.createIdentifier("input")],
+                            ),
+                            TypeFactory.keyword("any"),
+                        ),
+                    ),
+                    ts.factory.createIfStatement(
+                        ts.factory.createIdentifier("output.success"),
+                        ts.factory.createExpressionStatement(
+                            ts.factory.createBinaryExpression(
+                                ts.factory.createIdentifier("output.data"),
+                                ts.SyntaxKind.EqualsToken,
+                                ts.factory.createCallExpression(
+                                    ts.factory.createIdentifier("decode"),
+                                    undefined,
+                                    [ts.factory.createIdentifier("input")],
+                                ),
+                            ),
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createIdentifier("output"),
+                    ),
+                ]),
+            );
+}

package/src/programmers/protobuf/ProtobufValidateEncodeProgrammer.ts

@@ -1,86 +1,86 @@
-import ts from "typescript";
-
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProject } from "../../transformers/IProject";
-
-import { ValidateProgrammer } from "../ValidateProgrammer";
-import { ProtobufEncodeProgrammer } from "./ProtobufEncodeProgrammer";
-
-export namespace ProtobufValidateEncodeProgrammer {
-    export const write =
-        (project: IProject) =>
-        (modulo: ts.LeftHandSideExpression) =>
-        (type: ts.Type, name?: string) =>
-            ts.factory.createArrowFunction(
-                undefined,
-                undefined,
-                [
-                    IdentifierFactory.parameter(
-                        "input",
-                        ts.factory.createTypeReferenceNode(
-                            name ??
-                                TypeFactory.getFullName(project.checker)(type),
-                        ),
-                    ),
-                ],
-                ts.factory.createTypeReferenceNode(
-                    "typia.IValidation<Uint8Array>",
-                ),
-                undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
-                        "validate",
-                        ValidateProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: true,
-                            },
-                        })(modulo)(false)(type, name),
-                    ),
-                    StatementFactory.constant(
-                        "encode",
-                        ProtobufEncodeProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: false,
-                            },
-                        })(modulo)(type, name),
-                    ),
-                    StatementFactory.constant(
-                        "output",
-                        ts.factory.createAsExpression(
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("validate"),
-                                undefined,
-                                [ts.factory.createIdentifier("input")],
-                            ),
-                            TypeFactory.keyword("any"),
-                        ),
-                    ),
-                    ts.factory.createIfStatement(
-                        ts.factory.createIdentifier("output.success"),
-                        ts.factory.createExpressionStatement(
-                            ts.factory.createBinaryExpression(
-                                ts.factory.createIdentifier("output.data"),
-                                ts.SyntaxKind.EqualsToken,
-                                ts.factory.createCallExpression(
-                                    ts.factory.createIdentifier("encode"),
-                                    undefined,
-                                    [ts.factory.createIdentifier("input")],
-                                ),
-                            ),
-                        ),
-                    ),
-                    ts.factory.createReturnStatement(
-                        ts.factory.createIdentifier("output"),
-                    ),
-                ]),
-            );
-}
+import ts from "typescript";
+
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { ValidateProgrammer } from "../ValidateProgrammer";
+import { ProtobufEncodeProgrammer } from "./ProtobufEncodeProgrammer";
+
+export namespace ProtobufValidateEncodeProgrammer {
+    export const write =
+        (project: IProject) =>
+        (modulo: ts.LeftHandSideExpression) =>
+        (type: ts.Type, name?: string) =>
+            ts.factory.createArrowFunction(
+                undefined,
+                undefined,
+                [
+                    IdentifierFactory.parameter(
+                        "input",
+                        ts.factory.createTypeReferenceNode(
+                            name ??
+                                TypeFactory.getFullName(project.checker)(type),
+                        ),
+                    ),
+                ],
+                ts.factory.createTypeReferenceNode(
+                    "typia.IValidation<Uint8Array>",
+                ),
+                undefined,
+                ts.factory.createBlock([
+                    StatementFactory.constant(
+                        "validate",
+                        ValidateProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: true,
+                            },
+                        })(modulo)(false)(type, name),
+                    ),
+                    StatementFactory.constant(
+                        "encode",
+                        ProtobufEncodeProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(type, name),
+                    ),
+                    StatementFactory.constant(
+                        "output",
+                        ts.factory.createAsExpression(
+                            ts.factory.createCallExpression(
+                                ts.factory.createIdentifier("validate"),
+                                undefined,
+                                [ts.factory.createIdentifier("input")],
+                            ),
+                            TypeFactory.keyword("any"),
+                        ),
+                    ),
+                    ts.factory.createIfStatement(
+                        ts.factory.createIdentifier("output.success"),
+                        ts.factory.createExpressionStatement(
+                            ts.factory.createBinaryExpression(
+                                ts.factory.createIdentifier("output.data"),
+                                ts.SyntaxKind.EqualsToken,
+                                ts.factory.createCallExpression(
+                                    ts.factory.createIdentifier("encode"),
+                                    undefined,
+                                    [ts.factory.createIdentifier("input")],
+                                ),
+                            ),
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(
+                        ts.factory.createIdentifier("output"),
+                    ),
+                ]),
+            );
+}