typia 7.0.0-dev.20241012 → 7.0.0-dev.20241019

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

@@ -13,4 +13,5 @@ export interface IMetadataIteratorProps<Type extends ts.Type = ts.Type> {
   metadata: Metadata;
   type: Type;
   explore: MetadataFactory.IExplore;
+  intersected?: boolean;
 }

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

@@ -11,7 +11,7 @@ export namespace MetadataHelper {
         values: [
           MetadataConstantValue.create({
             value: key,
-            tags: undefined,
+            tags: [],
           }),
         ],
       }),

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

@@ -1,5 +1,5 @@
 import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataAlias } from "../../../schemas/metadata/MetadataAlias";
+import { MetadataAliasType } from "../../../schemas/metadata/MetadataAliasType";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
@@ -8,7 +8,7 @@ import { explore_metadata } from "./explore_metadata";
 
 export const emplace_metadata_alias = (
   props: IMetadataIteratorProps,
-): MetadataAlias => {
+): MetadataAliasType => {
   // CHECK EXISTENCE
   const [alias, newbie, closure] = props.collection.emplaceAlias(
     props.checker,

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

@@ -144,11 +144,11 @@ export const emplace_metadata_object = (
         key.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0) +
         key.templates.length +
         key.natives.filter(
-          (type) =>
-            type === "Boolean" ||
-            type === "BigInt" ||
-            type === "Number" ||
-            type === "String",
+          (native) =>
+            native.name === "Boolean" ||
+            native.name === "BigInt" ||
+            native.name === "Number" ||
+            native.name === "String",
         ).length !==
       key.size()
     )

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

@@ -12,6 +12,7 @@ export const explore_metadata = (props: IProps): Metadata => {
   if (props.type === null) return metadata;
 
   // ITERATE TYPESCRIPT TYPES
+  props.intersected ??= false;
   iterate_metadata({
     ...props,
     metadata,

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

@@ -31,7 +31,7 @@ export const iterate_metadata = (props: IMetadataIteratorProps): void => {
     return;
   }
   // CHECK SPECIAL CASES
-  else if (
+  if (
     (props.explore.aliased !== true && iterate_metadata_alias(props)) ||
     iterate_metadata_intersection(props) ||
     iterate_metadata_union(props) ||

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

@@ -1,6 +1,7 @@
 import ts from "typescript";
 
 import { MetadataAlias } from "../../../schemas/metadata/MetadataAlias";
+import { MetadataAliasType } from "../../../schemas/metadata/MetadataAliasType";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
@@ -18,11 +19,15 @@ export const iterate_metadata_alias = (
   if (node === undefined) return false;
 
   // CONSTRUCT DEFINITION
-  const alias: MetadataAlias = emplace_metadata_alias(props);
-  ArrayUtil.add(
+  const type: MetadataAliasType = emplace_metadata_alias(props);
+  ArrayUtil.take(
     props.metadata.aliases,
-    alias,
-    (elem) => elem.name === alias.name,
+    (elem) => elem.type.name === type.name,
+    () =>
+      MetadataAlias.create({
+        type,
+        tags: [],
+      }),
   );
   return true;
 };

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

@@ -73,12 +73,12 @@ const isArrayRecursive = (props: {
     props.metadata.arrays.some(
       (a) => a.type === props.array || next(a.type.value),
     ) ||
-    props.metadata.aliases.some((alias) => next(alias.value)) ||
+    props.metadata.aliases.some((alias) => next(alias.type.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.sets.some((s) => next(s.value)) ||
     (props.metadata.escaped !== null && next(props.metadata.escaped.returns)) ||
     (props.metadata.rest !== null && next(props.metadata.rest))
   );
@@ -105,8 +105,8 @@ const isTupleRecursive = (props: {
       (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.sets.some((s) => next(s.value)) ||
+    props.metadata.aliases.some((alias) => next(alias.type.value)) ||
     (props.metadata.escaped !== null && next(props.metadata.escaped.returns)) ||
     (props.metadata.rest !== null && next(props.metadata.rest))
   );
@@ -131,7 +131,7 @@ const isObjectRecursive = (props: {
         props.object === o.type ||
         o.type.properties.some((prop) => next(prop.value)),
     ) ||
-    props.metadata.aliases.some((alias) => next(alias.value)) ||
+    props.metadata.aliases.some((alias) => next(alias.type.value)) ||
     props.metadata.arrays.some(
       (array) => !array.type.recursive && next(array.type.value),
     ) ||
@@ -139,7 +139,7 @@ const isObjectRecursive = (props: {
       (tuple) => !tuple.type.recursive && tuple.type.elements.some(next),
     ) ||
     props.metadata.maps.some((map) => next(map.value)) ||
-    props.metadata.sets.some(next) ||
+    props.metadata.sets.some((set) => next(set.value)) ||
     (props.metadata.escaped !== null && next(props.metadata.escaped.returns)) ||
     (props.metadata.rest !== null && next(props.metadata.rest))
   );

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

@@ -1,13 +1,6 @@
-import ts from "typescript";
-
 import { IMetadataTypeTag } from "../../../schemas/metadata/IMetadataTypeTag";
 import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataAtomic } from "../../../schemas/metadata/MetadataAtomic";
-import { MetadataConstant } from "../../../schemas/metadata/MetadataConstant";
-import { MetadataConstantValue } from "../../../schemas/metadata/MetadataConstantValue";
-import { MetadataTemplate } from "../../../schemas/metadata/MetadataTemplate";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
+import { MetadataObjectType } from "../../../schemas/metadata/MetadataObjectType";
 
 import { MetadataCollection } from "../../MetadataCollection";
 import { MetadataFactory } from "../../MetadataFactory";
@@ -15,64 +8,57 @@ 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 = (
   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;
+  if (props.intersected === true) return false;
+  else if (props.type.isIntersection() === false) return false;
 
   // COSTRUCT FAKE METADATA LIST
-  const fakeCollection: MetadataCollection = props.collection.clone();
+  const fakeCollection: MetadataCollection = new MetadataCollection();
   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,
-          },
-          collection: fakeCollection,
-          errors: fakeErrors,
-          type: t,
-          explore: {
-            ...props.explore,
-            aliased: false,
-          },
-        });
-        return [m.getName(), m] as const;
-      }),
-    ).values(),
-  ];
+  const children: Metadata[] = props.type.types.map((t) =>
+    explore_metadata({
+      ...props,
+      options: {
+        ...props.options,
+        absorb: true,
+        functional: false,
+      },
+      collection: fakeCollection,
+      errors: fakeErrors,
+      type: t,
+      explore: {
+        ...props.explore,
+        aliased: false,
+      },
+      intersected: true,
+    }),
+  );
   if (fakeErrors.length) {
     props.errors.push(...fakeErrors);
     return true;
-  }
+  } else if (children.length === 0) return false;
+  else if (children.some((m) => m.any || m.size() === 0)) return false;
 
-  // 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;
+  // PREPARE MEATDATAS AND TAGS
+  const indexes: number[] = [];
+  const metadatas: Metadata[] = [];
+  const tagObjects: MetadataObjectType[] = [];
+  children.forEach((child, i) => {
+    if (
+      child.size() === 1 &&
+      child.objects.length === 1 &&
+      MetadataTypeTagFactory.is(child.objects[0]!.type)
+    )
+      tagObjects.push(child.objects[0]!.type);
+    else {
+      indexes.push(i);
+      metadatas.push(child);
+    }
+  });
 
-  // VALIDATE EACH TYPES
   const nonsensible = () => {
     props.errors.push({
       name: children.map((c) => c.getName()).join(" & "),
@@ -81,139 +67,135 @@ export const iterate_metadata_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();
 
-  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.type.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);
+  // NO METADATA CASE
+  if (metadatas.length === 0)
+    if (tagObjects.length !== 0) {
+      props.errors.push({
+        name: children.map((c) => c.getName()).join(" & "),
+        explore: { ...props.explore },
+        messages: ["type tag cannot be standalone"],
+      });
+      return true;
+    } else return false;
+  // ONLY OBJECTS CASE
+  else if (
+    metadatas.every((m) => m.objects.length === 1) &&
+    tagObjects.length === 0
+  )
+    return false;
+  else if (metadatas.length !== 1) {
+    const indexes: number[] = metadatas
+      .map((m, i) =>
+        m.size() === 1 &&
+        m.objects.length === 1 &&
+        (m.objects[0]!.type.properties.length === 0 ||
+          m.objects[0]!.type.properties.every((p) => p.value.optional === true))
+          ? i
+          : null,
+      )
+      .filter((i) => i !== null);
+    if (indexes.length && metadatas.length !== indexes.length)
+      for (const i of indexes.reverse()) metadatas.splice(i, 1);
+    else return nonsensible();
+  } else if (metadatas.some((m) => m.size() !== 1)) return nonsensible();
 
-  // ESCAPE WHEN ONLY CONSTANT TYPES EXIST
+  const candidates: Map<string, string> = new Map();
+  const assigners: Array<(tags: IMetadataTypeTag[]) => void> = [];
+  for (const meta of metadatas) {
+    for (const a of meta.atomics) {
+      candidates.set(a.type, a.type);
+      assigners.push((tags) =>
+        props.metadata.atomics
+          .find((atom) => atom.type === a.type)
+          ?.tags.push(tags),
+      );
+    }
+    for (const c of meta.constants)
+      for (const v of c.values) {
+        candidates.set(c.type, c.type);
+        assigners.push((tags) =>
+          props.metadata.constants
+            .find((constant) => constant.type === c.type)
+            ?.values.find((value) => value === v)
+            ?.tags?.push(tags),
+        );
+      }
+    for (const t of meta.templates) {
+      candidates.set("string", "string");
+      assigners.push((tags) =>
+        props.metadata.templates
+          .find((tpl) => tpl.getBaseName() === t.getBaseName())
+          ?.tags.push(tags),
+      );
+    }
+    if (meta.objects.length) {
+      candidates.set("object", "object");
+      assigners.push((tags) => props.metadata.objects.at(-1)?.tags.push(tags));
+    }
+    if (meta.arrays.length) {
+      candidates.set("array", "array");
+      assigners.push((tags) => props.metadata.arrays.at(-1)?.tags.push(tags));
+    }
+    if (meta.tuples.length) candidates.set("invalid", "tuple");
+    for (const n of meta.natives) {
+      candidates.set(`native::${n.name}`, "object");
+      assigners.push((tags) =>
+        props.metadata.natives
+          .find((native) => native.name === n.name)
+          ?.tags.push(tags),
+      );
+    }
+    for (const s of meta.sets) {
+      candidates.set(`set::${s.value.getName()}`, "object");
+      assigners.push((tags) =>
+        props.metadata.sets
+          .find((set) => set.value.getName() === s.value.getName())
+          ?.tags.push(tags),
+      );
+    }
+    for (const e of meta.maps) {
+      candidates.set(`map::${e.key.getName()}::${e.value.getName()}`, "object");
+      assigners.push((tags) =>
+        props.metadata.maps
+          .find(
+            (map) =>
+              map.key.getName() === e.key.getName() &&
+              map.value.getName() === e.value.getName(),
+          )
+          ?.tags.push(tags),
+      );
+    }
+  }
   if (
-    atomics.size + constants.length + arrays.size + templates.length > 1 ||
-    individuals.length + objects.length !== children.length
+    candidates.size !== 1 ||
+    candidates.has("nonsensible")
+    // ||
+    // (candidates.size !== 1 &&
+    //   Array.from(candidates.keys()).some((v) => v !== "object"))
   )
     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(
-        props.metadata.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)
-    ArrayUtil.take(
-      props.metadata.templates,
-      (o) => o.getBaseName() === templates[0]!.templates[0]!.getBaseName(),
-      () =>
-        MetadataTemplate.create({
-          row: templates[0]!.templates[0]!.row,
-          tags: [],
-        }),
-    );
+  const tags: IMetadataTypeTag[] = MetadataTypeTagFactory.analyze({
+    errors: props.errors,
+    type: candidates.values().next().value as "string",
+    objects: tagObjects,
+    explore: props.explore,
+  });
 
-  // ASSIGN TAGS
-  if (objects.length) {
-    const tags: IMetadataTypeTag[] = MetadataTypeTagFactory.analyze({
-      errors: props.errors,
-      type: target,
-      objects: objects
-        .map((om) => om.objects)
-        .flat()
-        .map((om) => om.type),
-      explore: 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);
-      }
-  }
+  iterate_metadata({
+    ...props,
+    type: props.type.types[indexes[0]!]!,
+    options: {
+      ...props.options,
+      functional: false,
+    },
+    explore: {
+      ...props.explore,
+      aliased: false,
+      escaped: false,
+    },
+  });
+  if (tags.length) assigners.forEach((fn) => fn(tags));
   return true;
 };

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

@@ -1,5 +1,7 @@
 import ts from "typescript";
 
+import { MetadataMap } from "../../../schemas/metadata/MetadataMap";
+
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 import { TypeFactory } from "../../TypeFactory";
@@ -26,7 +28,7 @@ export const iterate_metadata_map = (
 
   ArrayUtil.set(
     props.metadata.maps,
-    {
+    MetadataMap.create({
       key: explore_metadata({
         ...props,
         type: key,
@@ -45,7 +47,8 @@ export const iterate_metadata_map = (
           aliased: false,
         },
       }),
-    },
+      tags: [],
+    }),
     (elem) => `Map<${elem.key.getName()}, ${elem.value.getName()}>`,
   );
   return true;

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

@@ -1,5 +1,7 @@
 import ts from "typescript";
 
+import { MetadataNative } from "../../../schemas/metadata/MetadataNative";
+
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 import { TypeFactory } from "../../TypeFactory";
@@ -22,7 +24,15 @@ export const iterate_metadata_native = (
       info: simple,
     })
   ) {
-    ArrayUtil.set(props.metadata.natives, name, (str) => str);
+    ArrayUtil.take(
+      props.metadata.natives,
+      (native) => native.name === name,
+      () =>
+        MetadataNative.create({
+          name,
+          tags: [],
+        }),
+    );
     return true;
   }
 
@@ -35,7 +45,15 @@ export const iterate_metadata_native = (
         info: generic,
       })
     ) {
-      ArrayUtil.set(props.metadata.natives, generic.name ?? name, (str) => str);
+      ArrayUtil.take(
+        props.metadata.natives,
+        (native) => native.name === name,
+        () =>
+          MetadataNative.create({
+            name: generic.name ?? name,
+            tags: [],
+          }),
+      );
       return true;
     }
   return false;

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

@@ -1,5 +1,8 @@
 import ts from "typescript";
 
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataSet } from "../../../schemas/metadata/MetadataSet";
+
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 import { TypeFactory } from "../../TypeFactory";
@@ -22,18 +25,31 @@ export const iterate_metadata_set = (
   if (name.substring(0, 4) !== "Set<" || generic?.length !== 1) return false;
 
   const key: ts.Type = generic[0]!;
-  ArrayUtil.set(
+  const value: Metadata = explore_metadata({
+    ...props,
+    type: key,
+    explore: {
+      ...props.explore,
+      escaped: false,
+      aliased: false,
+    },
+  });
+  ArrayUtil.take(
     props.metadata.sets,
-    explore_metadata({
-      ...props,
-      type: key,
-      explore: {
-        ...props.explore,
-        escaped: false,
-        aliased: false,
-      },
-    }),
-    (elem) => elem.getName(),
+    (elem) => elem.value.getName() === value.getName(),
+    () =>
+      MetadataSet.create({
+        value: explore_metadata({
+          ...props,
+          type: key,
+          explore: {
+            ...props.explore,
+            escaped: false,
+            aliased: false,
+          },
+        }),
+        tags: [],
+      }),
   );
   return true;
 };

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

@@ -38,7 +38,7 @@ const iterate = (props: {
 
   // ITERATE CHILDREN
   for (const map of props.metadata.maps) next(map.value);
-  for (const set of props.metadata.sets) next(set);
+  for (const set of props.metadata.sets) next(set.value);
   if (props.metadata.escaped !== null) next(props.metadata.escaped.returns);
   if (props.metadata.rest !== null) next(props.metadata.rest);
 

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

@@ -35,8 +35,6 @@ export const iterate_metadata_template = (
         }),
       );
   });
-  props.metadata.templates.push(
-    MetadataTemplate.create({ row, tags: undefined }),
-  );
+  props.metadata.templates.push(MetadataTemplate.create({ row, tags: [] }));
   return true;
 };