typia 6.10.0 → 6.10.1-dev.20240919

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

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

@@ -70,7 +70,9 @@ export const iterate_metadata_function =
               functional: false,
             })(collection)(errors)(
               async
-                ? (signature.getReturnType().aliasTypeArguments?.[0] ??
+                ? (checker.getTypeArguments(
+                    signature.getReturnType() as ts.TypeReference,
+                  )?.[0] ??
                     checker.getTypeFromTypeNode(TypeFactory.keyword("any")))
                 : signature.getReturnType(),
               {

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

@@ -1,74 +1,74 @@
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
-
-import { MetadataCollection } from "../../MetadataCollection";
-
-export const iterate_metadata_sort =
-  (collection: MetadataCollection) => (meta: Metadata) => {
-    const visited: Set<Metadata> = new Set();
-    for (const array of collection.arrays())
-      iterate(visited)(collection)(array.value);
-    for (const tuple of collection.tuples())
-      for (const element of tuple.elements)
-        iterate(visited)(collection)(element);
-    for (const object of collection.objects())
-      for (const property of object.properties)
-        iterate(visited)(collection)(property.value);
-    iterate(visited)(collection)(meta);
-  };
-
-const iterate =
-  (visited: Set<Metadata>) =>
-  (collection: MetadataCollection) =>
-  (meta: Metadata) => {
-    if (visited.has(meta)) return;
-    visited.add(meta);
-
-    // ITERATE CHILDREN
-    for (const map of meta.maps) iterate(visited)(collection)(map.value);
-    for (const set of meta.sets) iterate(visited)(collection)(set);
-    if (meta.escaped !== null)
-      iterate(visited)(collection)(meta.escaped.returns);
-    if (meta.rest !== null) iterate(visited)(collection)(meta.rest);
-
-    // SORT OBJECTS
-    if (meta.objects.length > 1) {
-      meta.objects.sort((x, y) =>
-        MetadataObject.covers(x, y) ? -1 : MetadataObject.covers(y, x) ? 1 : 0,
-      );
-      meta.union_index = collection.getUnionIndex(meta);
-    }
-
-    // SORT ARRAYS AND TUPLES
-    if (meta.arrays.length > 1)
-      meta.arrays.sort((x, y) =>
-        Metadata.covers(x.type.value, y.type.value)
-          ? -1
-          : Metadata.covers(y.type.value, x.type.value)
-            ? 1
-            : 0,
-      );
-    if (meta.tuples.length > 1)
-      meta.tuples.sort((x, y) => {
-        const xt = Metadata.initialize();
-        const yt = Metadata.initialize();
-
-        xt.tuples.push(x);
-        yt.tuples.push(y);
-
-        return Metadata.covers(xt, yt) ? -1 : Metadata.covers(yt, xt) ? 1 : 0;
-      });
-
-    // SORT CONSTANT VALUES
-    for (const constant of meta.constants)
-      if (constant.type === "string") constant.values.sort();
-      else if (constant.type === "number")
-        constant.values.sort(
-          (a, b) => (a.value as number) - (b.value as number),
-        );
-      else if (constant.type === "bigint")
-        constant.values.sort((a, b) =>
-          (a.value as bigint) < (b.value as bigint) ? -1 : 1,
-        );
-      else constant.values.sort((a, _b) => (a.value === false ? -1 : 1));
-  };
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
+
+import { MetadataCollection } from "../../MetadataCollection";
+
+export const iterate_metadata_sort =
+  (collection: MetadataCollection) => (meta: Metadata) => {
+    const visited: Set<Metadata> = new Set();
+    for (const array of collection.arrays())
+      iterate(visited)(collection)(array.value);
+    for (const tuple of collection.tuples())
+      for (const element of tuple.elements)
+        iterate(visited)(collection)(element);
+    for (const object of collection.objects())
+      for (const property of object.properties)
+        iterate(visited)(collection)(property.value);
+    iterate(visited)(collection)(meta);
+  };
+
+const iterate =
+  (visited: Set<Metadata>) =>
+  (collection: MetadataCollection) =>
+  (meta: Metadata) => {
+    if (visited.has(meta)) return;
+    visited.add(meta);
+
+    // ITERATE CHILDREN
+    for (const map of meta.maps) iterate(visited)(collection)(map.value);
+    for (const set of meta.sets) iterate(visited)(collection)(set);
+    if (meta.escaped !== null)
+      iterate(visited)(collection)(meta.escaped.returns);
+    if (meta.rest !== null) iterate(visited)(collection)(meta.rest);
+
+    // SORT OBJECTS
+    if (meta.objects.length > 1) {
+      meta.objects.sort((x, y) =>
+        MetadataObject.covers(x, y) ? -1 : MetadataObject.covers(y, x) ? 1 : 0,
+      );
+      meta.union_index = collection.getUnionIndex(meta);
+    }
+
+    // SORT ARRAYS AND TUPLES
+    if (meta.arrays.length > 1)
+      meta.arrays.sort((x, y) =>
+        Metadata.covers(x.type.value, y.type.value)
+          ? -1
+          : Metadata.covers(y.type.value, x.type.value)
+            ? 1
+            : 0,
+      );
+    if (meta.tuples.length > 1)
+      meta.tuples.sort((x, y) => {
+        const xt = Metadata.initialize();
+        const yt = Metadata.initialize();
+
+        xt.tuples.push(x);
+        yt.tuples.push(y);
+
+        return Metadata.covers(xt, yt) ? -1 : Metadata.covers(yt, xt) ? 1 : 0;
+      });
+
+    // SORT CONSTANT VALUES
+    for (const constant of meta.constants)
+      if (constant.type === "string") constant.values.sort();
+      else if (constant.type === "number")
+        constant.values.sort(
+          (a, b) => (a.value as number) - (b.value as number),
+        );
+      else if (constant.type === "bigint")
+        constant.values.sort((a, b) =>
+          (a.value as bigint) < (b.value as bigint) ? -1 : 1,
+        );
+      else constant.values.sort((a, _b) => (a.value === false ? -1 : 1));
+  };