typia 5.3.0-dev.20231112 → 5.3.0-dev.20231119

package/src/programmers/protobuf/ProtobufIsDecodeProgrammer.ts

@@ -1,85 +1,82 @@
-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 { IsProgrammer } from "../IsProgrammer";
-import { ProtobufDecodeProgrammer } from "./ProtobufDecodeProgrammer";
-
-export namespace ProtobufIsDecodeProgrammer {
-    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.createUnionTypeNode([
-                    ts.factory.createTypeReferenceNode(
-                        `typia.Resolved<${
-                            name ??
-                            TypeFactory.getFullName(project.checker)(type)
-                        }>`,
-                    ),
-                    ts.factory.createLiteralTypeNode(ts.factory.createNull()),
-                ]),
-                undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
-                        "is",
-                        IsProgrammer.write({
-                            ...project,
-                            options: {
-                                ...project.options,
-                                functional: false,
-                                numeric: false,
-                            },
-                        })(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.createCallExpression(
-                            ts.factory.createIdentifier("decode"),
-                            undefined,
-                            [ts.factory.createIdentifier("input")],
-                        ),
-                    ),
-                    ts.factory.createIfStatement(
-                        ts.factory.createPrefixUnaryExpression(
-                            ts.SyntaxKind.ExclamationToken,
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("is"),
-                                undefined,
-                                [ts.factory.createIdentifier("output")],
-                            ),
-                        ),
-                        ts.factory.createReturnStatement(
-                            ts.factory.createNull(),
-                        ),
-                    ),
-                    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 { IsProgrammer } from "../IsProgrammer";
+import { ProtobufDecodeProgrammer } from "./ProtobufDecodeProgrammer";
+
+export namespace ProtobufIsDecodeProgrammer {
+  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.createUnionTypeNode([
+          ts.factory.createTypeReferenceNode(
+            `typia.Resolved<${
+              name ?? TypeFactory.getFullName(project.checker)(type)
+            }>`,
+          ),
+          ts.factory.createLiteralTypeNode(ts.factory.createNull()),
+        ]),
+        undefined,
+        ts.factory.createBlock([
+          StatementFactory.constant(
+            "is",
+            IsProgrammer.write({
+              ...project,
+              options: {
+                ...project.options,
+                functional: false,
+                numeric: false,
+              },
+            })(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.createCallExpression(
+              ts.factory.createIdentifier("decode"),
+              undefined,
+              [ts.factory.createIdentifier("input")],
+            ),
+          ),
+          ts.factory.createIfStatement(
+            ts.factory.createPrefixUnaryExpression(
+              ts.SyntaxKind.ExclamationToken,
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("is"),
+                undefined,
+                [ts.factory.createIdentifier("output")],
+              ),
+            ),
+            ts.factory.createReturnStatement(ts.factory.createNull()),
+          ),
+          ts.factory.createReturnStatement(
+            ts.factory.createIdentifier("output"),
+          ),
+        ]),
+      );
+}

package/src/programmers/protobuf/ProtobufIsEncodeProgrammer.ts

@@ -1,76 +1,75 @@
-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 { IsProgrammer } from "../IsProgrammer";
-import { ProtobufEncodeProgrammer } from "./ProtobufEncodeProgrammer";
-
-export namespace ProtobufIsEncodeProgrammer {
-    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.createUnionTypeNode([
-                    ts.factory.createTypeReferenceNode("Uint8Array"),
-                    ts.factory.createLiteralTypeNode(ts.factory.createNull()),
-                ]),
-                undefined,
-                ts.factory.createBlock([
-                    StatementFactory.constant(
-                        "is",
-                        IsProgrammer.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),
-                    ),
-                    ts.factory.createReturnStatement(
-                        ts.factory.createConditionalExpression(
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("is"),
-                                undefined,
-                                [ts.factory.createIdentifier("input")],
-                            ),
-                            undefined,
-                            ts.factory.createCallExpression(
-                                ts.factory.createIdentifier("encode"),
-                                undefined,
-                                [ts.factory.createIdentifier("input")],
-                            ),
-                            undefined,
-                            ts.factory.createNull(),
-                        ),
-                    ),
-                ]),
-            );
-}
+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 { IsProgrammer } from "../IsProgrammer";
+import { ProtobufEncodeProgrammer } from "./ProtobufEncodeProgrammer";
+
+export namespace ProtobufIsEncodeProgrammer {
+  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.createUnionTypeNode([
+          ts.factory.createTypeReferenceNode("Uint8Array"),
+          ts.factory.createLiteralTypeNode(ts.factory.createNull()),
+        ]),
+        undefined,
+        ts.factory.createBlock([
+          StatementFactory.constant(
+            "is",
+            IsProgrammer.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),
+          ),
+          ts.factory.createReturnStatement(
+            ts.factory.createConditionalExpression(
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("is"),
+                undefined,
+                [ts.factory.createIdentifier("input")],
+              ),
+              undefined,
+              ts.factory.createCallExpression(
+                ts.factory.createIdentifier("encode"),
+                undefined,
+                [ts.factory.createIdentifier("input")],
+              ),
+              undefined,
+              ts.factory.createNull(),
+            ),
+          ),
+        ]),
+      );
+}

package/src/programmers/protobuf/ProtobufMessageProgrammer.ts

@@ -1,165 +1,160 @@
-import ts from "typescript";
-
-import { MetadataCollection } from "../../factories/MetadataCollection";
-import { ProtobufFactory } from "../../factories/ProtobufFactory";
-
-import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
-import { MetadataObject } from "../../schemas/metadata/MetadataObject";
-import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
-
-import { IProject } from "../../transformers/IProject";
-
-import { MapUtil } from "../../utils/MapUtil";
-import { NameEncoder } from "../../utils/NameEncoder";
-
-import { ProtobufUtil } from "../helpers/ProtobufUtil";
-
-export namespace ProtobufMessageProgrammer {
-    export const write = (project: IProject) => (type: ts.Type) => {
-        // PARSE TARGET TYPE
-        const collection: MetadataCollection = new MetadataCollection();
-        ProtobufFactory.metadata("message")(project.checker, project.context)(
-            collection,
-        )(type);
-
-        // STRINGIFY
-        const hierarchies: Map<string, Hierarchy> = new Map();
-        for (const obj of collection.objects())
-            if (is_dynamic_object(obj) === false) emplace(hierarchies)(obj);
-
-        const content: string =
-            `syntax = "proto3";\n\n` +
-            [...hierarchies.values()]
-                .map((hier) => write_hierarchy(hier))
-                .join("\n\n");
-
-        // RETURNS
-        return ts.factory.createStringLiteral(content);
-    };
-
-    const emplace = (dict: Map<string, Hierarchy>) => (obj: MetadataObject) => {
-        const accessors: string[] = obj.name.split(".");
-        accessors.forEach((access, i) => {
-            const hierarchy: Hierarchy = MapUtil.take(dict)(access, () => ({
-                key: access,
-                object: null!,
-                children: new Map(),
-            }));
-            dict = hierarchy.children;
-            if (i === accessors.length - 1) hierarchy.object = obj;
-        });
-    };
-
-    const is_dynamic_object = (obj: MetadataObject): boolean =>
-        obj.properties.length === 1 &&
-        obj.properties[0]!.key.isSoleLiteral() === false;
-
-    const write_hierarchy = (hierarchy: Hierarchy): string => {
-        const elements: string[] = [
-            `message ${NameEncoder.encode(hierarchy.key)} {`,
-        ];
-        if (hierarchy.object !== null) {
-            const text: string = write_object(hierarchy.object);
-            elements.push(...text.split("\n").map((str) => `${TAB}${str}`));
-        }
-        if (hierarchy.children.size)
-            elements.push(
-                [...hierarchy.children.values()]
-                    .map((child) => write_hierarchy(child))
-                    .map((body) =>
-                        body
-                            .split("\n")
-                            .map((line) => `${TAB}${line}`)
-                            .join("\n"),
-                    )
-                    .join("\n\n"),
-            );
-        elements.push("}");
-        return elements.join("\n");
-    };
-
-    const write_object = (obj: MetadataObject): string => {
-        const ptr: IPointer<number> = { value: 0 };
-        return obj.properties
-            .map((prop) => {
-                const key: string = prop.key.getSoleLiteral()!;
-                const type: string = decode(ptr)(prop.value);
-                return type.indexOf("${name}") !== -1
-                    ? type.replace("${name}", key)
-                    : `${
-                          prop.value.arrays.length || type.startsWith("map<")
-                              ? ""
-                              : !prop.value.isRequired() || prop.value.nullable
-                              ? "optional "
-                              : "required "
-                      }${type} ${key} = ${++ptr.value};`;
-            })
-            .join("\n");
-    };
-
-    /* -----------------------------------------------------------
-        DECODERS
-    ----------------------------------------------------------- */
-    const decode =
-        (ptr: IPointer<number>) =>
-        (meta: Metadata): string => {
-            const elements: Set<string> = new Set();
-            if (meta.natives.length) elements.add("bytes");
-            for (const atomic of ProtobufUtil.getAtomics(meta))
-                elements.add(atomic);
-            for (const array of meta.arrays)
-                elements.add(`repeated ${decode(ptr)(array.type.value)}`);
-            for (const obj of meta.objects)
-                elements.add(
-                    is_dynamic_object(obj)
-                        ? decode_map(ptr)(
-                              MetadataProperty.create({
-                                  ...obj.properties[0]!,
-                                  key: (() => {
-                                      const key: Metadata =
-                                          Metadata.initialize();
-                                      key.atomics.push(
-                                          MetadataAtomic.create({
-                                              type: "string",
-                                              tags: [],
-                                          }),
-                                      );
-                                      return key;
-                                  })(),
-                              }),
-                          )
-                        : NameEncoder.encode(obj.name),
-                );
-            for (const map of meta.maps) elements.add(decode_map(ptr)(map));
-            return elements.size === 1
-                ? [...elements][0]!
-                : [
-                      "oneof ${name} {",
-                      ...[...elements].map(
-                          (str) =>
-                              `${TAB}${str} v${
-                                  ptr.value + 1
-                              } = ${++ptr.value};`,
-                      ),
-                      "}",
-                  ].join("\n");
-        };
-
-    const decode_map =
-        (ptr: IPointer<number>) =>
-        (prop: Metadata.Entry): string =>
-            `map<${decode(ptr)(prop.key)}, ${decode(ptr)(prop.value)}>`;
-}
-
-interface Hierarchy {
-    key: string;
-    object: MetadataObject | null;
-    children: Map<string, Hierarchy>;
-}
-
-interface IPointer<T> {
-    value: T;
-}
-
-const TAB = " ".repeat(4);
+import ts from "typescript";
+
+import { MetadataCollection } from "../../factories/MetadataCollection";
+import { ProtobufFactory } from "../../factories/ProtobufFactory";
+
+import { Metadata } from "../../schemas/metadata/Metadata";
+import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+import { MetadataObject } from "../../schemas/metadata/MetadataObject";
+import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
+
+import { IProject } from "../../transformers/IProject";
+
+import { MapUtil } from "../../utils/MapUtil";
+import { NameEncoder } from "../../utils/NameEncoder";
+
+import { ProtobufUtil } from "../helpers/ProtobufUtil";
+
+export namespace ProtobufMessageProgrammer {
+  export const write = (project: IProject) => (type: ts.Type) => {
+    // PARSE TARGET TYPE
+    const collection: MetadataCollection = new MetadataCollection();
+    ProtobufFactory.metadata("message")(project.checker, project.context)(
+      collection,
+    )(type);
+
+    // STRINGIFY
+    const hierarchies: Map<string, Hierarchy> = new Map();
+    for (const obj of collection.objects())
+      if (is_dynamic_object(obj) === false) emplace(hierarchies)(obj);
+
+    const content: string =
+      `syntax = "proto3";\n\n` +
+      [...hierarchies.values()]
+        .map((hier) => write_hierarchy(hier))
+        .join("\n\n");
+
+    // RETURNS
+    return ts.factory.createStringLiteral(content);
+  };
+
+  const emplace = (dict: Map<string, Hierarchy>) => (obj: MetadataObject) => {
+    const accessors: string[] = obj.name.split(".");
+    accessors.forEach((access, i) => {
+      const hierarchy: Hierarchy = MapUtil.take(dict)(access, () => ({
+        key: access,
+        object: null!,
+        children: new Map(),
+      }));
+      dict = hierarchy.children;
+      if (i === accessors.length - 1) hierarchy.object = obj;
+    });
+  };
+
+  const is_dynamic_object = (obj: MetadataObject): boolean =>
+    obj.properties.length === 1 &&
+    obj.properties[0]!.key.isSoleLiteral() === false;
+
+  const write_hierarchy = (hierarchy: Hierarchy): string => {
+    const elements: string[] = [
+      `message ${NameEncoder.encode(hierarchy.key)} {`,
+    ];
+    if (hierarchy.object !== null) {
+      const text: string = write_object(hierarchy.object);
+      elements.push(...text.split("\n").map((str) => `${TAB}${str}`));
+    }
+    if (hierarchy.children.size)
+      elements.push(
+        [...hierarchy.children.values()]
+          .map((child) => write_hierarchy(child))
+          .map((body) =>
+            body
+              .split("\n")
+              .map((line) => `${TAB}${line}`)
+              .join("\n"),
+          )
+          .join("\n\n"),
+      );
+    elements.push("}");
+    return elements.join("\n");
+  };
+
+  const write_object = (obj: MetadataObject): string => {
+    const ptr: IPointer<number> = { value: 0 };
+    return obj.properties
+      .map((prop) => {
+        const key: string = prop.key.getSoleLiteral()!;
+        const type: string = decode(ptr)(prop.value);
+        return type.indexOf("${name}") !== -1
+          ? type.replace("${name}", key)
+          : `${
+              prop.value.arrays.length || type.startsWith("map<")
+                ? ""
+                : !prop.value.isRequired() || prop.value.nullable
+                ? "optional "
+                : "required "
+            }${type} ${key} = ${++ptr.value};`;
+      })
+      .join("\n");
+  };
+
+  /* -----------------------------------------------------------
+        DECODERS
+    ----------------------------------------------------------- */
+  const decode =
+    (ptr: IPointer<number>) =>
+    (meta: Metadata): string => {
+      const elements: Set<string> = new Set();
+      if (meta.natives.length) elements.add("bytes");
+      for (const atomic of ProtobufUtil.getAtomics(meta)) elements.add(atomic);
+      for (const array of meta.arrays)
+        elements.add(`repeated ${decode(ptr)(array.type.value)}`);
+      for (const obj of meta.objects)
+        elements.add(
+          is_dynamic_object(obj)
+            ? decode_map(ptr)(
+                MetadataProperty.create({
+                  ...obj.properties[0]!,
+                  key: (() => {
+                    const key: Metadata = Metadata.initialize();
+                    key.atomics.push(
+                      MetadataAtomic.create({
+                        type: "string",
+                        tags: [],
+                      }),
+                    );
+                    return key;
+                  })(),
+                }),
+              )
+            : NameEncoder.encode(obj.name),
+        );
+      for (const map of meta.maps) elements.add(decode_map(ptr)(map));
+      return elements.size === 1
+        ? [...elements][0]!
+        : [
+            "oneof ${name} {",
+            ...[...elements].map(
+              (str) => `${TAB}${str} v${ptr.value + 1} = ${++ptr.value};`,
+            ),
+            "}",
+          ].join("\n");
+    };
+
+  const decode_map =
+    (ptr: IPointer<number>) =>
+    (prop: Metadata.Entry): string =>
+      `map<${decode(ptr)(prop.key)}, ${decode(ptr)(prop.value)}>`;
+}
+
+interface Hierarchy {
+  key: string;
+  object: MetadataObject | null;
+  children: Map<string, Hierarchy>;
+}
+
+interface IPointer<T> {
+  value: T;
+}
+
+const TAB = " ".repeat(4);