typia 5.5.7 → 5.5.8

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

@@ -1,48 +1,48 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataConstant } from "../../../schemas/metadata/MetadataConstant";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { MetadataFactory } from "../../MetadataFactory";
-
-export const iterate_metadata_constant =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (meta: Metadata, type: ts.Type): boolean => {
-    if (!options.constant) return false;
-
-    const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
-    if (type.isLiteral()) {
-      const value: string | number | bigint =
-        typeof type.value === "object"
-          ? BigInt(`${type.value.negative ? "-" : ""}${type.value.base10Value}`)
-          : type.value;
-      const constant: MetadataConstant = ArrayUtil.take(
-        meta.constants,
-        (elem) => elem.type === typeof value,
-        () =>
-          MetadataConstant.create({
-            type: typeof value as "number",
-            values: [],
-          }),
-      );
-      ArrayUtil.add(constant.values as Array<any>, value, (a, b) => a === b);
-      return true;
-    } else if (filter(ts.TypeFlags.BooleanLiteral)) {
-      const value: boolean = checker.typeToString(type) === "true";
-      const constant: MetadataConstant = ArrayUtil.take(
-        meta.constants,
-        (elem) => elem.type === "boolean",
-        () =>
-          MetadataConstant.create({
-            type: "boolean",
-            values: [],
-          }),
-      );
-      ArrayUtil.add(constant.values as boolean[], value, (a, b) => a === b);
-      return true;
-    }
-    return false;
-  };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataConstant } from "../../../schemas/metadata/MetadataConstant";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataFactory } from "../../MetadataFactory";
+
+export const iterate_metadata_constant =
+  (checker: ts.TypeChecker) =>
+  (options: MetadataFactory.IOptions) =>
+  (meta: Metadata, type: ts.Type): boolean => {
+    if (!options.constant) return false;
+
+    const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+    if (type.isLiteral()) {
+      const value: string | number | bigint =
+        typeof type.value === "object"
+          ? BigInt(`${type.value.negative ? "-" : ""}${type.value.base10Value}`)
+          : type.value;
+      const constant: MetadataConstant = ArrayUtil.take(
+        meta.constants,
+        (elem) => elem.type === typeof value,
+        () =>
+          MetadataConstant.create({
+            type: typeof value as "number",
+            values: [],
+          }),
+      );
+      ArrayUtil.add(constant.values as Array<any>, value, (a, b) => a === b);
+      return true;
+    } else if (filter(ts.TypeFlags.BooleanLiteral)) {
+      const value: boolean = checker.typeToString(type) === "true";
+      const constant: MetadataConstant = ArrayUtil.take(
+        meta.constants,
+        (elem) => elem.type === "boolean",
+        () =>
+          MetadataConstant.create({
+            type: "boolean",
+            values: [],
+          }),
+      );
+      ArrayUtil.add(constant.values as boolean[], value, (a, b) => a === b);
+      return true;
+    }
+    return false;
+  };

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

@@ -1,52 +1,52 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataEscaped } from "../../../schemas/metadata/MetadataEscaped";
-
-import { Writable } from "../../../typings/Writable";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { TypeFactory } from "../../TypeFactory";
-import { iterate_metadata } from "./iterate_metadata";
-
-export const iterate_metadata_escape =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (
-    meta: Metadata,
-    type: ts.Type,
-    explore: MetadataFactory.IExplore,
-  ): boolean => {
-    if (options.escape === false || explore.escaped === true) return false;
-
-    const escaped: ts.Type | null =
-      TypeFactory.getReturnType(checker)(type)("toJSON");
-    if (escaped === null) return false;
-
-    if (meta.escaped === null) {
-      Writable(meta).escaped = MetadataEscaped.create({
-        original: Metadata.initialize(),
-        returns: Metadata.initialize(),
-      });
-    }
-    iterate_metadata(checker)(options)(collection)(errors)(
-      meta.escaped!.original,
-      type,
-      {
-        ...explore,
-        escaped: true,
-      },
-    );
-    iterate_metadata(checker)(options)(collection)(errors)(
-      meta.escaped!.returns,
-      escaped,
-      {
-        ...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 { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { TypeFactory } from "../../TypeFactory";
+import { iterate_metadata } from "./iterate_metadata";
+
+export const iterate_metadata_escape =
+  (checker: ts.TypeChecker) =>
+  (options: MetadataFactory.IOptions) =>
+  (collection: MetadataCollection) =>
+  (errors: MetadataFactory.IError[]) =>
+  (
+    meta: Metadata,
+    type: ts.Type,
+    explore: MetadataFactory.IExplore,
+  ): boolean => {
+    if (options.escape === false || explore.escaped === true) return false;
+
+    const escaped: ts.Type | null =
+      TypeFactory.getReturnType(checker)(type)("toJSON");
+    if (escaped === null) return false;
+
+    if (meta.escaped === null) {
+      Writable(meta).escaped = MetadataEscaped.create({
+        original: Metadata.initialize(),
+        returns: Metadata.initialize(),
+      });
+    }
+    iterate_metadata(checker)(options)(collection)(errors)(
+      meta.escaped!.original,
+      type,
+      {
+        ...explore,
+        escaped: true,
+      },
+    );
+    iterate_metadata(checker)(options)(collection)(errors)(
+      meta.escaped!.returns,
+      escaped,
+      {
+        ...explore,
+        escaped: true,
+      },
+    );
+    return true;
+  };

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

@@ -166,8 +166,8 @@ export const iterate_metadata_intersection =
       booleanLiteral
         ? "boolean"
         : atomics.size
-        ? atomics.values().next().value
-        : "array";
+          ? atomics.values().next().value
+          : "array";
     if (
       target === "boolean" ||
       target === "bigint" ||

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

@@ -1,50 +1,50 @@
-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 { 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);
-
-    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 key: ts.Type = generic[0]!;
-    const value: ts.Type = generic[1]!;
-
-    ArrayUtil.set(
-      meta.maps,
-      {
-        key: explore_metadata(checker)(options)(collection)(errors)(key, {
-          ...explore,
-          escaped: false,
-          aliased: false,
-        }),
-        value: explore_metadata(checker)(options)(collection)(errors)(value, {
-          ...explore,
-          escaped: false,
-          aliased: false,
-        }),
-      },
-      (elem) => `Map<${elem.key.getName()}, ${elem.value.getName()}>`,
-    );
-    return true;
-  };
+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 { 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);
+
+    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 key: ts.Type = generic[0]!;
+    const value: ts.Type = generic[1]!;
+
+    ArrayUtil.set(
+      meta.maps,
+      {
+        key: explore_metadata(checker)(options)(collection)(errors)(key, {
+          ...explore,
+          escaped: false,
+          aliased: false,
+        }),
+        value: explore_metadata(checker)(options)(collection)(errors)(value, {
+          ...explore,
+          escaped: false,
+          aliased: false,
+        }),
+      },
+      (elem) => `Map<${elem.key.getName()}, ${elem.value.getName()}>`,
+    );
+    return true;
+  };