typia 5.3.5-dev.20231206 → 5.3.5

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

@@ -1,28 +1,28 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { emend_metadata_atomics } from "./emend_metadata_atomics";
-import { iterate_metadata } from "./iterate_metadata";
-
-export const explore_metadata =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (type: ts.Type | null, explore: MetadataFactory.IExplore): Metadata => {
-    // CONSTRUCT METADATA
-    const meta: Metadata = Metadata.initialize(explore.escaped);
-    if (type === null) return meta;
-
-    // ITERATE TYPESCRIPT TYPES
-    iterate_metadata(checker)(options)(collection)(errors)(meta, type, explore);
-    emend_metadata_atomics(meta);
-    if (meta.escaped) {
-      emend_metadata_atomics(meta.escaped.original);
-      emend_metadata_atomics(meta.escaped.returns);
-    }
-    return meta;
-  };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { emend_metadata_atomics } from "./emend_metadata_atomics";
+import { iterate_metadata } from "./iterate_metadata";
+
+export const explore_metadata =
+  (checker: ts.TypeChecker) =>
+  (options: MetadataFactory.IOptions) =>
+  (collection: MetadataCollection) =>
+  (errors: MetadataFactory.IError[]) =>
+  (type: ts.Type | null, explore: MetadataFactory.IExplore): Metadata => {
+    // CONSTRUCT METADATA
+    const meta: Metadata = Metadata.initialize(explore.escaped);
+    if (type === null) return meta;
+
+    // ITERATE TYPESCRIPT TYPES
+    iterate_metadata(checker)(options)(collection)(errors)(meta, type, explore);
+    emend_metadata_atomics(meta);
+    if (meta.escaped) {
+      emend_metadata_atomics(meta.escaped.original);
+      emend_metadata_atomics(meta.escaped.returns);
+    }
+    return meta;
+  };

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

@@ -1,94 +1,94 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { TypeFactory } from "../../TypeFactory";
-import { iterate_metadata_alias } from "./iterate_metadata_alias";
-import { iterate_metadata_array } from "./iterate_metadata_array";
-import { iterate_metadata_atomic } from "./iterate_metadata_atomic";
-import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
-import { iterate_metadata_constant } from "./iterate_metadata_constant";
-import { iterate_metadata_intersection } from "./iterate_metadata_intersection";
-import { iterate_metadata_map } from "./iterate_metadata_map";
-import { iterate_metadata_native } from "./iterate_metadata_native";
-import { iterate_metadata_object } from "./iterate_metadata_object";
-import { iterate_metadata_resolve } from "./iterate_metadata_resolve";
-import { iterate_metadata_set } from "./iterate_metadata_set";
-import { iterate_metadata_template } from "./iterate_metadata_template";
-import { iterate_metadata_tuple } from "./iterate_metadata_tuple";
-import { iterate_metadata_union } from "./iterate_metadata_union";
-
-export const iterate_metadata =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (meta: Metadata, type: ts.Type, explore: MetadataFactory.IExplore): void => {
-    if (type.isTypeParameter() === true) {
-      errors.push({
-        name: TypeFactory.getFullName(checker)(type),
-        explore: { ...explore },
-        messages: ["non-specified generic argument found."],
-      });
-      return;
-    }
-    // CHECK SPECIAL CASES
-    else if (
-      (explore.aliased !== true &&
-        iterate_metadata_alias(checker)(options)(collection)(errors)(
-          meta,
-          type,
-          explore,
-        )) ||
-      iterate_metadata_intersection(checker)(options)(collection)(errors)(
-        meta,
-        type,
-        explore,
-      ) ||
-      iterate_metadata_union(checker)(options)(collection)(errors)(
-        meta,
-        type,
-        explore,
-      ) ||
-      iterate_metadata_resolve(checker)(options)(collection)(errors)(
-        meta,
-        type,
-        explore,
-      )
-    )
-      return;
-
-    // ITERATE CASES
-    iterate_metadata_coalesce(meta, type) ||
-      iterate_metadata_constant(checker)(options)(meta, type) ||
-      iterate_metadata_template(checker)(options)(collection)(errors)(
-        meta,
-        type,
-        explore,
-      ) ||
-      iterate_metadata_atomic(meta, type) ||
-      iterate_metadata_tuple(checker)(options)(collection)(errors)(
-        meta,
-        type as ts.TupleType,
-        explore,
-      ) ||
-      iterate_metadata_array(checker)(options)(collection)(errors)(
-        meta,
-        type,
-        explore,
-      ) ||
-      iterate_metadata_native(checker)(meta, type) ||
-      iterate_metadata_map(checker)(options)(collection)(errors)(
-        meta,
-        type,
-        explore,
-      ) ||
-      iterate_metadata_set(checker)(options)(collection)(errors)(
-        meta,
-        type,
-        explore,
-      ) ||
-      iterate_metadata_object(checker)(options)(collection)(errors)(meta, type);
-  };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { TypeFactory } from "../../TypeFactory";
+import { iterate_metadata_alias } from "./iterate_metadata_alias";
+import { iterate_metadata_array } from "./iterate_metadata_array";
+import { iterate_metadata_atomic } from "./iterate_metadata_atomic";
+import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
+import { iterate_metadata_constant } from "./iterate_metadata_constant";
+import { iterate_metadata_intersection } from "./iterate_metadata_intersection";
+import { iterate_metadata_map } from "./iterate_metadata_map";
+import { iterate_metadata_native } from "./iterate_metadata_native";
+import { iterate_metadata_object } from "./iterate_metadata_object";
+import { iterate_metadata_resolve } from "./iterate_metadata_resolve";
+import { iterate_metadata_set } from "./iterate_metadata_set";
+import { iterate_metadata_template } from "./iterate_metadata_template";
+import { iterate_metadata_tuple } from "./iterate_metadata_tuple";
+import { iterate_metadata_union } from "./iterate_metadata_union";
+
+export const iterate_metadata =
+  (checker: ts.TypeChecker) =>
+  (options: MetadataFactory.IOptions) =>
+  (collection: MetadataCollection) =>
+  (errors: MetadataFactory.IError[]) =>
+  (meta: Metadata, type: ts.Type, explore: MetadataFactory.IExplore): void => {
+    if (type.isTypeParameter() === true) {
+      errors.push({
+        name: TypeFactory.getFullName(checker)(type),
+        explore: { ...explore },
+        messages: ["non-specified generic argument found."],
+      });
+      return;
+    }
+    // CHECK SPECIAL CASES
+    else if (
+      (explore.aliased !== true &&
+        iterate_metadata_alias(checker)(options)(collection)(errors)(
+          meta,
+          type,
+          explore,
+        )) ||
+      iterate_metadata_intersection(checker)(options)(collection)(errors)(
+        meta,
+        type,
+        explore,
+      ) ||
+      iterate_metadata_union(checker)(options)(collection)(errors)(
+        meta,
+        type,
+        explore,
+      ) ||
+      iterate_metadata_resolve(checker)(options)(collection)(errors)(
+        meta,
+        type,
+        explore,
+      )
+    )
+      return;
+
+    // ITERATE CASES
+    iterate_metadata_coalesce(meta, type) ||
+      iterate_metadata_constant(checker)(options)(meta, type) ||
+      iterate_metadata_template(checker)(options)(collection)(errors)(
+        meta,
+        type,
+        explore,
+      ) ||
+      iterate_metadata_atomic(meta, type) ||
+      iterate_metadata_tuple(checker)(options)(collection)(errors)(
+        meta,
+        type as ts.TupleType,
+        explore,
+      ) ||
+      iterate_metadata_array(checker)(options)(collection)(errors)(
+        meta,
+        type,
+        explore,
+      ) ||
+      iterate_metadata_native(checker)(meta, type) ||
+      iterate_metadata_map(checker)(options)(collection)(errors)(
+        meta,
+        type,
+        explore,
+      ) ||
+      iterate_metadata_set(checker)(options)(collection)(errors)(
+        meta,
+        type,
+        explore,
+      ) ||
+      iterate_metadata_object(checker)(options)(collection)(errors)(meta, type);
+  };

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

@@ -1,34 +1,34 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataAlias } from "../../../schemas/metadata/MetadataAlias";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { emplace_metadata_alias } from "./emplace_metadata_alias";
-
-export const iterate_metadata_alias =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (
-    meta: Metadata,
-    type: ts.Type,
-    explore: MetadataFactory.IExplore,
-  ): boolean => {
-    if (options.absorb !== false || type.aliasSymbol === undefined)
-      return false;
-
-    const node: ts.Declaration | undefined = type.aliasSymbol.declarations?.[0];
-    if (node === undefined) return false;
-
-    // CONSTRUCT DEFINITION
-    const alias: MetadataAlias = emplace_metadata_alias(checker)(options)(
-      collection,
-    )(errors)(type, meta.nullable, explore);
-    ArrayUtil.add(meta.aliases, alias, (elem) => elem.name === alias.name);
-    return true;
-  };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataAlias } from "../../../schemas/metadata/MetadataAlias";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { emplace_metadata_alias } from "./emplace_metadata_alias";
+
+export const iterate_metadata_alias =
+  (checker: ts.TypeChecker) =>
+  (options: MetadataFactory.IOptions) =>
+  (collection: MetadataCollection) =>
+  (errors: MetadataFactory.IError[]) =>
+  (
+    meta: Metadata,
+    type: ts.Type,
+    explore: MetadataFactory.IExplore,
+  ): boolean => {
+    if (options.absorb !== false || type.aliasSymbol === undefined)
+      return false;
+
+    const node: ts.Declaration | undefined = type.aliasSymbol.declarations?.[0];
+    if (node === undefined) return false;
+
+    // CONSTRUCT DEFINITION
+    const alias: MetadataAlias = emplace_metadata_alias(checker)(options)(
+      collection,
+    )(errors)(type, meta.nullable, explore);
+    ArrayUtil.add(meta.aliases, alias, (elem) => elem.name === alias.name);
+    return true;
+  };

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

@@ -1,37 +1,37 @@
-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,
-    type: ts.Type,
-    explore: MetadataFactory.IExplore,
-  ): boolean => {
-    if (!checker.isArrayType(type)) return false;
-
-    const arrayType: MetadataArrayType = emplace_metadata_array_type(checker)(
-      options,
-    )(collection)(errors)(type, meta.nullable, explore);
-    ArrayUtil.add(
-      meta.arrays,
-      MetadataArray.create({
-        type: arrayType,
-        tags: [],
-      }),
-      (elem) => elem.type.name === arrayType.name,
-    );
-    return true;
-  };
+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,
+    type: ts.Type,
+    explore: MetadataFactory.IExplore,
+  ): boolean => {
+    if (!checker.isArrayType(type)) return false;
+
+    const arrayType: MetadataArrayType = emplace_metadata_array_type(checker)(
+      options,
+    )(collection)(errors)(type, meta.nullable, explore);
+    ArrayUtil.add(
+      meta.arrays,
+      MetadataArray.create({
+        type: arrayType,
+        tags: [],
+      }),
+      (elem) => elem.type.name === arrayType.name,
+    );
+    return true;
+  };

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.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;
-}
+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.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;
-};
+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;
+};