typia 7.4.2-dev.20241217 → 7.4.2

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

@@ -1,31 +1,31 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
-import { emend_metadata_atomics } from "./emend_metadata_atomics";
-import { iterate_metadata } from "./iterate_metadata";
-
-export const explore_metadata = (props: Required<IProps>): Metadata => {
-  // CONSTRUCT METADATA
-  const metadata: Metadata = Metadata.initialize(props.explore.escaped);
-  if (props.type === null) return metadata;
-
-  // ITERATE TYPESCRIPT TYPES
-  props.intersected ??= false;
-  iterate_metadata({
-    ...props,
-    metadata,
-    type: props.type,
-  });
-  emend_metadata_atomics(metadata);
-  if (metadata.escaped) {
-    emend_metadata_atomics(metadata.escaped.original);
-    emend_metadata_atomics(metadata.escaped.returns);
-  }
-  return metadata;
-};
-
-interface IProps extends Omit<IMetadataIteratorProps, "metadata" | "type"> {
-  type: ts.Type | null;
-}
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+import { emend_metadata_atomics } from "./emend_metadata_atomics";
+import { iterate_metadata } from "./iterate_metadata";
+
+export const explore_metadata = (props: Required<IProps>): Metadata => {
+  // CONSTRUCT METADATA
+  const metadata: Metadata = Metadata.initialize(props.explore.escaped);
+  if (props.type === null) return metadata;
+
+  // ITERATE TYPESCRIPT TYPES
+  props.intersected ??= false;
+  iterate_metadata({
+    ...props,
+    metadata,
+    type: props.type,
+  });
+  emend_metadata_atomics(metadata);
+  if (metadata.escaped) {
+    emend_metadata_atomics(metadata.escaped.original);
+    emend_metadata_atomics(metadata.escaped.returns);
+  }
+  return metadata;
+};
+
+interface IProps extends Omit<IMetadataIteratorProps, "metadata" | "type"> {
+  type: ts.Type | null;
+}

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

@@ -1,54 +1,54 @@
-import ts from "typescript";
-
-import { TypeFactory } from "../../TypeFactory";
-import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
-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_escape } from "./iterate_metadata_escape";
-import { iterate_metadata_function } from "./iterate_metadata_function";
-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_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 = (props: IMetadataIteratorProps): void => {
-  if (props.type.isTypeParameter() === true) {
-    props.errors.push({
-      name: TypeFactory.getFullName({
-        checker: props.checker,
-        type: props.type,
-      }),
-      explore: { ...props.explore },
-      messages: ["non-specified generic argument found."],
-    });
-    return;
-  }
-  // CHECK SPECIAL CASES
-  if (
-    (props.explore.aliased !== true && iterate_metadata_alias(props)) ||
-    iterate_metadata_intersection(props) ||
-    iterate_metadata_union(props) ||
-    iterate_metadata_escape(props)
-  )
-    return;
-
-  // ITERATE CASES
-  iterate_metadata_coalesce(props) ||
-    iterate_metadata_function(props) ||
-    iterate_metadata_constant(props) ||
-    iterate_metadata_template(props) ||
-    iterate_metadata_atomic(props) ||
-    iterate_metadata_tuple(props as IMetadataIteratorProps<ts.TupleType>) ||
-    iterate_metadata_array(props) ||
-    iterate_metadata_native(props) ||
-    iterate_metadata_map(props) ||
-    iterate_metadata_set(props) ||
-    iterate_metadata_object(props);
-};
+import ts from "typescript";
+
+import { TypeFactory } from "../../TypeFactory";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+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_escape } from "./iterate_metadata_escape";
+import { iterate_metadata_function } from "./iterate_metadata_function";
+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_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 = (props: IMetadataIteratorProps): void => {
+  if (props.type.isTypeParameter() === true) {
+    props.errors.push({
+      name: TypeFactory.getFullName({
+        checker: props.checker,
+        type: props.type,
+      }),
+      explore: { ...props.explore },
+      messages: ["non-specified generic argument found."],
+    });
+    return;
+  }
+  // CHECK SPECIAL CASES
+  if (
+    (props.explore.aliased !== true && iterate_metadata_alias(props)) ||
+    iterate_metadata_intersection(props) ||
+    iterate_metadata_union(props) ||
+    iterate_metadata_escape(props)
+  )
+    return;
+
+  // ITERATE CASES
+  iterate_metadata_coalesce(props) ||
+    iterate_metadata_function(props) ||
+    iterate_metadata_constant(props) ||
+    iterate_metadata_template(props) ||
+    iterate_metadata_atomic(props) ||
+    iterate_metadata_tuple(props as IMetadataIteratorProps<ts.TupleType>) ||
+    iterate_metadata_array(props) ||
+    iterate_metadata_native(props) ||
+    iterate_metadata_map(props) ||
+    iterate_metadata_set(props) ||
+    iterate_metadata_object(props);
+};

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

@@ -1,33 +1,33 @@
-import ts from "typescript";
-
-import { MetadataAlias } from "../../../schemas/metadata/MetadataAlias";
-import { MetadataAliasType } from "../../../schemas/metadata/MetadataAliasType";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
-import { emplace_metadata_alias } from "./emplace_metadata_alias";
-
-export const iterate_metadata_alias = (
-  props: IMetadataIteratorProps,
-): boolean => {
-  if (props.options.absorb !== false || props.type.aliasSymbol === undefined)
-    return false;
-
-  const node: ts.Declaration | undefined =
-    props.type.aliasSymbol.declarations?.[0];
-  if (node === undefined) return false;
-
-  // CONSTRUCT DEFINITION
-  const type: MetadataAliasType = emplace_metadata_alias(props);
-  ArrayUtil.take(
-    props.metadata.aliases,
-    (elem) => elem.type.name === type.name,
-    () =>
-      MetadataAlias.create({
-        type,
-        tags: [],
-      }),
-  );
-  return true;
-};
+import ts from "typescript";
+
+import { MetadataAlias } from "../../../schemas/metadata/MetadataAlias";
+import { MetadataAliasType } from "../../../schemas/metadata/MetadataAliasType";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+import { emplace_metadata_alias } from "./emplace_metadata_alias";
+
+export const iterate_metadata_alias = (
+  props: IMetadataIteratorProps,
+): boolean => {
+  if (props.options.absorb !== false || props.type.aliasSymbol === undefined)
+    return false;
+
+  const node: ts.Declaration | undefined =
+    props.type.aliasSymbol.declarations?.[0];
+  if (node === undefined) return false;
+
+  // CONSTRUCT DEFINITION
+  const type: MetadataAliasType = emplace_metadata_alias(props);
+  ArrayUtil.take(
+    props.metadata.aliases,
+    (elem) => elem.type.name === type.name,
+    () =>
+      MetadataAlias.create({
+        type,
+        tags: [],
+      }),
+  );
+  return true;
+};

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

@@ -1,63 +1,63 @@
-import ts from "typescript";
-
-import { MetadataArray } from "../../../schemas/metadata/MetadataArray";
-import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
-import { emplace_metadata_array_type } from "./emplace_metadata_array_type";
-
-export const iterate_metadata_array = (
-  props: IMetadataIteratorProps,
-): boolean => {
-  const array: ts.Type | null =
-    props.checker.isArrayType(props.type) === false
-      ? find_array_extended({
-          checker: props.checker,
-          memory: new Map(),
-          type: props.type,
-        })
-      : props.type;
-  if (array === null) return false;
-
-  const arrayType: MetadataArrayType = emplace_metadata_array_type({
-    ...props,
-    array,
-  });
-  ArrayUtil.add(
-    props.metadata.arrays,
-    MetadataArray.create({
-      type: arrayType,
-      tags: [],
-    }),
-    (elem) => elem.type.name === arrayType.name,
-  );
-  return true;
-};
-
-const find_array_extended = (props: {
-  checker: ts.TypeChecker;
-  memory: Map<ts.Type, ts.Type | null>;
-  type: ts.Type;
-}): ts.Type | null => {
-  const cached = props.memory.get(props.type);
-  if (cached !== undefined) return null;
-
-  props.memory.set(props.type, null);
-  const res: ts.Type | null = (() => {
-    if (props.type.isClassOrInterface() === false) return null;
-    for (const t of props.type.resolvedBaseTypes ?? [])
-      if (props.checker.isArrayType(t)) return t;
-      else {
-        const res: ts.Type | null = find_array_extended({
-          ...props,
-          type: t,
-        });
-        if (res !== null) return res;
-      }
-    return null;
-  })();
-  props.memory.set(props.type, res);
-  return res;
-};
+import ts from "typescript";
+
+import { MetadataArray } from "../../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+import { emplace_metadata_array_type } from "./emplace_metadata_array_type";
+
+export const iterate_metadata_array = (
+  props: IMetadataIteratorProps,
+): boolean => {
+  const array: ts.Type | null =
+    props.checker.isArrayType(props.type) === false
+      ? find_array_extended({
+          checker: props.checker,
+          memory: new Map(),
+          type: props.type,
+        })
+      : props.type;
+  if (array === null) return false;
+
+  const arrayType: MetadataArrayType = emplace_metadata_array_type({
+    ...props,
+    array,
+  });
+  ArrayUtil.add(
+    props.metadata.arrays,
+    MetadataArray.create({
+      type: arrayType,
+      tags: [],
+    }),
+    (elem) => elem.type.name === arrayType.name,
+  );
+  return true;
+};
+
+const find_array_extended = (props: {
+  checker: ts.TypeChecker;
+  memory: Map<ts.Type, ts.Type | null>;
+  type: ts.Type;
+}): ts.Type | null => {
+  const cached = props.memory.get(props.type);
+  if (cached !== undefined) return null;
+
+  props.memory.set(props.type, null);
+  const res: ts.Type | null = (() => {
+    if (props.type.isClassOrInterface() === false) return null;
+    for (const t of props.type.resolvedBaseTypes ?? [])
+      if (props.checker.isArrayType(t)) return t;
+      else {
+        const res: ts.Type | null = find_array_extended({
+          ...props,
+          type: t,
+        });
+        if (res !== null) return res;
+      }
+    return null;
+  })();
+  props.memory.set(props.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.getFlags() & flag) !== 0;
-};
-
-export const iterate_metadata_atomic = (props: {
-  metadata: Metadata;
-  type: ts.Type;
-}): boolean => {
-  // PREPARE INTERNAL FUNCTIONS
-  const filter = same(props.type);
-  const check = (info: IAtomicInfo) => {
-    if (filter(info.atomic) || filter(info.literal)) {
-      ArrayUtil.add(
-        props.metadata.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 = (props: {
+  metadata: Metadata;
+  type: ts.Type;
+}): boolean => {
+  // PREPARE INTERNAL FUNCTIONS
+  const filter = same(props.type);
+  const check = (info: IAtomicInfo) => {
+    if (filter(info.atomic) || filter(info.literal)) {
+      ArrayUtil.add(
+        props.metadata.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,28 +1,28 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { Writable } from "../../../typings/Writable";
-
-export const iterate_metadata_coalesce = (props: {
-  metadata: Metadata;
-  type: ts.Type;
-}): boolean => {
-  const filter = (flag: ts.TypeFlags) => (props.type.getFlags() & flag) !== 0;
-  if (filter(ts.TypeFlags.Unknown) || filter(ts.TypeFlags.Any)) {
-    Writable(props.metadata).any = true;
-    return true;
-  } else if (filter(ts.TypeFlags.Null)) {
-    Writable(props.metadata).nullable = true;
-    return true;
-  } else if (
-    filter(ts.TypeFlags.Undefined) ||
-    filter(ts.TypeFlags.Never) ||
-    filter(ts.TypeFlags.Void) ||
-    filter(ts.TypeFlags.VoidLike)
-  ) {
-    Writable(props.metadata).required = false;
-    return true;
-  }
-  return false;
-};
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { Writable } from "../../../typings/Writable";
+
+export const iterate_metadata_coalesce = (props: {
+  metadata: Metadata;
+  type: ts.Type;
+}): boolean => {
+  const filter = (flag: ts.TypeFlags) => (props.type.getFlags() & flag) !== 0;
+  if (filter(ts.TypeFlags.Unknown) || filter(ts.TypeFlags.Any)) {
+    Writable(props.metadata).any = true;
+    return true;
+  } else if (filter(ts.TypeFlags.Null)) {
+    Writable(props.metadata).nullable = true;
+    return true;
+  } else if (
+    filter(ts.TypeFlags.Undefined) ||
+    filter(ts.TypeFlags.Never) ||
+    filter(ts.TypeFlags.Void) ||
+    filter(ts.TypeFlags.VoidLike)
+  ) {
+    Writable(props.metadata).required = false;
+    return true;
+  }
+  return false;
+};