typia 5.5.8 → 5.5.9

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

@@ -1,70 +1,70 @@
-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) === false) {
-      const array: ts.Type | null = find_array_extended(checker)(new Map())(
-        type,
-      );
-      if (array !== null)
-        return iterate_metadata_array(checker)(options)(collection)(errors)(
-          meta,
-          array,
-          explore,
-        );
-      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;
-  };
-
-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;
-  };
+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) === false) {
+      const array: ts.Type | null = find_array_extended(checker)(new Map())(
+        type,
+      );
+      if (array !== null)
+        return iterate_metadata_array(checker)(options)(collection)(errors)(
+          meta,
+          array,
+          explore,
+        );
+      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;
+  };
+
+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.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;
+};

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

@@ -1,131 +1,131 @@
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
-import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
-import { MetadataTupleType } from "../../../schemas/metadata/MetadataTupleType";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { iterate_metadata_comment_tags } from "./iterate_metadata_comment_tags";
-
-export const iterate_metadata_collection =
-  (errors: MetadataFactory.IError[]) =>
-  (collection: MetadataCollection): void => {
-    for (const array of collection.arrays())
-      if (array.recursive === null)
-        collection.setArrayRecursive(
-          array,
-          isArrayRecursive(new Set())(array)(array.value),
-        );
-    for (const tuple of collection.tuples())
-      if (tuple.recursive === null) {
-        const visited: Set<Metadata> = new Set();
-        collection.setTupleRecursive(
-          tuple,
-          tuple.elements.some(isTupleRecursive(visited)(tuple)),
-        );
-      }
-    for (const obj of collection.objects()) {
-      iterate_metadata_comment_tags(errors)(obj);
-      if (obj.recursive === null) {
-        const visited: Set<Metadata> = new Set();
-        collection.setObjectRecursive(
-          obj,
-          obj.properties.some((p) => isObjectRecursive(visited)(obj)(p.value)),
-        );
-      }
-    }
-  };
-
-const isArrayRecursive =
-  (visited: Set<Metadata>) =>
-  (array: MetadataArrayType) =>
-  (meta: Metadata): boolean => {
-    if (visited.has(meta)) return false;
-    visited.add(meta);
-
-    return (
-      meta.arrays.some(
-        (a) =>
-          a.type === array || isArrayRecursive(visited)(array)(a.type.value),
-      ) ||
-      meta.aliases.some((alias) =>
-        isArrayRecursive(visited)(array)(alias.value),
-      ) ||
-      meta.tuples.some(
-        (t) =>
-          !t.type.recursive &&
-          t.type.elements.some((e) => isArrayRecursive(visited)(array)(e)),
-      ) ||
-      meta.maps.some((m) => isArrayRecursive(visited)(array)(m.value)) ||
-      meta.sets.some((s) => isArrayRecursive(visited)(array)(s)) ||
-      (meta.escaped !== null &&
-        isArrayRecursive(visited)(array)(meta.escaped.returns)) ||
-      (meta.rest !== null && isArrayRecursive(visited)(array)(meta.rest))
-    );
-  };
-
-const isTupleRecursive =
-  (visited: Set<Metadata>) =>
-  (tuple: MetadataTupleType) =>
-  (meta: Metadata): boolean => {
-    if (visited.has(meta)) return false;
-    visited.add(meta);
-
-    return (
-      meta.tuples.some(
-        (t) =>
-          t.type === tuple ||
-          t.type.elements.some((e) => isTupleRecursive(visited)(tuple)(e)),
-      ) ||
-      meta.arrays.some(
-        (a) =>
-          !a.type.recursive && isTupleRecursive(visited)(tuple)(a.type.value),
-      ) ||
-      meta.maps.some((m) => isTupleRecursive(visited)(tuple)(m.value)) ||
-      meta.sets.some((s) => isTupleRecursive(visited)(tuple)(s)) ||
-      meta.aliases.some((alias) =>
-        isTupleRecursive(visited)(tuple)(alias.value),
-      ) ||
-      (meta.escaped !== null &&
-        isTupleRecursive(visited)(tuple)(meta.escaped.returns)) ||
-      (meta.rest !== null && isTupleRecursive(visited)(tuple)(meta.rest))
-    );
-  };
-
-const isObjectRecursive =
-  (visited: Set<Metadata>) =>
-  (obj: MetadataObject) =>
-  (meta: Metadata): boolean => {
-    if (visited.has(meta)) return false;
-
-    visited.add(meta);
-    return (
-      meta.objects.some(
-        (o) =>
-          obj === o ||
-          o.properties.some((prop) =>
-            isObjectRecursive(visited)(obj)(prop.value),
-          ),
-      ) ||
-      meta.aliases.some((alias) =>
-        isObjectRecursive(visited)(obj)(alias.value),
-      ) ||
-      meta.arrays.some(
-        (array) =>
-          !array.type.recursive &&
-          isObjectRecursive(visited)(obj)(array.type.value),
-      ) ||
-      meta.tuples.some(
-        (tuple) =>
-          !tuple.type.recursive &&
-          tuple.type.elements.some((elem) =>
-            isObjectRecursive(visited)(obj)(elem),
-          ),
-      ) ||
-      meta.maps.some((map) => isObjectRecursive(visited)(obj)(map.value)) ||
-      meta.sets.some((value) => isObjectRecursive(visited)(obj)(value)) ||
-      (meta.escaped !== null &&
-        isObjectRecursive(visited)(obj)(meta.escaped.returns)) ||
-      (meta.rest !== null && isObjectRecursive(visited)(obj)(meta.rest))
-    );
-  };
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
+import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
+import { MetadataTupleType } from "../../../schemas/metadata/MetadataTupleType";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { iterate_metadata_comment_tags } from "./iterate_metadata_comment_tags";
+
+export const iterate_metadata_collection =
+  (errors: MetadataFactory.IError[]) =>
+  (collection: MetadataCollection): void => {
+    for (const array of collection.arrays())
+      if (array.recursive === null)
+        collection.setArrayRecursive(
+          array,
+          isArrayRecursive(new Set())(array)(array.value),
+        );
+    for (const tuple of collection.tuples())
+      if (tuple.recursive === null) {
+        const visited: Set<Metadata> = new Set();
+        collection.setTupleRecursive(
+          tuple,
+          tuple.elements.some(isTupleRecursive(visited)(tuple)),
+        );
+      }
+    for (const obj of collection.objects()) {
+      iterate_metadata_comment_tags(errors)(obj);
+      if (obj.recursive === null) {
+        const visited: Set<Metadata> = new Set();
+        collection.setObjectRecursive(
+          obj,
+          obj.properties.some((p) => isObjectRecursive(visited)(obj)(p.value)),
+        );
+      }
+    }
+  };
+
+const isArrayRecursive =
+  (visited: Set<Metadata>) =>
+  (array: MetadataArrayType) =>
+  (meta: Metadata): boolean => {
+    if (visited.has(meta)) return false;
+    visited.add(meta);
+
+    return (
+      meta.arrays.some(
+        (a) =>
+          a.type === array || isArrayRecursive(visited)(array)(a.type.value),
+      ) ||
+      meta.aliases.some((alias) =>
+        isArrayRecursive(visited)(array)(alias.value),
+      ) ||
+      meta.tuples.some(
+        (t) =>
+          !t.type.recursive &&
+          t.type.elements.some((e) => isArrayRecursive(visited)(array)(e)),
+      ) ||
+      meta.maps.some((m) => isArrayRecursive(visited)(array)(m.value)) ||
+      meta.sets.some((s) => isArrayRecursive(visited)(array)(s)) ||
+      (meta.escaped !== null &&
+        isArrayRecursive(visited)(array)(meta.escaped.returns)) ||
+      (meta.rest !== null && isArrayRecursive(visited)(array)(meta.rest))
+    );
+  };
+
+const isTupleRecursive =
+  (visited: Set<Metadata>) =>
+  (tuple: MetadataTupleType) =>
+  (meta: Metadata): boolean => {
+    if (visited.has(meta)) return false;
+    visited.add(meta);
+
+    return (
+      meta.tuples.some(
+        (t) =>
+          t.type === tuple ||
+          t.type.elements.some((e) => isTupleRecursive(visited)(tuple)(e)),
+      ) ||
+      meta.arrays.some(
+        (a) =>
+          !a.type.recursive && isTupleRecursive(visited)(tuple)(a.type.value),
+      ) ||
+      meta.maps.some((m) => isTupleRecursive(visited)(tuple)(m.value)) ||
+      meta.sets.some((s) => isTupleRecursive(visited)(tuple)(s)) ||
+      meta.aliases.some((alias) =>
+        isTupleRecursive(visited)(tuple)(alias.value),
+      ) ||
+      (meta.escaped !== null &&
+        isTupleRecursive(visited)(tuple)(meta.escaped.returns)) ||
+      (meta.rest !== null && isTupleRecursive(visited)(tuple)(meta.rest))
+    );
+  };
+
+const isObjectRecursive =
+  (visited: Set<Metadata>) =>
+  (obj: MetadataObject) =>
+  (meta: Metadata): boolean => {
+    if (visited.has(meta)) return false;
+
+    visited.add(meta);
+    return (
+      meta.objects.some(
+        (o) =>
+          obj === o ||
+          o.properties.some((prop) =>
+            isObjectRecursive(visited)(obj)(prop.value),
+          ),
+      ) ||
+      meta.aliases.some((alias) =>
+        isObjectRecursive(visited)(obj)(alias.value),
+      ) ||
+      meta.arrays.some(
+        (array) =>
+          !array.type.recursive &&
+          isObjectRecursive(visited)(obj)(array.type.value),
+      ) ||
+      meta.tuples.some(
+        (tuple) =>
+          !tuple.type.recursive &&
+          tuple.type.elements.some((elem) =>
+            isObjectRecursive(visited)(obj)(elem),
+          ),
+      ) ||
+      meta.maps.some((map) => isObjectRecursive(visited)(obj)(map.value)) ||
+      meta.sets.some((value) => isObjectRecursive(visited)(obj)(value)) ||
+      (meta.escaped !== null &&
+        isObjectRecursive(visited)(obj)(meta.escaped.returns)) ||
+      (meta.rest !== null && isObjectRecursive(visited)(obj)(meta.rest))
+    );
+  };

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

@@ -1,26 +1,26 @@
-import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
-
-import { MetadataCommentTagFactory } from "../../MetadataCommentTagFactory";
-import { MetadataFactory } from "../../MetadataFactory";
-
-export const iterate_metadata_comment_tags =
-  (errors: MetadataFactory.IError[]) => (object: MetadataObject) => {
-    if (object.tagged_ === true) return;
-    object.tagged_ = true;
-
-    for (const property of object.properties) {
-      MetadataCommentTagFactory.analyze(errors)(property.value)(
-        property.jsDocTags,
-        {
-          top: false,
-          object,
-          property: property.key.isSoleLiteral()
-            ? property.key.getSoleLiteral()!
-            : {},
-          nested: null,
-          escaped: false,
-          aliased: false,
-        },
-      );
-    }
-  };
+import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
+
+import { MetadataCommentTagFactory } from "../../MetadataCommentTagFactory";
+import { MetadataFactory } from "../../MetadataFactory";
+
+export const iterate_metadata_comment_tags =
+  (errors: MetadataFactory.IError[]) => (object: MetadataObject) => {
+    if (object.tagged_ === true) return;
+    object.tagged_ = true;
+
+    for (const property of object.properties) {
+      MetadataCommentTagFactory.analyze(errors)(property.value)(
+        property.jsDocTags,
+        {
+          top: false,
+          object,
+          property: property.key.isSoleLiteral()
+            ? property.key.getSoleLiteral()!
+            : {},
+          nested: null,
+          escaped: false,
+          aliased: false,
+        },
+      );
+    }
+  };