typia 5.0.0-dev.20230820-2 → 5.0.0-dev.20230822

package/src/programmers/protobuf/ProtobufEncodeProgrammer.ts

@@ -7,13 +7,11 @@ import { ProtobufFactory } from "../../factories/ProtobufFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
 import { TypeFactory } from "../../factories/TypeFactory";
 
-import { IJsDocTagInfo } from "../../schemas/metadata/IJsDocTagInfo";
 import { IMetadataTag } from "../../schemas/metadata/IMetadataTag";
 import { Metadata } from "../../schemas/metadata/Metadata";
 import { MetadataArray } from "../../schemas/metadata/MetadataArray";
 import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 import { MetadataProperty } from "../../schemas/metadata/MetadataProperty";
-import { MetadataTuple } from "../../schemas/metadata/MetadataTuple";
 
 import { IProject } from "../../transformers/IProject";
 
@@ -24,7 +22,6 @@ import { IsProgrammer } from "../IsProgrammer";
 import { FunctionImporter } from "../helpers/FunctionImporeter";
 import { ProtobufUtil } from "../helpers/ProtobufUtil";
 import { ProtobufWire } from "../helpers/ProtobufWire";
-import { UnionExplorer } from "../helpers/UnionExplorer";
 import { UnionPredicator } from "../helpers/UnionPredicator";
 import { decode_union_object } from "../internal/decode_union_object";
 
@@ -107,7 +104,7 @@ export namespace ProtobufEncodeProgrammer {
         (meta: Metadata): ts.ArrowFunction => {
             const functors = collection
                 .objects()
-                .filter((obj) => obj._Messagable())
+                .filter((obj) => ProtobufUtil.isStaticObject(obj))
                 .map((obj) =>
                     StatementFactory.constant(
                         `${PREFIX}o${obj.index}`,
@@ -267,16 +264,18 @@ export namespace ProtobufEncodeProgrammer {
                           );
 
             // STARTS FROM ATOMIC TYPES
-            const unions: IUnion[] = ProtobufUtil.atomics(meta).map((type) => ({
-                type,
-                wire: () => null!,
-                is: () =>
-                    ts.factory.createStrictEquality(
-                        ts.factory.createStringLiteral(type),
-                        ts.factory.createTypeOfExpression(input),
-                    ),
-                value: (index) => decode_atomic(index!)(input, type, tags),
-            }));
+            const unions: IUnion[] = ProtobufUtil.getAtomics(meta).map(
+                (type) => ({
+                    type,
+                    wire: () => null!,
+                    is: () =>
+                        ts.factory.createStrictEquality(
+                            ts.factory.createStringLiteral(type),
+                            ts.factory.createTypeOfExpression(input),
+                        ),
+                    value: (index) => decode_atomic(index!)(input, type, tags),
+                }),
+            );
 
             // CONSIDER BYTES
             if (meta.natives.length)
@@ -287,15 +286,15 @@ export namespace ProtobufEncodeProgrammer {
                     value: (index) => decode_bytes("bytes")(index!)(input),
                 });
 
-            // CONSIDER MAPS
-            if (meta.maps.length)
+            // CONSIDER ARRAYS
+            if (meta.arrays.length)
                 unions.push({
-                    type: "map",
-                    is: () => ExpressionFactory.isInstanceOf("Map")(input),
+                    type: "array",
+                    is: () => ExpressionFactory.isArray(input),
                     value: (index) =>
-                        decode_map(project)(importer)(index!)(
+                        decode_array(project)(importer)(index!)(
                             input,
-                            meta.maps[0]!,
+                            meta.arrays[0]!,
                             {
                                 ...explore,
                                 from: "array",
@@ -304,15 +303,15 @@ export namespace ProtobufEncodeProgrammer {
                         ),
                 });
 
-            // CONSIDER ARRAYS
-            if (meta.arrays.length)
+            // CONSIDER MAPS
+            if (meta.maps.length)
                 unions.push({
-                    type: "array",
-                    is: () => ExpressionFactory.isArray(input),
+                    type: "map",
+                    is: () => ExpressionFactory.isInstanceOf("Map")(input),
                     value: (index) =>
-                        explore_arrays(project)(importer)(index!)(
+                        decode_map(project)(importer)(index!)(
                             input,
-                            meta.arrays,
+                            meta.maps[0]!,
                             {
                                 ...explore,
                                 from: "array",
@@ -472,7 +471,7 @@ export namespace ProtobufEncodeProgrammer {
                         : []),
                     ts.factory.createCallExpression(
                         ts.factory.createIdentifier(
-                            `${PREFIX}o${object.index}`,
+                            importer.useLocal(`${PREFIX}o${object.index}`),
                         ),
                         [],
                         [input],
@@ -648,7 +647,7 @@ export namespace ProtobufEncodeProgrammer {
         )
             return ProtobufWire.LEN;
 
-        const v = ProtobufUtil.atomics(meta)[0]!;
+        const v = ProtobufUtil.getAtomics(meta)[0]!;
         if (v === "string") return ProtobufWire.LEN;
         else if (v === "boolean" || v === "bigint") return ProtobufWire.VARIANT;
 
@@ -685,6 +684,9 @@ export namespace ProtobufEncodeProgrammer {
             const expected: string = `(${targets
                 .map((t) => t.name)
                 .join(" | ")})`;
+            const indexes: Map<MetadataObject, number> = new Map(
+                targets.map((t, i) => [t, index! + i]),
+            );
 
             // POSSIBLE TO SPECIALIZE?
             const specList = UnionPredicator.object(targets);
@@ -693,7 +695,12 @@ export namespace ProtobufEncodeProgrammer {
                     IsProgrammer.decode_object(importer),
                 )((i, o, e) =>
                     ExpressionFactory.selfCall(
-                        decode_object(project)(importer)(index)(i, o, e, tags),
+                        decode_object(project)(importer)(indexes.get(o)!)(
+                            i,
+                            o,
+                            e,
+                            tags,
+                        ),
                     ),
                 )((expr) => expr)((value, expected) =>
                     create_throw_error(importer)(expected)(value),
@@ -728,12 +735,9 @@ export namespace ProtobufEncodeProgrammer {
                         pred,
                         ts.factory.createReturnStatement(
                             ExpressionFactory.selfCall(
-                                decode_object(project)(importer)(index)(
-                                    input,
-                                    spec.object,
-                                    explore,
-                                    tags,
-                                ),
+                                decode_object(project)(importer)(
+                                    indexes.get(spec.object)!,
+                                )(input, spec.object, explore, tags),
                             ),
                         ),
                         i === array.length - 1
@@ -767,122 +771,10 @@ export namespace ProtobufEncodeProgrammer {
             return ts.factory.createBlock([condition], true);
         };
 
-    const explore_arrays =
-        (project: IProject) =>
-        (importer: FunctionImporter) =>
-        (index: number) =>
-        (
-            input: ts.Expression,
-            elements: MetadataArray[],
-            explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
-        ): ts.Block =>
-            elements.length === 1
-                ? decode_array(project)(importer)(index)(
-                      input,
-                      elements[0]!,
-                      explore,
-                      tags,
-                  )
-                : explore_array_like_union_types(importer)(
-                      UnionExplorer.array({
-                          checker: IsProgrammer.decode(project)(importer),
-                          decoder: (input, target, explore, tags) =>
-                              ts.factory.createCallExpression(
-                                  ts.factory.createArrowFunction(
-                                      undefined,
-                                      undefined,
-                                      [],
-                                      undefined,
-                                      undefined,
-                                      decode_array(project)(importer)(index)(
-                                          input,
-                                          target,
-                                          explore,
-                                          tags,
-                                      ),
-                                  ),
-                                  undefined,
-                                  undefined,
-                              ),
-                          empty: ts.factory.createStringLiteral("[]"),
-                          success: ts.factory.createTrue(),
-                          failure: (input, expected) =>
-                              create_throw_error(importer)(expected)(input),
-                      }),
-                  )(input, elements, explore, tags);
-
-    const explore_array_like_union_types =
-        (importer: FunctionImporter) =>
-        <T extends MetadataArray | MetadataTuple>(
-            factory: (
-                parameters: ts.ParameterDeclaration[],
-            ) => (
-                input: ts.Expression,
-                elements: T[],
-                explore: FeatureProgrammer.IExplore,
-                tags: IMetadataTag[],
-                jsDocTags: IJsDocTagInfo[],
-            ) => ts.ArrowFunction,
-        ) =>
-        (
-            input: ts.Expression,
-            elements: T[],
-            explore: FeatureProgrammer.IExplore,
-            tags: IMetadataTag[],
-        ): ts.Block => {
-            const arrow =
-                (parameters: ts.ParameterDeclaration[]) =>
-                (explore: FeatureProgrammer.IExplore) =>
-                (input: ts.Expression): ts.ArrowFunction =>
-                    factory(parameters)(input, elements, explore, tags, []);
-            if (elements.every((e) => e.recursive === false))
-                return StatementFactory.block(
-                    ts.factory.createCallExpression(
-                        arrow([])(explore)(input),
-                        undefined,
-                        [],
-                    ),
-                );
-
-            explore = {
-                ...explore,
-                source: "function",
-                from: "array",
-            };
-            return StatementFactory.block(
-                ts.factory.createCallExpression(
-                    ts.factory.createIdentifier(
-                        importer.emplaceUnion(
-                            PREFIX,
-                            elements.map((e) => e.name).join(" | "),
-                            () =>
-                                arrow(
-                                    FeatureProgrammer.parameterDeclarations(
-                                        CONFIG,
-                                    )(TypeFactory.keyword("any"))(
-                                        ts.factory.createIdentifier("input"),
-                                    ),
-                                )({
-                                    ...explore,
-                                    postfix: "",
-                                })(ts.factory.createIdentifier("input")),
-                        ),
-                    ),
-                    undefined,
-                    FeatureProgrammer.argumentsArray(CONFIG)(explore)(input),
-                ),
-            );
-        };
-
     /* -----------------------------------------------------------
         CONFIGURATIONS
     ----------------------------------------------------------- */
     const PREFIX = "$pe";
-    const CONFIG = {
-        path: false,
-        trace: false,
-    };
 
     const create_throw_error =
         (importer: FunctionImporter) =>

package/src/programmers/protobuf/ProtobufIsDecodeProgrammer.ts

@@ -46,27 +46,27 @@ export namespace ProtobufIsDecodeProgrammer {
                             },
                         })(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("input")],
+                                [ts.factory.createIdentifier("output")],
                             ),
                         ),
                         ts.factory.createReturnStatement(
                             ts.factory.createNull(),
                         ),
                     ),
-                    StatementFactory.constant(
-                        "output",
-                        ts.factory.createCallExpression(
-                            ts.factory.createIdentifier("decode"),
-                            undefined,
-                            [ts.factory.createIdentifier("input")],
-                        ),
-                    ),
                     ts.factory.createReturnStatement(
                         ts.factory.createIdentifier("output"),
                     ),

package/src/programmers/protobuf/ProtobufMessageProgrammer.ts

@@ -108,7 +108,7 @@ export namespace ProtobufMessageProgrammer {
         (meta: Metadata): string => {
             const elements: Set<string> = new Set();
             if (meta.natives.length) elements.add("bytes");
-            for (const atomic of ProtobufUtil.atomics(meta))
+            for (const atomic of ProtobufUtil.getAtomics(meta))
                 elements.add(decode_atomic(tags)(atomic));
             for (const array of meta.arrays)
                 elements.add(`repeated ${decode(ptr)(tags)(array.value)}`);

package/src/programmers/protobuf/ProtobufValidateDecodeProgrammer.ts

@@ -24,7 +24,9 @@ export namespace ProtobufValidateDecodeProgrammer {
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
-                    name ?? TypeFactory.getFullName(project.checker)(type),
+                    `typia.IValidation<${
+                        name ?? TypeFactory.getFullName(project.checker)(type)
+                    }>`,
                 ),
                 undefined,
                 ts.factory.createBlock([
@@ -52,32 +54,22 @@ export namespace ProtobufValidateDecodeProgrammer {
                     ),
                     StatementFactory.constant(
                         "output",
+                        ts.factory.createCallExpression(
+                            ts.factory.createIdentifier("decode"),
+                            undefined,
+                            [ts.factory.createIdentifier("input")],
+                        ),
+                    ),
+                    ts.factory.createReturnStatement(
                         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.createIdentifier("output")],
                             ),
+                            ts.factory.createTypeReferenceNode("any"),
                         ),
                     ),
-                    ts.factory.createReturnStatement(
-                        ts.factory.createIdentifier("output"),
-                    ),
                 ]),
             );
 }

package/src/protobuf.ts

@@ -1,7 +1,6 @@
 import { Namespace } from "./functional/Namespace";
 
 import { IValidation } from "./IValidation";
-import { Primitive } from "./Primitive";
 
 /* ===========================================================
     PROTOCOL BUFFER
@@ -28,7 +27,7 @@ export function message(): never {
 ----------------------------------------------------------- */
 export function decode(input: Uint8Array): never;
 
-export function decode<T>(input: Uint8Array): Primitive<T>;
+export function decode<T>(input: Uint8Array): T;
 
 /**
  * @internal
@@ -40,7 +39,7 @@ Object.assign(decode, Namespace.protobuf.decode("decode"));
 
 export function isDecode(input: Uint8Array): never;
 
-export function isDecode<T>(input: Uint8Array): Primitive<T> | null;
+export function isDecode<T>(input: Uint8Array): T | null;
 
 /**
  * @internal
@@ -53,7 +52,7 @@ Object.assign(isDecode, Namespace.protobuf.decode("isDecode"));
 
 export function assertDecode(input: Uint8Array): never;
 
-export function assertDecode<T>(input: Uint8Array): Primitive<T>;
+export function assertDecode<T>(input: Uint8Array): T;
 
 /**
  * @internal
@@ -66,7 +65,7 @@ Object.assign(assertDecode, Namespace.protobuf.decode("assertDecode"));
 
 export function validateDecode(input: Uint8Array): never;
 
-export function validateDecode<T>(input: Uint8Array): IValidation<Primitive<T>>;
+export function validateDecode<T>(input: Uint8Array): IValidation<T>;
 
 /**
  * @internal
@@ -127,50 +126,61 @@ Object.assign(validateEncode, Namespace.protobuf.encode("validateEncode"));
     FACTORY FUNCTIONS
 ----------------------------------------------------------- */
 export function createDecode(): never;
-export function createDecode<T>(): (input: Uint8Array) => Primitive<T>;
+export function createDecode<T>(): (input: Uint8Array) => T;
 
 /**
  * @internal
  */
-export function createDecode<T>(): (input: Uint8Array) => Primitive<T> {
+export function createDecode<T>(): (input: Uint8Array) => T {
     halt("createDecode");
 }
+Object.assign(createDecode, Namespace.protobuf.decode("createDecode"));
 
 export function createIsDecode(): never;
-export function createIsDecode<T>(): (input: Uint8Array) => Primitive<T> | null;
+export function createIsDecode<T>(): (input: Uint8Array) => T | null;
 
 /**
  * @internal
  */
-export function createIsDecode<T>(): (
-    input: Uint8Array,
-) => Primitive<T> | null {
+export function createIsDecode<T>(): (input: Uint8Array) => T | null {
     halt("createIsDecode");
 }
+Object.assign(createIsDecode, Namespace.is());
+Object.assign(createIsDecode, Namespace.protobuf.decode("createIsDecode"));
 
 export function createAssertDecode(): never;
-export function createAssertDecode<T>(): (input: Uint8Array) => Primitive<T>;
+export function createAssertDecode<T>(): (input: Uint8Array) => T;
 
 /**
  * @internal
  */
-export function createAssertDecode<T>(): (input: Uint8Array) => Primitive<T> {
+export function createAssertDecode<T>(): (input: Uint8Array) => T {
     halt("createAssertDecode");
 }
+Object.assign(createAssertDecode, Namespace.assert("createAssertDecode"));
+Object.assign(
+    createAssertDecode,
+    Namespace.protobuf.decode("createAssertDecode"),
+);
 
 export function createValidateDecode(): never;
 export function createValidateDecode<T>(): (
     input: Uint8Array,
-) => IValidation<Primitive<T>>;
+) => IValidation<T>;
 
 /**
  * @internal
  */
 export function createValidateDecode<T>(): (
     input: Uint8Array,
-) => IValidation<Primitive<T>> {
+) => IValidation<T> {
     halt("createValidateDecode");
 }
+Object.assign(createValidateDecode, Namespace.validate());
+Object.assign(
+    createValidateDecode,
+    Namespace.protobuf.decode("createValidateDecode"),
+);
 
 export function createEncode(): never;
 export function createEncode<T>(): (input: T) => Uint8Array;