@typia/transform 12.0.0-dev.20260225

package/src/features/AssertTransformer.ts

@@ -0,0 +1,24 @@
+import { AssertProgrammer } from "@typia/core";
+
+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/features/CreateAssertTransformer.ts

@@ -0,0 +1,24 @@
+import { AssertProgrammer } from "@typia/core";
+
+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/features/CreateIsTransformer.ts

@@ -0,0 +1,18 @@
+import { IsProgrammer } from "@typia/core";
+
+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/features/CreateRandomTransformer.ts

@@ -0,0 +1,42 @@
+import { RandomProgrammer } from "@typia/core";
+import ts from "typescript";
+
+import { ITransformProps } from "../ITransformProps";
+import { TransformerError } from "../TransformerError";
+
+export namespace CreateRandomTransformer {
+  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 = 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.",
+      });
+
+    // DO TRANSFORM
+    return RandomProgrammer.write({
+      context: {
+        ...props.context,
+        options: {
+          ...props.context.options,
+          functional: false,
+          numeric: false,
+        },
+      },
+      modulo: props.modulo,
+      type,
+      name: node.getFullText().trim(),
+      init: props.expression.arguments?.[0],
+    });
+  };
+}

package/src/features/CreateValidateTransformer.ts

@@ -0,0 +1,18 @@
+import { ValidateProgrammer } from "@typia/core";
+
+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/features/IsTransformer.ts

@@ -0,0 +1,18 @@
+import { IsProgrammer } from "@typia/core";
+
+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/features/RandomTransformer.ts

@@ -0,0 +1,40 @@
+import { RandomProgrammer } from "@typia/core";
+import ts from "typescript";
+
+import { ITransformProps } from "../ITransformProps";
+import { TransformerError } from "../TransformerError";
+
+export namespace RandomTransformer {
+  export const transform = (props: ITransformProps): ts.Expression => {
+    // CHECK GENERIC ARGUMENT EXISTENCE
+    if (!props.expression.typeArguments?.[0])
+      throw new TransformerError({
+        code: `typia.${props.modulo.getText()}`,
+        message: "generic argument is not specified.",
+      });
+
+    // 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.${props.modulo.getText()}`,
+        message: "non-specified generic argument.",
+      });
+
+    return ts.factory.createCallExpression(
+      RandomProgrammer.write({
+        context: props.context,
+        modulo: props.modulo,
+        type,
+        name: node.getFullText().trim(),
+        init: undefined,
+      }),
+      undefined,
+      props.expression.arguments.length
+        ? [props.expression.arguments[0]!]
+        : undefined,
+    );
+  };
+}

package/src/features/ValidateTransformer.ts

@@ -0,0 +1,18 @@
+import { ValidateProgrammer } from "@typia/core";
+
+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/features/functional/FunctionalGenericTransformer.ts

@@ -0,0 +1,55 @@
+import { ITypiaContext, TypeFactory } from "@typia/core";
+import ts from "typescript";
+
+import { ITransformProps } from "../../ITransformProps";
+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/features/http/CreateHttpAssertFormDataTransformer.ts

@@ -0,0 +1,13 @@
+import { HttpAssertFormDataProgrammer } from "@typia/core";
+
+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/features/http/CreateHttpAssertHeadersTransformer.ts

@@ -0,0 +1,13 @@
+import { HttpAssertHeadersProgrammer } from "@typia/core";
+
+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/features/http/CreateHttpAssertQueryTransformer.ts

@@ -0,0 +1,13 @@
+import { HttpAssertQueryProgrammer } from "@typia/core";
+
+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/features/http/CreateHttpFormDataTransformer.ts

@@ -0,0 +1,13 @@
+import { HttpFormDataProgrammer } from "@typia/core";
+
+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/features/http/CreateHttpHeadersTransformer.ts

@@ -0,0 +1,13 @@
+import { HttpHeadersProgrammer } from "@typia/core";
+
+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,
+    });
+}

package/src/features/http/CreateHttpIsFormDataTransformer.ts

@@ -0,0 +1,13 @@
+import { HttpIsFormDataProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpIsFormDataTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "http.createIsFormData",
+      write: HttpIsFormDataProgrammer.write,
+    });
+}

package/src/features/http/CreateHttpIsHeadersTransformer.ts

@@ -0,0 +1,13 @@
+import { HttpIsHeadersProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpIsHeadersTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "http.createIsHeaders",
+      write: HttpIsHeadersProgrammer.write,
+    });
+}

package/src/features/http/CreateHttpIsQueryTransformer.ts

@@ -0,0 +1,13 @@
+import { HttpIsQueryProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpIsQueryTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "http.createIsQuery",
+      write: HttpIsQueryProgrammer.write,
+    });
+}

package/src/features/http/CreateHttpParameterTransformer.ts

@@ -0,0 +1,13 @@
+import { HttpParameterProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpParameterTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "http.createParameter",
+      write: HttpParameterProgrammer.write,
+    });
+}

package/src/features/http/CreateHttpQueryTransformer.ts

@@ -0,0 +1,13 @@
+import { HttpQueryProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpQueryTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "http.createQuery",
+      write: HttpQueryProgrammer.write,
+    });
+}

package/src/features/http/CreateHttpValidateFormDataTransformer.ts

@@ -0,0 +1,13 @@
+import { HttpValidateFormDataProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpValidateFormDataTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "http.createValidateFormData",
+      write: HttpValidateFormDataProgrammer.write,
+    });
+}

package/src/features/http/CreateHttpValidateHeadersTransformer.ts

@@ -0,0 +1,13 @@
+import { HttpValidateHeadersProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpValidateHeadersTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "http.createValidateHeaders",
+      write: HttpValidateHeadersProgrammer.write,
+    });
+}

package/src/features/http/CreateHttpValidateQueryTransformer.ts

@@ -0,0 +1,13 @@
+import { HttpValidateQueryProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace CreateHttpValidateQueryTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.factory({
+      ...props,
+      method: "http.createValidateQuery",
+      write: HttpValidateQueryProgrammer.write,
+    });
+}

package/src/features/http/HttpAssertFormDataTransformer.ts

@@ -0,0 +1,13 @@
+import { HttpAssertFormDataProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace HttpAssertFormDataTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "http.assertFormData",
+      write: HttpAssertFormDataProgrammer.write,
+    });
+}

package/src/features/http/HttpAssertHeadersTransformer.ts

@@ -0,0 +1,13 @@
+import { HttpAssertHeadersProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace HttpAssertHeadersTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "http.assertHeaders",
+      write: HttpAssertHeadersProgrammer.write,
+    });
+}

package/src/features/http/HttpAssertQueryTransformer.ts

@@ -0,0 +1,13 @@
+import { HttpAssertQueryProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace HttpAssertQueryTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "http.assertQuery",
+      write: HttpAssertQueryProgrammer.write,
+    });
+}

package/src/features/http/HttpFormDataTransformer.ts

@@ -0,0 +1,13 @@
+import { HttpFormDataProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace HttpFormDataTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "http.formdata",
+      write: HttpFormDataProgrammer.write,
+    });
+}

package/src/features/http/HttpHeadersTransformer.ts

@@ -0,0 +1,13 @@
+import { HttpHeadersProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace HttpHeadersTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "http.headers",
+      write: HttpHeadersProgrammer.write,
+    });
+}

package/src/features/http/HttpIsFormDataTransformer.ts

@@ -0,0 +1,13 @@
+import { HttpIsFormDataProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace HttpIsFormDataTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "http.isFormData",
+      write: HttpIsFormDataProgrammer.write,
+    });
+}

package/src/features/http/HttpIsHeadersTransformer.ts

@@ -0,0 +1,13 @@
+import { HttpIsHeadersProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace HttpIsHeadersTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "http.isHeaders",
+      write: HttpIsHeadersProgrammer.write,
+    });
+}

package/src/features/http/HttpIsQueryTransformer.ts

@@ -0,0 +1,13 @@
+import { HttpIsQueryProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace HttpIsQueryTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "http.isQuery",
+      write: HttpIsQueryProgrammer.write,
+    });
+}

package/src/features/http/HttpParameterTransformer.ts

@@ -0,0 +1,13 @@
+import { HttpParameterProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace HttpParameterTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "http.parameter",
+      write: HttpParameterProgrammer.write,
+    });
+}

package/src/features/http/HttpQueryTransformer.ts

@@ -0,0 +1,13 @@
+import { HttpQueryProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace HttpQueryTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "http.query",
+      write: HttpQueryProgrammer.write,
+    });
+}

package/src/features/http/HttpValidateFormDataTransformer.ts

@@ -0,0 +1,13 @@
+import { HttpValidateFormDataProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace HttpValidateFormDataTransformer {
+  export const transform = (props: ITransformProps) =>
+    GenericTransformer.scalar({
+      ...props,
+      method: "http.validateFormData",
+      write: HttpValidateFormDataProgrammer.write,
+    });
+}

package/src/features/http/HttpValidateHeadersTransformer.ts

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

package/src/features/http/HttpValidateQueryTransformer.ts

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