typia 6.10.1-dev.20240914 → 7.0.0-dev.20240918

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

@@ -12,202 +12,202 @@ import { ArrayUtil } from "../../../utils/ArrayUtil";
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
 import { MetadataTypeTagFactory } from "../../MetadataTypeTagFactory";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
 import { explore_metadata } from "./explore_metadata";
 import { iterate_metadata } from "./iterate_metadata";
 import { iterate_metadata_array } from "./iterate_metadata_array";
 
-export const iterate_metadata_intersection =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (
-    meta: Metadata,
-    type: ts.Type,
-    explore: MetadataFactory.IExplore,
-  ): boolean => {
-    if (!type.isIntersection()) return false;
-    if (
-      // ONLY OBJECT TYPED INTERSECTION
-      type.types.every(
-        (child) =>
-          (child.getFlags() & ts.TypeFlags.Object) !== 0 &&
-          !checker.isArrayType(child) &&
-          !checker.isTupleType(child),
-      )
+export const iterate_metadata_intersection = (
+  props: IMetadataIteratorProps,
+): boolean => {
+  if (!props.type.isIntersection()) return false;
+  if (
+    // ONLY OBJECT TYPED INTERSECTION
+    props.type.types.every(
+      (child) =>
+        (child.getFlags() & ts.TypeFlags.Object) !== 0 &&
+        !props.checker.isArrayType(child) &&
+        !props.checker.isTupleType(child),
     )
-      return false;
+  )
+    return false;
 
-    // COSTRUCT FAKE METADATA LIST
-    const fakeCollection: MetadataCollection = collection.clone();
-    const fakeErrors: MetadataFactory.IError[] = [];
-    const children: Metadata[] = [
-      ...new Map(
-        type.types.map((t) => {
-          const m: Metadata = explore_metadata(checker)({
-            ...options,
+  // COSTRUCT FAKE METADATA LIST
+  const fakeCollection: MetadataCollection = props.collection.clone();
+  const fakeErrors: MetadataFactory.IError[] = [];
+  const children: Metadata[] = [
+    ...new Map(
+      props.type.types.map((t) => {
+        const m: Metadata = explore_metadata({
+          ...props,
+          options: {
+            ...props.options,
             absorb: true,
-          })(fakeCollection)(fakeErrors)(t, {
-            ...explore,
+          },
+          collection: fakeCollection,
+          errors: fakeErrors,
+          type: t,
+          explore: {
+            ...props.explore,
             aliased: false,
-          });
-          return [m.getName(), m] as const;
-        }),
-      ).values(),
-    ];
-    if (fakeErrors.length) {
-      errors.push(...fakeErrors);
-      return true;
-    }
-
-    // ONLY ONE CHILD AFTER REMOVING DUPLICATES
-    if (children.length === 1) {
-      iterate_metadata(checker)(options)(collection)(errors)(
-        meta,
-        type.types[0]!,
-        explore,
-      );
-      return true;
-    } else if (children.every((c) => c.objects.length === c.size()))
-      // ONLY OBJECT TYPED INTERSECTION (DETAILED)
-      return false;
+          },
+        });
+        return [m.getName(), m] as const;
+      }),
+    ).values(),
+  ];
+  if (fakeErrors.length) {
+    props.errors.push(...fakeErrors);
+    return true;
+  }
 
-    // VALIDATE EACH TYPES
-    const nonsensible = () => {
-      errors.push({
-        name: children.map((c) => c.getName()).join(" & "),
-        explore: { ...explore },
-        messages: ["nonsensible intersection"],
-      });
-      return true;
-    };
-    const individuals: (readonly [Metadata, number])[] = children
-      .map((child, i) => [child, i] as const)
-      .filter(
-        ([c]) =>
-          (c.size() === 1 &&
-            (c.atomics.length === 1 ||
-              (c.constants.length === 1 &&
-                c.constants[0]!.values.length === 1) ||
-              c.arrays.length === 1)) ||
-          c.templates.length === 1,
-      );
-    if (individuals.length !== 1) return nonsensible();
+  // ONLY ONE CHILD AFTER REMOVING DUPLICATES
+  if (children.length === 1) {
+    iterate_metadata({
+      ...props,
+      type: props.type.types[0]!,
+    });
+    return true;
+  } else if (children.every((c) => c.objects.length === c.size()))
+    // ONLY OBJECT TYPED INTERSECTION (DETAILED)
+    return false;
 
-    const objects: Metadata[] = children.filter(
-      (c) =>
-        c.nullable === false &&
-        c.isRequired() === true &&
-        c.objects.length &&
-        c.objects.length === c.size() &&
-        c.objects.every((o) => o.properties.every((p) => p.value.optional)),
-    );
-    const arrays: Set<string> = new Set(
-      individuals.map(([c]) => c.arrays.map((a) => a.type.name)).flat(),
-    );
-    const atomics: Set<"boolean" | "bigint" | "number" | "string"> = new Set(
-      individuals.map(([c]) => [...c.atomics.map((a) => a.type)]).flat(),
+  // VALIDATE EACH TYPES
+  const nonsensible = () => {
+    props.errors.push({
+      name: children.map((c) => c.getName()).join(" & "),
+      explore: { ...props.explore },
+      messages: ["nonsensible intersection"],
+    });
+    return true;
+  };
+  const individuals: (readonly [Metadata, number])[] = children
+    .map((child, i) => [child, i] as const)
+    .filter(
+      ([c]) =>
+        (c.size() === 1 &&
+          (c.atomics.length === 1 ||
+            (c.constants.length === 1 && c.constants[0]!.values.length === 1) ||
+            c.arrays.length === 1)) ||
+        c.templates.length === 1,
     );
-    const constants: Metadata[] = individuals
-      .filter((i) => i[0].constants.length === 1)
-      .map(([m]) => m);
-    const templates: Metadata[] = individuals
-      .filter((i) => i[0].templates.length === 1)
-      .map(([m]) => m);
+  if (individuals.length !== 1) return nonsensible();
 
-    // ESCAPE WHEN ONLY CONSTANT TYPES EXIST
-    if (
-      atomics.size + constants.length + arrays.size + templates.length > 1 ||
-      individuals.length + objects.length !== children.length
-    )
-      return nonsensible();
+  const objects: Metadata[] = children.filter(
+    (c) =>
+      c.nullable === false &&
+      c.isRequired() === true &&
+      c.objects.length &&
+      c.objects.length === c.size() &&
+      c.objects.every((o) => o.properties.every((p) => p.value.optional)),
+  );
+  const arrays: Set<string> = new Set(
+    individuals.map(([c]) => c.arrays.map((a) => a.type.name)).flat(),
+  );
+  const atomics: Set<"boolean" | "bigint" | "number" | "string"> = new Set(
+    individuals.map(([c]) => [...c.atomics.map((a) => a.type)]).flat(),
+  );
+  const constants: Metadata[] = individuals
+    .filter((i) => i[0].constants.length === 1)
+    .map(([m]) => m);
+  const templates: Metadata[] = individuals
+    .filter((i) => i[0].templates.length === 1)
+    .map(([m]) => m);
 
-    // RE-GENERATE TYPE
-    const target: "boolean" | "bigint" | "number" | "string" | "array" =
-      arrays.size
-        ? "array"
-        : atomics.size
-          ? atomics.values().next().value!
-          : constants.length
-            ? constants[0]!.constants[0]!.type
-            : "string";
-    if (target === "array") {
-      const name: string = arrays.values().next().value!;
-      if (!meta.arrays.some((a) => a.type.name === name)) {
-        iterate_metadata_array(checker)(options)(collection)(errors)(
-          meta,
-          type.types[individuals.find((i) => i[0].arrays.length === 1)![1]]!,
-          {
-            ...explore,
-            aliased: false,
-            escaped: false,
-          },
-        );
-      }
-    } else if (atomics.size)
-      ArrayUtil.add(
-        meta.atomics,
-        MetadataAtomic.create({
-          type: atomics.values().next().value as "string",
-          tags: [],
-        }),
-        (a, b) => a.type === b.type,
-      );
-    else if (constants.length)
-      ArrayUtil.take(
-        ArrayUtil.take(
-          meta.constants,
-          (o) => o.type === target,
-          () =>
-            MetadataConstant.create({
-              type: target,
-              values: [],
-            }),
-        ).values,
-        (o) => o.value === constants[0]!.constants[0]!.values[0]!.value,
-        () =>
-          MetadataConstantValue.create({
-            value: constants[0]!.constants[0]!.values[0]!.value,
-            tags: [],
-          }),
-      );
-    else if (templates.length)
+  // ESCAPE WHEN ONLY CONSTANT TYPES EXIST
+  if (
+    atomics.size + constants.length + arrays.size + templates.length > 1 ||
+    individuals.length + objects.length !== children.length
+  )
+    return nonsensible();
+
+  // RE-GENERATE TYPE
+  const target: "boolean" | "bigint" | "number" | "string" | "array" =
+    arrays.size
+      ? "array"
+      : atomics.size
+        ? atomics.values().next().value!
+        : constants.length
+          ? constants[0]!.constants[0]!.type
+          : "string";
+  if (target === "array") {
+    const name: string = arrays.values().next().value!;
+    if (!props.metadata.arrays.some((a) => a.type.name === name)) {
+      iterate_metadata_array({
+        ...props,
+        type: props.type.types[
+          individuals.find((i) => i[0].arrays.length === 1)![1]
+        ]!,
+        explore: {
+          ...props.explore,
+          aliased: false,
+          escaped: false,
+        },
+      });
+    }
+  } else if (atomics.size)
+    ArrayUtil.add(
+      props.metadata.atomics,
+      MetadataAtomic.create({
+        type: atomics.values().next().value as "string",
+        tags: [],
+      }),
+      (a, b) => a.type === b.type,
+    );
+  else if (constants.length)
+    ArrayUtil.take(
       ArrayUtil.take(
-        meta.templates,
-        (o) => o.getBaseName() === templates[0]!.templates[0]!.getBaseName(),
+        props.metadata.constants,
+        (o) => o.type === target,
         () =>
-          MetadataTemplate.create({
-            row: templates[0]!.templates[0]!.row,
-            tags: [],
+          MetadataConstant.create({
+            type: target,
+            values: [],
           }),
-      );
+      ).values,
+      (o) => o.value === constants[0]!.constants[0]!.values[0]!.value,
+      () =>
+        MetadataConstantValue.create({
+          value: constants[0]!.constants[0]!.values[0]!.value,
+          tags: [],
+        }),
+    );
+  else if (templates.length)
+    ArrayUtil.take(
+      props.metadata.templates,
+      (o) => o.getBaseName() === templates[0]!.templates[0]!.getBaseName(),
+      () =>
+        MetadataTemplate.create({
+          row: templates[0]!.templates[0]!.row,
+          tags: [],
+        }),
+    );
 
-    // ASSIGN TAGS
-    if (objects.length) {
-      const tags: IMetadataTypeTag[] = MetadataTypeTagFactory.analyze(errors)(
-        target,
-      )(objects.map((om) => om.objects).flat(), explore);
-      if (tags.length)
-        if (target === "array") meta.arrays.at(-1)!.tags.push(tags);
-        else if (atomics.size)
-          meta.atomics.find((a) => a.type === target)!.tags.push(tags);
-        else if (constants.length) {
-          const constant: MetadataConstant = meta.constants.find(
-            (c) => c.type === target,
-          )!;
-          const value: MetadataConstantValue = constant.values.find(
-            (v) => v.value === constants[0]!.constants[0]!.values[0]!.value,
-          )!;
-          value.tags ??= [];
-          value.tags.push(tags);
-        } else if (templates.length) {
-          const template: MetadataTemplate = meta.templates.find(
-            (t) =>
-              t.getBaseName() === templates[0]!.templates[0]!.getBaseName(),
-          )!;
-          template.tags ??= [];
-          template.tags.push(tags);
-        }
-    }
-    return true;
-  };
+  // ASSIGN TAGS
+  if (objects.length) {
+    const tags: IMetadataTypeTag[] = MetadataTypeTagFactory.analyze(
+      props.errors,
+    )(target)(objects.map((om) => om.objects).flat(), props.explore);
+    if (tags.length)
+      if (target === "array") props.metadata.arrays.at(-1)!.tags.push(tags);
+      else if (atomics.size)
+        props.metadata.atomics.find((a) => a.type === target)!.tags.push(tags);
+      else if (constants.length) {
+        const constant: MetadataConstant = props.metadata.constants.find(
+          (c) => c.type === target,
+        )!;
+        const value: MetadataConstantValue = constant.values.find(
+          (v) => v.value === constants[0]!.constants[0]!.values[0]!.value,
+        )!;
+        value.tags ??= [];
+        value.tags.push(tags);
+      } else if (templates.length) {
+        const template: MetadataTemplate = props.metadata.templates.find(
+          (t) => t.getBaseName() === templates[0]!.templates[0]!.getBaseName(),
+        )!;
+        template.tags ??= [];
+        template.tags.push(tags);
+      }
+  }
+  return true;
+};

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

@@ -1,50 +1,51 @@
 import ts from "typescript";
 
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
 import { TypeFactory } from "../../TypeFactory";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
 import { explore_metadata } from "./explore_metadata";
 
-export const iterate_metadata_map =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (
-    meta: Metadata,
-    type: ts.Type,
-    explore: MetadataFactory.IExplore,
-  ): boolean => {
-    type = checker.getApparentType(type);
+export const iterate_metadata_map = (
+  props: IMetadataIteratorProps,
+): boolean => {
+  const type: ts.Type = props.checker.getApparentType(props.type);
 
-    const name = TypeFactory.getFullName(checker)(type, type.getSymbol());
-    const generic = type.aliasSymbol
-      ? type.aliasTypeArguments
-      : checker.getTypeArguments(type as ts.TypeReference);
-    if (name.substring(0, 4) !== "Map<" || generic?.length !== 2) return false;
+  const name: string = TypeFactory.getFullName(props.checker)(
+    type,
+    type.getSymbol(),
+  );
+  const generic: readonly ts.Type[] | undefined = type.aliasSymbol
+    ? type.aliasTypeArguments
+    : props.checker.getTypeArguments(type as ts.TypeReference);
+  if (name.substring(0, 4) !== "Map<" || generic?.length !== 2) return false;
 
-    const key: ts.Type = generic[0]!;
-    const value: ts.Type = generic[1]!;
+  const key: ts.Type = generic[0]!;
+  const value: ts.Type = generic[1]!;
 
-    ArrayUtil.set(
-      meta.maps,
-      {
-        key: explore_metadata(checker)(options)(collection)(errors)(key, {
-          ...explore,
+  ArrayUtil.set(
+    props.metadata.maps,
+    {
+      key: explore_metadata({
+        ...props,
+        type: key,
+        explore: {
+          ...props.explore,
           escaped: false,
           aliased: false,
-        }),
-        value: explore_metadata(checker)(options)(collection)(errors)(value, {
-          ...explore,
+        },
+      }),
+      value: explore_metadata({
+        ...props,
+        type: value,
+        explore: {
+          ...props.explore,
           escaped: false,
           aliased: false,
-        }),
-      },
-      (elem) => `Map<${elem.key.getName()}, ${elem.value.getName()}>`,
-    );
-    return true;
-  };
+        },
+      }),
+    },
+    (elem) => `Map<${elem.key.getName()}, ${elem.value.getName()}>`,
+  );
+  return true;
+};

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

@@ -1,56 +1,69 @@
 import ts from "typescript";
 
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 import { TypeFactory } from "../../TypeFactory";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
 
-export const iterate_metadata_native =
-  (checker: ts.TypeChecker) =>
-  (meta: Metadata, type: ts.Type): boolean => {
-    const validator = validate(checker)(type);
-    const name: string = TypeFactory.getFullName(checker)(
-      type,
-      type.getSymbol(),
-    );
+export const iterate_metadata_native = (
+  props: IMetadataIteratorProps,
+): boolean => {
+  const name: string = TypeFactory.getFullName(props.checker)(
+    props.type,
+    props.type.getSymbol(),
+  );
+  const simple = SIMPLES.get(name);
+  if (
+    simple &&
+    validate({
+      checker: props.checker,
+      type: props.type,
+      info: simple,
+    })
+  ) {
+    ArrayUtil.set(props.metadata.natives, name, (str) => str);
+    return true;
+  }
 
-    const simple = SIMPLES.get(name);
-    if (simple && validator(simple)) {
-      ArrayUtil.set(meta.natives, name, (str) => str);
+  for (const generic of GENERICS)
+    if (
+      name.substring(0, generic.name.length) === generic.name &&
+      validate({
+        checker: props.checker,
+        type: props.type,
+        info: generic,
+      })
+    ) {
+      ArrayUtil.set(props.metadata.natives, generic.name ?? name, (str) => str);
       return true;
     }
+  return false;
+};
 
-    for (const generic of GENERICS)
-      if (
-        name.substring(0, generic.name.length) === generic.name &&
-        validator(generic)
-      ) {
-        ArrayUtil.set(meta.natives, generic.name ?? name, (str) => str);
-        return true;
-      }
-    return false;
-  };
-
-const validate =
-  (checker: ts.TypeChecker) => (type: ts.Type) => (info: IClassInfo) =>
-    (info.methods ?? []).every((method) => {
-      const returnType = TypeFactory.getReturnType(checker)(type)(method.name);
-      return (
-        returnType !== null &&
-        checker.typeToString(returnType) === method.return
-      );
-    }) &&
-    (info.properties ?? []).every((property) => {
-      const prop = checker.getPropertyOfType(type, property.name);
-      const propType = prop?.valueDeclaration
-        ? checker.getTypeAtLocation(prop?.valueDeclaration)
-        : undefined;
-      return (
-        propType !== undefined &&
-        checker.typeToString(propType) === property.type
-      );
-    });
+const validate = (props: {
+  checker: ts.TypeChecker;
+  type: ts.Type;
+  info: IClassInfo;
+}) =>
+  (props.info.methods ?? []).every((method) => {
+    const returnType = TypeFactory.getReturnType(props.checker)(props.type)(
+      method.name,
+    );
+    return (
+      returnType !== null &&
+      props.checker.typeToString(returnType) === method.return
+    );
+  }) &&
+  (props.info.properties ?? []).every((property) => {
+    const prop = props.checker.getPropertyOfType(props.type, property.name);
+    const propType = prop?.valueDeclaration
+      ? props.checker.getTypeAtLocation(prop?.valueDeclaration)
+      : undefined;
+    return (
+      propType !== undefined &&
+      props.checker.typeToString(propType) === property.type
+    );
+  });
 
 const getBinaryProps = (className: string): IClassInfo => ({
   name: className,

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

@@ -1,33 +1,27 @@
 import ts from "typescript";
 
-import { Metadata } from "../../../schemas/metadata/Metadata";
 import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
 import { emplace_metadata_object } from "./emplace_metadata_object";
 
-export const iterate_metadata_object =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (meta: Metadata, type: ts.Type, ensure: boolean = false): boolean => {
-    if (ensure === false) {
-      const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
-      if (
-        !filter(ts.TypeFlags.Object) &&
-        !type.isIntersection() &&
-        (type as any).intrinsicName !== "object"
-      )
-        return false;
-    }
+export const iterate_metadata_object = (
+  props: IMetadataIteratorProps,
+  ensure: boolean = false,
+): boolean => {
+  if (ensure === false) {
+    const filter = (flag: ts.TypeFlags) => (props.type.getFlags() & flag) !== 0;
+    if (
+      !filter(ts.TypeFlags.Object) &&
+      !props.type.isIntersection() &&
+      (props.type as any).intrinsicName !== "object"
+    )
+      return false;
+  }
 
-    const obj: MetadataObject = emplace_metadata_object(checker)(options)(
-      collection,
-    )(errors)(type, meta.nullable);
-    ArrayUtil.add(meta.objects, obj, (elem) => elem.name === obj.name);
-    return true;
-  };
+  const obj: MetadataObject = emplace_metadata_object(props);
+  ArrayUtil.add(props.metadata.objects, obj, (elem) => elem.name === obj.name);
+  return true;
+};