@typia/transform 12.0.0-dev.20260309 → 12.0.0-dev.20260310

package/src/features/protobuf/ProtobufCreateAssertEncodeTransformer.ts

@@ -1,13 +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,
-    });
-}
+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

@@ -1,13 +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,
-    });
-}
+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

@@ -1,13 +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,
-    });
-}
+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

@@ -1,13 +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,
-    });
-}
+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

@@ -1,13 +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,
-    });
-}
+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

@@ -1,13 +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,
-    });
-}
+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

@@ -1,13 +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,
-    });
-}
+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

@@ -1,13 +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,
-    });
-}
+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

@@ -1,13 +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,
-    });
-}
+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

@@ -1,13 +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,
-    });
-}
+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

@@ -1,13 +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,
-    });
-}
+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

@@ -1,34 +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,
-    });
-  };
-}
+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

@@ -1,13 +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,
-    });
-}
+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

@@ -1,13 +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,
-    });
-}
+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

@@ -1,69 +1,69 @@
-import {
-  LiteralFactory,
-  MetadataCollection,
-  MetadataFactory,
-  MetadataSchema,
-} 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: MetadataCollection = new MetadataCollection();
-    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);
-  };
-}
+import {
+  LiteralFactory,
+  MetadataCollection,
+  MetadataFactory,
+  MetadataSchema,
+} 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: MetadataCollection = new MetadataCollection();
+    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);
+  };
+}