typia 7.0.0-dev.20240918 → 7.0.0-dev.20240920

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

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

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

@@ -1,47 +1,47 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataEscaped } from "../../../schemas/metadata/MetadataEscaped";
-
-import { Writable } from "../../../typings/Writable";
-
-import { TypeFactory } from "../../TypeFactory";
-import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
-import { iterate_metadata } from "./iterate_metadata";
-
-export const iterate_metadata_escape = (
-  props: IMetadataIteratorProps,
-): boolean => {
-  if (props.options.escape === false || props.explore.escaped === true)
-    return false;
-
-  const escaped: ts.Type | null = TypeFactory.getReturnType(props.checker)(
-    props.type,
-  )("toJSON");
-  if (escaped === null) return false;
-
-  if (props.metadata.escaped === null) {
-    Writable(props.metadata).escaped = MetadataEscaped.create({
-      original: Metadata.initialize(),
-      returns: Metadata.initialize(),
-    });
-  }
-  iterate_metadata({
-    ...props,
-    metadata: props.metadata.escaped!.original,
-    explore: {
-      ...props.explore,
-      escaped: true,
-    },
-  });
-  iterate_metadata({
-    ...props,
-    metadata: props.metadata.escaped!.returns,
-    type: escaped,
-    explore: {
-      ...props.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 { TypeFactory } from "../../TypeFactory";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+import { iterate_metadata } from "./iterate_metadata";
+
+export const iterate_metadata_escape = (
+  props: IMetadataIteratorProps,
+): boolean => {
+  if (props.options.escape === false || props.explore.escaped === true)
+    return false;
+
+  const escaped: ts.Type | null = TypeFactory.getReturnType(props.checker)(
+    props.type,
+  )("toJSON");
+  if (escaped === null) return false;
+
+  if (props.metadata.escaped === null) {
+    Writable(props.metadata).escaped = MetadataEscaped.create({
+      original: Metadata.initialize(),
+      returns: Metadata.initialize(),
+    });
+  }
+  iterate_metadata({
+    ...props,
+    metadata: props.metadata.escaped!.original,
+    explore: {
+      ...props.explore,
+      escaped: true,
+    },
+  });
+  iterate_metadata({
+    ...props,
+    metadata: props.metadata.escaped!.returns,
+    type: escaped,
+    explore: {
+      ...props.explore,
+      escaped: true,
+    },
+  });
+  return true;
+};

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

@@ -69,9 +69,11 @@ export const iterate_metadata_function = (
               functional: false,
             },
             type: async
-              ? (signature.getReturnType().aliasTypeArguments?.[0] ??
+            ? (props.checker.getTypeArguments(
+                signature.getReturnType() as ts.TypeReference,
+              )?.[0] ??
                 props.checker.getTypeFromTypeNode(TypeFactory.keyword("any")))
-              : signature.getReturnType(),
+            : signature.getReturnType(),
             explore: {
               ...props.explore,
               top: false,

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

@@ -1,83 +1,83 @@
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
-
-import { MetadataCollection } from "../../MetadataCollection";
-
-export const iterate_metadata_sort = (props: {
-  collection: MetadataCollection;
-  metadata: Metadata;
-}) => {
-  const visited: Set<Metadata> = new Set();
-  const next = (metadata: Metadata) =>
-    iterate({
-      visited,
-      collection: props.collection,
-      metadata,
-    });
-  for (const array of props.collection.arrays()) next(array.value);
-  for (const tuple of props.collection.tuples())
-    for (const element of tuple.elements) next(element);
-  for (const object of props.collection.objects())
-    for (const property of object.properties) next(property.value);
-  next(props.metadata);
-};
-
-const iterate = (props: {
-  visited: Set<Metadata>;
-  collection: MetadataCollection;
-  metadata: Metadata;
-}) => {
-  if (props.visited.has(props.metadata)) return;
-  props.visited.add(props.metadata);
-
-  const next = (metadata: Metadata) =>
-    iterate({
-      ...props,
-      metadata,
-    });
-
-  // ITERATE CHILDREN
-  for (const map of props.metadata.maps) next(map.value);
-  for (const set of props.metadata.sets) next(set);
-  if (props.metadata.escaped !== null) next(props.metadata.escaped.returns);
-  if (props.metadata.rest !== null) next(props.metadata.rest);
-
-  // SORT OBJECTS
-  if (props.metadata.objects.length > 1) {
-    props.metadata.objects.sort((x, y) =>
-      MetadataObject.covers(x, y) ? -1 : MetadataObject.covers(y, x) ? 1 : 0,
-    );
-    props.metadata.union_index = props.collection.getUnionIndex(props.metadata);
-  }
-
-  // SORT ARRAYS AND TUPLES
-  if (props.metadata.arrays.length > 1)
-    props.metadata.arrays.sort((x, y) =>
-      Metadata.covers(x.type.value, y.type.value)
-        ? -1
-        : Metadata.covers(y.type.value, x.type.value)
-          ? 1
-          : 0,
-    );
-  if (props.metadata.tuples.length > 1)
-    props.metadata.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 props.metadata.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 = (props: {
+  collection: MetadataCollection;
+  metadata: Metadata;
+}) => {
+  const visited: Set<Metadata> = new Set();
+  const next = (metadata: Metadata) =>
+    iterate({
+      visited,
+      collection: props.collection,
+      metadata,
+    });
+  for (const array of props.collection.arrays()) next(array.value);
+  for (const tuple of props.collection.tuples())
+    for (const element of tuple.elements) next(element);
+  for (const object of props.collection.objects())
+    for (const property of object.properties) next(property.value);
+  next(props.metadata);
+};
+
+const iterate = (props: {
+  visited: Set<Metadata>;
+  collection: MetadataCollection;
+  metadata: Metadata;
+}) => {
+  if (props.visited.has(props.metadata)) return;
+  props.visited.add(props.metadata);
+
+  const next = (metadata: Metadata) =>
+    iterate({
+      ...props,
+      metadata,
+    });
+
+  // ITERATE CHILDREN
+  for (const map of props.metadata.maps) next(map.value);
+  for (const set of props.metadata.sets) next(set);
+  if (props.metadata.escaped !== null) next(props.metadata.escaped.returns);
+  if (props.metadata.rest !== null) next(props.metadata.rest);
+
+  // SORT OBJECTS
+  if (props.metadata.objects.length > 1) {
+    props.metadata.objects.sort((x, y) =>
+      MetadataObject.covers(x, y) ? -1 : MetadataObject.covers(y, x) ? 1 : 0,
+    );
+    props.metadata.union_index = props.collection.getUnionIndex(props.metadata);
+  }
+
+  // SORT ARRAYS AND TUPLES
+  if (props.metadata.arrays.length > 1)
+    props.metadata.arrays.sort((x, y) =>
+      Metadata.covers(x.type.value, y.type.value)
+        ? -1
+        : Metadata.covers(y.type.value, x.type.value)
+          ? 1
+          : 0,
+    );
+  if (props.metadata.tuples.length > 1)
+    props.metadata.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 props.metadata.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));
+};

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

@@ -1,26 +1,26 @@
-import ts from "typescript";
-
-import { MetadataTuple } from "../../../schemas/metadata/MetadataTuple";
-import { MetadataTupleType } from "../../../schemas/metadata/MetadataTupleType";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
-import { emplace_metadata_tuple } from "./emplace_metadata_tuple";
-
-export const iterate_metadata_tuple = (
-  props: IMetadataIteratorProps<ts.TupleType>,
-): boolean => {
-  if (!props.checker.isTupleType(props.type)) return false;
-
-  const tupleType: MetadataTupleType = emplace_metadata_tuple(props);
-  ArrayUtil.add(
-    props.metadata.tuples,
-    MetadataTuple.create({
-      type: tupleType,
-      tags: [],
-    }),
-    (elem) => elem.type.name === tupleType.name,
-  );
-  return true;
-};
+import ts from "typescript";
+
+import { MetadataTuple } from "../../../schemas/metadata/MetadataTuple";
+import { MetadataTupleType } from "../../../schemas/metadata/MetadataTupleType";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+import { emplace_metadata_tuple } from "./emplace_metadata_tuple";
+
+export const iterate_metadata_tuple = (
+  props: IMetadataIteratorProps<ts.TupleType>,
+): boolean => {
+  if (!props.checker.isTupleType(props.type)) return false;
+
+  const tupleType: MetadataTupleType = emplace_metadata_tuple(props);
+  ArrayUtil.add(
+    props.metadata.tuples,
+    MetadataTuple.create({
+      type: tupleType,
+      tags: [],
+    }),
+    (elem) => elem.type.name === tupleType.name,
+  );
+  return true;
+};

package/src/programmers/AssertProgrammer.ts

@@ -309,11 +309,11 @@ export namespace AssertProgrammer {
     (project: ITypiaContext) =>
     (importer: FunctionImporter): CheckerProgrammer.IConfig.IJoiner => ({
       object: assert_object(equals)(project)(importer),
-      array: (input, arrow) =>
+      array: (props) =>
         ts.factory.createCallExpression(
-          IdentifierFactory.access(input)("every"),
+          IdentifierFactory.access(props.input)("every"),
           undefined,
-          [arrow],
+          [props.arrow],
         ),
       failure: (value, expected, explore) =>
         create_guard_call(importer)(