typia 8.2.0 → 9.0.0-dev.20250405

package/src/transformers/features/reflect/ReflectMetadataTransformer.ts

@@ -1,69 +1,69 @@
-import ts from "typescript";
-
-import { LiteralFactory } from "../../../factories/LiteralFactory";
-import { MetadataCollection } from "../../../factories/MetadataCollection";
-import { MetadataFactory } from "../../../factories/MetadataFactory";
-
-import { IMetadataApplication } from "../../../schemas/metadata/IMetadataApplication";
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-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 collection: MetadataCollection = new MetadataCollection();
-    const metadatas: Array<Metadata> = types.map((type) => {
-      const result = MetadataFactory.analyze({
-        checker: props.context.checker,
-        transformer: props.context.transformer,
-        options: {
-          escape: true,
-          constant: true,
-          absorb: true,
-          functional: true,
-        },
-        collection,
-        type,
-      });
-      if (result.success === false)
-        throw TransformerError.from({
-          code: "typia.reflect.metadata",
-          errors: result.errors,
-        });
-      return result.data;
-    });
-
-    // CONVERT TO PRIMITIVE TYPE
-    const app: IMetadataApplication = {
-      metadatas: metadatas.map((metadata) => metadata.toJSON()),
-      components: collection.toJSON(),
-    };
-    return LiteralFactory.write(app);
-  };
-}
+import ts from "typescript";
+
+import { LiteralFactory } from "../../../factories/LiteralFactory";
+import { MetadataCollection } from "../../../factories/MetadataCollection";
+import { MetadataFactory } from "../../../factories/MetadataFactory";
+
+import { IMetadataApplication } from "../../../schemas/metadata/IMetadataApplication";
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+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 collection: MetadataCollection = new MetadataCollection();
+    const metadatas: Array<Metadata> = types.map((type) => {
+      const result = MetadataFactory.analyze({
+        checker: props.context.checker,
+        transformer: props.context.transformer,
+        options: {
+          escape: true,
+          constant: true,
+          absorb: true,
+          functional: true,
+        },
+        collection,
+        type,
+      });
+      if (result.success === false)
+        throw TransformerError.from({
+          code: "typia.reflect.metadata",
+          errors: result.errors,
+        });
+      return result.data;
+    });
+
+    // CONVERT TO PRIMITIVE TYPE
+    const app: IMetadataApplication = {
+      metadatas: metadatas.map((metadata) => metadata.toJSON()),
+      components: collection.toJSON(),
+    };
+    return LiteralFactory.write(app);
+  };
+}

package/src/transformers/features/reflect/ReflectNameTransformer.ts

@@ -1,82 +1,82 @@
-import ts from "typescript";
-
-import { MetadataCollection } from "../../../factories/MetadataCollection";
-import { MetadataFactory } from "../../../factories/MetadataFactory";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { ValidationPipe } from "../../../typings/ValidationPipe";
-
-import { ITransformProps } from "../../ITransformProps";
-import { ITypiaContext } from "../../ITypiaContext";
-import { TransformerError } from "../../TransformerError";
-
-export namespace ReflectNameTransformer {
-  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.",
-      });
-    const top: ts.Node = props.expression.typeArguments[0]!;
-    const regular: boolean = (() => {
-      // CHECK SECOND ARGUMENT EXISTENCE
-      const second: ts.Node | undefined = props.expression.typeArguments[1]!;
-      if (second === undefined) return false;
-
-      // GET BOOLEAN VALUE
-      const value: Metadata = getMetadata({
-        context: props.context,
-        node: second,
-      });
-      return value.size() === 1 &&
-        value.constants.length === 1 &&
-        value.constants[0]!.type === "boolean" &&
-        value.constants[0]!.values.length === 1
-        ? (value.constants[0]!.values[0]!.value as boolean)
-        : false;
-    })();
-
-    // RETURNS NAME
-    return ts.factory.createStringLiteral(
-      regular
-        ? getMetadata({
-            context: props.context,
-            node: top,
-          }).getName()
-        : top.getFullText(),
-    );
-  };
-}
-
-const getMetadata = (props: {
-  context: ITypiaContext;
-  node: ts.Node;
-}): Metadata => {
-  const type: ts.Type = props.context.checker.getTypeFromTypeNode(
-    props.node as ts.TypeNode,
-  );
-  const collection: MetadataCollection = new MetadataCollection({
-    replace: MetadataCollection.replace,
-  });
-  const result: ValidationPipe<Metadata, MetadataFactory.IError> =
-    MetadataFactory.analyze({
-      checker: props.context.checker,
-      transformer: props.context.transformer,
-      options: {
-        absorb: false,
-        constant: true,
-        escape: false,
-      },
-      collection,
-      type,
-    });
-  if (result.success === false)
-    throw TransformerError.from({
-      code: "typia.reflect.name",
-      errors: result.errors,
-    });
-  return result.data;
-};
+import ts from "typescript";
+
+import { MetadataCollection } from "../../../factories/MetadataCollection";
+import { MetadataFactory } from "../../../factories/MetadataFactory";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { ValidationPipe } from "../../../typings/ValidationPipe";
+
+import { ITransformProps } from "../../ITransformProps";
+import { ITypiaContext } from "../../ITypiaContext";
+import { TransformerError } from "../../TransformerError";
+
+export namespace ReflectNameTransformer {
+  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.",
+      });
+    const top: ts.Node = props.expression.typeArguments[0]!;
+    const regular: boolean = (() => {
+      // CHECK SECOND ARGUMENT EXISTENCE
+      const second: ts.Node | undefined = props.expression.typeArguments[1]!;
+      if (second === undefined) return false;
+
+      // GET BOOLEAN VALUE
+      const value: Metadata = getMetadata({
+        context: props.context,
+        node: second,
+      });
+      return value.size() === 1 &&
+        value.constants.length === 1 &&
+        value.constants[0]!.type === "boolean" &&
+        value.constants[0]!.values.length === 1
+        ? (value.constants[0]!.values[0]!.value as boolean)
+        : false;
+    })();
+
+    // RETURNS NAME
+    return ts.factory.createStringLiteral(
+      regular
+        ? getMetadata({
+            context: props.context,
+            node: top,
+          }).getName()
+        : top.getFullText(),
+    );
+  };
+}
+
+const getMetadata = (props: {
+  context: ITypiaContext;
+  node: ts.Node;
+}): Metadata => {
+  const type: ts.Type = props.context.checker.getTypeFromTypeNode(
+    props.node as ts.TypeNode,
+  );
+  const collection: MetadataCollection = new MetadataCollection({
+    replace: MetadataCollection.replace,
+  });
+  const result: ValidationPipe<Metadata, MetadataFactory.IError> =
+    MetadataFactory.analyze({
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      options: {
+        absorb: false,
+        constant: true,
+        escape: false,
+      },
+      collection,
+      type,
+    });
+  if (result.success === false)
+    throw TransformerError.from({
+      code: "typia.reflect.name",
+      errors: result.errors,
+    });
+  return result.data;
+};

package/src/transformers/internal/GenericTransformer.ts

@@ -1,101 +1,101 @@
-import ts from "typescript";
-
-import { IProgrammerProps } from "../IProgrammerProps";
-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 ts from "typescript";
+
+import { IProgrammerProps } from "../IProgrammerProps";
+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/typings/Atomic.ts

@@ -1,13 +1,13 @@
-export namespace Atomic {
-  export type Type = boolean | number | string | bigint;
-
-  export type Literal = "boolean" | "integer" | "number" | "string" | "bigint";
-
-  export type Mapper = {
-    boolean: boolean;
-    integer: number;
-    number: number;
-    string: string;
-    bigint: bigint;
-  };
-}
+export namespace Atomic {
+  export type Type = boolean | number | string | bigint;
+
+  export type Literal = "boolean" | "integer" | "number" | "string" | "bigint";
+
+  export type Mapper = {
+    boolean: boolean;
+    integer: number;
+    number: number;
+    string: string;
+    bigint: bigint;
+  };
+}

package/src/typings/ClassProperties.ts

@@ -1,5 +1,5 @@
-import { OmitNever } from "./OmitNever";
-
-export type ClassProperties<T extends object> = OmitNever<{
-  [K in keyof T]: T[K] extends Function ? never : T[K];
-}>;
+import { OmitNever } from "./OmitNever";
+
+export type ClassProperties<T extends object> = OmitNever<{
+  [K in keyof T]: T[K] extends Function ? never : T[K];
+}>;

package/src/typings/Customizable.ts

@@ -1,5 +1,5 @@
-export type Customizable = {
-  number: number;
-  string: string;
-  bigint: bigint;
-};
+export type Customizable = {
+  number: number;
+  string: string;
+  bigint: bigint;
+};

package/src/typings/Equal.ts

@@ -1,18 +1,18 @@
-/**
- * Compare the equivalence of the two types X and Y.
- *
- * The two types X and Y refer to any type that can be expressed in the type script, such as the union type and the object type.
- *
- * @template X One of the types to compare
- * @template Y One of the types to compare
- *
- * ```ts
- * type Answer = Equal<1 | 2, 1 | 2>; // true
- * ```
- *
- * @author Kyungsu Kang - https://github.com/kakasoo
- */
-export type Equal<X, Y> =
-  (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2
-    ? true
-    : false;
+/**
+ * Compare the equivalence of the two types X and Y.
+ *
+ * The two types X and Y refer to any type that can be expressed in the type script, such as the union type and the object type.
+ *
+ * @template X One of the types to compare
+ * @template Y One of the types to compare
+ *
+ * ```ts
+ * type Answer = Equal<1 | 2, 1 | 2>; // true
+ * ```
+ *
+ * @author Kyungsu Kang - https://github.com/kakasoo
+ */
+export type Equal<X, Y> =
+  (<T>() => T extends X ? 1 : 2) extends <T>() => T extends Y ? 1 : 2
+    ? true
+    : false;

package/src/typings/IsTuple.ts

@@ -1,9 +1,9 @@
-export type IsTuple<T extends readonly any[] | { length: number }> = [
-  T,
-] extends [never]
-  ? false
-  : T extends readonly any[]
-    ? number extends T["length"]
-      ? false
-      : true
-    : false;
+export type IsTuple<T extends readonly any[] | { length: number }> = [
+  T,
+] extends [never]
+  ? false
+  : T extends readonly any[]
+    ? number extends T["length"]
+      ? false
+      : true
+    : false;

package/src/typings/NativeClass.ts

@@ -1,23 +1,23 @@
-export type NativeClass =
-  | Date
-  | Set<any>
-  | Map<any, any>
-  | WeakSet<any>
-  | WeakMap<any, any>
-  | Uint8Array
-  | Uint8ClampedArray
-  | Uint16Array
-  | Uint32Array
-  | BigUint64Array
-  | Int8Array
-  | Int16Array
-  | Int32Array
-  | BigInt64Array
-  | Float32Array
-  | Float64Array
-  | ArrayBuffer
-  | SharedArrayBuffer
-  | DataView
-  | Blob
-  | File
-  | RegExp;
+export type NativeClass =
+  | Date
+  | Set<any>
+  | Map<any, any>
+  | WeakSet<any>
+  | WeakMap<any, any>
+  | Uint8Array
+  | Uint8ClampedArray
+  | Uint16Array
+  | Uint32Array
+  | BigUint64Array
+  | Int8Array
+  | Int16Array
+  | Int32Array
+  | BigInt64Array
+  | Float32Array
+  | Float64Array
+  | ArrayBuffer
+  | SharedArrayBuffer
+  | DataView
+  | Blob
+  | File
+  | RegExp;

package/src/typings/OmitNever.ts

@@ -1,3 +1,3 @@
-import { SpecialFields } from "./SpecialFields";
-
-export type OmitNever<T extends object> = Omit<T, SpecialFields<T, never>>;
+import { SpecialFields } from "./SpecialFields";
+
+export type OmitNever<T extends object> = Omit<T, SpecialFields<T, never>>;