typia 6.10.1-dev.20240914 → 7.0.0-dev.20240918

package/src/transformers/features/http/HttpValidateHeadersTransformer.ts

@@ -1,10 +1,13 @@
 import { HttpValidateHeadersProgrammer } from "../../../programmers/http/HttpValidateHeadersProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace HttpValidateHeadersTransformer {
-  export const transform = GenericTransformer.scalar("http.validateHeaders")(
-    (project) => (modulo) =>
-      HttpValidateHeadersProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "http.validateHeaders",
+      write: HttpValidateHeadersProgrammer.write,
+    });
 }

package/src/transformers/features/http/HttpValidateQueryTransformer.ts

@@ -1,9 +1,13 @@
 import { HttpValidateQueryProgrammer } from "../../../programmers/http/HttpValidateQueryProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace HttpValidateQueryTransformer {
-  export const transform = GenericTransformer.scalar("http.validateQuery")(
-    (project) => (modulo) => HttpValidateQueryProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "http.validateQuery",
+      write: HttpValidateQueryProgrammer.write,
+    });
 }

package/src/transformers/features/json/JsonApplicationTransformer.ts

@@ -11,82 +11,85 @@ import { JsonApplicationProgrammer } from "../../../programmers/json/JsonApplica
 
 import { ValidationPipe } from "../../../typings/ValidationPipe";
 
-import { IProject } from "../../IProject";
+import { ITransformProps } from "../../ITransformProps";
 import { TransformerError } from "../../TransformerError";
 
 export namespace JsonApplicationTransformer {
-  export const transform =
-    (project: IProject) =>
-    (expression: ts.CallExpression): ts.Expression => {
-      if (!expression.typeArguments?.length)
-        throw new TransformerError({
-          code: "typia.json.application",
-          message: "no generic argument.",
-        });
+  export const transform = (
+    props: Pick<ITransformProps, "context" | "expression">,
+  ): ts.Expression => {
+    if (!props.expression.typeArguments?.length)
+      throw new TransformerError({
+        code: "typia.json.application",
+        message: "no generic argument.",
+      });
 
-      //----
-      // GET ARGUMENTS
-      //----
-      // VALIDATE TUPLE ARGUMENTS
-      const top: ts.Node = expression.typeArguments[0]!;
-      if (!ts.isTupleTypeNode(top)) return expression;
-      else if (top.elements.some((child) => !ts.isTypeNode(child)))
-        return expression;
+    //----
+    // GET ARGUMENTS
+    //----
+    // VALIDATE TUPLE ARGUMENTS
+    const top: ts.Node = props.expression.typeArguments[0]!;
+    if (!ts.isTupleTypeNode(top)) return props.expression;
+    else if (top.elements.some((child) => !ts.isTypeNode(child)))
+      return props.expression;
 
-      // GET TYPES
-      const types: ts.Type[] = top.elements.map((child) =>
-        project.checker.getTypeFromTypeNode(child as ts.TypeNode),
-      );
-      if (types.some((t) => t.isTypeParameter()))
-        throw new TransformerError({
-          code: "typia.json.application",
-          message: "non-specified generic argument(s).",
-        });
+    // GET TYPES
+    const types: ts.Type[] = top.elements.map((child) =>
+      props.context.checker.getTypeFromTypeNode(child as ts.TypeNode),
+    );
+    if (types.some((t) => t.isTypeParameter()))
+      throw new TransformerError({
+        code: "typia.json.application",
+        message: "non-specified generic argument(s).",
+      });
 
-      // ADDITIONAL PARAMETERS
-      const version: "3.0" | "3.1" = get_parameter<"3.0" | "3.1">({
-        checker: project.checker,
-        name: "Version",
-        is: (str) => str === "3.0" || str === "3.1",
-        cast: (str) => str as "3.0" | "3.1",
-        default: () => "3.1",
-      })(expression.typeArguments[1]);
+    // ADDITIONAL PARAMETERS
+    const version: "3.0" | "3.1" = get_parameter<"3.0" | "3.1">({
+      checker: props.context.checker,
+      name: "Version",
+      is: (str) => str === "3.0" || str === "3.1",
+      cast: (str) => str as "3.0" | "3.1",
+      default: () => "3.1",
+    })(props.expression.typeArguments[1]);
 
-      //----
-      // GENERATORS
-      //----
-      // METADATA
-      const collection: MetadataCollection = new MetadataCollection({
-        replace: MetadataCollection.replace,
-      });
-      const results: ValidationPipe<Metadata, MetadataFactory.IError>[] =
-        types.map((type) =>
-          MetadataFactory.analyze(
-            project.checker,
-            project.context,
-          )({
+    //----
+    // GENERATORS
+    //----
+    // METADATA
+    const collection: MetadataCollection = new MetadataCollection({
+      replace: MetadataCollection.replace,
+    });
+    const results: ValidationPipe<Metadata, MetadataFactory.IError>[] =
+      types.map((type) =>
+        MetadataFactory.analyze({
+          checker: props.context.checker,
+          transformer: props.context.transformer,
+          options: {
             escape: true,
             constant: true,
             absorb: false,
             validate: JsonApplicationProgrammer.validate,
-          })(collection)(type),
-        );
+          },
+          collection,
+          type,
+        }),
+      );
 
-      // REPORT BUG IF REQUIRED
-      const metadatas: Metadata[] = [];
-      const errors: MetadataFactory.IError[] = [];
-      for (const r of results) {
-        if (r.success === false) errors.push(...r.errors);
-        else metadatas.push(r.data);
-      }
-      if (errors.length)
-        throw TransformerError.from("typia.json.application")(errors);
+    // REPORT BUG IF REQUIRED
+    const metadatas: Metadata[] = [];
+    const errors: MetadataFactory.IError[] = [];
+    for (const r of results) {
+      if (r.success === false) errors.push(...r.errors);
+      else metadatas.push(r.data);
+    }
+    if (errors.length)
+      throw TransformerError.from("typia.json.application")(errors);
 
-      // APPLICATION
-      const app: IJsonApplication<any> =
-        JsonApplicationProgrammer.write(version)(metadatas);
-      return LiteralFactory.generate(app);
-    };
+    // APPLICATION
+    const app: IJsonApplication<any> =
+      JsonApplicationProgrammer.write(version)(metadatas);
+    return LiteralFactory.generate(app);
+  };
 
   const get_parameter =
     <Value>(props: {

package/src/transformers/features/json/JsonAssertParseTransformer.ts

@@ -1,9 +1,13 @@
 import { JsonAssertParseProgrammer } from "../../../programmers/json/JsonAssertParseProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonAssertParseTransformer {
-  export const transform = GenericTransformer.scalar("json.assertParse")(
-    (project) => (modulo) => JsonAssertParseProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "json.assertParse",
+      write: JsonAssertParseProgrammer.write,
+    });
 }

package/src/transformers/features/json/JsonAssertStringifyTransformer.ts

@@ -1,10 +1,13 @@
 import { JsonAssertStringifyProgrammer } from "../../../programmers/json/JsonAssertStringifyProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonAssertStringifyTransformer {
-  export const transform = GenericTransformer.scalar("json.assertStringify")(
-    (project) => (modulo) =>
-      JsonAssertStringifyProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "json.assertStringify",
+      write: JsonAssertStringifyProgrammer.write,
+    });
 }

package/src/transformers/features/json/JsonCreateAssertParseTransformer.ts

@@ -1,9 +1,13 @@
 import { JsonAssertParseProgrammer } from "../../../programmers/json/JsonAssertParseProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonCreateAssertParseTransformer {
-  export const transform = GenericTransformer.factory("json.createAssertParse")(
-    (project) => (modulo) => JsonAssertParseProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "json.createAssertParse",
+      write: JsonAssertParseProgrammer.write,
+    });
 }

package/src/transformers/features/json/JsonCreateAssertStringifyTransformer.ts

@@ -1,12 +1,13 @@
 import { JsonAssertStringifyProgrammer } from "../../../programmers/json/JsonAssertStringifyProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonCreateAssertStringifyTransformer {
-  export const transform = GenericTransformer.factory(
-    "json.createAssertStringify",
-  )(
-    (project) => (modulo) =>
-      JsonAssertStringifyProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "json.createAssertStringify",
+      write: JsonAssertStringifyProgrammer.write,
+    });
 }

package/src/transformers/features/json/JsonCreateIsParseTransformer.ts

@@ -1,9 +1,13 @@
 import { JsonIsParseProgrammer } from "../../../programmers/json/JsonIsParseProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonCreateIsParseTransformer {
-  export const transform = GenericTransformer.factory("json.createIsParse")(
-    (project) => (modulo) => JsonIsParseProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "json.createIsParse",
+      write: JsonIsParseProgrammer.write,
+    });
 }

package/src/transformers/features/json/JsonCreateIsStringifyTransformer.ts

@@ -1,9 +1,13 @@
 import { JsonIsStringifyProgrammer } from "../../../programmers/json/JsonIsStringifyProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonCreateIsStringifyTransformer {
-  export const transform = GenericTransformer.factory("json.createIsStringify")(
-    (project) => (modulo) => JsonIsStringifyProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "json.stringify",
+      write: JsonIsStringifyProgrammer.write,
+    });
 }

package/src/transformers/features/json/JsonCreateStringifyTransformer.ts

@@ -1,9 +1,13 @@
 import { JsonStringifyProgrammer } from "../../../programmers/json/JsonStringifyProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonCreateStringifyTransformer {
-  export const transform = GenericTransformer.factory("json.createStringify")(
-    (project) => (modulo) => JsonStringifyProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "json.createStringify",
+      write: JsonStringifyProgrammer.write,
+    });
 }

package/src/transformers/features/json/JsonCreateValidateParseTransformer.ts

@@ -1,11 +1,13 @@
 import { JsonValidateParseProgrammer } from "../../../programmers/json/JsonValidateParseProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonCreateValidateParseTransformer {
-  export const transform = GenericTransformer.factory(
-    "json.createValidateParse",
-  )(
-    (project) => (modulo) => JsonValidateParseProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "json.createValidateParse",
+      write: JsonValidateParseProgrammer.write,
+    });
 }

package/src/transformers/features/json/JsonCreateValidateStringifyProgrammer.ts

@@ -1,12 +1,13 @@
 import { JsonValidateStringifyProgrammer } from "../../../programmers/json/JsonValidateStringifyProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonCreateValidateStringifyTransformer {
-  export const transform = GenericTransformer.factory(
-    "json.createValidateStringify",
-  )(
-    (project) => (modulo) =>
-      JsonValidateStringifyProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "json.createValidateStringify",
+      write: JsonValidateStringifyProgrammer.write,
+    });
 }

package/src/transformers/features/json/JsonIsParseTransformer.ts

@@ -1,9 +1,13 @@
 import { JsonIsParseProgrammer } from "../../../programmers/json/JsonIsParseProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonIsParseTransformer {
-  export const transform = GenericTransformer.scalar("json.isParse")(
-    (project) => (modulo) => JsonIsParseProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "json.isParse",
+      write: JsonIsParseProgrammer.write,
+    });
 }

package/src/transformers/features/json/JsonIsStringifyTransformer.ts

@@ -1,9 +1,13 @@
 import { JsonIsStringifyProgrammer } from "../../../programmers/json/JsonIsStringifyProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonIsStringifyTransformer {
-  export const transform = GenericTransformer.scalar("json.isStringify")(
-    (project) => (modulo) => JsonIsStringifyProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "json.isStringify",
+      write: JsonIsStringifyProgrammer.write,
+    });
 }

package/src/transformers/features/json/JsonStringifyTransformer.ts

@@ -1,9 +1,13 @@
 import { JsonStringifyProgrammer } from "../../../programmers/json/JsonStringifyProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonStringifyTransformer {
-  export const transform = GenericTransformer.scalar("json.stringify")(
-    (project) => (modulo) => JsonStringifyProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "json.stringify",
+      write: JsonStringifyProgrammer.write,
+    });
 }

package/src/transformers/features/json/JsonValidateParseTransformer.ts

@@ -1,9 +1,13 @@
 import { JsonValidateParseProgrammer } from "../../../programmers/json/JsonValidateParseProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonValidateParseTransformer {
-  export const transform = GenericTransformer.scalar("json.validatParse")(
-    (project) => (modulo) => JsonValidateParseProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "json.validatParse",
+      write: JsonValidateParseProgrammer.write,
+    });
 }

package/src/transformers/features/json/JsonValidateStringifyTransformer.ts

@@ -1,10 +1,13 @@
 import { JsonValidateStringifyProgrammer } from "../../../programmers/json/JsonValidateStringifyProgrammer";
 
+import { ITransformProps } from "../../ITransformProps";
 import { GenericTransformer } from "../../internal/GenericTransformer";
 
 export namespace JsonValidateStringifyTransformer {
-  export const transform = GenericTransformer.scalar("json.validatStringify")(
-    (project) => (modulo) =>
-      JsonValidateStringifyProgrammer.write(project)(modulo),
-  );
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "json.validatStringify",
+      write: JsonValidateStringifyProgrammer.write,
+    });
 }

package/src/transformers/features/llm/LlmApplicationTransformer.ts

@@ -15,69 +15,69 @@ import { LlmApplicationProgrammer } from "../../../programmers/llm/LlmApplicatio
 
 import { ValidationPipe } from "../../../typings/ValidationPipe";
 
-import { IProject } from "../../IProject";
+import { ITransformProps } from "../../ITransformProps";
 import { TransformerError } from "../../TransformerError";
 
 export namespace LlmApplicationTransformer {
-  export const transform =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (expression: ts.CallExpression): ts.Expression => {
-      // GET GENERIC ARGUMENT
-      if (!expression.typeArguments?.length)
-        throw new TransformerError({
-          code: "typia.llm.schema",
-          message: "no generic argument.",
-        });
+  export const transform = (props: ITransformProps): ts.Expression => {
+    // GET GENERIC ARGUMENT
+    if (!props.expression.typeArguments?.length)
+      throw new TransformerError({
+        code: "typia.llm.schema",
+        message: "no generic argument.",
+      });
 
-      const top: ts.Node = expression.typeArguments[0]!;
-      if (ts.isTypeNode(top) === false) return expression;
+    const top: ts.Node = props.expression.typeArguments[0]!;
+    if (ts.isTypeNode(top) === false) return props.expression;
 
-      // GET TYPE
-      const type: ts.Type = project.checker.getTypeFromTypeNode(top);
-      const collection: MetadataCollection = new MetadataCollection({
-        replace: MetadataCollection.replace,
-      });
-      const result: ValidationPipe<Metadata, MetadataFactory.IError> =
-        MetadataFactory.analyze(
-          project.checker,
-          project.context,
-        )({
+    // GET TYPE
+    const type: ts.Type = props.context.checker.getTypeFromTypeNode(top);
+    const collection: MetadataCollection = new MetadataCollection({
+      replace: MetadataCollection.replace,
+    });
+    const result: ValidationPipe<Metadata, MetadataFactory.IError> =
+      MetadataFactory.analyze({
+        checker: props.context.checker,
+        transformer: props.context.transformer,
+        options: {
           escape: true,
           constant: true,
           absorb: false,
           functional: true,
           validate: LlmApplicationProgrammer.validate,
-        })(collection)(type);
-      if (result.success === false)
-        throw TransformerError.from("typia.llm.application")(result.errors);
+        },
+        collection,
+        type,
+      });
+    if (result.success === false)
+      throw TransformerError.from("typia.llm.application")(result.errors);
 
-      // GENERATE LLM APPLICATION
-      const schema: ILlmApplication = LlmApplicationProgrammer.write(
-        result.data,
-      );
-      const literal: ts.Expression = LiteralFactory.generate(schema);
-      if (!expression.arguments?.[0]) return literal;
-      return ExpressionFactory.selfCall(
-        ts.factory.createBlock(
-          [
-            StatementFactory.constant("app", LiteralFactory.generate(schema)),
-            ts.factory.createExpressionStatement(
-              ts.factory.createCallExpression(
-                ts.factory.createAsExpression(
-                  IdentifierFactory.access(modulo)("finalize"),
-                  TypeFactory.keyword("any"),
-                ),
-                undefined,
-                [ts.factory.createIdentifier("app"), expression.arguments[0]],
+    // GENERATE LLM APPLICATION
+    const schema: ILlmApplication = LlmApplicationProgrammer.write(result.data);
+
+    return ExpressionFactory.selfCall(
+      ts.factory.createBlock(
+        [
+          StatementFactory.constant("app", LiteralFactory.generate(schema)),
+          ts.factory.createExpressionStatement(
+            ts.factory.createCallExpression(
+              ts.factory.createAsExpression(
+                IdentifierFactory.access(props.modulo)("finalize"),
+                TypeFactory.keyword("any"),
               ),
+              undefined,
+              [
+                ts.factory.createIdentifier("app"),
+                ...(props.expression.arguments?.[0]
+                  ? [props.expression.arguments[0]]
+                  : []),
+              ],
             ),
-            ts.factory.createReturnStatement(
-              ts.factory.createIdentifier("app"),
-            ),
-          ],
-          true,
-        ),
-      );
-    };
+          ),
+          ts.factory.createReturnStatement(ts.factory.createIdentifier("app")),
+        ],
+        true,
+      ),
+    );
+  };
 }