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

package/src/features/misc/MiscCreateValidatePruneTransformer.ts

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

package/src/features/misc/MiscIsCloneTransformer.ts

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

package/src/features/misc/MiscIsPruneTransformer.ts

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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