typia 7.0.0-dev.20241018 → 7.0.0-dev.20241019

package/src/programmers/protobuf/ProtobufMessageProgrammer.ts

@@ -1,20 +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 { MetadataMap } from "../../schemas/metadata/MetadataMap";
 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 {
@@ -48,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: {
@@ -74,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(
@@ -87,7 +96,7 @@ export namespace ProtobufMessageProgrammer {
           .map((body) =>
             body
               .split("\n")
-              .map((line) => `${TAB}${line}`)
+              .map((line) => `  ${line}`)
               .join("\n"),
           )
           .join("\n\n"),
@@ -96,24 +105,17 @@ 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");
   };
@@ -121,96 +123,53 @@ export namespace ProtobufMessageProgrammer {
   /* -----------------------------------------------------------
     DECODERS
   ----------------------------------------------------------- */
-  const decode = (props: {
-    sequence: IPointer<number>;
-    metadata: Metadata;
+  const decodeProperty = (props: {
+    key: string;
+    value: Metadata;
+    union: IProtobufPropertyType[];
   }): string => {
-    const union: Map<string, number | null> = new Map();
-    for (const native of props.metadata.natives)
-      if (native.name === "Uint8Array")
-        union.set("bytes", ProtobufUtil.getSequence(native.tags[0] ?? []));
-    ProtobufUtil.getAtomics(props.metadata, union);
-    for (const array of props.metadata.arrays)
-      union.set(
-        `repeated ${decode({
-          sequence: props.sequence,
-          metadata: array.type.value,
-        })}`,
-        ProtobufUtil.getSequence(array.tags[0] ?? []),
-      );
-    for (const obj of props.metadata.objects)
-      union.set(
-        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),
-        ProtobufUtil.getSequence(obj.tags[0] ?? []),
-      );
-    for (const entry of props.metadata.maps)
-      union.set(
-        decode_map({
-          sequence: props.sequence,
-          entry,
-        }),
-        ProtobufUtil.getSequence(entry.tags[0] ?? []),
-      );
-
-    const sequenced: boolean = Array.from(union.values()).every(
-      (x) => x !== null,
-    );
-    if (sequenced === false)
-      return union.size === 1
-        ? union.keys().next().value!
-        : [
-            "oneof ${name} {",
-            ...Array.from(union.keys()).map((str) => {
-              const index: number = ++props.sequence.value;
-              return `${TAB}${str} v${index} = ${index};`;
-            }),
-            "}",
-          ].join("\n");
-    else if (union.size === 1) {
-      const [key, value] = union.entries().next().value!;
-      props.sequence.value = value!;
-      return `${key} $\{name} = ${value}`;
+    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(" ");
     }
-    props.sequence.value = Math.max(
-      ...Array.from(union.values()).filter((v) => v !== null),
-    );
     return [
-      "oneof ${name} {",
-      ...Array.from(union.entries()).map(
-        ([key, value]) => `${TAB}${key} v${value} = ${value};`,
-      ),
-      "}",
+      `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: MetadataMap | MetadataProperty;
-  }): 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 {
@@ -218,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/MetadataProperty.ts

@@ -1,5 +1,6 @@
 import { ClassProperties } from "../../typings/ClassProperties";
 
+import { IProtobufProperty } from "../protobuf/IProtobufProperty";
 import { IJsDocTagInfo } from "./IJsDocTagInfo";
 import { IMetadataDictionary } from "./IMetadataDictionary";
 import { IMetadataProperty } from "./IMetadataProperty";
@@ -11,10 +12,7 @@ export class MetadataProperty {
   public readonly description: string | null;
   public readonly jsDocTags: IJsDocTagInfo[];
 
-  /**
-   * @internal
-   */
-  public readonly sequences_?: Set<number>;
+  public of_protobuf_?: IProtobufProperty;
 
   /* -----------------------------------------------------------
         CONSTRUCTORS

package/src/schemas/protobuf/IProtobufProperty.ts

@@ -0,0 +1,6 @@
+import { IProtobufPropertyType } from "./IProtobufPropertyType";
+
+export interface IProtobufProperty {
+  fixed: boolean;
+  union: IProtobufPropertyType[];
+}

package/src/schemas/protobuf/IProtobufPropertyType.ts

@@ -0,0 +1,37 @@
+import { IProtobufSchema } from "./IProtobufSchema";
+
+export type IProtobufPropertyType =
+  | IProtobufPropertyType.IByte
+  | IProtobufPropertyType.IBoolean
+  | IProtobufPropertyType.IBigint
+  | IProtobufPropertyType.INumber
+  | IProtobufPropertyType.IString
+  | IProtobufPropertyType.IArray
+  | IProtobufPropertyType.IObject
+  | IProtobufPropertyType.IMap;
+export namespace IProtobufPropertyType {
+  export interface IByte extends IProtobufSchema.IByte {
+    index: number;
+  }
+  export interface IBoolean extends IProtobufSchema.IBoolean {
+    index: number;
+  }
+  export interface IBigint extends IProtobufSchema.IBigint {
+    index: number;
+  }
+  export interface INumber extends IProtobufSchema.INumber {
+    index: number;
+  }
+  export interface IString extends IProtobufSchema.IString {
+    index: number;
+  }
+  export interface IArray extends IProtobufSchema.IArray {
+    index: number;
+  }
+  export interface IObject extends IProtobufSchema.IObject {
+    index: number;
+  }
+  export interface IMap extends IProtobufSchema.IMap {
+    index: number;
+  }
+}

package/src/schemas/protobuf/IProtobufSchema.ts

@@ -0,0 +1,50 @@
+import { MetadataArrayType } from "../metadata/MetadataArrayType";
+import { MetadataMap } from "../metadata/MetadataMap";
+import { MetadataObjectType } from "../metadata/MetadataObjectType";
+
+export type IProtobufSchema =
+  | IProtobufSchema.IByte
+  | IProtobufSchema.IBoolean
+  | IProtobufSchema.IBigint
+  | IProtobufSchema.INumber
+  | IProtobufSchema.IString
+  | IProtobufSchema.IArray
+  | IProtobufSchema.IObject
+  | IProtobufSchema.IMap;
+export namespace IProtobufSchema {
+  export interface IByte {
+    type: "bytes";
+  }
+  export interface IBoolean {
+    type: "bool";
+  }
+  export interface IBigint {
+    type: "bigint";
+    name: "int64" | "uint64";
+  }
+  export interface INumber {
+    type: "number";
+    name: "int32" | "int64" | "uint32" | "uint64" | "float" | "double";
+  }
+  export interface IString {
+    type: "string";
+  }
+  export interface IArray {
+    type: "array";
+    array: MetadataArrayType;
+    value: Exclude<IProtobufSchema, IArray | IMap>;
+  }
+  export interface IObject {
+    type: "object";
+    object: MetadataObjectType;
+  }
+  export interface IMap {
+    type: "map";
+    map: MetadataMap | MetadataObjectType;
+    key:
+      | IProtobufSchema.IBoolean
+      | IProtobufSchema.INumber
+      | IProtobufSchema.IString;
+    value: Exclude<IProtobufSchema, IArray | IMap>;
+  }
+}

package/src/utils/{NameEncoder.ts → ProtobufNameEncoder.ts}

@@ -1,4 +1,4 @@
-export namespace NameEncoder {
+export namespace ProtobufNameEncoder {
   export const encode = (str: string): string => {
     for (const [before, after] of REPLACERS)
       str = str.split(before).join(after);

package/lib/utils/NameEncoder.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"NameEncoder.js","sourceRoot":"","sources":["../../src/utils/NameEncoder.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAiB,WAAW,CAY3B;AAZD,WAAiB,WAAW;IACb,kBAAM,GAAG,UAAC,GAAW;;;YAChC,KAA8B,IAAA,cAAA,SAAA,SAAS,CAAA,oCAAA;gBAA5B,IAAA,KAAA,8BAAe,EAAd,MAAM,QAAA,EAAE,KAAK,QAAA;gBACvB,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;aAAA;;;;;;;;;QACtC,OAAO,GAAG,CAAC;IACb,CAAC,CAAC;IAEW,kBAAM,GAAG,UAAC,GAAW;;;YAChC,KAA8B,IAAA,cAAA,SAAA,SAAS,CAAA,oCAAA;gBAA5B,IAAA,KAAA,8BAAe,EAAd,MAAM,QAAA,EAAE,KAAK,QAAA;gBACvB,IAAI,KAAK,KAAK,EAAE;oBAAE,GAAG,GAAG,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;aAAA;;;;;;;;;QACxD,OAAO,GAAG,CAAC;IACb,CAAC,CAAC;AACJ,CAAC,EAZgB,WAAW,2BAAX,WAAW,QAY3B;AAED,IAAM,SAAS,GAAuB;IACpC,CAAC,GAAG,EAAE,UAAU,CAAC;IACjB,CAAC,GAAG,EAAE,OAAO,CAAC;IACd,CAAC,GAAG,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,OAAO,CAAC;IACd,CAAC,GAAG,EAAE,OAAO,CAAC;IACd,CAAC,GAAG,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,MAAM,CAAC;IACb,CAAC,GAAG,EAAE,OAAO,CAAC;IACd,CAAC,GAAG,EAAE,OAAO,CAAC;IACd,CAAC,GAAG,EAAE,SAAS,CAAC;IAChB,CAAC,GAAG,EAAE,aAAa,CAAC;IACpB,CAAC,GAAG,EAAE,eAAe,CAAC;IACtB,CAAC,GAAG,EAAE,eAAe,CAAC;IACtB,CAAC,GAAG,EAAE,SAAS,CAAC;CACjB,CAAC"}