typia 7.0.0-dev.20240916 → 7.0.0-dev.20240918

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

@@ -1,10 +1,7 @@
 import ts from "typescript";
 
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
 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";
@@ -21,80 +18,34 @@ 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 =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (meta: Metadata, type: ts.Type, explore: MetadataFactory.IExplore): void => {
-    if (type.isTypeParameter() === true) {
-      errors.push({
-        name: TypeFactory.getFullName(checker)(type),
-        explore: { ...explore },
-        messages: ["non-specified generic argument found."],
-      });
-      return;
-    }
-    // CHECK SPECIAL CASES
-    else if (
-      (explore.aliased !== true &&
-        iterate_metadata_alias(checker)(options)(collection)(errors)(
-          meta,
-          type,
-          explore,
-        )) ||
-      iterate_metadata_intersection(checker)(options)(collection)(errors)(
-        meta,
-        type,
-        explore,
-      ) ||
-      iterate_metadata_union(checker)(options)(collection)(errors)(
-        meta,
-        type,
-        explore,
-      ) ||
-      iterate_metadata_escape(checker)(options)(collection)(errors)(
-        meta,
-        type,
-        explore,
-      )
-    )
-      return;
+export const iterate_metadata = (props: IMetadataIteratorProps): void => {
+  if (props.type.isTypeParameter() === true) {
+    props.errors.push({
+      name: TypeFactory.getFullName(props.checker)(props.type),
+      explore: { ...props.explore },
+      messages: ["non-specified generic argument found."],
+    });
+    return;
+  }
+  // CHECK SPECIAL CASES
+  else 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(meta, type) ||
-      iterate_metadata_function(checker)(options)(collection)(errors)(
-        meta,
-        type,
-        explore,
-      ) ||
-      iterate_metadata_constant(checker)(options)(meta, type) ||
-      iterate_metadata_template(checker)(options)(collection)(errors)(
-        meta,
-        type,
-        explore,
-      ) ||
-      iterate_metadata_atomic(meta, type) ||
-      iterate_metadata_tuple(checker)(options)(collection)(errors)(
-        meta,
-        type as ts.TupleType,
-        explore,
-      ) ||
-      iterate_metadata_array(checker)(options)(collection)(errors)(
-        meta,
-        type,
-        explore,
-      ) ||
-      iterate_metadata_native(checker)(meta, type) ||
-      iterate_metadata_map(checker)(options)(collection)(errors)(
-        meta,
-        type,
-        explore,
-      ) ||
-      iterate_metadata_set(checker)(options)(collection)(errors)(
-        meta,
-        type,
-        explore,
-      ) ||
-      iterate_metadata_object(checker)(options)(collection)(errors)(meta, type);
-  };
+  // 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,34 +1,28 @@
 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 { IMetadataIteratorProps } from "./IMetadataIteratorProps";
 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;
+export const iterate_metadata_alias = (
+  props: IMetadataIteratorProps,
+): boolean => {
+  if (props.options.absorb !== false || props.type.aliasSymbol === undefined)
+    return false;
 
-    const node: ts.Declaration | undefined = type.aliasSymbol.declarations?.[0];
-    if (node === undefined) return false;
+  const node: ts.Declaration | undefined =
+    props.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;
-  };
+  // CONSTRUCT DEFINITION
+  const alias: MetadataAlias = emplace_metadata_alias(props);
+  ArrayUtil.add(
+    props.metadata.aliases,
+    alias,
+    (elem) => elem.name === alias.name,
+  );
+  return true;
+};

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

@@ -1,63 +1,63 @@
 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 { IMetadataIteratorProps } from "./IMetadataIteratorProps";
 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,
-    alias: ts.Type,
-    explore: MetadataFactory.IExplore,
-  ): boolean => {
-    const array: ts.Type | null =
-      checker.isArrayType(alias) === false
-        ? find_array_extended(checker)(new Map())(alias)
-        : alias;
-    if (array === null) return false;
+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(checker)(
-      options,
-    )(collection)(errors)(alias, array, meta.nullable, explore);
-    ArrayUtil.add(
-      meta.arrays,
-      MetadataArray.create({
-        type: arrayType,
-        tags: [],
-      }),
-      (elem) => elem.type.name === arrayType.name,
-    );
-    return true;
-  };
+  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 =
-  (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;
+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;
 
-    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;
-  };
+  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

@@ -10,16 +10,16 @@ const same = (type: ts.Type | null) => {
   return (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
 };
 
-export const iterate_metadata_atomic = (
-  meta: Metadata,
-  type: ts.Type,
-): boolean => {
+export const iterate_metadata_atomic = (props: {
+  metadata: Metadata;
+  type: ts.Type;
+}): boolean => {
   // PREPARE INTERNAL FUNCTIONS
-  const filter = same(type);
+  const filter = same(props.type);
   const check = (info: IAtomicInfo) => {
     if (filter(info.atomic) || filter(info.literal)) {
       ArrayUtil.add(
-        meta.atomics,
+        props.metadata.atomics,
         MetadataAtomic.create({ type: info.name, tags: [] }),
         (x, y) => x.type === y.type,
       );

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

@@ -4,16 +4,16 @@ import { Metadata } from "../../../schemas/metadata/Metadata";
 
 import { Writable } from "../../../typings/Writable";
 
-export const iterate_metadata_coalesce = (
-  meta: Metadata,
-  type: ts.Type,
-): boolean => {
-  const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+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(meta).any = true;
+    Writable(props.metadata).any = true;
     return true;
   } else if (filter(ts.TypeFlags.Null)) {
-    Writable(meta).nullable = true;
+    Writable(props.metadata).nullable = true;
     return true;
   } else if (
     filter(ts.TypeFlags.Undefined) ||
@@ -21,7 +21,7 @@ export const iterate_metadata_coalesce = (
     filter(ts.TypeFlags.Void) ||
     filter(ts.TypeFlags.VoidLike)
   ) {
-    Writable(meta).required = false;
+    Writable(props.metadata).required = false;
     return true;
   }
   return false;

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

@@ -7,125 +7,139 @@ 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(
+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,
-          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)),
-        );
-      }
+          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 =
-  (visited: Set<Metadata>) =>
-  (array: MetadataArrayType) =>
-  (meta: Metadata): boolean => {
-    if (visited.has(meta)) return false;
-    visited.add(meta);
+const isArrayRecursive = (props: {
+  visited: Set<Metadata>;
+  array: MetadataArrayType;
+  metadata: Metadata;
+}): boolean => {
+  if (props.visited.has(props.metadata)) return false;
+  props.visited.add(props.metadata);
 
-    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 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 =
-  (visited: Set<Metadata>) =>
-  (tuple: MetadataTupleType) =>
-  (meta: Metadata): boolean => {
-    if (visited.has(meta)) return false;
-    visited.add(meta);
+const isTupleRecursive = (props: {
+  visited: Set<Metadata>;
+  tuple: MetadataTupleType;
+  metadata: Metadata;
+}): boolean => {
+  if (props.visited.has(props.metadata)) return false;
+  props.visited.add(props.metadata);
 
-    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 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 =
-  (visited: Set<Metadata>) =>
-  (obj: MetadataObject) =>
-  (meta: Metadata): boolean => {
-    if (visited.has(meta)) return false;
+const isObjectRecursive = (props: {
+  visited: Set<Metadata>;
+  object: MetadataObject;
+  metadata: Metadata;
+}): boolean => {
+  if (props.visited.has(props.metadata)) return false;
+  props.visited.add(props.metadata);
 
-    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))
-    );
-  };
+  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_comment_tags.ts

@@ -3,26 +3,28 @@ 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;
+export const iterate_metadata_comment_tags = (props: {
+  errors: MetadataFactory.IError[];
+  object: MetadataObject;
+}) => {
+  if (props.object.tagged_ === true) return;
+  props.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()!
-            : {},
-          parameter: null,
-          nested: null,
-          aliased: false,
-          escaped: false,
-          output: false,
-        },
-      );
-    }
-  };
+  for (const property of props.object.properties) {
+    MetadataCommentTagFactory.analyze(props.errors)(property.value)(
+      property.jsDocTags,
+      {
+        top: false,
+        object: props.object,
+        property: property.key.isSoleLiteral()
+          ? property.key.getSoleLiteral()!
+          : {},
+        parameter: null,
+        nested: null,
+        aliased: false,
+        escaped: false,
+        output: false,
+      },
+    );
+  }
+};