typia 6.6.2 → 6.7.0-dev.20240802

package/src/transformers/features/CreateAssertTransformer.ts

@@ -1,16 +1,16 @@
-import { AssertProgrammer } from "../../programmers/AssertProgrammer";
-
-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));
-}
+import { AssertProgrammer } from "../../programmers/AssertProgrammer";
+
+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));
+}

package/src/transformers/features/CreateIsTransformer.ts

@@ -1,10 +1,10 @@
-import { IsProgrammer } from "../../programmers/IsProgrammer";
-
-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),
-    );
-}
+import { IsProgrammer } from "../../programmers/IsProgrammer";
+
+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),
+    );
+}

package/src/transformers/features/CreateRandomTransformer.ts

@@ -1,40 +1,40 @@
-import ts from "typescript";
-
-import { RandomProgrammer } from "../../programmers/RandomProgrammer";
-
-import { IProject } from "../IProject";
-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.",
-        });
-
-      // GET TYPE INFO
-      const node: ts.TypeNode = expression.typeArguments[0];
-      const type: ts.Type = project.checker.getTypeFromTypeNode(node);
-
-      if (type.isTypeParameter())
-        throw new TransformerError({
-          code: "typia.createRandom",
-          message: "non-specified generic argument.",
-        });
-
-      // DO TRANSFORM
-      return RandomProgrammer.write({
-        ...project,
-        options: {
-          ...project.options,
-          functional: false,
-          numeric: false,
-        },
-      })(modulo)(expression.arguments?.[0])(type, node.getFullText().trim());
-    };
-}
+import ts from "typescript";
+
+import { RandomProgrammer } from "../../programmers/RandomProgrammer";
+
+import { IProject } from "../IProject";
+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.",
+        });
+
+      // GET TYPE INFO
+      const node: ts.TypeNode = expression.typeArguments[0];
+      const type: ts.Type = project.checker.getTypeFromTypeNode(node);
+
+      if (type.isTypeParameter())
+        throw new TransformerError({
+          code: "typia.createRandom",
+          message: "non-specified generic argument.",
+        });
+
+      // DO TRANSFORM
+      return RandomProgrammer.write({
+        ...project,
+        options: {
+          ...project.options,
+          functional: false,
+          numeric: false,
+        },
+      })(modulo)(expression.arguments?.[0])(type, node.getFullText().trim());
+    };
+}

package/src/transformers/features/CreateValidateTransformer.ts

@@ -1,13 +1,13 @@
-import { ValidateProgrammer } from "../../programmers/ValidateProgrammer";
-
-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),
-    );
-}
+import { ValidateProgrammer } from "../../programmers/ValidateProgrammer";
+
+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),
+    );
+}

package/src/transformers/features/IsTransformer.ts

@@ -1,10 +1,10 @@
-import { IsProgrammer } from "../../programmers/IsProgrammer";
-
-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),
-    );
-}
+import { IsProgrammer } from "../../programmers/IsProgrammer";
+
+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),
+    );
+}

package/src/transformers/features/RandomTransformer.ts

@@ -1,44 +1,44 @@
-import ts from "typescript";
-
-import { RandomProgrammer } from "../../programmers/RandomProgrammer";
-
-import { IProject } from "../IProject";
-import { TransformerError } from "../TransformerError";
-
-export namespace RandomTransformer {
-  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.${modulo.getText()}`,
-          message: "generic argument is not specified.",
-        });
-
-      // GET TYPE INFO
-      const node: ts.TypeNode = expression.typeArguments[0];
-      const type: ts.Type = project.checker.getTypeFromTypeNode(node);
-
-      if (type.isTypeParameter())
-        throw new TransformerError({
-          code: `typia.${modulo.getText()}`,
-          message: "non-specified generic argument.",
-        });
-
-      // DO TRANSFORM
-      return ts.factory.createCallExpression(
-        RandomProgrammer.write({
-          ...project,
-          options: {
-            ...project.options,
-            functional: false,
-            numeric: false,
-          },
-        })(modulo)()(type, node.getFullText().trim()),
-        undefined,
-        expression.arguments.length ? [expression.arguments[0]!] : undefined,
-      );
-    };
-}
+import ts from "typescript";
+
+import { RandomProgrammer } from "../../programmers/RandomProgrammer";
+
+import { IProject } from "../IProject";
+import { TransformerError } from "../TransformerError";
+
+export namespace RandomTransformer {
+  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.${modulo.getText()}`,
+          message: "generic argument is not specified.",
+        });
+
+      // GET TYPE INFO
+      const node: ts.TypeNode = expression.typeArguments[0];
+      const type: ts.Type = project.checker.getTypeFromTypeNode(node);
+
+      if (type.isTypeParameter())
+        throw new TransformerError({
+          code: `typia.${modulo.getText()}`,
+          message: "non-specified generic argument.",
+        });
+
+      // DO TRANSFORM
+      return ts.factory.createCallExpression(
+        RandomProgrammer.write({
+          ...project,
+          options: {
+            ...project.options,
+            functional: false,
+            numeric: false,
+          },
+        })(modulo)()(type, node.getFullText().trim()),
+        undefined,
+        expression.arguments.length ? [expression.arguments[0]!] : undefined,
+      );
+    };
+}

package/src/transformers/features/ValidateTransformer.ts

@@ -1,11 +1,11 @@
-import { ValidateProgrammer } from "../../programmers/ValidateProgrammer";
-
-import { GenericTransformer } from "../internal/GenericTransformer";
-
-export namespace ValidateTransformer {
-  export const transform = (equals: boolean) =>
-    GenericTransformer.scalar(equals ? "validateEquals" : "validate")(
-      (project) => (modulo) =>
-        ValidateProgrammer.write(project)(modulo)(equals),
-    );
-}
+import { ValidateProgrammer } from "../../programmers/ValidateProgrammer";
+
+import { GenericTransformer } from "../internal/GenericTransformer";
+
+export namespace ValidateTransformer {
+  export const transform = (equals: boolean) =>
+    GenericTransformer.scalar(equals ? "validateEquals" : "validate")(
+      (project) => (modulo) =>
+        ValidateProgrammer.write(project)(modulo)(equals),
+    );
+}

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

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

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

@@ -1,12 +1,12 @@
-import { HttpAssertFormDataProgrammer } from "../../../programmers/http/HttpAssertFormDataProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateHttpAssertFormDataTransformer {
-  export const transform = GenericTransformer.factory(
-    "http.createAssertFormData",
-  )(
-    (project) => (modulo) =>
-      HttpAssertFormDataProgrammer.write(project)(modulo),
-  );
-}
+import { HttpAssertFormDataProgrammer } from "../../../programmers/http/HttpAssertFormDataProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpAssertFormDataTransformer {
+  export const transform = GenericTransformer.factory(
+    "http.createAssertFormData",
+  )(
+    (project) => (modulo) =>
+      HttpAssertFormDataProgrammer.write(project)(modulo),
+  );
+}

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

@@ -1,11 +1,11 @@
-import { HttpAssertHeadersProgrammer } from "../../../programmers/http/HttpAssertHeadersProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateHttpAssertHeadersTransformer {
-  export const transform = GenericTransformer.factory(
-    "http.createAssertHeaders",
-  )(
-    (project) => (modulo) => HttpAssertHeadersProgrammer.write(project)(modulo),
-  );
-}
+import { HttpAssertHeadersProgrammer } from "../../../programmers/http/HttpAssertHeadersProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpAssertHeadersTransformer {
+  export const transform = GenericTransformer.factory(
+    "http.createAssertHeaders",
+  )(
+    (project) => (modulo) => HttpAssertHeadersProgrammer.write(project)(modulo),
+  );
+}

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

@@ -1,9 +1,9 @@
-import { HttpAssertQueryProgrammer } from "../../../programmers/http/HttpAssertQueryProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateHttpAssertQueryTransformer {
-  export const transform = GenericTransformer.factory("http.createAssertQuery")(
-    (project) => (modulo) => HttpAssertQueryProgrammer.write(project)(modulo),
-  );
-}
+import { HttpAssertQueryProgrammer } from "../../../programmers/http/HttpAssertQueryProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpAssertQueryTransformer {
+  export const transform = GenericTransformer.factory("http.createAssertQuery")(
+    (project) => (modulo) => HttpAssertQueryProgrammer.write(project)(modulo),
+  );
+}

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

@@ -1,9 +1,9 @@
-import { HttpFormDataProgrammer } from "../../../programmers/http/HttpFormDataProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateHttpFormDataTransformer {
-  export const transform = GenericTransformer.factory("http.createFormData")(
-    (project) => (modulo) => HttpFormDataProgrammer.write(project)(modulo),
-  );
-}
+import { HttpFormDataProgrammer } from "../../../programmers/http/HttpFormDataProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpFormDataTransformer {
+  export const transform = GenericTransformer.factory("http.createFormData")(
+    (project) => (modulo) => HttpFormDataProgrammer.write(project)(modulo),
+  );
+}

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

@@ -1,9 +1,9 @@
-import { HttpHeadersProgrammer } from "../../../programmers/http/HttpHeadersProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateHttpHeadersTransformer {
-  export const transform = GenericTransformer.factory("http.createHeaders")(
-    (project) => (modulo) => HttpHeadersProgrammer.write(project)(modulo),
-  );
-}
+import { HttpHeadersProgrammer } from "../../../programmers/http/HttpHeadersProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpHeadersTransformer {
+  export const transform = GenericTransformer.factory("http.createHeaders")(
+    (project) => (modulo) => HttpHeadersProgrammer.write(project)(modulo),
+  );
+}

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

@@ -1,9 +1,9 @@
-import { HttpIsFormDataProgrammer } from "../../../programmers/http/HttpIsFormDataProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateHttpIsFormDataTransformer {
-  export const transform = GenericTransformer.factory("http.createIsFormData")(
-    (project) => (modulo) => HttpIsFormDataProgrammer.write(project)(modulo),
-  );
-}
+import { HttpIsFormDataProgrammer } from "../../../programmers/http/HttpIsFormDataProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpIsFormDataTransformer {
+  export const transform = GenericTransformer.factory("http.createIsFormData")(
+    (project) => (modulo) => HttpIsFormDataProgrammer.write(project)(modulo),
+  );
+}

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

@@ -1,9 +1,9 @@
-import { HttpIsHeadersProgrammer } from "../../../programmers/http/HttpIsHeadersProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateHttpIsHeadersTransformer {
-  export const transform = GenericTransformer.factory("http.createIsHeaders")(
-    (project) => (modulo) => HttpIsHeadersProgrammer.write(project)(modulo),
-  );
-}
+import { HttpIsHeadersProgrammer } from "../../../programmers/http/HttpIsHeadersProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpIsHeadersTransformer {
+  export const transform = GenericTransformer.factory("http.createIsHeaders")(
+    (project) => (modulo) => HttpIsHeadersProgrammer.write(project)(modulo),
+  );
+}

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

@@ -1,9 +1,9 @@
-import { HttpIsQueryProgrammer } from "../../../programmers/http/HttpIsQueryProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateHttpIsQueryTransformer {
-  export const transform = GenericTransformer.factory("http.createIsQuery")(
-    (project) => (modulo) => HttpIsQueryProgrammer.write(project)(modulo),
-  );
-}
+import { HttpIsQueryProgrammer } from "../../../programmers/http/HttpIsQueryProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpIsQueryTransformer {
+  export const transform = GenericTransformer.factory("http.createIsQuery")(
+    (project) => (modulo) => HttpIsQueryProgrammer.write(project)(modulo),
+  );
+}

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

@@ -1,9 +1,9 @@
-import { HttpParameterProgrammer } from "../../../programmers/http/HttpParameterProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateHttpParameterTransformer {
-  export const transform = GenericTransformer.factory("http.createParameter")(
-    (project) => (modulo) => HttpParameterProgrammer.write(project)(modulo),
-  );
-}
+import { HttpParameterProgrammer } from "../../../programmers/http/HttpParameterProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpParameterTransformer {
+  export const transform = GenericTransformer.factory("http.createParameter")(
+    (project) => (modulo) => HttpParameterProgrammer.write(project)(modulo),
+  );
+}

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

@@ -1,9 +1,9 @@
-import { HttpQueryProgrammer } from "../../../programmers/http/HttpQueryProgrammer";
-
-import { GenericTransformer } from "../../internal/GenericTransformer";
-
-export namespace CreateHttpQueryTransformer {
-  export const transform = GenericTransformer.factory("http.createQuery")(
-    (project) => (modulo) => HttpQueryProgrammer.write(project)(modulo),
-  );
-}
+import { HttpQueryProgrammer } from "../../../programmers/http/HttpQueryProgrammer";
+
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpQueryTransformer {
+  export const transform = GenericTransformer.factory("http.createQuery")(
+    (project) => (modulo) => HttpQueryProgrammer.write(project)(modulo),
+  );
+}