@typia/transform 12.0.0-dev.20260307-2 → 12.0.0-dev.20260310

package/src/features/reflect/ReflectSchemasTransformer.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 ReflectSchemasTransformer {
-  export const transform = (
-    props: Pick<ITransformProps, "context" | "expression">,
-  ): ts.Expression => {
-    if (!props.expression.typeArguments?.length)
-      throw new TransformerError({
-        code: "typia.reflect.schemas",
-        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.schemas",
-        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.schemas",
-          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 ReflectSchemasTransformer {
+  export const transform = (
+    props: Pick<ITransformProps, "context" | "expression">,
+  ): ts.Expression => {
+    if (!props.expression.typeArguments?.length)
+      throw new TransformerError({
+        code: "typia.reflect.schemas",
+        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.schemas",
+        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.schemas",
+          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);
+  };
+}

package/src/index.ts

@@ -1,7 +1,7 @@
-import { transform } from "./transform";
-
-export default transform;
-
-export * from "./ImportTransformer";
-export * from "./TypiaGenerator";
-export * from "./transform";
+import { transform } from "./transform";
+
+export default transform;
+
+export * from "./ImportTransformer";
+export * from "./TypiaGenerator";
+export * from "./transform";

package/src/internal/GenericTransformer.ts

@@ -1,101 +1,101 @@
-import { IProgrammerProps } from "@typia/core";
-import ts from "typescript";
-
-import { ITransformProps } from "../ITransformProps";
-import { TransformerError } from "../TransformerError";
-
-export namespace GenericTransformer {
-  export interface IProps extends ITransformProps {
-    method: string;
-    write: (props: IProgrammerProps) => ts.Expression | ts.ArrowFunction;
-  }
-
-  export const scalar = (props: IProps) => {
-    // CHECK PARAMETER
-    if (props.expression.arguments.length === 0)
-      throw new TransformerError({
-        code: `typia.${props.method}`,
-        message: `no input value.`,
-      });
-
-    // GET TYPE INFO
-    const [type, node, generic]: [ts.Type, ts.Node, boolean] =
-      props.expression.typeArguments && props.expression.typeArguments[0]
-        ? [
-            props.context.checker.getTypeFromTypeNode(
-              props.expression.typeArguments[0],
-            ),
-            props.expression.typeArguments[0],
-            true,
-          ]
-        : [
-            props.context.checker.getTypeAtLocation(
-              props.expression.arguments[0]!,
-            ),
-            props.expression.arguments[0]!,
-            false,
-          ];
-    if (type.isTypeParameter())
-      throw new TransformerError({
-        code: `typia.${props.method}`,
-        message: `non-specified generic argument.`,
-      });
-
-    // DO TRANSFORM
-    return ts.factory.createCallExpression(
-      props.write({
-        context: props.context,
-        modulo: props.modulo,
-        type,
-        name: generic
-          ? node.getFullText().trim()
-          : getTypeName({
-              checker: props.context.checker,
-              type,
-              node,
-            }),
-      }),
-      undefined,
-      props.expression.arguments,
-    );
-  };
-
-  export const factory = (props: IProps) => {
-    // CHECK GENERIC ARGUMENT EXISTENCE
-    if (!props.expression.typeArguments?.[0])
-      throw new TransformerError({
-        code: `typia.${props.method}`,
-        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.method}`,
-        message: `non-specified generic argument.`,
-      });
-
-    // DO TRANSFORM
-    return props.write({
-      context: props.context,
-      modulo: props.modulo,
-      type,
-      name: node.getFullText().trim(),
-      init: props.expression.arguments[0],
-    });
-  };
-
-  const getTypeName = (props: {
-    checker: ts.TypeChecker;
-    type: ts.Type;
-    node: ts.Node;
-  }): string =>
-    props.checker.typeToString(
-      props.type,
-      props.node,
-      ts.TypeFormatFlags.NodeBuilderFlagsMask,
-    );
-}
+import { IProgrammerProps } from "@typia/core";
+import ts from "typescript";
+
+import { ITransformProps } from "../ITransformProps";
+import { TransformerError } from "../TransformerError";
+
+export namespace GenericTransformer {
+  export interface IProps extends ITransformProps {
+    method: string;
+    write: (props: IProgrammerProps) => ts.Expression | ts.ArrowFunction;
+  }
+
+  export const scalar = (props: IProps) => {
+    // CHECK PARAMETER
+    if (props.expression.arguments.length === 0)
+      throw new TransformerError({
+        code: `typia.${props.method}`,
+        message: `no input value.`,
+      });
+
+    // GET TYPE INFO
+    const [type, node, generic]: [ts.Type, ts.Node, boolean] =
+      props.expression.typeArguments && props.expression.typeArguments[0]
+        ? [
+            props.context.checker.getTypeFromTypeNode(
+              props.expression.typeArguments[0],
+            ),
+            props.expression.typeArguments[0],
+            true,
+          ]
+        : [
+            props.context.checker.getTypeAtLocation(
+              props.expression.arguments[0]!,
+            ),
+            props.expression.arguments[0]!,
+            false,
+          ];
+    if (type.isTypeParameter())
+      throw new TransformerError({
+        code: `typia.${props.method}`,
+        message: `non-specified generic argument.`,
+      });
+
+    // DO TRANSFORM
+    return ts.factory.createCallExpression(
+      props.write({
+        context: props.context,
+        modulo: props.modulo,
+        type,
+        name: generic
+          ? node.getFullText().trim()
+          : getTypeName({
+              checker: props.context.checker,
+              type,
+              node,
+            }),
+      }),
+      undefined,
+      props.expression.arguments,
+    );
+  };
+
+  export const factory = (props: IProps) => {
+    // CHECK GENERIC ARGUMENT EXISTENCE
+    if (!props.expression.typeArguments?.[0])
+      throw new TransformerError({
+        code: `typia.${props.method}`,
+        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.method}`,
+        message: `non-specified generic argument.`,
+      });
+
+    // DO TRANSFORM
+    return props.write({
+      context: props.context,
+      modulo: props.modulo,
+      type,
+      name: node.getFullText().trim(),
+      init: props.expression.arguments[0],
+    });
+  };
+
+  const getTypeName = (props: {
+    checker: ts.TypeChecker;
+    type: ts.Type;
+    node: ts.Node;
+  }): string =>
+    props.checker.typeToString(
+      props.type,
+      props.node,
+      ts.TypeFormatFlags.NodeBuilderFlagsMask,
+    );
+}

package/src/transform.ts

@@ -1,68 +1,68 @@
-import { ITransformOptions, ITypiaContext } from "@typia/core";
-import ts from "typescript";
-
-import { FileTransformer } from "./FileTransformer";
-
-/**
- * TypeScript transformer for typia runtime code generation.
- *
- * `transform` is the entry point for typia's compile-time transformation. It
- * converts `typia.*<T>()` function calls (e.g., `typia.is<User>(data)`) into
- * optimized runtime validation, serialization, or transformation code.
- *
- * The transformer analyzes the generic type parameter `T` at compile time and
- * generates specialized code that performs type checking without runtime
- * reflection. This approach provides both type safety and high performance.
- *
- * **Requirements:**
- *
- * - TypeScript's `strictNullChecks` or `strict` compiler option must be enabled
- * - The transformer must be configured in `tsconfig.json` via ts-patch or
- *   ttypescript
- *
- * **Configuration example (tsconfig.json):**
- *
- * ```json
- * {
- *   "compilerOptions": {
- *     "strict": true,
- *     "plugins": [{ "transform": "typia/lib/transform" }]
- *   }
- * }
- * ```
- *
- * @author Jeongho Nam - https://github.com/samchon
- * @param program TypeScript program instance from the compiler
- * @param options Optional transformer configuration (finite, numeric,
- *   functional, undefined)
- * @param extras Diagnostic utilities for error reporting during transformation
- * @returns Transformer factory that processes source files
- */
-export const transform = (
-  program: ts.Program,
-  options: ITransformOptions | undefined,
-  extras: ITypiaContext["extras"],
-): ts.TransformerFactory<ts.SourceFile> => {
-  const compilerOptions: ts.CompilerOptions = program.getCompilerOptions();
-  const strict: boolean =
-    compilerOptions.strictNullChecks !== undefined
-      ? !!compilerOptions.strictNullChecks
-      : !!compilerOptions.strict;
-  if (strict === false)
-    extras.addDiagnostic({
-      category: ts.DiagnosticCategory.Error,
-      code: "(typia)" as any,
-      file: undefined,
-      start: undefined,
-      length: undefined,
-      messageText: "strict mode is required.",
-    });
-  return FileTransformer.transform({
-    program,
-    compilerOptions,
-    checker: program.getTypeChecker(),
-    printer: ts.createPrinter(),
-    options: options ?? {},
-    extras,
-  });
-};
+import { ITransformOptions, ITypiaContext } from "@typia/core";
+import ts from "typescript";
+
+import { FileTransformer } from "./FileTransformer";
+
+/**
+ * TypeScript transformer for typia runtime code generation.
+ *
+ * `transform` is the entry point for typia's compile-time transformation. It
+ * converts `typia.*<T>()` function calls (e.g., `typia.is<User>(data)`) into
+ * optimized runtime validation, serialization, or transformation code.
+ *
+ * The transformer analyzes the generic type parameter `T` at compile time and
+ * generates specialized code that performs type checking without runtime
+ * reflection. This approach provides both type safety and high performance.
+ *
+ * **Requirements:**
+ *
+ * - TypeScript's `strictNullChecks` or `strict` compiler option must be enabled
+ * - The transformer must be configured in `tsconfig.json` via ts-patch or
+ *   ttypescript
+ *
+ * **Configuration example (tsconfig.json):**
+ *
+ * ```json
+ * {
+ *   "compilerOptions": {
+ *     "strict": true,
+ *     "plugins": [{ "transform": "typia/lib/transform" }]
+ *   }
+ * }
+ * ```
+ *
+ * @author Jeongho Nam - https://github.com/samchon
+ * @param program TypeScript program instance from the compiler
+ * @param options Optional transformer configuration (finite, numeric,
+ *   functional, undefined)
+ * @param extras Diagnostic utilities for error reporting during transformation
+ * @returns Transformer factory that processes source files
+ */
+export const transform = (
+  program: ts.Program,
+  options: ITransformOptions | undefined,
+  extras: ITypiaContext["extras"],
+): ts.TransformerFactory<ts.SourceFile> => {
+  const compilerOptions: ts.CompilerOptions = program.getCompilerOptions();
+  const strict: boolean =
+    compilerOptions.strictNullChecks !== undefined
+      ? !!compilerOptions.strictNullChecks
+      : !!compilerOptions.strict;
+  if (strict === false)
+    extras.addDiagnostic({
+      category: ts.DiagnosticCategory.Error,
+      code: "(typia)" as any,
+      file: undefined,
+      start: undefined,
+      length: undefined,
+      messageText: "strict mode is required.",
+    });
+  return FileTransformer.transform({
+    program,
+    compilerOptions,
+    checker: program.getTypeChecker(),
+    printer: ts.createPrinter(),
+    options: options ?? {},
+    extras,
+  });
+};