typia 5.3.12-dev.20240118 → 6.0.0-dev.20240118

package/src/programmers/AssertProgrammer.ts

@@ -8,7 +8,7 @@ import { IProject } from "../transformers/IProject";
 
 import { CheckerProgrammer } from "./CheckerProgrammer";
 import { IsProgrammer } from "./IsProgrammer";
-import { FunctionImporter } from "./helpers/FunctionImporeter";
+import { FunctionImporter } from "./helpers/FunctionImporter";
 import { OptionPredicator } from "./helpers/OptionPredicator";
 import { check_object } from "./internal/check_object";
 
@@ -84,7 +84,7 @@ export namespace AssertProgrammer {
         combiner: combiner(props.equals)(project)(importer),
         joiner: joiner(props.equals)(project)(importer),
         success: ts.factory.createTrue(),
-        addition: () => importer.declare(modulo),
+        addition: () => importer.declare(),
       })(importer)(type, name);
 
       return ts.factory.createArrowFunction(
@@ -276,7 +276,7 @@ export namespace AssertProgrammer {
       expected: string,
       value: ts.Expression,
     ): ts.Expression =>
-      ts.factory.createCallExpression(importer.use("guard"), undefined, [
+      ts.factory.createCallExpression(importer.use("guard", true), undefined, [
         exceptionable ?? ts.factory.createIdentifier("_exceptionable"),
         ts.factory.createObjectLiteralExpression(
           [

package/src/programmers/CheckerProgrammer.ts

@@ -19,7 +19,7 @@ import { TransformerError } from "../transformers/TransformerError";
 
 import { FeatureProgrammer } from "./FeatureProgrammer";
 import { AtomicPredicator } from "./helpers/AtomicPredicator";
-import { FunctionImporter } from "./helpers/FunctionImporeter";
+import { FunctionImporter } from "./helpers/FunctionImporter";
 import { ICheckEntry } from "./helpers/ICheckEntry";
 import { IExpressionEntry } from "./helpers/IExpressionEntry";
 import { OptionPredicator } from "./helpers/OptionPredicator";

package/src/programmers/FeatureProgrammer.ts

@@ -13,7 +13,7 @@ import { MetadataObject } from "../schemas/metadata/MetadataObject";
 import { IProject } from "../transformers/IProject";
 
 import { CheckerProgrammer } from "./CheckerProgrammer";
-import { FunctionImporter } from "./helpers/FunctionImporeter";
+import { FunctionImporter } from "./helpers/FunctionImporter";
 import { IExpressionEntry } from "./helpers/IExpressionEntry";
 import { UnionExplorer } from "./helpers/UnionExplorer";
 import { feature_object_entries } from "./internal/feature_object_entries";

package/src/programmers/IsProgrammer.ts

@@ -11,7 +11,7 @@ import { MetadataObject } from "../schemas/metadata/MetadataObject";
 import { IProject } from "../transformers/IProject";
 
 import { CheckerProgrammer } from "./CheckerProgrammer";
-import { FunctionImporter } from "./helpers/FunctionImporeter";
+import { FunctionImporter } from "./helpers/FunctionImporter";
 import { IExpressionEntry } from "./helpers/IExpressionEntry";
 import { OptionPredicator } from "./helpers/OptionPredicator";
 import { disable_function_importer_declare } from "./helpers/disable_function_importer_declare";
@@ -122,7 +122,7 @@ export namespace IsProgrammer {
           numeric: OptionPredicator.numeric(project.options),
         })(project)(importer),
         trace: equals,
-        addition: () => importer.declare(modulo),
+        addition: () => importer.declare(),
       };
 
       config.decoder = () => (input, target, explore) => {

package/src/programmers/RandomProgrammer.ts

@@ -21,7 +21,7 @@ import { TransformerError } from "../transformers/TransformerError";
 
 import { Escaper } from "../utils/Escaper";
 
-import { FunctionImporter } from "./helpers/FunctionImporeter";
+import { FunctionImporter } from "./helpers/FunctionImporter";
 import { RandomJoiner } from "./helpers/RandomJoiner";
 import { RandomRanger } from "./helpers/RandomRanger";
 import { random_custom } from "./internal/random_custom";
@@ -88,7 +88,7 @@ export namespace RandomProgrammer {
           undefined,
           ts.factory.createBlock(
             [
-              ...importer.declare(modulo),
+              ...importer.declare(),
               ...functions.objects,
               ...functions.arrays,
               ...functions.tuples,
@@ -265,7 +265,7 @@ export namespace RandomProgrammer {
       // PICK UP A TYPE
       if (expressions.length === 1) return expressions[0]!;
       return ts.factory.createCallExpression(
-        ts.factory.createCallExpression(importer.use("pick"), undefined, [
+        ts.factory.createCallExpression(COALESCE(importer)("pick"), undefined, [
           ts.factory.createArrayLiteralExpression(
             expressions.map((expr) =>
               ts.factory.createArrowFunction(

package/src/programmers/ValidateProgrammer.ts

@@ -9,7 +9,7 @@ import { IProject } from "../transformers/IProject";
 
 import { CheckerProgrammer } from "./CheckerProgrammer";
 import { IsProgrammer } from "./IsProgrammer";
-import { FunctionImporter } from "./helpers/FunctionImporeter";
+import { FunctionImporter } from "./helpers/FunctionImporter";
 import { OptionPredicator } from "./helpers/OptionPredicator";
 import { check_everything } from "./internal/check_everything";
 import { check_object } from "./internal/check_object";
@@ -84,7 +84,7 @@ export namespace ValidateProgrammer {
         combiner: combine(equals)(project)(importer),
         joiner: joiner(equals)(project)(importer),
         success: ts.factory.createTrue(),
-        addition: () => importer.declare(modulo),
+        addition: () => importer.declare(),
       })(importer)(type, name);
 
       return ts.factory.createArrowFunction(
@@ -121,13 +121,16 @@ export namespace ValidateProgrammer {
                   "$report",
                   ts.factory.createCallExpression(
                     IdentifierFactory.access(
-                      ts.factory.createParenthesizedExpression(
-                        ts.factory.createAsExpression(
-                          modulo,
-                          TypeFactory.keyword("any"),
-                        ),
+                      ts.factory.createCallExpression(
+                        ts.factory.createIdentifier("require"),
+                        [],
+                        [
+                          ts.factory.createStringLiteral(
+                            "typia/lib/functional/$report",
+                          ),
+                        ],
                       ),
-                    )("report"),
+                    )("$report"),
                     [],
                     [ts.factory.createIdentifier("errors")],
                   ),

package/src/programmers/helpers/{FunctionImporeter.ts → FunctionImporter.ts}

@@ -2,10 +2,9 @@ import ts from "typescript";
 
 import { IdentifierFactory } from "../../factories/IdentifierFactory";
 import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
 
 export class FunctionImporter {
-  private readonly used_: Set<string> = new Set();
+  private readonly used_: Map<string, boolean> = new Map();
   private readonly local_: Set<string> = new Set();
   private readonly unions_: Map<string, [string, ts.ArrowFunction]> = new Map();
   private sequence_: number = 0;
@@ -16,8 +15,8 @@ export class FunctionImporter {
     return this.used_.size === 0;
   }
 
-  public use(name: string): ts.Identifier {
-    this.used_.add(name);
+  public use(name: string, currying: boolean = false): ts.Identifier {
+    this.used_.set(name, !!currying);
     return ts.factory.createIdentifier("$" + name);
   }
 
@@ -30,21 +29,25 @@ export class FunctionImporter {
     return this.local_.has(name);
   }
 
-  public declare(
-    modulo: ts.LeftHandSideExpression,
-    includeUnions: boolean = true,
-  ): ts.Statement[] {
+  public declare(includeUnions: boolean = true): ts.Statement[] {
     return [
-      ...[...this.used_].map((name) =>
-        StatementFactory.constant(
-          "$" + name,
-          IdentifierFactory.access(
-            ts.factory.createParenthesizedExpression(
-              ts.factory.createAsExpression(modulo, TypeFactory.keyword("any")),
-            ),
-          )(name),
-        ),
-      ),
+      ...[...this.used_].map(([key, value]) => {
+        const accessor = IdentifierFactory.access(
+          ts.factory.createCallExpression(
+            ts.factory.createIdentifier("require"),
+            undefined,
+            [ts.factory.createStringLiteral(`typia/lib/functional/$${key}`)],
+          ),
+        )(`$${key}`);
+        return StatementFactory.constant(
+          `$${key}`,
+          value
+            ? ts.factory.createCallExpression(accessor, undefined, [
+                ts.factory.createStringLiteral(this.method),
+              ])
+            : accessor,
+        );
+      }),
       ...(includeUnions === true
         ? [...this.unions_.values()].map(([key, arrow]) =>
             StatementFactory.constant(key, arrow),

package/src/programmers/helpers/StringifyJoinder.ts

@@ -5,7 +5,7 @@ import { TemplateFactory } from "../../factories/TemplateFactory";
 
 import { stringify_dynamic_properties } from "../internal/stringify_dynamic_properties";
 import { stringify_regular_properties } from "../internal/stringify_regular_properties";
-import { FunctionImporter } from "./FunctionImporeter";
+import { FunctionImporter } from "./FunctionImporter";
 import { IExpressionEntry } from "./IExpressionEntry";
 
 export namespace StringifyJoiner {
@@ -65,14 +65,13 @@ export namespace StringifyJoiner {
     TemplateFactory.generate([
       ts.factory.createStringLiteral(`[`),
       ts.factory.createCallExpression(
-        ts.factory.createPropertyAccessExpression(
+        IdentifierFactory.access(
           ts.factory.createCallExpression(
             IdentifierFactory.access(input)("map"),
             undefined,
             [arrow],
           ),
-          ts.factory.createIdentifier("join"),
-        ),
+        )("join"),
         undefined,
         [ts.factory.createStringLiteral(`,`)],
       ),

package/src/programmers/helpers/disable_function_importer_declare.ts

@@ -1,6 +1,6 @@
 import ts from "typescript";
 
-import { FunctionImporter } from "./FunctionImporeter";
+import { FunctionImporter } from "./FunctionImporter";
 
 export const disable_function_importer_declare = (
   importer: FunctionImporter,
@@ -9,10 +9,11 @@ export const disable_function_importer_declare = (
 const disable = (importer: FunctionImporter): MethodOnly<FunctionImporter> => ({
   method: importer.method,
   empty: (): boolean => importer.empty(),
-  use: (name: string): ts.Identifier => importer.use(name),
+  use: (name: string, currying?: boolean): ts.Identifier =>
+    importer.use(name, currying),
   useLocal: (name: string): string => importer.useLocal(name),
   hasLocal: (name: string): boolean => importer.hasLocal(name),
-  declare: (_modulo: ts.LeftHandSideExpression): ts.Statement[] => [],
+  declare: (): ts.Statement[] => [],
   declareUnions: (): ts.Statement[] => [],
   increment: (): number => importer.increment(),
   emplaceUnion: (

package/src/programmers/http/HttpHeadersProgrammer.ts

@@ -20,7 +20,7 @@ import { Atomic } from "../../typings/Atomic";
 import { Escaper } from "../../utils/Escaper";
 import { MapUtil } from "../../utils/MapUtil";
 
-import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { FunctionImporter } from "../helpers/FunctionImporter";
 import { HttpMetadataUtil } from "../helpers/HttpMetadataUtil";
 
 export namespace HttpHeadersProgrammer {
@@ -65,10 +65,7 @@ export namespace HttpHeadersProgrammer {
           }>`,
         ),
         undefined,
-        ts.factory.createBlock(
-          [...importer.declare(modulo), ...statements],
-          true,
-        ),
+        ts.factory.createBlock([...importer.declare(), ...statements], true),
       );
     };
 
@@ -243,7 +240,7 @@ export namespace HttpHeadersProgrammer {
     (value: ts.Expression) =>
       type === "string"
         ? value
-        : ts.factory.createCallExpression(importer.use(type), undefined, [
+        : ts.factory.createCallExpression(reader(importer)(type), undefined, [
             value,
           ]);
 
@@ -270,7 +267,7 @@ export namespace HttpHeadersProgrammer {
         ),
         undefined,
         undefined,
-        [importer.use(type)],
+        [reader(importer)(type)],
       );
       return ts.factory.createConditionalExpression(
         ExpressionFactory.isArray(accessor),
@@ -278,7 +275,7 @@ export namespace HttpHeadersProgrammer {
         ts.factory.createCallExpression(
           IdentifierFactory.access(accessor)("map"),
           undefined,
-          [importer.use(type)],
+          [reader(importer)(type)],
         ),
         undefined,
         value.isRequired() === false
@@ -312,3 +309,6 @@ const SINGULAR: Set<string> = new Set([
   "server",
   "user-agent",
 ]);
+
+const reader = (importer: FunctionImporter) => (type: Atomic.Literal) =>
+  IdentifierFactory.access(importer.use("HeadersReader"))(type);

package/src/programmers/http/HttpParameterProgrammer.ts

@@ -12,7 +12,7 @@ import { IProject } from "../../transformers/IProject";
 import { TransformerError } from "../../transformers/TransformerError";
 
 import { AssertProgrammer } from "../AssertProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { FunctionImporter } from "../helpers/FunctionImporter";
 import { HttpMetadataUtil } from "../helpers/HttpMetadataUtil";
 
 export namespace HttpParameterProgrammer {
@@ -46,9 +46,11 @@ export namespace HttpParameterProgrammer {
         ),
         StatementFactory.constant(
           "value",
-          ts.factory.createCallExpression(importer.use(atomic), undefined, [
-            ts.factory.createIdentifier("input"),
-          ]),
+          ts.factory.createCallExpression(
+            IdentifierFactory.access(importer.use("ParameterReader"))(atomic),
+            undefined,
+            [ts.factory.createIdentifier("input")],
+          ),
         ),
         ts.factory.createReturnStatement(
           ts.factory.createCallExpression(
@@ -72,7 +74,7 @@ export namespace HttpParameterProgrammer {
           name ?? TypeFactory.getFullName(project.checker)(type),
         ),
         undefined,
-        ts.factory.createBlock([...importer.declare(modulo), ...block], true),
+        ts.factory.createBlock([...importer.declare(), ...block], true),
       );
     };
 

package/src/programmers/http/HttpQueryProgrammer.ts

@@ -18,7 +18,7 @@ import { Atomic } from "../../typings/Atomic";
 
 import { Escaper } from "../../utils/Escaper";
 
-import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { FunctionImporter } from "../helpers/FunctionImporter";
 import { HttpMetadataUtil } from "../helpers/HttpMetadataUtil";
 
 export namespace HttpQueryProgrammer {
@@ -63,10 +63,7 @@ export namespace HttpQueryProgrammer {
           }>`,
         ),
         undefined,
-        ts.factory.createBlock(
-          [...importer.declare(modulo), ...statements],
-          true,
-        ),
+        ts.factory.createBlock([...importer.declare(), ...statements], true),
       );
     };
 
@@ -135,7 +132,7 @@ export namespace HttpQueryProgrammer {
             ts.factory.createToken(ts.SyntaxKind.EqualsToken),
             ts.factory.createAsExpression(
               ts.factory.createCallExpression(
-                importer.use("params"),
+                IdentifierFactory.access(importer.use("QueryReader"))("params"),
                 undefined,
                 [input],
               ),
@@ -224,7 +221,7 @@ export namespace HttpQueryProgrammer {
     (onlyUndefindable: boolean) =>
     (value: ts.Expression) => {
       const call = ts.factory.createCallExpression(
-        importer.use(type),
+        IdentifierFactory.access(importer.use("QueryReader"))(type),
         undefined,
         [value],
       );
@@ -242,11 +239,15 @@ export namespace HttpQueryProgrammer {
     (value: Metadata) =>
     (expression: ts.Expression): ts.Expression =>
       value.nullable || value.isRequired() === false
-        ? ts.factory.createCallExpression(importer.use("array"), undefined, [
-            expression,
-            value.nullable
-              ? ts.factory.createNull()
-              : ts.factory.createIdentifier("undefined"),
-          ])
+        ? ts.factory.createCallExpression(
+            IdentifierFactory.access(importer.use("QueryReader"))("array"),
+            undefined,
+            [
+              expression,
+              value.nullable
+                ? ts.factory.createNull()
+                : ts.factory.createIdentifier("undefined"),
+            ],
+          )
         : expression;
 }

package/src/programmers/internal/check_dynamic_key.ts

@@ -4,7 +4,7 @@ import { Metadata } from "../../schemas/metadata/Metadata";
 
 import { IProject } from "../../transformers/IProject";
 
-import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { FunctionImporter } from "../helpers/FunctionImporter";
 import { ICheckEntry } from "../helpers/ICheckEntry";
 import { check_bigint } from "./check_bigint";
 import { check_number } from "./check_number";

package/src/programmers/internal/check_dynamic_properties.ts

@@ -6,7 +6,7 @@ import { StatementFactory } from "../../factories/StatementFactory";
 
 import { IProject } from "../../transformers/IProject";
 
-import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { FunctionImporter } from "../helpers/FunctionImporter";
 import { IExpressionEntry } from "../helpers/IExpressionEntry";
 import { check_dynamic_key } from "./check_dynamic_key";
 import { check_everything } from "./check_everything";

package/src/programmers/internal/check_object.ts

@@ -2,7 +2,7 @@ import ts from "typescript";
 
 import { IProject } from "../../transformers/IProject";
 
-import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { FunctionImporter } from "../helpers/FunctionImporter";
 import { IExpressionEntry } from "../helpers/IExpressionEntry";
 import { check_dynamic_properties } from "./check_dynamic_properties";
 import { check_everything } from "./check_everything";

package/src/programmers/internal/feature_object_entries.ts

@@ -7,7 +7,7 @@ import { MetadataObject } from "../../schemas/metadata/MetadataObject";
 import { Escaper } from "../../utils/Escaper";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { FunctionImporter } from "../helpers/FunctionImporter";
 
 /**
  * @internal

package/src/programmers/json/JsonStringifyProgrammer.ts

@@ -24,7 +24,7 @@ import { ArrayUtil } from "../../utils/ArrayUtil";
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { IsProgrammer } from "../IsProgrammer";
 import { AtomicPredicator } from "../helpers/AtomicPredicator";
-import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { FunctionImporter } from "../helpers/FunctionImporter";
 import { IExpressionEntry } from "../helpers/IExpressionEntry";
 import { OptionPredicator } from "../helpers/OptionPredicator";
 import { StringifyJoiner } from "../helpers/StringifyJoinder";
@@ -51,7 +51,7 @@ export namespace JsonStringifyProgrammer {
           ...IsProgrammer.write_function_statements(project)(importer)(
             collection,
           ),
-          ...importer.declare(modulo),
+          ...importer.declare(),
         ],
       })(importer);
     };
@@ -868,7 +868,7 @@ export namespace JsonStringifyProgrammer {
     (value: ts.Expression) =>
       ts.factory.createExpressionStatement(
         ts.factory.createCallExpression(
-          importer.use("throws"),
+          importer.use("throws", true),
           [],
           [
             ts.factory.createObjectLiteralExpression(

package/src/programmers/misc/MiscCloneProgrammer.ts

@@ -18,7 +18,7 @@ import { TransformerError } from "../../transformers/TransformerError";
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { IsProgrammer } from "../IsProgrammer";
 import { CloneJoiner } from "../helpers/CloneJoiner";
-import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { FunctionImporter } from "../helpers/FunctionImporter";
 import { UnionExplorer } from "../helpers/UnionExplorer";
 import { decode_union_object } from "../internal/decode_union_object";
 import { wrap_metadata_rest_tuple } from "../internal/wrap_metadata_rest_tuple";
@@ -33,7 +33,7 @@ export namespace MiscCloneProgrammer {
           ...IsProgrammer.write_function_statements(project)(importer)(
             collection,
           ),
-          ...importer.declare(modulo),
+          ...importer.declare(),
         ],
       })(importer);
     };
@@ -127,9 +127,11 @@ export namespace MiscCloneProgrammer {
             !!t.type.elements.length && t.type.elements.every((e) => e.any),
         )
       )
-        return ts.factory.createCallExpression(importer.use("any"), undefined, [
-          input,
-        ]);
+        return ts.factory.createCallExpression(
+          importer.use("clone"),
+          undefined,
+          [input],
+        );
 
       interface IUnion {
         type: string;
@@ -694,7 +696,7 @@ export namespace MiscCloneProgrammer {
     (value: ts.Expression) =>
       ts.factory.createExpressionStatement(
         ts.factory.createCallExpression(
-          importer.use("throws"),
+          importer.use("throws", true),
           [],
           [
             ts.factory.createObjectLiteralExpression(

package/src/programmers/misc/MiscPruneProgrammer.ts

@@ -17,7 +17,7 @@ import { TransformerError } from "../../transformers/TransformerError";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { IsProgrammer } from "../IsProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporeter";
+import { FunctionImporter } from "../helpers/FunctionImporter";
 import { PruneJoiner } from "../helpers/PruneJoiner";
 import { UnionExplorer } from "../helpers/UnionExplorer";
 import { decode_union_object } from "../internal/decode_union_object";
@@ -33,7 +33,7 @@ export namespace MiscPruneProgrammer {
           ...IsProgrammer.write_function_statements(project)(importer)(
             collection,
           ),
-          ...importer.declare(modulo),
+          ...importer.declare(),
         ],
       })(importer);
     };