typia 6.10.0 → 7.0.0-dev.20240916

package/src/transformers/CallExpressionTransformer.ts

@@ -14,7 +14,8 @@ import { FunctionalGenericTransformer } from "./features/functional/FunctionalGe
 
 import { NamingConvention } from "../utils/NamingConvention";
 
-import { IProject } from "./IProject";
+import { ITransformProps } from "./ITransformProps";
+import { ITypiaContext } from "./ITypiaContext";
 import { AssertTransformer } from "./features/AssertTransformer";
 import { CreateAssertTransformer } from "./features/CreateAssertTransformer";
 import { CreateIsTransformer } from "./features/CreateIsTransformer";
@@ -113,14 +114,14 @@ import { ReflectNameTransformer } from "./features/reflect/ReflectNameTransforme
 
 export namespace CallExpressionTransformer {
   export const transform =
-    (project: IProject) =>
+    (context: ITypiaContext) =>
     (expression: ts.CallExpression): ts.Expression | null => {
       //----
       // VALIDATIONS
       //----
       // SIGNATURE DECLARATION
       const declaration: ts.Declaration | undefined =
-        project.checker.getResolvedSignature(expression)?.declaration;
+        context.checker.getResolvedSignature(expression)?.declaration;
       if (!declaration) return expression;
 
       // FILE PATH
@@ -134,16 +135,18 @@ export namespace CallExpressionTransformer {
       //----
       // FUNCTION NAME
       const module: string = location.split(path.sep).at(-1)!.split(".")[0]!;
-      const { name } = project.checker.getTypeAtLocation(declaration).symbol;
+      const { name } = context.checker.getTypeAtLocation(declaration).symbol;
 
       // FIND TRANSFORMER
       const functor: (() => Task) | undefined = FUNCTORS[module]?.[name];
       if (functor === undefined) return expression;
 
       // RETURNS WITH TRANSFORMATION
-      const result: ts.Expression | null = functor()(project)(
-        expression.expression,
-      )(expression);
+      const result: ts.Expression | null = functor()({
+        context,
+        modulo: expression.expression,
+        expression,
+      });
       return result ?? expression;
     };
 
@@ -155,11 +158,7 @@ export namespace CallExpressionTransformer {
   };
 }
 
-type Task = (
-  project: IProject,
-) => (
-  modulo: ts.LeftHandSideExpression,
-) => (expression: ts.CallExpression) => ts.Expression | null;
+type Task = (props: ITransformProps) => ts.Expression | null;
 
 const FUNCTORS: Record<string, Record<string, () => Task>> = {
   module: {
@@ -169,21 +168,20 @@ const FUNCTORS: Record<string, Record<string, () => Task>> = {
       AssertTransformer.transform({ equals: false, guard: true }),
     assertType: () =>
       AssertTransformer.transform({ equals: false, guard: false }),
-    is: () => IsTransformer.transform(false),
-    validate: () => ValidateTransformer.transform(false),
+    is: () => IsTransformer.transform({ equals: false }),
+    validate: () => ValidateTransformer.transform({ equals: false }),
 
     // STRICT
     assertEquals: () =>
       AssertTransformer.transform({ equals: true, guard: false }),
     assertGuardEquals: () =>
       AssertTransformer.transform({ equals: true, guard: true }),
-    equals: () => IsTransformer.transform(true),
-    validateEquals: () => ValidateTransformer.transform(true),
+    equals: () => IsTransformer.transform({ equals: true }),
+    validateEquals: () => ValidateTransformer.transform({ equals: true }),
 
     // RANDOM + INTERNAL
     random: () => RandomTransformer.transform,
-    metadata: () => (project) => () =>
-      ReflectMetadataTransformer.transform(project),
+    metadata: () => ReflectMetadataTransformer.transform,
 
     // FACTORIES
     createAssert: () =>
@@ -192,14 +190,16 @@ const FUNCTORS: Record<string, Record<string, () => Task>> = {
       CreateAssertTransformer.transform({ equals: false, guard: true }),
     createAssertType: () =>
       CreateAssertTransformer.transform({ equals: false, guard: false }),
-    createIs: () => CreateIsTransformer.transform(false),
-    createValidate: () => CreateValidateTransformer.transform(false),
+    createIs: () => CreateIsTransformer.transform({ equals: false }),
+    createValidate: () =>
+      CreateValidateTransformer.transform({ equals: false }),
     createAssertEquals: () =>
       CreateAssertTransformer.transform({ equals: true, guard: false }),
     createAssertGuardEquals: () =>
       CreateAssertTransformer.transform({ equals: true, guard: true }),
-    createEquals: () => CreateIsTransformer.transform(true),
-    createValidateEquals: () => CreateValidateTransformer.transform(true),
+    createEquals: () => CreateIsTransformer.transform({ equals: true }),
+    createValidateEquals: () =>
+      CreateValidateTransformer.transform({ equals: true }),
     createRandom: () => CreateRandomTransformer.transform,
   },
   functional: {
@@ -207,37 +207,49 @@ const FUNCTORS: Record<string, Record<string, () => Task>> = {
     assertFunction: () =>
       FunctionalGenericTransformer.transform({
         method: "assertFunction",
-        equals: false,
+        config: {
+          equals: false,
+        },
         programmer: FunctionalAssertFunctionProgrammer.write,
       }),
     assertParameters: () =>
       FunctionalGenericTransformer.transform({
         method: "assertParameters",
-        equals: false,
+        config: {
+          equals: false,
+        },
         programmer: FunctionalAssertParametersProgrammer.write,
       }),
     assertReturn: () =>
       FunctionalGenericTransformer.transform({
         method: "assertReturn",
-        equals: false,
+        config: {
+          equals: false,
+        },
         programmer: FunctionAssertReturnProgrammer.write,
       }),
     assertEqualsFunction: () =>
       FunctionalGenericTransformer.transform({
         method: "assertEqualsFunction",
-        equals: true,
+        config: {
+          equals: true,
+        },
         programmer: FunctionalAssertFunctionProgrammer.write,
       }),
     assertEqualsParameters: () =>
       FunctionalGenericTransformer.transform({
         method: "assertEqualsParameters",
-        equals: true,
+        config: {
+          equals: true,
+        },
         programmer: FunctionalAssertParametersProgrammer.write,
       }),
     assertEqualsReturn: () =>
       FunctionalGenericTransformer.transform({
         method: "assertEqualsReturn",
-        equals: true,
+        config: {
+          equals: true,
+        },
         programmer: FunctionAssertReturnProgrammer.write,
       }),
 
@@ -245,37 +257,49 @@ const FUNCTORS: Record<string, Record<string, () => Task>> = {
     isFunction: () =>
       FunctionalGenericTransformer.transform({
         method: "isFunction",
-        equals: false,
+        config: {
+          equals: false,
+        },
         programmer: FunctionalIsFunctionProgrammer.write,
       }),
     isParameters: () =>
       FunctionalGenericTransformer.transform({
         method: "isParameters",
-        equals: false,
+        config: {
+          equals: false,
+        },
         programmer: FunctionalIsParametersProgrammer.write,
       }),
     isReturn: () =>
       FunctionalGenericTransformer.transform({
         method: "isReturn",
-        equals: false,
+        config: {
+          equals: false,
+        },
         programmer: FunctionalIsReturnProgrammer.write,
       }),
     equalsFunction: () =>
       FunctionalGenericTransformer.transform({
         method: "equalsFunction",
-        equals: true,
+        config: {
+          equals: true,
+        },
         programmer: FunctionalIsFunctionProgrammer.write,
       }),
     equalsParameters: () =>
       FunctionalGenericTransformer.transform({
         method: "equalsParameters",
-        equals: true,
+        config: {
+          equals: true,
+        },
         programmer: FunctionalIsParametersProgrammer.write,
       }),
     equalsReturn: () =>
       FunctionalGenericTransformer.transform({
         method: "equalsReturn",
-        equals: true,
+        config: {
+          equals: true,
+        },
         programmer: FunctionalIsReturnProgrammer.write,
       }),
 
@@ -283,37 +307,49 @@ const FUNCTORS: Record<string, Record<string, () => Task>> = {
     validateFunction: () =>
       FunctionalGenericTransformer.transform({
         method: "validateFunction",
-        equals: false,
+        config: {
+          equals: false,
+        },
         programmer: FunctionalValidateFunctionProgrammer.write,
       }),
     validateParameters: () =>
       FunctionalGenericTransformer.transform({
         method: "validateParameters",
-        equals: false,
+        config: {
+          equals: false,
+        },
         programmer: FunctionalValidateParametersProgrammer.write,
       }),
     validateReturn: () =>
       FunctionalGenericTransformer.transform({
         method: "validateReturn",
-        equals: false,
+        config: {
+          equals: false,
+        },
         programmer: FunctionalValidateReturnProgrammer.write,
       }),
     validateEqualsFunction: () =>
       FunctionalGenericTransformer.transform({
         method: "validateEqualsFunction",
-        equals: true,
+        config: {
+          equals: true,
+        },
         programmer: FunctionalValidateFunctionProgrammer.write,
       }),
     validateEqualsParameters: () =>
       FunctionalGenericTransformer.transform({
         method: "validateEqualsParameters",
-        equals: true,
+        config: {
+          equals: true,
+        },
         programmer: FunctionalValidateParametersProgrammer.write,
       }),
     validateEqualsReturn: () =>
       FunctionalGenericTransformer.transform({
         method: "validateEqualsReturn",
-        equals: true,
+        config: {
+          equals: true,
+        },
         programmer: FunctionalValidateReturnProgrammer.write,
       }),
   },
@@ -356,14 +392,12 @@ const FUNCTORS: Record<string, Record<string, () => Task>> = {
     createValidateQuery: () => CreateHttpValidateQueryTransformer.transform,
   },
   llm: {
-    application: () => (project) =>
-      LlmApplicationTransformer.transform(project),
-    schema: () => (project) => () => LlmSchemaTransformer.transform(project),
+    application: () => LlmApplicationTransformer.transform,
+    schema: () => LlmSchemaTransformer.transform,
   },
   json: {
     // SCHEMA
-    application: () => (project) => () =>
-      JsonApplicationTransformer.transform(project),
+    application: () => JsonApplicationTransformer.transform,
 
     // PARSER
     isParse: () => JsonIsParseTransformer.transform,
@@ -415,13 +449,11 @@ const FUNCTORS: Record<string, Record<string, () => Task>> = {
       ProtobufCreateValidateDecodeTransformer.transform,
   },
   reflect: {
-    metadata: () => (project) => () =>
-      ReflectMetadataTransformer.transform(project),
-    name: () => (project) => () => ReflectNameTransformer.transform(project),
+    metadata: () => ReflectMetadataTransformer.transform,
+    name: () => ReflectNameTransformer.transform,
   },
   misc: {
-    literals: () => (project) => () =>
-      MiscLiteralsTransformer.transform(project),
+    literals: () => MiscLiteralsTransformer.transform,
 
     // CLONE
     clone: () => MiscCloneTransformer.transform,

package/src/transformers/FileTransformer.ts

@@ -2,41 +2,41 @@ import ts from "typescript";
 
 import { Singleton } from "../utils/Singleton";
 
-import { IProject } from "./IProject";
+import { ITypiaContext } from "./ITypiaContext";
 import { NodeTransformer } from "./NodeTransformer";
 import { TransformerError } from "./TransformerError";
 
 export namespace FileTransformer {
   export const transform =
-    (environments: Omit<IProject, "context">) =>
-    (context: ts.TransformationContext) =>
+    (environments: Omit<ITypiaContext, "transformer">) =>
+    (transformer: ts.TransformationContext) =>
     (file: ts.SourceFile): ts.SourceFile => {
       if (file.isDeclarationFile) return file;
 
-      const project: IProject = {
+      const project: ITypiaContext = {
         ...environments,
-        context,
+        transformer,
       };
       checkJsDocParsingMode.get(project, file);
 
       return ts.visitEachChild(
         file,
         (node) => iterate_node(project)(node),
-        context,
+        transformer,
       );
     };
 
   const iterate_node =
-    (project: IProject) =>
+    (project: ITypiaContext) =>
     (node: ts.Node): ts.Node =>
       ts.visitEachChild(
         try_transform_node(project)(node) ?? node,
         (child) => iterate_node(project)(child),
-        project.context,
+        project.transformer,
       );
 
   const try_transform_node =
-    (project: IProject) =>
+    (project: ITypiaContext) =>
     (node: ts.Node): ts.Node | null => {
       try {
         return NodeTransformer.transform(project)(node);
@@ -65,7 +65,7 @@ const isTransformerError = (error: any): error is TransformerError =>
   typeof error.message === "string";
 
 const checkJsDocParsingMode = new Singleton(
-  (project: IProject, file: ts.SourceFile) => {
+  (project: ITypiaContext, file: ts.SourceFile) => {
     if (
       typeof file.jsDocParsingMode === "number" &&
       file.jsDocParsingMode !== 0

package/src/transformers/IProgrammerProps.ts

@@ -0,0 +1,11 @@
+import ts from "typescript";
+
+import { ITypiaContext } from "./ITypiaContext";
+
+export interface IProgrammerProps {
+  context: ITypiaContext;
+  modulo: ts.LeftHandSideExpression;
+  type: ts.Type;
+  name: string | undefined;
+  init?: ts.Expression | undefined;
+}

package/src/transformers/ITransformProps.ts

@@ -0,0 +1,9 @@
+import ts from "typescript";
+
+import { ITypiaContext } from "./ITypiaContext";
+
+export interface ITransformProps {
+  context: ITypiaContext;
+  modulo: ts.LeftHandSideExpression;
+  expression: ts.CallExpression;
+}

package/src/transformers/{IProject.ts → ITypiaContext.ts}

@@ -2,13 +2,13 @@ import ts from "typescript";
 
 import { ITransformOptions } from "./ITransformOptions";
 
-export interface IProject {
+export interface ITypiaContext {
   program: ts.Program;
   compilerOptions: ts.CompilerOptions;
   checker: ts.TypeChecker;
   printer: ts.Printer;
   options: ITransformOptions;
-  context: ts.TransformationContext;
+  transformer: ts.TransformationContext;
   extras: {
     addDiagnostic: (diag: ts.Diagnostic) => number;
   };

package/src/transformers/NodeTransformer.ts

@@ -1,11 +1,11 @@
 import ts from "typescript";
 
 import { CallExpressionTransformer } from "./CallExpressionTransformer";
-import { IProject } from "./IProject";
+import { ITypiaContext } from "./ITypiaContext";
 
 export namespace NodeTransformer {
   export const transform =
-    (project: IProject) =>
+    (project: ITypiaContext) =>
     (expression: ts.Node): ts.Node | null =>
       ts.isCallExpression(expression) && expression.parent
         ? CallExpressionTransformer.transform(project)(expression)

package/src/transformers/features/AssertTransformer.ts

@@ -1,16 +1,24 @@
 import { AssertProgrammer } from "../../programmers/AssertProgrammer";
 
+import { ITransformProps } from "../ITransformProps";
 import { GenericTransformer } from "../internal/GenericTransformer";
 
 export namespace AssertTransformer {
-  export const transform = (props: { equals: boolean; guard: boolean }) =>
-    GenericTransformer.scalar(
-      props.equals
-        ? props.guard
-          ? "assertGuardEquals"
-          : "assertEquals"
-        : props.guard
-          ? "assertGuard"
-          : "assert",
-    )((project) => (modulo) => AssertProgrammer.write(project)(modulo)(props));
+  export const transform =
+    (config: AssertProgrammer.IConfig) => (props: ITransformProps) =>
+      GenericTransformer.scalar({
+        ...props,
+        method: config.equals
+          ? config.guard
+            ? "assertGuardEquals"
+            : "assertEquals"
+          : config.guard
+            ? "assertGuard"
+            : "assert",
+        write: (x) =>
+          AssertProgrammer.write({
+            ...x,
+            config,
+          }),
+      });
 }

package/src/transformers/features/CreateAssertTransformer.ts

@@ -1,16 +1,24 @@
 import { AssertProgrammer } from "../../programmers/AssertProgrammer";
 
+import { ITransformProps } from "../ITransformProps";
 import { GenericTransformer } from "../internal/GenericTransformer";
 
 export namespace CreateAssertTransformer {
-  export const transform = (props: { equals: boolean; guard: boolean }) =>
-    GenericTransformer.factory(
-      props.equals
-        ? props.guard
-          ? "createAssertGuardEquals"
-          : "createAssertEquals"
-        : props.guard
-          ? "createAssertGuard"
-          : "createAssert",
-    )((project) => (modulo) => AssertProgrammer.write(project)(modulo)(props));
+  export const transform =
+    (config: AssertProgrammer.IConfig) => (props: ITransformProps) =>
+      GenericTransformer.factory({
+        ...props,
+        method: config.equals
+          ? config.guard
+            ? "assertGuardEquals"
+            : "assertEquals"
+          : config.guard
+            ? "assertGuard"
+            : "assert",
+        write: (x) =>
+          AssertProgrammer.write({
+            ...x,
+            config,
+          }),
+      });
 }

package/src/transformers/features/CreateIsTransformer.ts

@@ -1,10 +1,18 @@
 import { IsProgrammer } from "../../programmers/IsProgrammer";
 
+import { ITransformProps } from "../ITransformProps";
 import { GenericTransformer } from "../internal/GenericTransformer";
 
 export namespace CreateIsTransformer {
-  export const transform = (equals: boolean) =>
-    GenericTransformer.factory(equals ? "createEquals" : "createIs")(
-      (project) => (modulo) => IsProgrammer.write(project)(modulo)(equals),
-    );
+  export const transform =
+    (config: IsProgrammer.IConfig) => (props: ITransformProps) =>
+      GenericTransformer.factory({
+        ...props,
+        method: config.equals ? "equals" : "is",
+        write: (x) =>
+          IsProgrammer.write({
+            ...x,
+            config,
+          }),
+      });
 }

package/src/transformers/features/CreateRandomTransformer.ts

@@ -2,39 +2,42 @@ import ts from "typescript";
 
 import { RandomProgrammer } from "../../programmers/RandomProgrammer";
 
-import { IProject } from "../IProject";
+import { ITransformProps } from "../ITransformProps";
 import { TransformerError } from "../TransformerError";
 
 export namespace CreateRandomTransformer {
-  export const transform =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (expression: ts.CallExpression): ts.Expression => {
-      // CHECK GENERIC ARGUMENT EXISTENCE
-      if (!expression.typeArguments?.[0])
-        throw new TransformerError({
-          code: "typia.createRandom",
-          message: "generic argument is not specified.",
-        });
+  export const transform = (props: ITransformProps): ts.Expression => {
+    // CHECK GENERIC ARGUMENT EXISTENCE
+    if (!props.expression.typeArguments?.[0])
+      throw new TransformerError({
+        code: "typia.createRandom",
+        message: "generic argument is not specified.",
+      });
 
-      // GET TYPE INFO
-      const node: ts.TypeNode = expression.typeArguments[0];
-      const type: ts.Type = project.checker.getTypeFromTypeNode(node);
+    // GET TYPE INFO
+    const node: ts.TypeNode = props.expression.typeArguments[0];
+    const type: ts.Type = props.context.checker.getTypeFromTypeNode(node);
 
-      if (type.isTypeParameter())
-        throw new TransformerError({
-          code: "typia.createRandom",
-          message: "non-specified generic argument.",
-        });
+    if (type.isTypeParameter())
+      throw new TransformerError({
+        code: "typia.createRandom",
+        message: "non-specified generic argument.",
+      });
 
-      // DO TRANSFORM
-      return RandomProgrammer.write({
-        ...project,
+    // DO TRANSFORM
+    return RandomProgrammer.write({
+      context: {
+        ...props.context,
         options: {
-          ...project.options,
+          ...props.context.options,
           functional: false,
           numeric: false,
         },
-      })(modulo)(expression.arguments?.[0])(type, node.getFullText().trim());
-    };
+      },
+      modulo: props.modulo,
+      type,
+      name: node.getFullText().trim(),
+      init: props.expression.arguments?.[0],
+    });
+  };
 }

package/src/transformers/features/CreateValidateTransformer.ts

@@ -1,13 +1,18 @@
 import { ValidateProgrammer } from "../../programmers/ValidateProgrammer";
 
+import { ITransformProps } from "../ITransformProps";
 import { GenericTransformer } from "../internal/GenericTransformer";
 
 export namespace CreateValidateTransformer {
-  export const transform = (equals: boolean) =>
-    GenericTransformer.factory(
-      equals ? "createValidateEquals" : "createValidate",
-    )(
-      (project) => (modulo) =>
-        ValidateProgrammer.write(project)(modulo)(equals),
-    );
+  export const transform =
+    (config: ValidateProgrammer.IConfig) => (props: ITransformProps) =>
+      GenericTransformer.factory({
+        ...props,
+        method: config.equals ? "validateEquals" : "validate",
+        write: (x) =>
+          ValidateProgrammer.write({
+            ...x,
+            config,
+          }),
+      });
 }

package/src/transformers/features/IsTransformer.ts

@@ -1,10 +1,18 @@
 import { IsProgrammer } from "../../programmers/IsProgrammer";
 
+import { ITransformProps } from "../ITransformProps";
 import { GenericTransformer } from "../internal/GenericTransformer";
 
 export namespace IsTransformer {
-  export const transform = (equals: boolean) =>
-    GenericTransformer.scalar(equals ? "equals" : "is")(
-      (project) => (modulo) => IsProgrammer.write(project)(modulo)(equals),
-    );
+  export const transform =
+    (config: IsProgrammer.IConfig) => (props: ITransformProps) =>
+      GenericTransformer.scalar({
+        ...props,
+        method: config.equals ? "equals" : "is",
+        write: (x) =>
+          IsProgrammer.write({
+            ...x,
+            config,
+          }),
+      });
 }