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

package/src/programmers/protobuf/ProtobufEncodeProgrammer.ts

@@ -30,7 +30,7 @@ export namespace ProtobufEncodeProgrammer {
         (project: IProject) =>
         (modulo: ts.LeftHandSideExpression) =>
         (type: ts.Type, name?: string): ts.ArrowFunction => {
-            const importer = new FunctionImporter();
+            const importer = new FunctionImporter(modulo.getText());
             const collection = new MetadataCollection();
             const meta: Metadata = ProtobufFactory.metadata(modulo.getText())(
                 project.checker,
@@ -75,7 +75,6 @@ export namespace ProtobufEncodeProgrammer {
                 ),
             ];
 
-            // @todo
             return ts.factory.createArrowFunction(
                 undefined,
                 undefined,
@@ -459,6 +458,11 @@ export namespace ProtobufEncodeProgrammer {
                 );
             return ts.factory.createBlock(
                 [
+                    ts.factory.createIdentifier(
+                        `//${index !== null ? ` ${index} -> ` : ""}${
+                            object.name
+                        }`,
+                    ),
                     ...(index !== null
                         ? [
                               decode_tag(ProtobufWire.LEN)(index),
@@ -672,30 +676,27 @@ export namespace ProtobufEncodeProgrammer {
             targets: MetadataObject[],
             explore: FeatureProgrammer.IExplore,
             tags: IMetadataTag[],
+            indexes?: Map<MetadataObject, number>,
         ): ts.Block => {
             if (targets.length === 1)
-                return decode_object(project)(importer)(index)(
-                    input,
-                    targets[0]!,
-                    explore,
-                    tags,
-                );
+                return decode_object(project)(importer)(
+                    indexes ? indexes.get(targets[0]!)! : index,
+                )(input, targets[0]!, explore, tags);
 
             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);
+            indexes ??= new Map(targets.map((t, i) => [t, index! + i]));
+
             if (specList.length === 0) {
                 const condition: ts.Expression = decode_union_object(
                     IsProgrammer.decode_object(importer),
                 )((i, o, e) =>
                     ExpressionFactory.selfCall(
-                        decode_object(project)(importer)(indexes.get(o)!)(
+                        decode_object(project)(importer)(indexes!.get(o)!)(
                             i,
                             o,
                             e,
@@ -736,7 +737,7 @@ export namespace ProtobufEncodeProgrammer {
                         ts.factory.createReturnStatement(
                             ExpressionFactory.selfCall(
                                 decode_object(project)(importer)(
-                                    indexes.get(spec.object)!,
+                                    indexes!.get(spec.object)!,
                                 )(input, spec.object, explore, tags),
                             ),
                         ),
@@ -751,6 +752,7 @@ export namespace ProtobufEncodeProgrammer {
                                               remained,
                                               explore,
                                               tags,
+                                              indexes,
                                           ),
                                       ),
                                   )

package/src/programmers/protobuf/ProtobufIsDecodeProgrammer.ts

@@ -25,7 +25,10 @@ export namespace ProtobufIsDecodeProgrammer {
                 ],
                 ts.factory.createUnionTypeNode([
                     ts.factory.createTypeReferenceNode(
-                        name ?? TypeFactory.getFullName(project.checker)(type),
+                        `typia.Resolved<${
+                            name ??
+                            TypeFactory.getFullName(project.checker)(type)
+                        }>`,
                     ),
                     ts.factory.createLiteralTypeNode(ts.factory.createNull()),
                 ]),
@@ -33,7 +36,14 @@ export namespace ProtobufIsDecodeProgrammer {
                 ts.factory.createBlock([
                     StatementFactory.constant(
                         "is",
-                        IsProgrammer.write(project)(modulo)(false)(type, name),
+                        IsProgrammer.write({
+                            ...project,
+                            options: {
+                                ...project.options,
+                                functional: false,
+                                numeric: false,
+                            },
+                        })(modulo)(false)(type, name),
                     ),
                     StatementFactory.constant(
                         "decode",

package/src/programmers/protobuf/ProtobufValidateDecodeProgrammer.ts

@@ -24,9 +24,9 @@ export namespace ProtobufValidateDecodeProgrammer {
                     ),
                 ],
                 ts.factory.createTypeReferenceNode(
-                    `typia.IValidation<${
+                    `typia.IValidation<typia.Resolved<${
                         name ?? TypeFactory.getFullName(project.checker)(type)
-                    }>`,
+                    }>>`,
                 ),
                 undefined,
                 ts.factory.createBlock([