typia 7.0.0-dev.20241012 → 7.0.0-dev.20241019

package/src/programmers/protobuf/ProtobufEncodeProgrammer.ts

@@ -11,6 +11,7 @@ import { TypeFactory } from "../../factories/TypeFactory";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
 import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
+import { MetadataMap } from "../../schemas/metadata/MetadataMap";
 import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
 import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
 
@@ -306,11 +307,12 @@ export namespace ProtobufEncodeProgrammer {
                 );
 
     // STARTS FROM ATOMIC TYPES
+    // @todo
     const unions: IUnion[] = [];
-    const numbers = ProtobufUtil.getNumbers(props.metadata);
-    const bigints = ProtobufUtil.getBigints(props.metadata);
+    const numbers = Array.from(ProtobufUtil.getNumbers(props.metadata).keys());
+    const bigints = Array.from(ProtobufUtil.getBigints(props.metadata).keys());
 
-    for (const atom of ProtobufUtil.getAtomics(props.metadata))
+    for (const [atom] of ProtobufUtil.getAtomics(props.metadata))
       if (atom === "bool")
         unions.push({
           type: "bool",
@@ -333,7 +335,7 @@ export namespace ProtobufEncodeProgrammer {
       )
         unions.push(
           decode_number({
-            candidates: numbers,
+            candidates: numbers as ProtobufAtomic.Numeric[],
             type: atom,
             input: props.input,
           }),
@@ -342,7 +344,7 @@ export namespace ProtobufEncodeProgrammer {
         if (numbers.some((n) => n === atom))
           unions.push(
             decode_number({
-              candidates: numbers,
+              candidates: numbers as ProtobufAtomic.Numeric[],
               type: atom,
               input: props.input,
             }),
@@ -350,7 +352,7 @@ export namespace ProtobufEncodeProgrammer {
         else
           unions.push(
             decode_bigint({
-              candidates: bigints,
+              candidates: bigints as ProtobufAtomic.BigNumeric[],
               type: atom,
               input: props.input,
             }),
@@ -489,7 +491,7 @@ export namespace ProtobufEncodeProgrammer {
     functor: FunctionProgrammer;
     index: number;
     input: ts.Expression;
-    entry: Metadata.Entry;
+    entry: MetadataMap | MetadataProperty;
     explore: FeatureProgrammer.IExplore;
   }): ts.Block => {
     const each: ts.Statement[] = [
@@ -822,7 +824,8 @@ export namespace ProtobufEncodeProgrammer {
     )
       return ProtobufWire.LEN;
 
-    const v = ProtobufUtil.getAtomics(metadata)[0]!;
+    // @todo
+    const v = ProtobufUtil.getAtomics(metadata).keys().next().value!;
     if (v === "string") return ProtobufWire.LEN;
     else if (
       v === "bool" ||

package/src/programmers/protobuf/ProtobufMessageProgrammer.ts

@@ -1,19 +1,19 @@
 import ts from "typescript";
 
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { MetadataCollection } from "../../factories/MetadataCollection";
 import { ProtobufFactory } from "../../factories/ProtobufFactory";
 
 import { Metadata } from "../../schemas/metadata/Metadata";
-import { MetadataAtomic } from "../../schemas/metadata/MetadataAtomic";
 import { MetadataObjectType } from "../../schemas/metadata/MetadataObjectType";
-import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
+import { IProtobufProperty } from "../../schemas/protobuf/IProtobufProperty";
+import { IProtobufPropertyType } from "../../schemas/protobuf/IProtobufPropertyType";
+import { IProtobufSchema } from "../../schemas/protobuf/IProtobufSchema";
 
 import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { MapUtil } from "../../utils/MapUtil";
-import { NameEncoder } from "../../utils/NameEncoder";
-
-import { ProtobufUtil } from "../helpers/ProtobufUtil";
+import { ProtobufNameEncoder } from "../../utils/ProtobufNameEncoder";
 
 export namespace ProtobufMessageProgrammer {
   export interface IProps {
@@ -47,7 +47,17 @@ export namespace ProtobufMessageProgrammer {
         .join("\n\n");
 
     // RETURNS
-    return ts.factory.createStringLiteral(content);
+    return ts.factory.createCallExpression(
+      IdentifierFactory.access(
+        ts.factory.createArrayLiteralExpression(
+          content.split("\n").map((str) => ts.factory.createStringLiteral(str)),
+          true,
+        ),
+        "join",
+      ),
+      undefined,
+      [ts.factory.createStringLiteral("\n")],
+    );
   };
 
   const emplace = (props: {
@@ -73,11 +83,11 @@ export namespace ProtobufMessageProgrammer {
 
   const write_hierarchy = (hierarchy: Hierarchy): string => {
     const elements: string[] = [
-      `message ${NameEncoder.encode(hierarchy.key)} {`,
+      `message ${ProtobufNameEncoder.encode(hierarchy.key)} {`,
     ];
     if (hierarchy.object !== null) {
       const text: string = write_object(hierarchy.object);
-      elements.push(...text.split("\n").map((str) => `${TAB}${str}`));
+      elements.push(...text.split("\n").map((str) => `  ${str}`));
     }
     if (hierarchy.children.size)
       elements.push(
@@ -86,7 +96,7 @@ export namespace ProtobufMessageProgrammer {
           .map((body) =>
             body
               .split("\n")
-              .map((line) => `${TAB}${line}`)
+              .map((line) => `  ${line}`)
               .join("\n"),
           )
           .join("\n\n"),
@@ -95,97 +105,71 @@ export namespace ProtobufMessageProgrammer {
     return elements.join("\n");
   };
 
-  const write_object = (object: MetadataObjectType): string => {
-    const sequence: IPointer<number> = { value: 0 };
-    return object.properties
+  const write_object = (obj: MetadataObjectType): string => {
+    return obj.properties
       .map((p) => {
+        if (p.of_protobuf_ === undefined) ProtobufFactory.emplaceObject(obj);
+        const schema: IProtobufProperty = p.of_protobuf_!;
         const key: string = p.key.getSoleLiteral()!;
-        const type: string = decode({
-          sequence,
-          metadata: p.value,
+        return decodeProperty({
+          key,
+          value: p.value,
+          union: schema.union,
         });
-        return type.indexOf("${name}") !== -1
-          ? type.replace("${name}", key)
-          : `${
-              p.value.arrays.length || type.startsWith("map<")
-                ? ""
-                : !p.value.isRequired() || p.value.nullable
-                  ? "optional "
-                  : "required "
-            }${type} ${key} = ${++sequence.value};`;
       })
       .join("\n");
   };
 
   /* -----------------------------------------------------------
-        DECODERS
-    ----------------------------------------------------------- */
-  const decode = (props: {
-    sequence: IPointer<number>;
-    metadata: Metadata;
+    DECODERS
+  ----------------------------------------------------------- */
+  const decodeProperty = (props: {
+    key: string;
+    value: Metadata;
+    union: IProtobufPropertyType[];
   }): string => {
-    const elements: Set<string> = new Set();
-    if (props.metadata.natives.length) elements.add("bytes");
-    for (const atomic of ProtobufUtil.getAtomics(props.metadata))
-      elements.add(atomic);
-    for (const array of props.metadata.arrays)
-      elements.add(
-        `repeated ${decode({
-          sequence: props.sequence,
-          metadata: array.type.value,
-        })}`,
-      );
-    for (const obj of props.metadata.objects)
-      elements.add(
-        is_dynamic_object(obj.type)
-          ? decode_map({
-              sequence: props.sequence,
-              entry: MetadataProperty.create({
-                ...obj.type.properties[0]!,
-                key: (() => {
-                  const key: Metadata = Metadata.initialize();
-                  key.atomics.push(
-                    MetadataAtomic.create({
-                      type: "string",
-                      tags: [],
-                    }),
-                  );
-                  return key;
-                })(),
-              }),
-            })
-          : NameEncoder.encode(obj.type.name),
-      );
-    for (const entry of props.metadata.maps)
-      elements.add(
-        decode_map({
-          sequence: props.sequence,
-          entry,
-        }),
-      );
-    return elements.size === 1
-      ? [...elements][0]!
-      : [
-          "oneof ${name} {",
-          ...[...elements].map((str) => {
-            const index: number = ++props.sequence.value;
-            return `${TAB}${str} v${index} = ${index};`;
-          }),
-          "}",
-        ].join("\n");
+    if (props.union.length === 1) {
+      const top = props.union[0]!;
+      return [
+        ...(top.type === "array" || top.type === "map"
+          ? []
+          : [
+              props.value.isRequired() && props.value.nullable === false
+                ? "required"
+                : "optional",
+            ]),
+        decodeSchema(top),
+        props.key,
+        "=",
+        `${top.index};`,
+      ].join(" ");
+    }
+    return [
+      `oneof ${props.key} {`,
+      ...props.union
+        .map((type) => `${decodeSchema(type)} v${type.index} = ${type.index};`)
+        .map((str) => str.split("\n"))
+        .map((str) => `  ${str}`),
+      `}`,
+    ].join("\n");
   };
 
-  const decode_map = (props: {
-    sequence: IPointer<number>;
-    entry: Metadata.Entry;
-  }): string =>
-    `map<${decode({
-      sequence: props.sequence,
-      metadata: props.entry.key,
-    })}, ${decode({
-      sequence: props.sequence,
-      metadata: props.entry.value,
-    })}>`;
+  const decodeSchema = (schema: IProtobufSchema): string => {
+    if (
+      schema.type === "bytes" ||
+      schema.type === "bool" ||
+      schema.type === "string"
+    )
+      return schema.type;
+    else if (schema.type === "bigint" || schema.type === "number")
+      return schema.name;
+    else if (schema.type === "array")
+      return `repeated ${decodeSchema(schema.value)}`;
+    else if (schema.type === "object")
+      return ProtobufNameEncoder.encode(schema.object.name);
+    // else if (schema.type === "map")
+    return `map<${decodeSchema(schema.key)}, ${decodeSchema(schema.value)}>`;
+  };
 }
 
 interface Hierarchy {
@@ -193,9 +177,3 @@ interface Hierarchy {
   object: MetadataObjectType | null;
   children: Map<string, Hierarchy>;
 }
-
-interface IPointer<T> {
-  value: T;
-}
-
-const TAB = " ".repeat(2);

package/src/schemas/metadata/IMetadata.ts

@@ -1,39 +1,35 @@
-import { IMetadataAtomic } from "./IMetadataAtomic";
-import { IMetadataConstant } from "./IMetadataConstant";
-import { IMetadataEntry } from "./IMetadataEntry";
-import { IMetadataEscaped } from "./IMetadataEscaped";
-import { IMetadataFunction } from "./IMetadataFunction";
-import { IMetadataTemplate } from "./IMetadataTemplate";
-import { IMetadataTypeTag } from "./IMetadataTypeTag";
-
-export interface IMetadata {
-  any: boolean;
-  required: boolean;
-  optional: boolean;
-  nullable: boolean;
-  functions: IMetadataFunction[];
-
-  atomics: IMetadataAtomic[];
-  constants: IMetadataConstant[];
-  templates: IMetadataTemplate[];
-  escaped: IMetadataEscaped | null;
-
-  rest: IMetadata | null;
-  arrays: {
-    name: string;
-    tags: IMetadataTypeTag[][];
-  }[];
-  tuples: {
-    name: string;
-    tags: IMetadataTypeTag[][];
-  }[];
-  objects: {
-    name: string;
-    tags: IMetadataTypeTag[][];
-  }[];
-  aliases: string[];
-
-  natives: string[];
-  sets: IMetadata[];
-  maps: IMetadataEntry[];
-}
+import { IMetadataAlias } from "./IMetadataAlias";
+import { IMetadataArray } from "./IMetadataArray";
+import { IMetadataAtomic } from "./IMetadataAtomic";
+import { IMetadataConstant } from "./IMetadataConstant";
+import { IMetadataEscaped } from "./IMetadataEscaped";
+import { IMetadataFunction } from "./IMetadataFunction";
+import { IMetadataMap } from "./IMetadataMap";
+import { IMetadataNative } from "./IMetadataNative";
+import { IMetadataObject } from "./IMetadataObject";
+import { IMetadataSet } from "./IMetadataSet";
+import { IMetadataTemplate } from "./IMetadataTemplate";
+import { IMetadataTuple } from "./IMetadataTuple";
+
+export interface IMetadata {
+  any: boolean;
+  required: boolean;
+  optional: boolean;
+  nullable: boolean;
+  functions: IMetadataFunction[];
+
+  atomics: IMetadataAtomic[];
+  constants: IMetadataConstant[];
+  templates: IMetadataTemplate[];
+  escaped: IMetadataEscaped | null;
+
+  rest: IMetadata | null;
+  arrays: IMetadataArray[];
+  tuples: IMetadataTuple[];
+  objects: IMetadataObject[];
+  aliases: IMetadataAlias[];
+
+  natives: IMetadataNative[];
+  sets: IMetadataSet[];
+  maps: IMetadataMap[];
+}

package/src/schemas/metadata/IMetadataAlias.ts

@@ -1,12 +1,6 @@
-import { IJsDocTagInfo } from "./IJsDocTagInfo";
-import { IMetadata } from "./IMetadata";
-
-export interface IMetadataAlias {
-  name: string;
-  value: IMetadata;
-  nullables: boolean[];
-
-  description: string | null;
-  jsDocTags: IJsDocTagInfo[];
-  recursive: boolean;
-}
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export interface IMetadataAlias {
+  name: string;
+  tags: IMetadataTypeTag[][];
+}

package/src/schemas/metadata/IMetadataAliasType.ts

@@ -0,0 +1,12 @@
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadata } from "./IMetadata";
+
+export interface IMetadataAliasType {
+  name: string;
+  value: IMetadata;
+  nullables: boolean[];
+
+  description: string | null;
+  jsDocTags: IJsDocTagInfo[];
+  recursive: boolean;
+}

package/src/schemas/metadata/IMetadataArray.ts

@@ -1,6 +1,6 @@
-import { IMetadataTypeTag } from "./IMetadataTypeTag";
-
-export interface IMetadataArray {
-  name: string;
-  tags: IMetadataTypeTag[][];
-}
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export interface IMetadataArray {
+  name: string;
+  tags: IMetadataTypeTag[][];
+}

package/src/schemas/metadata/IMetadataComponents.ts

@@ -1,11 +1,11 @@
-import { IMetadataAlias } from "./IMetadataAlias";
-import { IMetadataArrayType } from "./IMetadataArrayType";
-import { IMetadataObjectType } from "./IMetadataObjectType";
-import { IMetadataTupleType } from "./IMetadataTupleType";
-
-export interface IMetadataComponents {
-  objects: IMetadataObjectType[];
-  aliases: IMetadataAlias[];
-  arrays: IMetadataArrayType[];
-  tuples: IMetadataTupleType[];
-}
+import { IMetadataAliasType } from "./IMetadataAliasType";
+import { IMetadataArrayType } from "./IMetadataArrayType";
+import { IMetadataObjectType } from "./IMetadataObjectType";
+import { IMetadataTupleType } from "./IMetadataTupleType";
+
+export interface IMetadataComponents {
+  objects: IMetadataObjectType[];
+  aliases: IMetadataAliasType[];
+  arrays: IMetadataArrayType[];
+  tuples: IMetadataTupleType[];
+}

package/src/schemas/metadata/IMetadataConstantValue.ts

@@ -5,7 +5,7 @@ import { IMetadataTypeTag } from "./IMetadataTypeTag";
 
 export interface IMetadataConstantValue<T extends Atomic.Type> {
   value: T;
-  tags?: IMetadataTypeTag[][] | undefined;
+  tags: IMetadataTypeTag[][];
   description?: string | null;
   jsDocTags?: IJsDocTagInfo[];
 }

package/src/schemas/metadata/IMetadataDictionary.ts

@@ -1,11 +1,11 @@
-import { MetadataAlias } from "./MetadataAlias";
+import { MetadataAliasType } from "./MetadataAliasType";
 import { MetadataArrayType } from "./MetadataArrayType";
 import { MetadataObjectType } from "./MetadataObjectType";
 import { MetadataTupleType } from "./MetadataTupleType";
 
 export interface IMetadataDictionary {
   objects: Map<string, MetadataObjectType>;
-  aliases: Map<string, MetadataAlias>;
+  aliases: Map<string, MetadataAliasType>;
   arrays: Map<string, MetadataArrayType>;
   tuples: Map<string, MetadataTupleType>;
 }

package/src/schemas/metadata/IMetadataMap.ts

@@ -0,0 +1,8 @@
+import { IMetadata } from "./IMetadata";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export interface IMetadataMap {
+  key: IMetadata;
+  value: IMetadata;
+  tags: IMetadataTypeTag[][];
+}

package/src/schemas/metadata/IMetadataNative.ts

@@ -0,0 +1,6 @@
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export interface IMetadataNative {
+  name: string;
+  tags: IMetadataTypeTag[][];
+}

package/src/schemas/metadata/IMetadataObjectType.ts

@@ -1,13 +1,13 @@
-import { IJsDocTagInfo } from "./IJsDocTagInfo";
-import { IMetadataProperty } from "./IMetadataProperty";
-
-export interface IMetadataObjectType {
-  name: string;
-  properties: IMetadataProperty[];
-  description?: undefined | string;
-  jsDocTags: IJsDocTagInfo[];
-
-  index: number;
-  recursive: boolean;
-  nullables: boolean[];
-}
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadataProperty } from "./IMetadataProperty";
+
+export interface IMetadataObjectType {
+  name: string;
+  properties: IMetadataProperty[];
+  description?: undefined | string;
+  jsDocTags: IJsDocTagInfo[];
+
+  index: number;
+  recursive: boolean;
+  nullables: boolean[];
+}

package/src/schemas/metadata/IMetadataSet.ts

@@ -0,0 +1,7 @@
+import { IMetadata } from "./IMetadata";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export interface IMetadataSet {
+  value: IMetadata;
+  tags: IMetadataTypeTag[][];
+}

package/src/schemas/metadata/IMetadataTemplate.ts

@@ -1,7 +1,7 @@
-import { IMetadata } from "./IMetadata";
-import { IMetadataTypeTag } from "./IMetadataTypeTag";
-
-export interface IMetadataTemplate {
-  row: IMetadata[];
-  tags?: IMetadataTypeTag[][] | undefined;
-}
+import { IMetadata } from "./IMetadata";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export interface IMetadataTemplate {
+  row: IMetadata[];
+  tags: IMetadataTypeTag[][];
+}

package/src/schemas/metadata/IMetadataTuple.ts

@@ -1,6 +1,6 @@
-import { IMetadataTypeTag } from "./IMetadataTypeTag";
-
-export interface IMetadataTuple {
-  name: string;
-  tags: IMetadataTypeTag[][];
-}
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export interface IMetadataTuple {
+  name: string;
+  tags: IMetadataTypeTag[][];
+}

package/src/schemas/metadata/IMetadataTypeTag.ts

@@ -1,16 +1,16 @@
-import type ts from "typescript";
-
-export interface IMetadataTypeTag {
-  target: "boolean" | "bigint" | "number" | "string" | "array";
-  name: string;
-  kind: string;
-  exclusive: boolean | string[];
-  value?: any;
-  validate?: string | undefined;
-  schema?: object | undefined;
-
-  /**
-   * @internal
-   */
-  predicate?: (input: ts.Expression) => ts.Expression;
-}
+import type ts from "typescript";
+
+export interface IMetadataTypeTag {
+  target: "boolean" | "bigint" | "number" | "string" | "array" | "object";
+  name: string;
+  kind: string;
+  exclusive: boolean | string[];
+  value?: any;
+  validate?: string | undefined;
+  schema?: object | undefined;
+
+  /**
+   * @internal
+   */
+  predicate?: (input: ts.Expression) => ts.Expression;
+}