typia 9.2.0 → 9.3.0-dev.20250511

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

@@ -1,146 +1,146 @@
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
-import { MetadataObjectType } from "../../../schemas/metadata/MetadataObjectType";
-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.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((s) => next(s.value)) ||
-    (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.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))
-  );
-};
-
-const isObjectRecursive = (props: {
-  visited: Set<Metadata>;
-  object: MetadataObjectType;
-  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.type ||
-        o.type.properties.some((prop) => next(prop.value)),
-    ) ||
-    props.metadata.aliases.some((alias) => next(alias.type.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((set) => next(set.value)) ||
-    (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 { MetadataObjectType } from "../../../schemas/metadata/MetadataObjectType";
+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.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((s) => next(s.value)) ||
+    (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.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))
+  );
+};
+
+const isObjectRecursive = (props: {
+  visited: Set<Metadata>;
+  object: MetadataObjectType;
+  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.type ||
+        o.type.properties.some((prop) => next(prop.value)),
+    ) ||
+    props.metadata.aliases.some((alias) => next(alias.type.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((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_comment_tags.ts

@@ -1,32 +1,32 @@
-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: MetadataObjectType;
-}) => {
-  if (props.object.tagged_ === true) return;
-  props.object.tagged_ = true;
-
-  for (const property of props.object.properties) {
-    MetadataCommentTagFactory.analyze({
-      errors: props.errors,
-      metadata: property.value,
-      tags: property.jsDocTags,
-      explore: {
-        top: false,
-        object: props.object,
-        property: property.key.isSoleLiteral()
-          ? property.key.getSoleLiteral()!
-          : {},
-        parameter: null,
-        nested: null,
-        aliased: false,
-        escaped: false,
-        output: false,
-      },
-    });
-  }
-};
+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: MetadataObjectType;
+}) => {
+  if (props.object.tagged_ === true) return;
+  props.object.tagged_ = true;
+
+  for (const property of props.object.properties) {
+    MetadataCommentTagFactory.analyze({
+      errors: props.errors,
+      metadata: property.value,
+      tags: property.jsDocTags,
+      explore: {
+        top: false,
+        object: props.object,
+        property: property.key.isSoleLiteral()
+          ? property.key.getSoleLiteral()!
+          : {},
+        parameter: null,
+        nested: null,
+        aliased: false,
+        escaped: false,
+        output: false,
+      },
+    });
+  }
+};

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;
+};