typia 6.7.3-dev.20240808 → 6.8.0-dev.20240811

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

@@ -1,64 +1,63 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-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";
-import { emplace_metadata_array_type } from "./emplace_metadata_array_type";
-
-export const iterate_metadata_array =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (
-    meta: Metadata,
-    alias: ts.Type,
-    explore: MetadataFactory.IExplore,
-  ): boolean => {
-    const array: ts.Type | null =
-      checker.isArrayType(alias) === false
-        ? find_array_extended(checker)(new Map())(alias)
-        : alias;
-    if (array === null) return false;
-
-    const arrayType: MetadataArrayType = emplace_metadata_array_type(checker)(
-      options,
-    )(collection)(errors)(alias, array, meta.nullable, explore);
-    ArrayUtil.add(
-      meta.arrays,
-      MetadataArray.create({
-        type: arrayType,
-        tags: [],
-      }),
-      (elem) => elem.type.name === arrayType.name,
-    );
-    return true;
-  };
-
-const find_array_extended =
-  (checker: ts.TypeChecker) =>
-  (memory: Map<ts.Type, ts.Type | null>) =>
-  (type: ts.Type): ts.Type | null => {
-    const cached = memory.get(type);
-    if (cached !== undefined) return null;
-
-    memory.set(type, null);
-    const res: ts.Type | null = (() => {
-      if (TypePredicator.isInterfaceOrClass(type) === false) return null;
-      for (const t of type.resolvedBaseTypes ?? [])
-        if (checker.isArrayType(t)) return t;
-        else {
-          const res: ts.Type | null = find_array_extended(checker)(memory)(t);
-          if (res !== null) return res;
-        }
-      return null;
-    })();
-    memory.set(type, res);
-    return res;
-  };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataArray } from "../../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { emplace_metadata_array_type } from "./emplace_metadata_array_type";
+
+export const iterate_metadata_array =
+  (checker: ts.TypeChecker) =>
+  (options: MetadataFactory.IOptions) =>
+  (collection: MetadataCollection) =>
+  (errors: MetadataFactory.IError[]) =>
+  (
+    meta: Metadata,
+    alias: ts.Type,
+    explore: MetadataFactory.IExplore,
+  ): boolean => {
+    const array: ts.Type | null =
+      checker.isArrayType(alias) === false
+        ? find_array_extended(checker)(new Map())(alias)
+        : alias;
+    if (array === null) return false;
+
+    const arrayType: MetadataArrayType = emplace_metadata_array_type(checker)(
+      options,
+    )(collection)(errors)(alias, array, meta.nullable, explore);
+    ArrayUtil.add(
+      meta.arrays,
+      MetadataArray.create({
+        type: arrayType,
+        tags: [],
+      }),
+      (elem) => elem.type.name === arrayType.name,
+    );
+    return true;
+  };
+
+const find_array_extended =
+  (checker: ts.TypeChecker) =>
+  (memory: Map<ts.Type, ts.Type | null>) =>
+  (type: ts.Type): ts.Type | null => {
+    const cached = memory.get(type);
+    if (cached !== undefined) return null;
+
+    memory.set(type, null);
+    const res: ts.Type | null = (() => {
+      if (type.isClassOrInterface() === false) return null;
+      for (const t of type.resolvedBaseTypes ?? [])
+        if (checker.isArrayType(t)) return t;
+        else {
+          const res: ts.Type | null = find_array_extended(checker)(memory)(t);
+          if (res !== null) return res;
+        }
+      return null;
+    })();
+    memory.set(type, res);
+    return res;
+  };

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

@@ -1,62 +1,62 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataAtomic } from "../../../schemas/metadata/MetadataAtomic";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-const same = (type: ts.Type | null) => {
-  if (type === null) return () => false;
-  return (flag: ts.TypeFlags) => (type.flags & flag) !== 0;
-};
-
-export const iterate_metadata_atomic = (
-  meta: Metadata,
-  type: ts.Type,
-): boolean => {
-  // PREPARE INTERNAL FUNCTIONS
-  const filter = same(type);
-  const check = (info: IAtomicInfo) => {
-    if (filter(info.atomic) || filter(info.literal)) {
-      ArrayUtil.add(
-        meta.atomics,
-        MetadataAtomic.create({ type: info.name, tags: [] }),
-        (x, y) => x.type === y.type,
-      );
-      return true;
-    }
-    return false;
-  };
-
-  // CHECK EACH TYPES
-  return ATOMICS.some((info) => check(info));
-};
-
-const ATOMICS: IAtomicInfo[] = [
-  {
-    name: "boolean",
-    atomic: ts.TypeFlags.BooleanLike,
-    literal: ts.TypeFlags.BooleanLiteral,
-  },
-  {
-    name: "number",
-    atomic: ts.TypeFlags.NumberLike,
-    literal: ts.TypeFlags.NumberLiteral,
-  },
-  {
-    name: "bigint",
-    atomic: ts.TypeFlags.BigInt,
-    literal: ts.TypeFlags.BigIntLiteral,
-  },
-  {
-    name: "string",
-    atomic: ts.TypeFlags.StringLike,
-    literal: ts.TypeFlags.StringLiteral,
-  },
-];
-
-interface IAtomicInfo {
-  name: "boolean" | "number" | "bigint" | "string";
-  atomic: ts.TypeFlags;
-  literal: ts.TypeFlags;
-}
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataAtomic } from "../../../schemas/metadata/MetadataAtomic";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+const same = (type: ts.Type | null) => {
+  if (type === null) return () => false;
+  return (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+};
+
+export const iterate_metadata_atomic = (
+  meta: Metadata,
+  type: ts.Type,
+): boolean => {
+  // PREPARE INTERNAL FUNCTIONS
+  const filter = same(type);
+  const check = (info: IAtomicInfo) => {
+    if (filter(info.atomic) || filter(info.literal)) {
+      ArrayUtil.add(
+        meta.atomics,
+        MetadataAtomic.create({ type: info.name, tags: [] }),
+        (x, y) => x.type === y.type,
+      );
+      return true;
+    }
+    return false;
+  };
+
+  // CHECK EACH TYPES
+  return ATOMICS.some((info) => check(info));
+};
+
+const ATOMICS: IAtomicInfo[] = [
+  {
+    name: "boolean",
+    atomic: ts.TypeFlags.BooleanLike,
+    literal: ts.TypeFlags.BooleanLiteral,
+  },
+  {
+    name: "number",
+    atomic: ts.TypeFlags.NumberLike,
+    literal: ts.TypeFlags.NumberLiteral,
+  },
+  {
+    name: "bigint",
+    atomic: ts.TypeFlags.BigInt,
+    literal: ts.TypeFlags.BigIntLiteral,
+  },
+  {
+    name: "string",
+    atomic: ts.TypeFlags.StringLike,
+    literal: ts.TypeFlags.StringLiteral,
+  },
+];
+
+interface IAtomicInfo {
+  name: "boolean" | "number" | "bigint" | "string";
+  atomic: ts.TypeFlags;
+  literal: ts.TypeFlags;
+}

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

@@ -1,33 +1,33 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { Writable } from "../../../typings/Writable";
-
-import { TypeFactory } from "../../TypeFactory";
-
-export const iterate_metadata_coalesce = (
-  meta: Metadata,
-  type: ts.Type,
-): boolean => {
-  const filter = (flag: ts.TypeFlags) => (type.flags & flag) !== 0;
-  if (filter(ts.TypeFlags.Unknown) || filter(ts.TypeFlags.Any)) {
-    Writable(meta).any = true;
-    return true;
-  } else if (filter(ts.TypeFlags.Null)) {
-    Writable(meta).nullable = true;
-    return true;
-  } else if (
-    filter(ts.TypeFlags.Undefined) ||
-    filter(ts.TypeFlags.Never) ||
-    filter(ts.TypeFlags.Void) ||
-    filter(ts.TypeFlags.VoidLike)
-  ) {
-    Writable(meta).required = false;
-    return true;
-  } else if (TypeFactory.isFunction(type) === true) {
-    Writable(meta).functional = true;
-    return true;
-  }
-  return false;
-};
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { Writable } from "../../../typings/Writable";
+
+import { TypeFactory } from "../../TypeFactory";
+
+export const iterate_metadata_coalesce = (
+  meta: Metadata,
+  type: ts.Type,
+): boolean => {
+  const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+  if (filter(ts.TypeFlags.Unknown) || filter(ts.TypeFlags.Any)) {
+    Writable(meta).any = true;
+    return true;
+  } else if (filter(ts.TypeFlags.Null)) {
+    Writable(meta).nullable = true;
+    return true;
+  } else if (
+    filter(ts.TypeFlags.Undefined) ||
+    filter(ts.TypeFlags.Never) ||
+    filter(ts.TypeFlags.Void) ||
+    filter(ts.TypeFlags.VoidLike)
+  ) {
+    Writable(meta).required = false;
+    return true;
+  } else if (TypeFactory.isFunction(type) === true) {
+    Writable(meta).functional = true;
+    return true;
+  }
+  return false;
+};

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

@@ -1,77 +1,76 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-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";
-
-export const iterate_metadata_constant =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (meta: Metadata, type: ts.Type): boolean => {
-    if (!options.constant) return false;
-
-    const filter = (flag: ts.TypeFlags) => (type.flags & flag) !== 0;
-    const comment = () => {
-      if (!filter(ts.TypeFlags.EnumLiteral)) return {};
-      return {
-        jsDocTags: type.symbol?.getJsDocTags(),
-        description: type.symbol
-          ? CommentFactory.description(type.symbol) ?? null
-          : undefined,
-      };
-    };
-    if (TypePredicator.isLiteral(type)) {
-      const value: string | number | bigint =
-        typeof type.value === "object"
-          ? BigInt(`${type.value.negative ? "-" : ""}${type.value.base10Value}`)
-          : type.value;
-      const constant: MetadataConstant = ArrayUtil.take(
-        meta.constants,
-        (elem) => elem.type === typeof value,
-        () =>
-          MetadataConstant.create({
-            type: typeof value as "number",
-            values: [],
-          }),
-      );
-      ArrayUtil.add(
-        constant.values,
-        MetadataConstantValue.create({
-          value,
-          tags: [],
-          ...comment(),
-        }),
-        (a, b) => a.value === b.value,
-      );
-      return true;
-    } else if (filter(ts.TypeFlags.BooleanLiteral)) {
-      comment();
-      const value: boolean = checker.typeToString(type) === "true";
-      const constant: MetadataConstant = ArrayUtil.take(
-        meta.constants,
-        (elem) => elem.type === "boolean",
-        () =>
-          MetadataConstant.create({
-            type: "boolean",
-            values: [],
-          }),
-      );
-      ArrayUtil.add(
-        constant.values,
-        MetadataConstantValue.create({
-          value,
-          tags: [],
-          ...comment(),
-        }),
-        (a, b) => a.value === b.value,
-      );
-      return true;
-    }
-    return false;
-  };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataConstant } from "../../../schemas/metadata/MetadataConstant";
+import { MetadataConstantValue } from "../../../schemas/metadata/MetadataConstantValue";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { CommentFactory } from "../../CommentFactory";
+import { MetadataFactory } from "../../MetadataFactory";
+
+export const iterate_metadata_constant =
+  (checker: ts.TypeChecker) =>
+  (options: MetadataFactory.IOptions) =>
+  (meta: Metadata, type: ts.Type): boolean => {
+    if (!options.constant) return false;
+
+    const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+    const comment = () => {
+      if (!filter(ts.TypeFlags.EnumLiteral)) return {};
+      return {
+        jsDocTags: type.symbol?.getJsDocTags(),
+        description: type.symbol
+          ? CommentFactory.description(type.symbol) ?? null
+          : undefined,
+      };
+    };
+    if (type.isLiteral()) {
+      const value: string | number | bigint =
+        typeof type.value === "object"
+          ? BigInt(`${type.value.negative ? "-" : ""}${type.value.base10Value}`)
+          : type.value;
+      const constant: MetadataConstant = ArrayUtil.take(
+        meta.constants,
+        (elem) => elem.type === typeof value,
+        () =>
+          MetadataConstant.create({
+            type: typeof value as "number",
+            values: [],
+          }),
+      );
+      ArrayUtil.add(
+        constant.values,
+        MetadataConstantValue.create({
+          value,
+          tags: [],
+          ...comment(),
+        }),
+        (a, b) => a.value === b.value,
+      );
+      return true;
+    } else if (filter(ts.TypeFlags.BooleanLiteral)) {
+      comment();
+      const value: boolean = checker.typeToString(type) === "true";
+      const constant: MetadataConstant = ArrayUtil.take(
+        meta.constants,
+        (elem) => elem.type === "boolean",
+        () =>
+          MetadataConstant.create({
+            type: "boolean",
+            values: [],
+          }),
+      );
+      ArrayUtil.add(
+        constant.values,
+        MetadataConstantValue.create({
+          value,
+          tags: [],
+          ...comment(),
+        }),
+        (a, b) => a.value === b.value,
+      );
+      return true;
+    }
+    return false;
+  };