@typia/transform 12.0.0-dev.20260225

package/src/features/misc/MiscIsPruneTransformer.ts

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

package/src/features/misc/MiscLiteralsTransformer.ts

@@ -0,0 +1,34 @@
+import { MiscLiteralsProgrammer } from "@typia/core";
+import ts from "typescript";
+
+import { ITransformProps } from "../../ITransformProps";
+import { TransformerError } from "../../TransformerError";
+
+export namespace MiscLiteralsTransformer {
+  export const transform = (
+    props: Omit<ITransformProps, "modulo">,
+  ): ts.Expression => {
+    // CHECK GENERIC ARGUMENT EXISTENCE
+    if (!props.expression.typeArguments?.[0])
+      throw new TransformerError({
+        code: "typia.misc.literals",
+        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.misc.literals",
+        message: "non-specified generic argument.",
+      });
+
+    // DO TRANSFORM
+    return MiscLiteralsProgrammer.write({
+      context: props.context,
+      type,
+    });
+  };
+}

package/src/features/misc/MiscPruneTransformer.ts

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

package/src/features/misc/MiscValidateCloneTransformer.ts

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

package/src/features/misc/MiscValidatePruneTransformer.ts

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

package/src/features/notations/NotationAssertGeneralTransformer.ts

@@ -0,0 +1,19 @@
+import { NotationAssertGeneralProgrammer } from "@typia/core";
+import { NamingConvention } from "@typia/utils";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace NotationAssertGeneralTransformer {
+  export const transform =
+    (rename: (str: string) => string) => (props: ITransformProps) =>
+      GenericTransformer.scalar({
+        ...props,
+        method: `notations.assert${NamingConvention.capitalize(rename.name)}`,
+        write: (x) =>
+          NotationAssertGeneralProgrammer.write({
+            ...x,
+            rename,
+          }),
+      });
+}

package/src/features/notations/NotationCreateAssertGeneralTransformer.ts

@@ -0,0 +1,19 @@
+import { NotationAssertGeneralProgrammer } from "@typia/core";
+import { NamingConvention } from "@typia/utils";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace NotationCreateAssertGeneralTransformer {
+  export const transform =
+    (rename: (str: string) => string) => (props: ITransformProps) =>
+      GenericTransformer.factory({
+        ...props,
+        method: `notations.createAssert${NamingConvention.capitalize(rename.name)}`,
+        write: (x) =>
+          NotationAssertGeneralProgrammer.write({
+            ...x,
+            rename,
+          }),
+      });
+}

package/src/features/notations/NotationCreateGeneralTransformer.ts

@@ -0,0 +1,19 @@
+import { NotationGeneralProgrammer } from "@typia/core";
+import { NamingConvention } from "@typia/utils";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace NotationCreateGeneralTransformer {
+  export const transform =
+    (rename: (str: string) => string) => (props: ITransformProps) =>
+      GenericTransformer.factory({
+        ...props,
+        method: `notations.create${NamingConvention.capitalize(rename.name)}`,
+        write: (x) =>
+          NotationGeneralProgrammer.write({
+            ...x,
+            rename,
+          }),
+      });
+}

package/src/features/notations/NotationCreateIsGeneralTransformer.ts

@@ -0,0 +1,19 @@
+import { NotationIsGeneralProgrammer } from "@typia/core";
+import { NamingConvention } from "@typia/utils";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace NotationCreateIsGeneralTransformer {
+  export const transform =
+    (rename: (str: string) => string) => (props: ITransformProps) =>
+      GenericTransformer.factory({
+        ...props,
+        method: `notations.createIs${NamingConvention.capitalize(rename.name)}`,
+        write: (x) =>
+          NotationIsGeneralProgrammer.write({
+            ...x,
+            rename,
+          }),
+      });
+}

package/src/features/notations/NotationCreateValidateGeneralTransformer.ts

@@ -0,0 +1,19 @@
+import { NotationValidateGeneralProgrammer } from "@typia/core";
+import { NamingConvention } from "@typia/utils";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace NotationCreateValidateGeneralTransformer {
+  export const transform =
+    (rename: (str: string) => string) => (props: ITransformProps) =>
+      GenericTransformer.factory({
+        ...props,
+        method: `notations.createValidate${NamingConvention.capitalize(rename.name)}`,
+        write: (x) =>
+          NotationValidateGeneralProgrammer.write({
+            ...x,
+            rename,
+          }),
+      });
+}

package/src/features/notations/NotationGeneralTransformer.ts

@@ -0,0 +1,18 @@
+import { NotationGeneralProgrammer } from "@typia/core";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace NotationGeneralTransformer {
+  export const transform =
+    (rename: (str: string) => string) => (props: ITransformProps) =>
+      GenericTransformer.scalar({
+        ...props,
+        method: `notations.${rename.name}`,
+        write: (x) =>
+          NotationGeneralProgrammer.write({
+            ...x,
+            rename,
+          }),
+      });
+}

package/src/features/notations/NotationIsGeneralTransformer.ts

@@ -0,0 +1,19 @@
+import { NotationIsGeneralProgrammer } from "@typia/core";
+import { NamingConvention } from "@typia/utils";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace NotationIsGeneralTransformer {
+  export const transform =
+    (rename: (str: string) => string) => (props: ITransformProps) =>
+      GenericTransformer.scalar({
+        ...props,
+        method: `notations.is${NamingConvention.capitalize(rename.name)}`,
+        write: (x) =>
+          NotationIsGeneralProgrammer.write({
+            ...x,
+            rename,
+          }),
+      });
+}

package/src/features/notations/NotationValidateGeneralTransformer.ts

@@ -0,0 +1,19 @@
+import { NotationValidateGeneralProgrammer } from "@typia/core";
+import { NamingConvention } from "@typia/utils";
+
+import { ITransformProps } from "../../ITransformProps";
+import { GenericTransformer } from "../../internal/GenericTransformer";
+
+export namespace NotationValidateGeneralTransformer {
+  export const transform =
+    (rename: (str: string) => string) => (props: ITransformProps) =>
+      GenericTransformer.scalar({
+        ...props,
+        method: `notations.validate${NamingConvention.capitalize(rename.name)}`,
+        write: (x) =>
+          NotationValidateGeneralProgrammer.write({
+            ...x,
+            rename,
+          }),
+      });
+}

package/src/features/protobuf/ProtobufAssertDecodeTransformer.ts

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

package/src/features/protobuf/ProtobufAssertEncodeTransformer.ts

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

package/src/features/protobuf/ProtobufCreateAssertDecodeTransformer.ts

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

package/src/features/protobuf/ProtobufCreateAssertEncodeTransformer.ts

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

package/src/features/protobuf/ProtobufCreateDecodeTransformer.ts

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

package/src/features/protobuf/ProtobufCreateEncodeTransformer.ts

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

package/src/features/protobuf/ProtobufCreateIsDecodeTransformer.ts

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

package/src/features/protobuf/ProtobufCreateIsEncodeTransformer.ts

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

package/src/features/protobuf/ProtobufCreateValidateDecodeTransformer.ts

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

package/src/features/protobuf/ProtobufCreateValidateEncodeTransformer.ts

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

package/src/features/protobuf/ProtobufDecodeTransformer.ts

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

package/src/features/protobuf/ProtobufEncodeTransformer.ts

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

package/src/features/protobuf/ProtobufIsDecodeTransformer.ts

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

package/src/features/protobuf/ProtobufIsEncodeTransformer.ts

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

package/src/features/protobuf/ProtobufMessageTransformer.ts

@@ -0,0 +1,34 @@
+import { ProtobufMessageProgrammer } from "@typia/core";
+import ts from "typescript";
+
+import { ITransformProps } from "../../ITransformProps";
+import { TransformerError } from "../../TransformerError";
+
+export namespace ProtobufMessageTransformer {
+  export const transform = (
+    props: Pick<ITransformProps, "context" | "expression">,
+  ): ts.Expression => {
+    // CHECK GENERIC ARGUMENT EXISTENCE
+    if (!props.expression.typeArguments || !props.expression.typeArguments[0])
+      throw new TransformerError({
+        code: "typia.protobuf.message",
+        message: "generic argument is not specified.",
+      });
+
+    // GET TYPE INFO
+    const type: ts.Type = props.context.checker.getTypeFromTypeNode(
+      props.expression.typeArguments[0],
+    );
+    if (type.isTypeParameter())
+      throw new TransformerError({
+        code: "tyipa.protobuf.message",
+        message: "non-specified generic argument.",
+      });
+
+    // DO TRANSFORM
+    return ProtobufMessageProgrammer.write({
+      context: props.context,
+      type,
+    });
+  };
+}

package/src/features/protobuf/ProtobufValidateDecodeTransformer.ts

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

package/src/features/protobuf/ProtobufValidateEncodeTransformer.ts

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

package/src/features/reflect/ReflectMetadataTransformer.ts

@@ -0,0 +1,69 @@
+import {
+  LiteralFactory,
+  MetadataFactory,
+  MetadataSchema,
+  MetadataStorage,
+} from "@typia/core";
+import { IMetadataSchemaCollection } from "@typia/interface";
+import ts from "typescript";
+
+import { ITransformProps } from "../../ITransformProps";
+import { TransformerError } from "../../TransformerError";
+
+export namespace ReflectMetadataTransformer {
+  export const transform = (
+    props: Pick<ITransformProps, "context" | "expression">,
+  ): ts.Expression => {
+    if (!props.expression.typeArguments?.length)
+      throw new TransformerError({
+        code: "typia.reflect.metadata",
+        message: "no generic argument.",
+      });
+
+    // 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) =>
+      props.context.checker.getTypeFromTypeNode(child as ts.TypeNode),
+    );
+    if (types.some((t) => t.isTypeParameter()))
+      throw new TransformerError({
+        code: "typia.reflect.metadata",
+        message: "non-specified generic argument(s).",
+      });
+
+    // METADATA
+    const components: MetadataStorage = new MetadataStorage();
+    const schemas: Array<MetadataSchema> = types.map((type) => {
+      const result = MetadataFactory.analyze({
+        checker: props.context.checker,
+        transformer: props.context.transformer,
+        options: {
+          escape: true,
+          constant: true,
+          absorb: true,
+          functional: true,
+        },
+        components: components,
+        type,
+      });
+      if (result.success === false)
+        throw TransformerError.from({
+          code: "typia.reflect.metadata",
+          errors: result.errors,
+        });
+      return result.data;
+    });
+
+    // CONVERT TO PRIMITIVE TYPE
+    const collection: IMetadataSchemaCollection = {
+      schemas: schemas.map((s) => s.toJSON()),
+      components: components.toJSON(),
+    };
+    return LiteralFactory.write(collection);
+  };
+}