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

package/src/features/llm/LlmParseTransformer.ts

@@ -1,95 +1,95 @@
-import {
-  LlmMetadataFactory,
-  LlmParseProgrammer,
-  MetadataCollection,
-  MetadataFactory,
-  MetadataSchema,
-} from "@typia/core";
-import { ILlmSchema, ValidationPipe } from "@typia/interface";
-import ts from "typescript";
-
-import { ITransformProps } from "../../ITransformProps";
-import { TransformerError } from "../../TransformerError";
-
-export namespace LlmParseTransformer {
-  export const transform = (props: ITransformProps): ts.Expression => {
-    // CHECK PARAMETER
-    if (props.expression.arguments.length === 0)
-      throw new TransformerError({
-        code: "typia.llm.parse",
-        message: "no input value.",
-      });
-
-    // GET GENERIC ARGUMENT
-    if (!props.expression.typeArguments?.length)
-      throw new TransformerError({
-        code: "typia.llm.parse",
-        message: "no generic argument.",
-      });
-
-    const top: ts.Node = props.expression.typeArguments[0]!;
-    if (ts.isTypeNode(top) === false) return props.expression;
-
-    // GET TYPE AND CONFIG
-    const config: Partial<ILlmSchema.IConfig> = LlmMetadataFactory.getConfig({
-      context: props.context,
-      method: "parse",
-      node: props.expression.typeArguments[1],
-    }) as Partial<ILlmSchema.IConfig>;
-
-    const type: ts.Type = props.context.checker.getTypeFromTypeNode(top);
-
-    if (type.isTypeParameter())
-      throw new TransformerError({
-        code: "typia.llm.parse",
-        message: "non-specified generic argument.",
-      });
-
-    // VALIDATE TYPE
-    const analyze = (validate: boolean): MetadataSchema => {
-      const result: ValidationPipe<MetadataSchema, MetadataFactory.IError> =
-        MetadataFactory.analyze({
-          checker: props.context.checker,
-          transformer: props.context.transformer,
-          options: {
-            absorb: validate,
-            escape: true,
-            constant: true,
-            validate:
-              validate === true
-                ? (metadata, explore) =>
-                    LlmParseProgrammer.validate({
-                      config,
-                      metadata,
-                      explore,
-                    })
-                : undefined,
-          },
-          components: new MetadataCollection({
-            replace: MetadataCollection.replace,
-          }),
-          type,
-        });
-      if (result.success === false)
-        throw TransformerError.from({
-          code: "typia.llm.parse",
-          errors: result.errors,
-        });
-      return result.data;
-    };
-    analyze(true);
-
-    // GENERATE CODE
-    return ts.factory.createCallExpression(
-      LlmParseProgrammer.write({
-        context: props.context,
-        modulo: props.modulo,
-        metadata: analyze(false),
-        name: (top as ts.TypeNode).getFullText().trim(),
-        config,
-      }),
-      undefined,
-      props.expression.arguments,
-    );
-  };
-}
+import {
+  LlmMetadataFactory,
+  LlmParseProgrammer,
+  MetadataCollection,
+  MetadataFactory,
+  MetadataSchema,
+} from "@typia/core";
+import { ILlmSchema, ValidationPipe } from "@typia/interface";
+import ts from "typescript";
+
+import { ITransformProps } from "../../ITransformProps";
+import { TransformerError } from "../../TransformerError";
+
+export namespace LlmParseTransformer {
+  export const transform = (props: ITransformProps): ts.Expression => {
+    // CHECK PARAMETER
+    if (props.expression.arguments.length === 0)
+      throw new TransformerError({
+        code: "typia.llm.parse",
+        message: "no input value.",
+      });
+
+    // GET GENERIC ARGUMENT
+    if (!props.expression.typeArguments?.length)
+      throw new TransformerError({
+        code: "typia.llm.parse",
+        message: "no generic argument.",
+      });
+
+    const top: ts.Node = props.expression.typeArguments[0]!;
+    if (ts.isTypeNode(top) === false) return props.expression;
+
+    // GET TYPE AND CONFIG
+    const config: Partial<ILlmSchema.IConfig> = LlmMetadataFactory.getConfig({
+      context: props.context,
+      method: "parse",
+      node: props.expression.typeArguments[1],
+    }) as Partial<ILlmSchema.IConfig>;
+
+    const type: ts.Type = props.context.checker.getTypeFromTypeNode(top);
+
+    if (type.isTypeParameter())
+      throw new TransformerError({
+        code: "typia.llm.parse",
+        message: "non-specified generic argument.",
+      });
+
+    // VALIDATE TYPE
+    const analyze = (validate: boolean): MetadataSchema => {
+      const result: ValidationPipe<MetadataSchema, MetadataFactory.IError> =
+        MetadataFactory.analyze({
+          checker: props.context.checker,
+          transformer: props.context.transformer,
+          options: {
+            absorb: validate,
+            escape: true,
+            constant: true,
+            validate:
+              validate === true
+                ? (metadata, explore) =>
+                    LlmParseProgrammer.validate({
+                      config,
+                      metadata,
+                      explore,
+                    })
+                : undefined,
+          },
+          components: new MetadataCollection({
+            replace: MetadataCollection.replace,
+          }),
+          type,
+        });
+      if (result.success === false)
+        throw TransformerError.from({
+          code: "typia.llm.parse",
+          errors: result.errors,
+        });
+      return result.data;
+    };
+    analyze(true);
+
+    // GENERATE CODE
+    return ts.factory.createCallExpression(
+      LlmParseProgrammer.write({
+        context: props.context,
+        modulo: props.modulo,
+        metadata: analyze(false),
+        name: (top as ts.TypeNode).getFullText().trim(),
+        config,
+      }),
+      undefined,
+      props.expression.arguments,
+    );
+  };
+}

package/src/features/llm/LlmSchemaTransformer.ts

@@ -1,87 +1,87 @@
-import {
-  LlmMetadataFactory,
-  LlmSchemaProgrammer,
-  MetadataCollection,
-  MetadataFactory,
-  MetadataSchema,
-} from "@typia/core";
-import { ILlmSchema, ValidationPipe } from "@typia/interface";
-import ts from "typescript";
-
-import { ITransformProps } from "../../ITransformProps";
-import { TransformerError } from "../../TransformerError";
-
-export namespace LlmSchemaTransformer {
-  export const transform = (props: ITransformProps): ts.Expression => {
-    // GET GENERIC ARGUMENT
-    if (!props.expression.typeArguments?.length)
-      throw new TransformerError({
-        code: "typia.llm.schema",
-        message: "no generic argument.",
-      });
-
-    const top: ts.Node = props.expression.typeArguments[0]!;
-    if (ts.isTypeNode(top) === false) return props.expression;
-
-    // GET TYPE
-    const config: Partial<ILlmSchema.IConfig> = LlmMetadataFactory.getConfig({
-      context: props.context,
-      method: "schema",
-      node: props.expression.typeArguments[1],
-    }) as Partial<ILlmSchema.IConfig>;
-
-    const type: ts.Type = props.context.checker.getTypeFromTypeNode(top);
-
-    // VALIDATE TYPE
-    const analyze = (validate: boolean): MetadataSchema => {
-      const result: ValidationPipe<MetadataSchema, MetadataFactory.IError> =
-        MetadataFactory.analyze({
-          checker: props.context.checker,
-          transformer: props.context.transformer,
-          options: {
-            absorb: validate,
-            constant: true,
-            escape: true,
-            validate:
-              validate === true
-                ? (metadata: MetadataSchema) =>
-                    LlmSchemaProgrammer.validate({
-                      config,
-                      metadata,
-                    })
-                : undefined,
-          },
-          components: new MetadataCollection({
-            replace: MetadataCollection.replace,
-          }),
-          type,
-        });
-      if (result.success === false)
-        throw TransformerError.from({
-          code: "typia.llm.schema",
-          errors: result.errors,
-        });
-      return result.data;
-    };
-    analyze(true);
-
-    // GENERATE LLM SCHEMA
-    const expr = LlmSchemaProgrammer.write({
-      context: props.context,
-      metadata: analyze(false),
-      config,
-    });
-
-    // If user provided $defs argument and expression is a function, call it with $defs
-    if (
-      props.expression.arguments?.[0] !== undefined &&
-      ts.isArrowFunction(expr)
-    ) {
-      return ts.factory.createCallExpression(expr, undefined, [
-        props.expression.arguments[0]!,
-      ]);
-    }
-
-    return expr;
-  };
-}
+import {
+  LlmMetadataFactory,
+  LlmSchemaProgrammer,
+  MetadataCollection,
+  MetadataFactory,
+  MetadataSchema,
+} from "@typia/core";
+import { ILlmSchema, ValidationPipe } from "@typia/interface";
+import ts from "typescript";
+
+import { ITransformProps } from "../../ITransformProps";
+import { TransformerError } from "../../TransformerError";
+
+export namespace LlmSchemaTransformer {
+  export const transform = (props: ITransformProps): ts.Expression => {
+    // GET GENERIC ARGUMENT
+    if (!props.expression.typeArguments?.length)
+      throw new TransformerError({
+        code: "typia.llm.schema",
+        message: "no generic argument.",
+      });
+
+    const top: ts.Node = props.expression.typeArguments[0]!;
+    if (ts.isTypeNode(top) === false) return props.expression;
+
+    // GET TYPE
+    const config: Partial<ILlmSchema.IConfig> = LlmMetadataFactory.getConfig({
+      context: props.context,
+      method: "schema",
+      node: props.expression.typeArguments[1],
+    }) as Partial<ILlmSchema.IConfig>;
+
+    const type: ts.Type = props.context.checker.getTypeFromTypeNode(top);
+
+    // VALIDATE TYPE
+    const analyze = (validate: boolean): MetadataSchema => {
+      const result: ValidationPipe<MetadataSchema, MetadataFactory.IError> =
+        MetadataFactory.analyze({
+          checker: props.context.checker,
+          transformer: props.context.transformer,
+          options: {
+            absorb: validate,
+            constant: true,
+            escape: true,
+            validate:
+              validate === true
+                ? (metadata: MetadataSchema) =>
+                    LlmSchemaProgrammer.validate({
+                      config,
+                      metadata,
+                    })
+                : undefined,
+          },
+          components: new MetadataCollection({
+            replace: MetadataCollection.replace,
+          }),
+          type,
+        });
+      if (result.success === false)
+        throw TransformerError.from({
+          code: "typia.llm.schema",
+          errors: result.errors,
+        });
+      return result.data;
+    };
+    analyze(true);
+
+    // GENERATE LLM SCHEMA
+    const expr = LlmSchemaProgrammer.write({
+      context: props.context,
+      metadata: analyze(false),
+      config,
+    });
+
+    // If user provided $defs argument and expression is a function, call it with $defs
+    if (
+      props.expression.arguments?.[0] !== undefined &&
+      ts.isArrowFunction(expr)
+    ) {
+      return ts.factory.createCallExpression(expr, undefined, [
+        props.expression.arguments[0]!,
+      ]);
+    }
+
+    return expr;
+  };
+}

package/src/features/misc/MiscAssertCloneTransformer.ts

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

package/src/features/misc/MiscAssertPruneTransformer.ts

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

package/src/features/misc/MiscCloneTransformer.ts

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

package/src/features/misc/MiscCreateAssertCloneTransformer.ts

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

package/src/features/misc/MiscCreateAssertPruneTransformer.ts

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

package/src/features/misc/MiscCreateCloneTransformer.ts

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

package/src/features/misc/MiscCreateIsCloneTransformer.ts

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

package/src/features/misc/MiscCreateIsPruneTransformer.ts

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

package/src/features/misc/MiscCreatePruneTransformer.ts

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

package/src/features/misc/MiscCreateValidateCloneTransformer.ts

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