typia 5.5.5 → 5.5.6-dev.20240319

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,
+        },
+      );
+    }
+  };

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

@@ -1,48 +1,48 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataConstant } from "../../../schemas/metadata/MetadataConstant";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-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;
-    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 as Array<any>, value, (a, b) => a === b);
-      return true;
-    } else if (filter(ts.TypeFlags.BooleanLiteral)) {
-      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 as boolean[], value, (a, b) => a === b);
-      return true;
-    }
-    return false;
-  };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataConstant } from "../../../schemas/metadata/MetadataConstant";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+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;
+    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 as Array<any>, value, (a, b) => a === b);
+      return true;
+    } else if (filter(ts.TypeFlags.BooleanLiteral)) {
+      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 as boolean[], value, (a, b) => a === b);
+      return true;
+    }
+    return false;
+  };

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

@@ -1,52 +1,52 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataEscaped } from "../../../schemas/metadata/MetadataEscaped";
-
-import { Writable } from "../../../typings/Writable";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { TypeFactory } from "../../TypeFactory";
-import { iterate_metadata } from "./iterate_metadata";
-
-export const iterate_metadata_escape =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (
-    meta: Metadata,
-    type: ts.Type,
-    explore: MetadataFactory.IExplore,
-  ): boolean => {
-    if (options.escape === false || explore.escaped === true) return false;
-
-    const escaped: ts.Type | null =
-      TypeFactory.getReturnType(checker)(type)("toJSON");
-    if (escaped === null) return false;
-
-    if (meta.escaped === null) {
-      Writable(meta).escaped = MetadataEscaped.create({
-        original: Metadata.initialize(),
-        returns: Metadata.initialize(),
-      });
-    }
-    iterate_metadata(checker)(options)(collection)(errors)(
-      meta.escaped!.original,
-      type,
-      {
-        ...explore,
-        escaped: true,
-      },
-    );
-    iterate_metadata(checker)(options)(collection)(errors)(
-      meta.escaped!.returns,
-      escaped,
-      {
-        ...explore,
-        escaped: true,
-      },
-    );
-    return true;
-  };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataEscaped } from "../../../schemas/metadata/MetadataEscaped";
+
+import { Writable } from "../../../typings/Writable";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { TypeFactory } from "../../TypeFactory";
+import { iterate_metadata } from "./iterate_metadata";
+
+export const iterate_metadata_escape =
+  (checker: ts.TypeChecker) =>
+  (options: MetadataFactory.IOptions) =>
+  (collection: MetadataCollection) =>
+  (errors: MetadataFactory.IError[]) =>
+  (
+    meta: Metadata,
+    type: ts.Type,
+    explore: MetadataFactory.IExplore,
+  ): boolean => {
+    if (options.escape === false || explore.escaped === true) return false;
+
+    const escaped: ts.Type | null =
+      TypeFactory.getReturnType(checker)(type)("toJSON");
+    if (escaped === null) return false;
+
+    if (meta.escaped === null) {
+      Writable(meta).escaped = MetadataEscaped.create({
+        original: Metadata.initialize(),
+        returns: Metadata.initialize(),
+      });
+    }
+    iterate_metadata(checker)(options)(collection)(errors)(
+      meta.escaped!.original,
+      type,
+      {
+        ...explore,
+        escaped: true,
+      },
+    );
+    iterate_metadata(checker)(options)(collection)(errors)(
+      meta.escaped!.returns,
+      escaped,
+      {
+        ...explore,
+        escaped: true,
+      },
+    );
+    return true;
+  };