typia 7.0.0-dev.20241011 → 7.0.0-dev.20241012

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

@@ -1,6 +1,6 @@
 import { Metadata } from "../../../schemas/metadata/Metadata";
 import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
-import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../../schemas/metadata/MetadataObjectType";
 import { MetadataTupleType } from "../../../schemas/metadata/MetadataTupleType";
 
 import { MetadataCollection } from "../../MetadataCollection";
@@ -114,7 +114,7 @@ const isTupleRecursive = (props: {
 
 const isObjectRecursive = (props: {
   visited: Set<Metadata>;
-  object: MetadataObject;
+  object: MetadataObjectType;
   metadata: Metadata;
 }): boolean => {
   if (props.visited.has(props.metadata)) return false;
@@ -128,7 +128,8 @@ const isObjectRecursive = (props: {
   return (
     props.metadata.objects.some(
       (o) =>
-        props.object === o || o.properties.some((prop) => next(prop.value)),
+        props.object === o.type ||
+        o.type.properties.some((prop) => next(prop.value)),
     ) ||
     props.metadata.aliases.some((alias) => next(alias.value)) ||
     props.metadata.arrays.some(

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

@@ -1,11 +1,11 @@
-import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../../schemas/metadata/MetadataObjectType";
 
 import { MetadataCommentTagFactory } from "../../MetadataCommentTagFactory";
 import { MetadataFactory } from "../../MetadataFactory";
 
 export const iterate_metadata_comment_tags = (props: {
   errors: MetadataFactory.IError[];
-  object: MetadataObject;
+  object: MetadataObjectType;
 }) => {
   if (props.object.tagged_ === true) return;
   props.object.tagged_ = true;

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

@@ -1,76 +1,76 @@
-import ts from "typescript";
-
-import { MetadataConstant } from "../../../schemas/metadata/MetadataConstant";
-import { MetadataConstantValue } from "../../../schemas/metadata/MetadataConstantValue";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { CommentFactory } from "../../CommentFactory";
-import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
-
-export const iterate_metadata_constant = (
-  props: IMetadataIteratorProps,
-): boolean => {
-  if (!props.options.constant) return false;
-
-  const filter = (flag: ts.TypeFlags) => (props.type.getFlags() & flag) !== 0;
-  const comment = () => {
-    if (!filter(ts.TypeFlags.EnumLiteral)) return {};
-    return {
-      jsDocTags: props.type.symbol?.getJsDocTags(),
-      description: props.type.symbol
-        ? (CommentFactory.description(props.type.symbol) ?? null)
-        : undefined,
-    };
-  };
-  if (props.type.isLiteral()) {
-    const value: string | number | bigint =
-      typeof props.type.value === "object"
-        ? BigInt(
-            `${props.type.value.negative ? "-" : ""}${props.type.value.base10Value}`,
-          )
-        : props.type.value;
-    const constant: MetadataConstant = ArrayUtil.take(
-      props.metadata.constants,
-      (elem) => elem.type === typeof value,
-      () =>
-        MetadataConstant.create({
-          type: typeof value as "number",
-          values: [],
-        }),
-    );
-    ArrayUtil.add(
-      constant.values,
-      MetadataConstantValue.create({
-        value,
-        tags: [],
-        ...comment(),
-      }),
-      (a, b) => a.value === b.value,
-    );
-    return true;
-  } else if (filter(ts.TypeFlags.BooleanLiteral)) {
-    comment();
-    const value: boolean = props.checker.typeToString(props.type) === "true";
-    const constant: MetadataConstant = ArrayUtil.take(
-      props.metadata.constants,
-      (elem) => elem.type === "boolean",
-      () =>
-        MetadataConstant.create({
-          type: "boolean",
-          values: [],
-        }),
-    );
-    ArrayUtil.add(
-      constant.values,
-      MetadataConstantValue.create({
-        value,
-        tags: [],
-        ...comment(),
-      }),
-      (a, b) => a.value === b.value,
-    );
-    return true;
-  }
-  return false;
-};
+import ts from "typescript";
+
+import { MetadataConstant } from "../../../schemas/metadata/MetadataConstant";
+import { MetadataConstantValue } from "../../../schemas/metadata/MetadataConstantValue";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { CommentFactory } from "../../CommentFactory";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+
+export const iterate_metadata_constant = (
+  props: IMetadataIteratorProps,
+): boolean => {
+  if (!props.options.constant) return false;
+
+  const filter = (flag: ts.TypeFlags) => (props.type.getFlags() & flag) !== 0;
+  const comment = () => {
+    if (!filter(ts.TypeFlags.EnumLiteral)) return {};
+    return {
+      jsDocTags: props.type.symbol?.getJsDocTags(),
+      description: props.type.symbol
+        ? (CommentFactory.description(props.type.symbol) ?? null)
+        : undefined,
+    };
+  };
+  if (props.type.isLiteral()) {
+    const value: string | number | bigint =
+      typeof props.type.value === "object"
+        ? BigInt(
+            `${props.type.value.negative ? "-" : ""}${props.type.value.base10Value}`,
+          )
+        : props.type.value;
+    const constant: MetadataConstant = ArrayUtil.take(
+      props.metadata.constants,
+      (elem) => elem.type === typeof value,
+      () =>
+        MetadataConstant.create({
+          type: typeof value as "number",
+          values: [],
+        }),
+    );
+    ArrayUtil.add(
+      constant.values,
+      MetadataConstantValue.create({
+        value,
+        tags: [],
+        ...comment(),
+      }),
+      (a, b) => a.value === b.value,
+    );
+    return true;
+  } else if (filter(ts.TypeFlags.BooleanLiteral)) {
+    comment();
+    const value: boolean = props.checker.typeToString(props.type) === "true";
+    const constant: MetadataConstant = ArrayUtil.take(
+      props.metadata.constants,
+      (elem) => elem.type === "boolean",
+      () =>
+        MetadataConstant.create({
+          type: "boolean",
+          values: [],
+        }),
+    );
+    ArrayUtil.add(
+      constant.values,
+      MetadataConstantValue.create({
+        value,
+        tags: [],
+        ...comment(),
+      }),
+      (a, b) => a.value === b.value,
+    );
+    return true;
+  }
+  return false;
+};

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

@@ -1,49 +1,49 @@
-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.getReturnTypeOfClassMethod({
-    checker: props.checker,
-    class: props.type,
-    function: "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.getReturnTypeOfClassMethod({
+    checker: props.checker,
+    class: props.type,
+    function: "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;
+};