typia 3.5.5 → 3.5.7

package/src/programmers/StringifyProgrammer.ts

@@ -54,8 +54,12 @@ export namespace StringifyProgrammer {
 
                 return [
                     ...importer.declare(modulo),
-                    ...isFunctors,
-                    ...isUnioners,
+                    ...isFunctors.filter((_, i) =>
+                        importer.hasLocal(`$io${i}`),
+                    ),
+                    ...isUnioners.filter((_, i) =>
+                        importer.hasLocal(`$iu${i}`),
+                    ),
                 ];
             },
         );
@@ -374,13 +378,13 @@ export namespace StringifyProgrammer {
                                           decoder: decode(project, importer),
                                           trace: false,
                                           path: false,
-                                      })(obj)(input);
+                                      })(importer)(obj)(input);
                                   return StringifyJoiner.object(importer)(
                                       input,
                                       entries,
                                   );
                               })()
-                            : explore_objects(input, meta, {
+                            : explore_objects(importer)(input, meta, {
                                   ...explore,
                                   from: "object",
                               }),
@@ -430,12 +434,12 @@ export namespace StringifyProgrammer {
             StringifyJoiner.array,
         );
 
-    const decode_object = () =>
+    const decode_object = (importer: FunctionImporter) =>
         FeatureProgrammer.decode_object({
             trace: false,
             path: false,
             functors: FUNCTORS,
-        });
+        })(importer);
 
     const decode_tuple =
         (project: IProject, importer: FunctionImporter) =>
@@ -590,20 +594,26 @@ export namespace StringifyProgrammer {
                 create_throw_error(importer, input, expected),
         });
 
-    const explore_objects = (
-        input: ts.Expression,
-        meta: Metadata,
-        explore: FeatureProgrammer.IExplore,
-    ) => {
-        if (meta.objects.length === 1)
-            return decode_object()(input, meta.objects[0]!, explore);
+    const explore_objects =
+        (importer: FunctionImporter) =>
+        (
+            input: ts.Expression,
+            meta: Metadata,
+            explore: FeatureProgrammer.IExplore,
+        ) => {
+            if (meta.objects.length === 1)
+                return decode_object(importer)(
+                    input,
+                    meta.objects[0]!,
+                    explore,
+                );
 
-        return ts.factory.createCallExpression(
-            ts.factory.createIdentifier(`${UNIONERS}${meta.union_index!}`),
-            undefined,
-            [input],
-        );
-    };
+            return ts.factory.createCallExpression(
+                ts.factory.createIdentifier(`${UNIONERS}${meta.union_index!}`),
+                undefined,
+                [input],
+            );
+        };
 
     /* -----------------------------------------------------------
         RETURN SCRIPTS
@@ -731,10 +741,10 @@ export namespace StringifyProgrammer {
         importer: FunctionImporter,
     ): FeatureProgrammer.IConfig.IObjector => ({
         checker: IsProgrammer.decode(project, importer),
-        decoder: decode_object(),
+        decoder: decode_object(importer),
         joiner: StringifyJoiner.object(importer),
         unionizer: decode_union_object(IsProgrammer.decode_object(importer))(
-            decode_object(),
+            decode_object(importer),
         )((exp) => exp)((value, expected) =>
             create_throw_error(importer, value, expected),
         ),

package/src/programmers/ValidateProgrammer.ts

@@ -95,8 +95,8 @@ const combine =
             })(importer).combiner(explore);
 
         const path: string = explore.postfix
-            ? `path + ${explore.postfix}`
-            : "path";
+            ? `_path + ${explore.postfix}`
+            : "_path";
         return (logic) => (input, binaries, expected) =>
             logic === "and"
                 ? binaries
@@ -109,7 +109,7 @@ const combine =
                                         explore.source === "top"
                                             ? ts.factory.createTrue()
                                             : ts.factory.createIdentifier(
-                                                  "exceptionable",
+                                                  "_exceptionable",
                                               ),
                                     )(
                                         ts.factory.createIdentifier(path),
@@ -126,7 +126,7 @@ const combine =
                       create_report_call(
                           explore.source === "top"
                               ? ts.factory.createTrue()
-                              : ts.factory.createIdentifier("exceptionable"),
+                              : ts.factory.createIdentifier("_exceptionable"),
                       )(ts.factory.createIdentifier(path), expected, input),
                   );
     };
@@ -141,7 +141,7 @@ const validate_object = (equals: boolean) => (importer: FunctionImporter) =>
         superfluous: (value) =>
             create_report_call()(
                 ts.factory.createAdd(
-                    ts.factory.createIdentifier("path"),
+                    ts.factory.createIdentifier("_path"),
                     ts.factory.createCallExpression(
                         importer.use("join"),
                         undefined,
@@ -155,7 +155,7 @@ const validate_object = (equals: boolean) => (importer: FunctionImporter) =>
             ts.factory.createLogicalOr(
                 ts.factory.createStrictEquality(
                     ts.factory.createFalse(),
-                    ts.factory.createIdentifier("exceptionable"),
+                    ts.factory.createIdentifier("_exceptionable"),
                 ),
                 expr,
             ),
@@ -177,10 +177,10 @@ const joiner =
             create_report_call(
                 explore?.from === "top"
                     ? ts.factory.createTrue()
-                    : ts.factory.createIdentifier("exceptionable"),
+                    : ts.factory.createIdentifier("_exceptionable"),
             )(
                 ts.factory.createIdentifier(
-                    explore?.postfix ? `path + ${explore.postfix}` : "path",
+                    explore?.postfix ? `_path + ${explore.postfix}` : "_path",
                 ),
                 expected,
                 value,
@@ -222,7 +222,7 @@ const create_report_call =
             ts.factory.createIdentifier("$report"),
             undefined,
             [
-                exceptionable || ts.factory.createIdentifier("exceptionable"),
+                exceptionable ?? ts.factory.createIdentifier("_exceptionable"),
                 ts.factory.createObjectLiteralExpression(
                     [
                         ts.factory.createPropertyAssignment("path", path),

package/src/programmers/helpers/FunctionImporeter.ts

@@ -5,6 +5,7 @@ import { StatementFactory } from "../../factories/StatementFactory";
 
 export class FunctionImporter {
     private readonly used_: Set<string> = new Set();
+    private readonly local_: Set<string> = new Set();
     private sequence_: number = 0;
 
     public empty(): boolean {
@@ -16,6 +17,15 @@ export class FunctionImporter {
         return ts.factory.createIdentifier("$" + name);
     }
 
+    public useLocal(name: string): string {
+        this.local_.add(name);
+        return name;
+    }
+
+    public hasLocal(name: string): boolean {
+        return this.local_.has(name);
+    }
+
     public declare(modulo: ts.LeftHandSideExpression): ts.Statement[] {
         return [...this.used_].map((name) =>
             StatementFactory.constant(
@@ -28,4 +38,9 @@ export class FunctionImporter {
     public increment(): number {
         return ++this.sequence_;
     }
+
+    public trace(): void {
+        console.log(...this.used_);
+        console.log(...this.local_);
+    }
 }

package/src/programmers/internal/feature_object_entries.ts

@@ -7,6 +7,7 @@ import { MetadataObject } from "../../metadata/MetadataObject";
 import { Escaper } from "../../utils/Escaper";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
+import { FunctionImporter } from "../helpers/FunctionImporeter";
 
 export const feature_object_entries =
     <Output extends ts.ConciseBody>(
@@ -15,6 +16,7 @@ export const feature_object_entries =
             "decoder" | "path" | "trace"
         >,
     ) =>
+    (importer: FunctionImporter) =>
     (obj: MetadataObject) =>
     (input: ts.Expression) =>
         obj.properties.map((prop) => {
@@ -46,7 +48,10 @@ export const feature_object_entries =
                         postfix:
                             sole !== null
                                 ? IdentifierFactory.postfix(sole)
-                                : `$join(key)`,
+                                : (() => {
+                                      importer.use("join");
+                                      return `$join(key)`;
+                                  })(),
                     },
                     prop.tags,
                 ),