typia 7.0.0-dev.20241002-2 → 7.0.0-dev.20241005

package/src/programmers/json/JsonStringifyProgrammer.ts

@@ -23,7 +23,7 @@ import { Atomic } from "../../typings/Atomic";
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { IsProgrammer } from "../IsProgrammer";
 import { AtomicPredicator } from "../helpers/AtomicPredicator";
-import { FunctionImporter } from "../helpers/FunctionImporter";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
 import { OptionPredicator } from "../helpers/OptionPredicator";
 import { StringifyJoiner } from "../helpers/StringifyJoinder";
 import { StringifyPredicator } from "../helpers/StringifyPredicator";
@@ -40,7 +40,7 @@ export namespace JsonStringifyProgrammer {
   export const decompose = (props: {
     validated: boolean;
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name: string | undefined;
   }): FeatureProgrammer.IDecomposed => {
@@ -49,7 +49,7 @@ export namespace JsonStringifyProgrammer {
       config.addition = (collection) =>
         IsProgrammer.write_function_statements({
           context: props.context,
-          importer: props.importer,
+          functor: props.functor,
           collection,
         });
     const composed: FeatureProgrammer.IComposed = FeatureProgrammer.compose({
@@ -71,24 +71,24 @@ export namespace JsonStringifyProgrammer {
   };
 
   export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       ...props,
       validated: false,
-      importer,
+      functor,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };
 
   const write_array_functions = (props: {
     config: FeatureProgrammer.IConfig;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     collection: MetadataCollection;
   }): ts.VariableStatement[] =>
     props.collection
@@ -109,7 +109,7 @@ export namespace JsonStringifyProgrammer {
             undefined,
             decode_array_inline({
               config: props.config,
-              importer: props.importer,
+              functor: props.functor,
               input: ts.factory.createIdentifier("input"),
               array: MetadataArray.create({
                 type,
@@ -129,7 +129,7 @@ export namespace JsonStringifyProgrammer {
   const write_tuple_functions = (props: {
     context: ITypiaContext;
     config: FeatureProgrammer.IConfig;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     collection: MetadataCollection;
   }): ts.VariableStatement[] =>
     props.collection
@@ -151,7 +151,7 @@ export namespace JsonStringifyProgrammer {
             decode_tuple_inline({
               context: props.context,
               config: props.config,
-              importer: props.importer,
+              functor: props.functor,
               input: ts.factory.createIdentifier("input"),
               tuple,
               explore: {
@@ -171,7 +171,7 @@ export namespace JsonStringifyProgrammer {
   const decode = (props: {
     context: ITypiaContext;
     config: FeatureProgrammer.IConfig;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     input: ts.Expression;
     metadata: Metadata;
     explore: FeatureProgrammer.IExplore;
@@ -514,7 +514,8 @@ export namespace JsonStringifyProgrammer {
           undefined,
           undefined,
           iterate({
-            importer: props.importer,
+            context: props.context,
+            functor: props.functor,
             input: props.input,
             expected: props.metadata.getName(),
             unions,
@@ -527,7 +528,7 @@ export namespace JsonStringifyProgrammer {
   };
 
   const decode_object = (props: {
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     input: ts.Expression;
     object: MetadataObject;
     explore: FeatureProgrammer.IExplore;
@@ -538,7 +539,7 @@ export namespace JsonStringifyProgrammer {
         path: false,
         prefix: PREFIX,
       },
-      importer: props.importer,
+      functor: props.functor,
       object: props.object,
       input: props.input,
       explore: props.explore,
@@ -546,7 +547,7 @@ export namespace JsonStringifyProgrammer {
 
   const decode_array = (props: {
     config: FeatureProgrammer.IConfig;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     input: ts.Expression;
     array: MetadataArray;
     explore: FeatureProgrammer.IExplore;
@@ -554,7 +555,7 @@ export namespace JsonStringifyProgrammer {
     props.array.type.recursive
       ? ts.factory.createCallExpression(
           ts.factory.createIdentifier(
-            props.importer.useLocal(
+            props.functor.useLocal(
               `${props.config.prefix}a${props.array.type.index}`,
             ),
           ),
@@ -573,14 +574,14 @@ export namespace JsonStringifyProgrammer {
 
   const decode_array_inline = (props: {
     config: FeatureProgrammer.IConfig;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     input: ts.Expression;
     array: MetadataArray;
     explore: FeatureProgrammer.IExplore;
   }) =>
     FeatureProgrammer.decode_array({
       config: props.config,
-      importer: props.importer,
+      functor: props.functor,
       combiner: StringifyJoiner.array,
       array: props.array,
       input: props.input,
@@ -590,7 +591,7 @@ export namespace JsonStringifyProgrammer {
   const decode_tuple = (props: {
     context: ITypiaContext;
     config: FeatureProgrammer.IConfig;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     input: ts.Expression;
     tuple: MetadataTuple;
     explore: FeatureProgrammer.IExplore;
@@ -598,7 +599,7 @@ export namespace JsonStringifyProgrammer {
     props.tuple.type.recursive
       ? ts.factory.createCallExpression(
           ts.factory.createIdentifier(
-            props.importer.useLocal(
+            props.functor.useLocal(
               `${props.config.prefix}t${props.tuple.type.index}`,
             ),
           ),
@@ -620,7 +621,7 @@ export namespace JsonStringifyProgrammer {
   const decode_tuple_inline = (props: {
     context: ITypiaContext;
     config: FeatureProgrammer.IConfig;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     input: ts.Expression;
     tuple: MetadataTupleType;
     explore: FeatureProgrammer.IExplore;
@@ -660,7 +661,7 @@ export namespace JsonStringifyProgrammer {
         },
       });
       return ts.factory.createCallExpression(
-        props.importer.use("rest"),
+        props.context.importer.internal("jsonStringifyRest"),
         undefined,
         [code],
       );
@@ -673,14 +674,13 @@ export namespace JsonStringifyProgrammer {
 
   const decode_atomic = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
     input: ts.Expression;
     type: string;
     explore: FeatureProgrammer.IExplore;
   }): ts.Expression => {
     if (props.type === "string")
       return ts.factory.createCallExpression(
-        props.importer.use("string"),
+        props.context.importer.internal("jsonStringifyString"),
         undefined,
         [props.input],
       );
@@ -691,7 +691,7 @@ export namespace JsonStringifyProgrammer {
       props = {
         ...props,
         input: ts.factory.createCallExpression(
-          props.importer.use("number"),
+          props.context.importer.internal("jsonStringifyNumber"),
           undefined,
           [props.input],
         ),
@@ -708,7 +708,7 @@ export namespace JsonStringifyProgrammer {
 
   const decode_constant_string = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     input: ts.Expression;
     values: string[];
     explore: FeatureProgrammer.IExplore;
@@ -728,7 +728,7 @@ export namespace JsonStringifyProgrammer {
   const decode_to_json = (props: {
     context: ITypiaContext;
     config: FeatureProgrammer.IConfig;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     input: ts.Expression;
     metadata: Metadata;
     explore: FeatureProgrammer.IExplore;
@@ -753,21 +753,21 @@ export namespace JsonStringifyProgrammer {
   ----------------------------------------------------------- */
   const explore_objects = (props: {
     config: FeatureProgrammer.IConfig;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     input: ts.Expression;
     metadata: Metadata;
     explore: FeatureProgrammer.IExplore;
   }) =>
     props.metadata.objects.length === 1
       ? decode_object({
-          importer: props.importer,
+          functor: props.functor,
           input: props.input,
           object: props.metadata.objects[0]!,
           explore: props.explore,
         })
       : ts.factory.createCallExpression(
           ts.factory.createIdentifier(
-            props.importer.useLocal(`${PREFIX}u${props.metadata.union_index!}`),
+            props.functor.useLocal(`${PREFIX}u${props.metadata.union_index!}`),
           ),
           undefined,
           FeatureProgrammer.argumentsArray(props),
@@ -776,7 +776,7 @@ export namespace JsonStringifyProgrammer {
   const explore_arrays = (props: {
     context: ITypiaContext;
     config: FeatureProgrammer.IConfig;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     input: ts.Expression;
     arrays: MetadataArray[];
     explore: FeatureProgrammer.IExplore;
@@ -790,7 +790,7 @@ export namespace JsonStringifyProgrammer {
             checker: (v) =>
               IsProgrammer.decode({
                 context: props.context,
-                importer: props.importer,
+                functor: props.functor,
                 metadata: v.definition,
                 input: v.input,
                 explore: v.explore,
@@ -798,7 +798,7 @@ export namespace JsonStringifyProgrammer {
             decoder: (v) =>
               decode_array({
                 config: props.config,
-                importer: props.importer,
+                functor: props.functor,
                 input: v.input,
                 array: v.definition,
                 explore: v.explore,
@@ -807,7 +807,8 @@ export namespace JsonStringifyProgrammer {
             success: ts.factory.createTrue(),
             failure: (v) =>
               create_throw_error({
-                importer: props.importer,
+                context: props.context,
+                functor: props.functor,
                 expected: v.expected,
                 input: v.input,
               }),
@@ -824,7 +825,7 @@ export namespace JsonStringifyProgrammer {
     T extends MetadataArray | MetadataTuple,
   >(props: {
     config: FeatureProgrammer.IConfig;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     factory: (next: {
       parameters: ts.ParameterDeclaration[];
       input: ts.Expression;
@@ -864,7 +865,7 @@ export namespace JsonStringifyProgrammer {
     };
     return ts.factory.createCallExpression(
       ts.factory.createIdentifier(
-        props.importer.emplaceUnion(
+        props.functor.emplaceUnion(
           props.config.prefix,
           props.elements.map((e) => e.type.name).join(" | "),
           () =>
@@ -951,7 +952,8 @@ export namespace JsonStringifyProgrammer {
   };
 
   const iterate = (props: {
-    importer: FunctionImporter;
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
     input: ts.Expression;
     unions: IUnion[];
     expected: string;
@@ -976,7 +978,7 @@ export namespace JsonStringifyProgrammer {
 
   const configure = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
   }): FeatureProgrammer.IConfig => {
     const config: FeatureProgrammer.IConfig<ts.Expression> = {
       types: {
@@ -994,7 +996,7 @@ export namespace JsonStringifyProgrammer {
       decoder: (next) =>
         decode({
           context: props.context,
-          importer: props.importer,
+          functor: props.functor,
           config,
           metadata: next.metadata,
           input: next.input,
@@ -1004,14 +1006,14 @@ export namespace JsonStringifyProgrammer {
         checker: (next) =>
           IsProgrammer.decode({
             context: props.context,
-            importer: props.importer,
+            functor: props.functor,
             metadata: next.metadata,
             input: next.input,
             explore: next.explore,
           }),
         decoder: (next) =>
           decode_object({
-            importer: props.importer,
+            functor: props.functor,
             input: next.input,
             object: next.object,
             explore: next.explore,
@@ -1019,21 +1021,21 @@ export namespace JsonStringifyProgrammer {
         joiner: (next) =>
           StringifyJoiner.object({
             ...next,
-            importer: props.importer,
+            context: props.context,
           }),
         unionizer: (next) =>
           decode_union_object({
             checker: (v) =>
               IsProgrammer.decode_object({
                 context: props.context,
-                importer: props.importer,
+                functor: props.functor,
                 input: v.input,
                 object: v.object,
                 explore: v.explore,
               }),
             decoder: (v) =>
               decode_object({
-                importer: props.importer,
+                functor: props.functor,
                 input: v.input,
                 object: v.object,
                 explore: v.explore,
@@ -1041,7 +1043,8 @@ export namespace JsonStringifyProgrammer {
             success: (exp) => exp,
             escaper: (v) =>
               create_throw_error({
-                importer: props.importer,
+                context: props.context,
+                functor: props.functor,
                 expected: v.expected,
                 input: v.input,
               }),
@@ -1051,7 +1054,8 @@ export namespace JsonStringifyProgrammer {
           }),
         failure: (next) =>
           create_throw_error({
-            importer: props.importer,
+            context: props.context,
+            functor: props.functor,
             expected: next.expected,
             input: next.input,
           }),
@@ -1060,14 +1064,14 @@ export namespace JsonStringifyProgrammer {
         arrays: (collection) =>
           write_array_functions({
             config,
-            importer: props.importer,
+            functor: props.functor,
             collection,
           }),
         tuples: (collection) =>
           write_tuple_functions({
             config,
             context: props.context,
-            importer: props.importer,
+            functor: props.functor,
             collection,
           }),
       },
@@ -1077,24 +1081,29 @@ export namespace JsonStringifyProgrammer {
 
   const initializer: FeatureProgrammer.IConfig["initializer"] = (props) =>
     JsonMetadataFactory.analyze({
-      method: `typia.json.${props.importer.method}`,
+      method: props.functor.method,
       checker: props.context.checker,
       transformer: props.context.transformer,
       type: props.type,
     });
 
   const create_throw_error = (props: {
-    importer: FunctionImporter;
+    context: ITypiaContext;
+    functor: FunctionProgrammer;
     expected: string;
     input: ts.Expression;
   }) =>
     ts.factory.createExpressionStatement(
       ts.factory.createCallExpression(
-        props.importer.use("throws"),
+        props.context.importer.internal("throwTypeGuardError"),
         [],
         [
           ts.factory.createObjectLiteralExpression(
             [
+              ts.factory.createPropertyAssignment(
+                "method",
+                ts.factory.createStringLiteral(props.functor.method),
+              ),
               ts.factory.createPropertyAssignment(
                 "expected",
                 ts.factory.createStringLiteral(props.expected),

package/src/programmers/json/JsonValidateParseProgrammer.ts

@@ -9,13 +9,13 @@ import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { ValidateProgrammer } from "../ValidateProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
 
 export namespace JsonValidateParseProgrammer {
   export const decompose = (props: {
     context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name: string | undefined;
   }): FeatureProgrammer.IDecomposed => {
@@ -76,19 +76,19 @@ export namespace JsonValidateParseProgrammer {
   };
 
   export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       context: props.context,
       modulo: props.modulo,
-      importer,
+      functor,
       type: props.type,
       name: props.name,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };

package/src/programmers/json/JsonValidateStringifyProgrammer.ts

@@ -9,14 +9,14 @@ import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { FeatureProgrammer } from "../FeatureProgrammer";
 import { ValidateProgrammer } from "../ValidateProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
 import { JsonStringifyProgrammer } from "./JsonStringifyProgrammer";
 
 export namespace JsonValidateStringifyProgrammer {
   export const decompose = (props: {
     context: ITypiaContext;
     modulo: ts.LeftHandSideExpression;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name: string | undefined;
   }): FeatureProgrammer.IDecomposed => {
@@ -100,19 +100,19 @@ export namespace JsonValidateStringifyProgrammer {
   };
 
   export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       context: props.context,
       modulo: props.modulo,
-      importer,
+      functor,
       type: props.type,
       name: props.name,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };

package/src/programmers/llm/LlmApplicationProgrammer.ts

@@ -12,23 +12,23 @@ import { LlmSchemaProgrammer } from "./LlmSchemaProgrammer";
 
 export namespace LlmApplicationProgrammer {
   export const validate = (
-    meta: Metadata,
+    metadata: Metadata,
     explore: MetadataFactory.IExplore,
   ): string[] => {
-    if (explore.top === false) return LlmSchemaProgrammer.validate(meta);
+    if (explore.top === false) return LlmSchemaProgrammer.validate(metadata);
 
     const output: string[] = [];
     const valid: boolean =
-      meta.size() === 1 &&
-      meta.objects.length === 1 &&
-      meta.isRequired() === true &&
-      meta.nullable === false;
+      metadata.size() === 1 &&
+      metadata.objects.length === 1 &&
+      metadata.isRequired() === true &&
+      metadata.nullable === false;
     if (valid === false)
       output.push(
         "LLM application's generic arugment must be a class/interface type.",
       );
 
-    const object: MetadataObject | undefined = meta.objects[0];
+    const object: MetadataObject | undefined = metadata.objects[0];
     if (object !== undefined) {
       if (object.properties.some((p) => p.key.isSoleLiteral() === false))
         output.push("LLM application does not allow dynamic keys.");
@@ -124,7 +124,7 @@ export namespace LlmApplicationProgrammer {
         const jsDocTagDescription: string | null = writeDescriptionFromJsDocTag(
           {
             jsDocTags: p.jsDocTags,
-            tag: "param",
+            name: "param",
             parameter: p.name,
           },
         );
@@ -141,11 +141,11 @@ export namespace LlmApplicationProgrammer {
               description:
                 writeDescriptionFromJsDocTag({
                   jsDocTags: props.jsDocTags,
-                  tag: "return",
+                  name: "return",
                 }) ??
                 writeDescriptionFromJsDocTag({
                   jsDocTags: props.jsDocTags,
-                  tag: "returns",
+                  name: "returns",
                 }),
               jsDocTags: [],
             })
@@ -201,7 +201,7 @@ export namespace LlmApplicationProgrammer {
 
   const writeDescriptionFromJsDocTag = (props: {
     jsDocTags: IJsDocTagInfo[];
-    tag: string;
+    name: string;
     parameter?: string;
   }): string | null => {
     const parametric: (elem: IJsDocTagInfo) => boolean = props.parameter
@@ -212,7 +212,7 @@ export namespace LlmApplicationProgrammer {
           ) !== undefined
       : () => true;
     const tag: IJsDocTagInfo | undefined = props.jsDocTags.find(
-      (tag) => tag.name === props.tag && tag.text && parametric(tag),
+      (tag) => tag.name === props.name && tag.text && parametric(tag),
     );
     return tag && tag.text
       ? (tag.text.find((elem) => elem.kind === "text")?.text ?? null)

package/src/programmers/llm/LlmSchemaProgrammer.ts

@@ -6,23 +6,25 @@ import { AtomicPredicator } from "../helpers/AtomicPredicator";
 import { llm_schema_station } from "../internal/llm_schema_station";
 
 export namespace LlmSchemaProgrammer {
-  export const validate = (meta: Metadata): string[] => {
+  export const validate = (metadata: Metadata): string[] => {
     const output: string[] = [];
     if (
-      meta.atomics.some((a) => a.type === "bigint") ||
-      meta.constants.some((c) => c.type === "bigint")
+      metadata.atomics.some((a) => a.type === "bigint") ||
+      metadata.constants.some((c) => c.type === "bigint")
     )
       output.push("LLM schema does not support bigint type.");
     if (
-      meta.tuples.some((t) =>
+      metadata.tuples.some((t) =>
         t.type.elements.some((e) => e.isRequired() === false),
       ) ||
-      meta.arrays.some((a) => a.type.value.isRequired() === false)
+      metadata.arrays.some((a) => a.type.value.isRequired() === false)
     )
       output.push("LLM schema does not support undefined type in array.");
-    if (meta.maps.length) output.push("LLM schema does not support Map type.");
-    if (meta.sets.length) output.push("LLM schema does not support Set type.");
-    for (const native of meta.natives)
+    if (metadata.maps.length)
+      output.push("LLM schema does not support Map type.");
+    if (metadata.sets.length)
+      output.push("LLM schema does not support Set type.");
+    for (const native of metadata.natives)
       if (
         AtomicPredicator.native(native) === false &&
         native !== "Date" &&
@@ -31,10 +33,10 @@ export namespace LlmSchemaProgrammer {
       )
         output.push(`LLM schema does not support ${native} type.`);
     if (
-      meta.aliases.some((a) => a.recursive) ||
-      meta.arrays.some((a) => a.type.recursive) ||
-      meta.objects.some((o) => o.recursive) ||
-      meta.tuples.some((t) => t.type.recursive)
+      metadata.aliases.some((a) => a.recursive) ||
+      metadata.arrays.some((a) => a.type.recursive) ||
+      metadata.objects.some((o) => o.recursive) ||
+      metadata.tuples.some((t) => t.type.recursive)
     )
       output.push("LLM schema does not support recursive type.");
     return output;

package/src/programmers/misc/MiscAssertCloneProgrammer.ts

@@ -9,13 +9,13 @@ import { ITypiaContext } from "../../transformers/ITypiaContext";
 
 import { AssertProgrammer } from "../AssertProgrammer";
 import { FeatureProgrammer } from "../FeatureProgrammer";
-import { FunctionImporter } from "../helpers/FunctionImporter";
+import { FunctionProgrammer } from "../helpers/FunctionProgrammer";
 import { MiscCloneProgrammer } from "./MiscCloneProgrammer";
 
 export namespace MiscAssertCloneProgrammer {
   export const decompose = (props: {
     context: ITypiaContext;
-    importer: FunctionImporter;
+    functor: FunctionProgrammer;
     type: ts.Type;
     name: string | undefined;
     init?: ts.Expression | undefined;
@@ -76,16 +76,16 @@ export namespace MiscAssertCloneProgrammer {
   };
 
   export const write = (props: IProgrammerProps): ts.CallExpression => {
-    const importer: FunctionImporter = new FunctionImporter(
+    const functor: FunctionProgrammer = new FunctionProgrammer(
       props.modulo.getText(),
     );
     const result: FeatureProgrammer.IDecomposed = decompose({
       ...props,
-      importer,
+      functor,
     });
     return FeatureProgrammer.writeDecomposed({
       modulo: props.modulo,
-      importer,
+      functor,
       result,
     });
   };