typia 6.7.2 → 6.7.3-dev.20240808

package/src/factories/internal/metadata/iterate_metadata.ts

@@ -2,6 +2,8 @@ import ts from "typescript";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
 
+import { TypePredicator } from "../../../utils/TypePredicator";
+
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
 import { TypeFactory } from "../../TypeFactory";
@@ -26,7 +28,7 @@ export const iterate_metadata =
   (collection: MetadataCollection) =>
   (errors: MetadataFactory.IError[]) =>
   (meta: Metadata, type: ts.Type, explore: MetadataFactory.IExplore): void => {
-    if (type.isTypeParameter() === true) {
+    if (TypePredicator.isTypeParameter(type) === true) {
       errors.push({
         name: TypeFactory.getFullName(checker)(type),
         explore: { ...explore },

package/src/factories/internal/metadata/iterate_metadata_array.ts

@@ -5,6 +5,7 @@ import { MetadataArray } from "../../../schemas/metadata/MetadataArray";
 import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
+import { TypePredicator } from "../../../utils/TypePredicator";
 
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
@@ -49,7 +50,7 @@ const find_array_extended =
 
     memory.set(type, null);
     const res: ts.Type | null = (() => {
-      if (type.isClassOrInterface() === false) return null;
+      if (TypePredicator.isInterfaceOrClass(type) === false) return null;
       for (const t of type.resolvedBaseTypes ?? [])
         if (checker.isArrayType(t)) return t;
         else {

package/src/factories/internal/metadata/iterate_metadata_atomic.ts

@@ -7,7 +7,7 @@ import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 const same = (type: ts.Type | null) => {
   if (type === null) return () => false;
-  return (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+  return (flag: ts.TypeFlags) => (type.flags & flag) !== 0;
 };
 
 export const iterate_metadata_atomic = (

package/src/factories/internal/metadata/iterate_metadata_coalesce.ts

@@ -10,7 +10,7 @@ export const iterate_metadata_coalesce = (
   meta: Metadata,
   type: ts.Type,
 ): boolean => {
-  const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+  const filter = (flag: ts.TypeFlags) => (type.flags & flag) !== 0;
   if (filter(ts.TypeFlags.Unknown) || filter(ts.TypeFlags.Any)) {
     Writable(meta).any = true;
     return true;

package/src/factories/internal/metadata/iterate_metadata_constant.ts

@@ -5,6 +5,7 @@ import { MetadataConstant } from "../../../schemas/metadata/MetadataConstant";
 import { MetadataConstantValue } from "../../../schemas/metadata/MetadataConstantValue";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
+import { TypePredicator } from "../../../utils/TypePredicator";
 
 import { CommentFactory } from "../../CommentFactory";
 import { MetadataFactory } from "../../MetadataFactory";
@@ -15,7 +16,7 @@ export const iterate_metadata_constant =
   (meta: Metadata, type: ts.Type): boolean => {
     if (!options.constant) return false;
 
-    const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+    const filter = (flag: ts.TypeFlags) => (type.flags & flag) !== 0;
     const comment = () => {
       if (!filter(ts.TypeFlags.EnumLiteral)) return {};
       return {
@@ -25,7 +26,7 @@ export const iterate_metadata_constant =
           : undefined,
       };
     };
-    if (type.isLiteral()) {
+    if (TypePredicator.isLiteral(type)) {
       const value: string | number | bigint =
         typeof type.value === "object"
           ? BigInt(`${type.value.negative ? "-" : ""}${type.value.base10Value}`)

package/src/factories/internal/metadata/iterate_metadata_intersection.ts

@@ -8,6 +8,7 @@ import { MetadataConstantValue } from "../../../schemas/metadata/MetadataConstan
 import { MetadataTemplate } from "../../../schemas/metadata/MetadataTemplate";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
+import { TypePredicator } from "../../../utils/TypePredicator";
 
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
@@ -26,12 +27,12 @@ export const iterate_metadata_intersection =
     type: ts.Type,
     explore: MetadataFactory.IExplore,
   ): boolean => {
-    if (!type.isIntersection()) return false;
+    if (TypePredicator.isIntersection(type) === false) return false;
     if (
       // ONLY OBJECT TYPED INTERSECTION
       type.types.every(
         (child) =>
-          (child.getFlags() & ts.TypeFlags.Object) !== 0 &&
+          (child.flags & ts.TypeFlags.Object) !== 0 &&
           !checker.isArrayType(child) &&
           !checker.isTupleType(child),
       )

package/src/factories/internal/metadata/iterate_metadata_map.ts

@@ -21,7 +21,7 @@ export const iterate_metadata_map =
   ): boolean => {
     type = checker.getApparentType(type);
 
-    const name = TypeFactory.getFullName(checker)(type, type.getSymbol());
+    const name = TypeFactory.getFullName(checker)(type, type.symbol);
     const generic = type.aliasSymbol
       ? type.aliasTypeArguments
       : checker.getTypeArguments(type as ts.TypeReference);

package/src/factories/internal/metadata/iterate_metadata_native.ts

@@ -10,10 +10,7 @@ export const iterate_metadata_native =
   (checker: ts.TypeChecker) =>
   (meta: Metadata, type: ts.Type): boolean => {
     const validator = validate(checker)(type);
-    const name: string = TypeFactory.getFullName(checker)(
-      type,
-      type.getSymbol(),
-    );
+    const name: string = TypeFactory.getFullName(checker)(type, type.symbol);
 
     const simple = SIMPLES.get(name);
     if (simple && validator(simple)) {

package/src/factories/internal/metadata/iterate_metadata_object.ts

@@ -4,6 +4,7 @@ import { Metadata } from "../../../schemas/metadata/Metadata";
 import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
+import { TypePredicator } from "../../../utils/TypePredicator";
 
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
@@ -16,10 +17,10 @@ export const iterate_metadata_object =
   (errors: MetadataFactory.IError[]) =>
   (meta: Metadata, type: ts.Type, ensure: boolean = false): boolean => {
     if (ensure === false) {
-      const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+      const filter = (flag: ts.TypeFlags) => (type.flags & flag) !== 0;
       if (
         !filter(ts.TypeFlags.Object) &&
-        !type.isIntersection() &&
+        !TypePredicator.isIntersection(type) &&
         (type as any).intrinsicName !== "object"
       )
         return false;

package/src/factories/internal/metadata/iterate_metadata_set.ts

@@ -21,7 +21,7 @@ export const iterate_metadata_set =
   ): boolean => {
     type = checker.getApparentType(type);
 
-    const name = TypeFactory.getFullName(checker)(type, type.getSymbol());
+    const name = TypeFactory.getFullName(checker)(type, type.symbol);
     const generic = type.aliasSymbol
       ? type.aliasTypeArguments
       : checker.getTypeArguments(type as ts.TypeReference);

package/src/factories/internal/metadata/iterate_metadata_template.ts

@@ -18,7 +18,7 @@ export const iterate_metadata_template =
     type: ts.Type,
     explore: MetadataFactory.IExplore,
   ): boolean => {
-    const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+    const filter = (flag: ts.TypeFlags) => (type.flags & flag) !== 0;
     if (!filter(ts.TypeFlags.TemplateLiteral)) return false;
 
     const template: ts.TemplateLiteralType = type as ts.TemplateLiteralType;

package/src/factories/internal/metadata/iterate_metadata_union.ts

@@ -2,6 +2,8 @@ import ts from "typescript";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
 
+import { TypePredicator } from "../../../utils/TypePredicator";
+
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
 import { iterate_metadata } from "./iterate_metadata";
@@ -16,7 +18,7 @@ export const iterate_metadata_union =
     type: ts.Type,
     explore: MetadataFactory.IExplore,
   ): boolean => {
-    if (!type.isUnion()) return false;
+    if (TypePredicator.isUnion(type) === false) return false;
     type.types.forEach((t) =>
       iterate_metadata(checker)(options)(collection)(errors)(meta, t, {
         ...explore,

package/src/schemas/metadata/IMetadataConstantValue.ts

@@ -1,11 +1,11 @@
-import { Atomic } from "../../typings/Atomic";
-
-import { IJsDocTagInfo } from "./IJsDocTagInfo";
-import { IMetadataTypeTag } from "./IMetadataTypeTag";
-
-export interface IMetadataConstantValue<T extends Atomic.Type> {
-  value: T;
-  tags?: IMetadataTypeTag[][] | undefined;
-  description?: string | null;
-  jsDocTags?: IJsDocTagInfo[];
-}
+import { Atomic } from "../../typings/Atomic";
+
+import { IJsDocTagInfo } from "./IJsDocTagInfo";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export interface IMetadataConstantValue<T extends Atomic.Type> {
+  value: T;
+  tags?: IMetadataTypeTag[][] | undefined;
+  description?: string | null;
+  jsDocTags?: IJsDocTagInfo[];
+}

package/src/schemas/metadata/IMetadataTemplate.ts

@@ -1,7 +1,7 @@
-import { IMetadata } from "./IMetadata";
-import { IMetadataTypeTag } from "./IMetadataTypeTag";
-
-export interface IMetadataTemplate {
-  row: IMetadata[];
-  tags?: IMetadataTypeTag[][] | undefined;
-}
+import { IMetadata } from "./IMetadata";
+import { IMetadataTypeTag } from "./IMetadataTypeTag";
+
+export interface IMetadataTemplate {
+  row: IMetadata[];
+  tags?: IMetadataTypeTag[][] | undefined;
+}

package/src/tags/Type.ts

@@ -1,32 +1,32 @@
-import { TagBase } from "./TagBase";
-
-export type Type<
-  Value extends "int32" | "uint32" | "int64" | "uint64" | "float" | "double",
-> = TagBase<{
-  target: Value extends "int64" | "uint64" ? "bigint" | "number" : "number";
-  kind: "type";
-  value: Value;
-  validate: Value extends "int32"
-    ? `Math.floor($input) === $input && -2147483648 <= $input && $input <= 2147483647`
-    : Value extends "uint32"
-      ? `Math.floor($input) === $input && 0 <= $input && $input <= 4294967295`
-      : Value extends "int64"
-        ? {
-            number: `Math.floor($input) === $input && -9223372036854775808 <= $input && $input <= 9223372036854775807`;
-            bigint: `true`;
-          }
-        : Value extends "uint64"
-          ? {
-              number: `Math.floor($input) === $input && 0 <= $input && $input <= 18446744073709551615`;
-              bigint: `BigInt(0) <= $input`;
-            }
-          : Value extends "float"
-            ? `-1.175494351e38 <= $input && $input <= 3.4028235e38`
-            : `true`;
-  exclusive: true;
-  schema: {
-    type: Value extends "int32" | "uint32" | "int64" | "uint64"
-      ? "integer"
-      : "number";
-  };
-}>;
+import { TagBase } from "./TagBase";
+
+export type Type<
+  Value extends "int32" | "uint32" | "int64" | "uint64" | "float" | "double",
+> = TagBase<{
+  target: Value extends "int64" | "uint64" ? "bigint" | "number" : "number";
+  kind: "type";
+  value: Value;
+  validate: Value extends "int32"
+    ? `Math.floor($input) === $input && -2147483648 <= $input && $input <= 2147483647`
+    : Value extends "uint32"
+      ? `Math.floor($input) === $input && 0 <= $input && $input <= 4294967295`
+      : Value extends "int64"
+        ? {
+            number: `Math.floor($input) === $input && -9223372036854775808 <= $input && $input <= 9223372036854775807`;
+            bigint: `true`;
+          }
+        : Value extends "uint64"
+          ? {
+              number: `Math.floor($input) === $input && 0 <= $input && $input <= 18446744073709551615`;
+              bigint: `BigInt(0) <= $input`;
+            }
+          : Value extends "float"
+            ? `-1.175494351e38 <= $input && $input <= 3.4028235e38`
+            : `true`;
+  exclusive: true;
+  schema: {
+    type: Value extends "int32" | "uint32" | "int64" | "uint64"
+      ? "integer"
+      : "number";
+  };
+}>;

package/src/transformers/features/CreateRandomTransformer.ts

@@ -2,6 +2,8 @@ import ts from "typescript";
 
 import { RandomProgrammer } from "../../programmers/RandomProgrammer";
 
+import { TypePredicator } from "../../utils/TypePredicator";
+
 import { IProject } from "../IProject";
 import { TransformerError } from "../TransformerError";
 
@@ -21,7 +23,7 @@ export namespace CreateRandomTransformer {
       const node: ts.TypeNode = expression.typeArguments[0];
       const type: ts.Type = project.checker.getTypeFromTypeNode(node);
 
-      if (type.isTypeParameter())
+      if (TypePredicator.isTypeParameter(type))
         throw new TransformerError({
           code: "typia.createRandom",
           message: "non-specified generic argument.",

package/src/transformers/features/RandomTransformer.ts

@@ -2,6 +2,8 @@ import ts from "typescript";
 
 import { RandomProgrammer } from "../../programmers/RandomProgrammer";
 
+import { TypePredicator } from "../../utils/TypePredicator";
+
 import { IProject } from "../IProject";
 import { TransformerError } from "../TransformerError";
 
@@ -21,7 +23,7 @@ export namespace RandomTransformer {
       const node: ts.TypeNode = expression.typeArguments[0];
       const type: ts.Type = project.checker.getTypeFromTypeNode(node);
 
-      if (type.isTypeParameter())
+      if (TypePredicator.isTypeParameter(type))
         throw new TransformerError({
           code: `typia.${modulo.getText()}`,
           message: "non-specified generic argument.",

package/src/transformers/features/json/JsonApplicationTransformer.ts

@@ -11,6 +11,8 @@ import { JsonApplicationProgrammer } from "../../../programmers/json/JsonApplica
 
 import { ValidationPipe } from "../../../typings/ValidationPipe";
 
+import { TypePredicator } from "../../../utils/TypePredicator";
+
 import { IProject } from "../../IProject";
 import { TransformerError } from "../../TransformerError";
 
@@ -37,7 +39,7 @@ export namespace JsonApplicationTransformer {
       const types: ts.Type[] = top.elements.map((child) =>
         project.checker.getTypeFromTypeNode(child as ts.TypeNode),
       );
-      if (types.some((t) => t.isTypeParameter()))
+      if (types.some(TypePredicator.isTypeParameter))
         throw new TransformerError({
           code: "typia.json.application",
           message: "non-specified generic argument(s).",
@@ -102,8 +104,8 @@ export namespace JsonApplicationTransformer {
       // CHECK LITERAL TYPE
       const type: ts.Type = props.checker.getTypeFromTypeNode(node);
       if (
-        !type.isLiteral() &&
-        (type.getFlags() & ts.TypeFlags.BooleanLiteral) === 0
+        !TypePredicator.isLiteral(type) &&
+        (type.flags & ts.TypeFlags.BooleanLiteral) === 0
       )
         throw new TransformerError({
           code: "typia.json.application",
@@ -111,7 +113,7 @@ export namespace JsonApplicationTransformer {
         });
 
       // GET VALUE AND VALIDATE IT
-      const value = type.isLiteral()
+      const value = TypePredicator.isLiteral(type)
         ? type.value
         : props.checker.typeToString(type);
       if (typeof value !== "string" || props.is(value) === false)

package/src/transformers/features/misc/MiscLiteralsTransformer.ts

@@ -2,6 +2,8 @@ import ts from "typescript";
 
 import { MiscLiteralsProgrammer } from "../../../programmers/misc/MiscLiteralsProgrammer";
 
+import { TypePredicator } from "../../../utils/TypePredicator";
+
 import { IProject } from "../../IProject";
 import { TransformerError } from "../../TransformerError";
 
@@ -20,7 +22,7 @@ export namespace MiscLiteralsTransformer {
       const node: ts.TypeNode = expression.typeArguments[0];
       const type: ts.Type = project.checker.getTypeFromTypeNode(node);
 
-      if (type.isTypeParameter())
+      if (TypePredicator.isTypeParameter(type))
         throw new TransformerError({
           code: "typia.misc.literals",
           message: "non-specified generic argument.",

package/src/transformers/features/protobuf/ProtobufMessageTransformer.ts

@@ -2,6 +2,8 @@ import ts from "typescript";
 
 import { ProtobufMessageProgrammer } from "../../../programmers/protobuf/ProtobufMessageProgrammer";
 
+import { TypePredicator } from "../../../utils/TypePredicator";
+
 import { IProject } from "../../IProject";
 import { TransformerError } from "../../TransformerError";
 
@@ -21,7 +23,7 @@ export namespace ProtobufMessageTransformer {
       const type: ts.Type = project.checker.getTypeFromTypeNode(
         expression.typeArguments[0],
       );
-      if (type.isTypeParameter())
+      if (TypePredicator.isTypeParameter(type))
         throw new TransformerError({
           code: "tyipa.protobuf.message",
           message: "non-specified generic argument.",

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

@@ -7,6 +7,8 @@ import { MetadataFactory } from "../../../factories/MetadataFactory";
 import { IMetadataApplication } from "../../../schemas/metadata/IMetadataApplication";
 import { Metadata } from "../../../schemas/metadata/Metadata";
 
+import { TypePredicator } from "../../../utils/TypePredicator";
+
 import { IProject } from "../../IProject";
 import { TransformerError } from "../../TransformerError";
 
@@ -30,7 +32,7 @@ export namespace ReflectMetadataTransformer {
       const types: ts.Type[] = top.elements.map((child) =>
         project.checker.getTypeFromTypeNode(child as ts.TypeNode),
       );
-      if (types.some((t) => t.isTypeParameter()))
+      if (types.some(TypePredicator.isTypeParameter))
         throw new TransformerError({
           code: "typia.reflect.metadata",
           message: "non-specified generic argument(s).",

package/src/transformers/internal/GenericTransformer.ts

@@ -1,5 +1,7 @@
 import ts from "typescript";
 
+import { TypePredicator } from "../../utils/TypePredicator";
+
 import { IProject } from "../IProject";
 import { TransformerError } from "../TransformerError";
 
@@ -36,7 +38,7 @@ export namespace GenericTransformer {
               expression.arguments[0]!,
               false,
             ];
-      if (type.isTypeParameter())
+      if (TypePredicator.isTypeParameter(type))
         throw new TransformerError({
           code: `typia.${method}`,
           message: `non-specified generic argument.`,
@@ -82,7 +84,7 @@ export namespace GenericTransformer {
       const node: ts.TypeNode = expression.typeArguments[0];
       const type: ts.Type = project.checker.getTypeFromTypeNode(node);
 
-      if (type.isTypeParameter())
+      if (TypePredicator.isTypeParameter(type))
         throw new TransformerError({
           code: `typia.${method}`,
           message: `non-specified generic argument.`,

package/src/utils/TypePredicator.ts

@@ -0,0 +1,32 @@
+import ts from "typescript";
+
+export namespace TypePredicator {
+  export const isLiteral = (type: ts.Type): type is ts.LiteralType =>
+    !!(
+      type.flags &
+      (ts.TypeFlags.EnumLiteral |
+        ts.TypeFlags.StringLiteral |
+        ts.TypeFlags.NumberLiteral |
+        ts.TypeFlags.BigIntLiteral)
+    );
+
+  export const isTypeParameter = (type: ts.Type): type is ts.TypeParameter =>
+    !!(type.flags & ts.TypeFlags.TypeParameter);
+
+  export const isIntersection = (type: ts.Type): type is ts.IntersectionType =>
+    !!(type.flags & ts.TypeFlags.Intersection);
+
+  export const isUnion = (type: ts.Type): type is ts.UnionType =>
+    !!(type.flags & ts.TypeFlags.Union);
+
+  export const isUnionOrIntersection = (
+    type: ts.Type,
+  ): type is ts.UnionOrIntersectionType =>
+    !!(type.flags & ts.TypeFlags.UnionOrIntersection);
+
+  export const isClass = (type: ts.Type): type is ts.InterfaceType =>
+    !!(ts.getObjectFlags(type) & ts.ObjectFlags.Class);
+
+  export const isInterfaceOrClass = (type: ts.Type): type is ts.InterfaceType =>
+    !!(ts.getObjectFlags(type) & ts.ObjectFlags.ClassOrInterface);
+}