typia 7.0.0-dev.20240916 → 7.0.0-dev.20240919

package/src/transform.ts

@@ -1,35 +1,35 @@
-import ts from "typescript";
-
-import { FileTransformer } from "./transformers/FileTransformer";
-import { ITransformOptions } from "./transformers/ITransformOptions";
-import { ITypiaContext } from "./transformers/ITypiaContext";
-
-export const transform = (
-  program: ts.Program,
-  options: ITransformOptions | undefined,
-  extras: ITypiaContext["extras"],
-): ts.TransformerFactory<ts.SourceFile> => {
-  const compilerOptions: ts.CompilerOptions = program.getCompilerOptions();
-  const strict: boolean =
-    compilerOptions.strictNullChecks !== undefined
-      ? !!compilerOptions.strictNullChecks
-      : !!compilerOptions.strict;
-  if (strict === false)
-    extras.addDiagnostic({
-      category: ts.DiagnosticCategory.Error,
-      code: "(typia)" as any,
-      file: undefined,
-      start: undefined,
-      length: undefined,
-      messageText: "strict mode is required.",
-    });
-  return FileTransformer.transform({
-    program,
-    compilerOptions,
-    checker: program.getTypeChecker(),
-    printer: ts.createPrinter(),
-    options: options ?? {},
-    extras,
-  });
-};
-export default transform;
+import ts from "typescript";
+
+import { FileTransformer } from "./transformers/FileTransformer";
+import { ITransformOptions } from "./transformers/ITransformOptions";
+import { ITypiaContext } from "./transformers/ITypiaContext";
+
+export const transform = (
+  program: ts.Program,
+  options: ITransformOptions | undefined,
+  extras: ITypiaContext["extras"],
+): ts.TransformerFactory<ts.SourceFile> => {
+  const compilerOptions: ts.CompilerOptions = program.getCompilerOptions();
+  const strict: boolean =
+    compilerOptions.strictNullChecks !== undefined
+      ? !!compilerOptions.strictNullChecks
+      : !!compilerOptions.strict;
+  if (strict === false)
+    extras.addDiagnostic({
+      category: ts.DiagnosticCategory.Error,
+      code: "(typia)" as any,
+      file: undefined,
+      start: undefined,
+      length: undefined,
+      messageText: "strict mode is required.",
+    });
+  return FileTransformer.transform({
+    program,
+    compilerOptions,
+    checker: program.getTypeChecker(),
+    printer: ts.createPrinter(),
+    options: options ?? {},
+    extras,
+  });
+};
+export default transform;

package/src/transformers/ITypiaContext.ts

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

package/src/transformers/NodeTransformer.ts

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

package/src/transformers/features/AssertTransformer.ts

@@ -1,24 +1,24 @@
-import { AssertProgrammer } from "../../programmers/AssertProgrammer";
-
-import { ITransformProps } from "../ITransformProps";
-import { GenericTransformer } from "../internal/GenericTransformer";
-
-export namespace AssertTransformer {
-  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,
-          }),
-      });
-}
+import { AssertProgrammer } from "../../programmers/AssertProgrammer";
+
+import { ITransformProps } from "../ITransformProps";
+import { GenericTransformer } from "../internal/GenericTransformer";
+
+export namespace AssertTransformer {
+  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,24 +1,24 @@
-import { AssertProgrammer } from "../../programmers/AssertProgrammer";
-
-import { ITransformProps } from "../ITransformProps";
-import { GenericTransformer } from "../internal/GenericTransformer";
-
-export namespace CreateAssertTransformer {
-  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,
-          }),
-      });
-}
+import { AssertProgrammer } from "../../programmers/AssertProgrammer";
+
+import { ITransformProps } from "../ITransformProps";
+import { GenericTransformer } from "../internal/GenericTransformer";
+
+export namespace CreateAssertTransformer {
+  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,18 +1,18 @@
-import { IsProgrammer } from "../../programmers/IsProgrammer";
-
-import { ITransformProps } from "../ITransformProps";
-import { GenericTransformer } from "../internal/GenericTransformer";
-
-export namespace CreateIsTransformer {
-  export const transform =
-    (config: IsProgrammer.IConfig) => (props: ITransformProps) =>
-      GenericTransformer.factory({
-        ...props,
-        method: config.equals ? "equals" : "is",
-        write: (x) =>
-          IsProgrammer.write({
-            ...x,
-            config,
-          }),
-      });
-}
+import { IsProgrammer } from "../../programmers/IsProgrammer";
+
+import { ITransformProps } from "../ITransformProps";
+import { GenericTransformer } from "../internal/GenericTransformer";
+
+export namespace CreateIsTransformer {
+  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/CreateValidateTransformer.ts

@@ -1,18 +1,18 @@
-import { ValidateProgrammer } from "../../programmers/ValidateProgrammer";
-
-import { ITransformProps } from "../ITransformProps";
-import { GenericTransformer } from "../internal/GenericTransformer";
-
-export namespace CreateValidateTransformer {
-  export const transform =
-    (config: ValidateProgrammer.IConfig) => (props: ITransformProps) =>
-      GenericTransformer.factory({
-        ...props,
-        method: config.equals ? "validateEquals" : "validate",
-        write: (x) =>
-          ValidateProgrammer.write({
-            ...x,
-            config,
-          }),
-      });
-}
+import { ValidateProgrammer } from "../../programmers/ValidateProgrammer";
+
+import { ITransformProps } from "../ITransformProps";
+import { GenericTransformer } from "../internal/GenericTransformer";
+
+export namespace CreateValidateTransformer {
+  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,18 +1,18 @@
-import { IsProgrammer } from "../../programmers/IsProgrammer";
-
-import { ITransformProps } from "../ITransformProps";
-import { GenericTransformer } from "../internal/GenericTransformer";
-
-export namespace IsTransformer {
-  export const transform =
-    (config: IsProgrammer.IConfig) => (props: ITransformProps) =>
-      GenericTransformer.scalar({
-        ...props,
-        method: config.equals ? "equals" : "is",
-        write: (x) =>
-          IsProgrammer.write({
-            ...x,
-            config,
-          }),
-      });
-}
+import { IsProgrammer } from "../../programmers/IsProgrammer";
+
+import { ITransformProps } from "../ITransformProps";
+import { GenericTransformer } from "../internal/GenericTransformer";
+
+export namespace IsTransformer {
+  export const transform =
+    (config: IsProgrammer.IConfig) => (props: ITransformProps) =>
+      GenericTransformer.scalar({
+        ...props,
+        method: config.equals ? "equals" : "is",
+        write: (x) =>
+          IsProgrammer.write({
+            ...x,
+            config,
+          }),
+      });
+}

package/src/transformers/features/ValidateTransformer.ts

@@ -1,18 +1,18 @@
-import { ValidateProgrammer } from "../../programmers/ValidateProgrammer";
-
-import { ITransformProps } from "../ITransformProps";
-import { GenericTransformer } from "../internal/GenericTransformer";
-
-export namespace ValidateTransformer {
-  export const transform =
-    (config: ValidateProgrammer.IConfig) => (props: ITransformProps) =>
-      GenericTransformer.scalar({
-        ...props,
-        method: config.equals ? "validateEquals" : "validate",
-        write: (x) =>
-          ValidateProgrammer.write({
-            ...x,
-            config,
-          }),
-      });
-}
+import { ValidateProgrammer } from "../../programmers/ValidateProgrammer";
+
+import { ITransformProps } from "../ITransformProps";
+import { GenericTransformer } from "../internal/GenericTransformer";
+
+export namespace ValidateTransformer {
+  export const transform =
+    (config: ValidateProgrammer.IConfig) => (props: ITransformProps) =>
+      GenericTransformer.scalar({
+        ...props,
+        method: config.equals ? "validateEquals" : "validate",
+        write: (x) =>
+          ValidateProgrammer.write({
+            ...x,
+            config,
+          }),
+      });
+}

package/src/transformers/features/functional/FunctionalGenericTransformer.ts

@@ -1,57 +1,57 @@
-import ts from "typescript";
-
-import { TypeFactory } from "../../../factories/TypeFactory";
-
-import { ITransformProps } from "../../ITransformProps";
-import { ITypiaContext } from "../../ITypiaContext";
-import { TransformerError } from "../../TransformerError";
-
-export namespace FunctionalGenericTransformer {
-  export interface IConfig {
-    equals: boolean;
-  }
-  export interface ISpecification {
-    method: string;
-    config: IConfig;
-    programmer: (p: {
-      context: ITypiaContext;
-      modulo: ts.LeftHandSideExpression;
-      expression: ts.Expression;
-      declaration: ts.FunctionDeclaration;
-      config: IConfig;
-      init?: ts.Expression;
-    }) => ts.Expression;
-  }
-  export const transform =
-    (spec: ISpecification) =>
-    (props: ITransformProps): ts.Expression => {
-      // CHECK PARAMETER
-      if (props.expression.arguments.length === 0)
-        throw new TransformerError({
-          code: `typia.functional.${spec.method}`,
-          message: `no input value.`,
-        });
-
-      // GET TYPE INFO
-      const type: ts.Type =
-        props.expression.typeArguments && props.expression.typeArguments[0]
-          ? props.context.checker.getTypeFromTypeNode(
-              props.expression.typeArguments[0],
-            )
-          : props.context.checker.getTypeAtLocation(
-              props.expression.arguments[0]!,
-            );
-      if (TypeFactory.isFunction(type) === false)
-        throw new TransformerError({
-          code: `typia.functional.${spec.method}`,
-          message: `input value is not a function.`,
-        });
-      return spec.programmer({
-        ...props,
-        config: spec.config,
-        expression: props.expression.arguments[0] as ts.Expression,
-        declaration: type.symbol!.declarations![0] as ts.FunctionDeclaration,
-        init: props.expression.arguments[1],
-      });
-    };
-}
+import ts from "typescript";
+
+import { TypeFactory } from "../../../factories/TypeFactory";
+
+import { ITransformProps } from "../../ITransformProps";
+import { ITypiaContext } from "../../ITypiaContext";
+import { TransformerError } from "../../TransformerError";
+
+export namespace FunctionalGenericTransformer {
+  export interface IConfig {
+    equals: boolean;
+  }
+  export interface ISpecification {
+    method: string;
+    config: IConfig;
+    programmer: (p: {
+      context: ITypiaContext;
+      modulo: ts.LeftHandSideExpression;
+      expression: ts.Expression;
+      declaration: ts.FunctionDeclaration;
+      config: IConfig;
+      init?: ts.Expression;
+    }) => ts.Expression;
+  }
+  export const transform =
+    (spec: ISpecification) =>
+    (props: ITransformProps): ts.Expression => {
+      // CHECK PARAMETER
+      if (props.expression.arguments.length === 0)
+        throw new TransformerError({
+          code: `typia.functional.${spec.method}`,
+          message: `no input value.`,
+        });
+
+      // GET TYPE INFO
+      const type: ts.Type =
+        props.expression.typeArguments && props.expression.typeArguments[0]
+          ? props.context.checker.getTypeFromTypeNode(
+              props.expression.typeArguments[0],
+            )
+          : props.context.checker.getTypeAtLocation(
+              props.expression.arguments[0]!,
+            );
+      if (TypeFactory.isFunction(type) === false)
+        throw new TransformerError({
+          code: `typia.functional.${spec.method}`,
+          message: `input value is not a function.`,
+        });
+      return spec.programmer({
+        ...props,
+        config: spec.config,
+        expression: props.expression.arguments[0] as ts.Expression,
+        declaration: type.symbol!.declarations![0] as ts.FunctionDeclaration,
+        init: props.expression.arguments[1],
+      });
+    };
+}

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

@@ -1,13 +1,13 @@
-import { HttpAssertFormDataProgrammer } from "../../../programmers/http/HttpAssertFormDataProgrammer";
-
-import { ITransformProps } from "../../ITransformProps";
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateHttpAssertFormDataTransformer {
-  export const transform = (props: ITransformProps) =>
-    GenericTransformer.factory({
-      ...props,
-      method: "http.createAssertFormData",
-      write: HttpAssertFormDataProgrammer.write,
-    });
-}
+import { HttpAssertFormDataProgrammer } from "../../../programmers/http/HttpAssertFormDataProgrammer";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpAssertFormDataTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "http.createAssertFormData",
+      write: HttpAssertFormDataProgrammer.write,
+    });
+}

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

@@ -1,13 +1,13 @@
-import { HttpAssertHeadersProgrammer } from "../../../programmers/http/HttpAssertHeadersProgrammer";
-
-import { ITransformProps } from "../../ITransformProps";
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateHttpAssertHeadersTransformer {
-  export const transform = (props: ITransformProps) =>
-    GenericTransformer.factory({
-      ...props,
-      method: "http.createAssertHeaders",
-      write: HttpAssertHeadersProgrammer.write,
-    });
-}
+import { HttpAssertHeadersProgrammer } from "../../../programmers/http/HttpAssertHeadersProgrammer";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpAssertHeadersTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "http.createAssertHeaders",
+      write: HttpAssertHeadersProgrammer.write,
+    });
+}

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

@@ -1,13 +1,13 @@
-import { HttpAssertQueryProgrammer } from "../../../programmers/http/HttpAssertQueryProgrammer";
-
-import { ITransformProps } from "../../ITransformProps";
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateHttpAssertQueryTransformer {
-  export const transform = (props: ITransformProps) =>
-    GenericTransformer.factory({
-      ...props,
-      method: "http.createAssertQuery",
-      write: HttpAssertQueryProgrammer.write,
-    });
-}
+import { HttpAssertQueryProgrammer } from "../../../programmers/http/HttpAssertQueryProgrammer";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpAssertQueryTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "http.createAssertQuery",
+      write: HttpAssertQueryProgrammer.write,
+    });
+}

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

@@ -1,13 +1,13 @@
-import { HttpFormDataProgrammer } from "../../../programmers/http/HttpFormDataProgrammer";
-
-import { ITransformProps } from "../../ITransformProps";
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateHttpFormDataTransformer {
-  export const transform = (props: ITransformProps) =>
-    GenericTransformer.factory({
-      ...props,
-      method: "http.createFormData",
-      write: HttpFormDataProgrammer.write,
-    });
-}
+import { HttpFormDataProgrammer } from "../../../programmers/http/HttpFormDataProgrammer";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpFormDataTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "http.createFormData",
+      write: HttpFormDataProgrammer.write,
+    });
+}

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

@@ -1,13 +1,13 @@
-import { HttpHeadersProgrammer } from "../../../programmers/http/HttpHeadersProgrammer";
-
-import { ITransformProps } from "../../ITransformProps";
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateHttpHeadersTransformer {
-  export const transform = (props: ITransformProps) =>
-    GenericTransformer.factory({
-      ...props,
-      method: "http.createHeaders",
-      write: HttpHeadersProgrammer.write,
-    });
-}
+import { HttpHeadersProgrammer } from "../../../programmers/http/HttpHeadersProgrammer";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpHeadersTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "http.createHeaders",
+      write: HttpHeadersProgrammer.write,
+    });
+}