typia 6.7.2 → 6.8.0-dev.20240811

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

@@ -1,220 +1,220 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { TypeFactory } from "../../TypeFactory";
-
-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(),
-    );
-
-    const simple = SIMPLES.get(name);
-    if (simple && validator(simple)) {
-      ArrayUtil.set(meta.natives, name, (str) => str);
-      return true;
-    }
-
-    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 getBinaryProps = (className: string): IClassInfo => ({
-  name: className,
-  methods: [
-    ...["indexOf", "lastIndexOf"].map((name) => ({
-      name,
-      return: "number",
-    })),
-    ...["some", "every"].map((name) => ({
-      name,
-      return: "boolean",
-    })),
-    ...["join", "toLocaleString"].map((name) => ({
-      name,
-      return: "string",
-    })),
-    ...["reverse", "slice", "subarray"].map((name) => ({
-      name,
-      return: className,
-    })),
-  ],
-  properties: ["BYTES_PER_ELEMENT", "length", "byteLength", "byteOffset"].map(
-    (name) => ({
-      name,
-      type: "number",
-    }),
-  ),
-});
-const SIMPLES: Map<string, IClassInfo> = new Map([
-  [
-    "Date",
-    {
-      methods: ["getTime", "getFullYear", "getMonth", "getMinutes"].map(
-        (name) => ({
-          name,
-          return: "number",
-        }),
-      ),
-    },
-  ],
-  [
-    "Boolean",
-    {
-      methods: [
-        {
-          name: "valueOf",
-          return: "boolean",
-        },
-      ],
-    },
-  ],
-  [
-    "Number",
-    {
-      methods: [
-        ...["toFixed", "toExponential", "toPrecision"].map((name) => ({
-          name,
-          return: "string",
-        })),
-        { name: "valueOf", return: "number" },
-      ],
-    },
-  ],
-  [
-    "String",
-    {
-      methods: [
-        "charAt",
-        "concat",
-        "valueOf",
-        "trim",
-        "replace",
-        "substring",
-      ].map((name) => ({ name, return: "string" })),
-    },
-  ],
-  ...[
-    "Uint8Array",
-    "Uint8ClampedArray",
-    "Uint16Array",
-    "Uint32Array",
-    "BigUint64Array",
-    "Int8Array",
-    "Int16Array",
-    "Int32Array",
-    "BigInt64Array",
-    "Float32Array",
-    "Float64Array",
-  ].map((name) => [name, getBinaryProps(name)] as const),
-  ...["ArrayBuffer", "SharedArrayBuffer"].map((className) => {
-    const info: IClassInfo = {
-      methods: [{ name: "slice", return: className }],
-      properties: [{ name: "byteLength", type: "number" }],
-    };
-    return [className, info] as const;
-  }),
-  ...["Blob", "File"].map(
-    (className) =>
-      [
-        className,
-        {
-          methods: [
-            { name: "arrayBuffer", return: "Promise<ArrayBuffer>" },
-            { name: "slice", return: "Blob" },
-            { name: "text", return: "Promise<string>" },
-          ],
-          properties: [
-            { name: "size", type: "number" },
-            { name: "type", type: "string" },
-          ],
-        },
-      ] satisfies [string, IClassInfo],
-  ),
-  [
-    "DataView",
-    {
-      methods: [
-        "getFloat32",
-        "getFloat64",
-        "getInt8",
-        "getInt16",
-        "getInt32",
-        "getUint8",
-        "getUint16",
-        "getUint32",
-      ].map((name) => ({
-        name,
-        return: "number",
-      })),
-    },
-  ],
-  [
-    "RegExp",
-    {
-      methods: [
-        {
-          name: "test",
-          return: "boolean",
-        },
-      ],
-    },
-  ],
-]);
-const GENERICS: Array<IClassInfo & { name: string }> = [
-  "WeakMap",
-  "WeakSet",
-].map((name) => ({
-  name,
-  methods: ["has", "delete"].map((name) => ({
-    name,
-    return: "boolean",
-  })),
-}));
-
-interface IClassInfo {
-  name?: string;
-  methods?: IMethod[];
-  properties?: IProperty[];
-}
-interface IProperty {
-  name: string;
-  type: string;
-}
-interface IMethod {
-  name: string;
-  return: string;
-}
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { TypeFactory } from "../../TypeFactory";
+
+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(),
+    );
+
+    const simple = SIMPLES.get(name);
+    if (simple && validator(simple)) {
+      ArrayUtil.set(meta.natives, name, (str) => str);
+      return true;
+    }
+
+    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 getBinaryProps = (className: string): IClassInfo => ({
+  name: className,
+  methods: [
+    ...["indexOf", "lastIndexOf"].map((name) => ({
+      name,
+      return: "number",
+    })),
+    ...["some", "every"].map((name) => ({
+      name,
+      return: "boolean",
+    })),
+    ...["join", "toLocaleString"].map((name) => ({
+      name,
+      return: "string",
+    })),
+    ...["reverse", "slice", "subarray"].map((name) => ({
+      name,
+      return: className,
+    })),
+  ],
+  properties: ["BYTES_PER_ELEMENT", "length", "byteLength", "byteOffset"].map(
+    (name) => ({
+      name,
+      type: "number",
+    }),
+  ),
+});
+const SIMPLES: Map<string, IClassInfo> = new Map([
+  [
+    "Date",
+    {
+      methods: ["getTime", "getFullYear", "getMonth", "getMinutes"].map(
+        (name) => ({
+          name,
+          return: "number",
+        }),
+      ),
+    },
+  ],
+  [
+    "Boolean",
+    {
+      methods: [
+        {
+          name: "valueOf",
+          return: "boolean",
+        },
+      ],
+    },
+  ],
+  [
+    "Number",
+    {
+      methods: [
+        ...["toFixed", "toExponential", "toPrecision"].map((name) => ({
+          name,
+          return: "string",
+        })),
+        { name: "valueOf", return: "number" },
+      ],
+    },
+  ],
+  [
+    "String",
+    {
+      methods: [
+        "charAt",
+        "concat",
+        "valueOf",
+        "trim",
+        "replace",
+        "substring",
+      ].map((name) => ({ name, return: "string" })),
+    },
+  ],
+  ...[
+    "Uint8Array",
+    "Uint8ClampedArray",
+    "Uint16Array",
+    "Uint32Array",
+    "BigUint64Array",
+    "Int8Array",
+    "Int16Array",
+    "Int32Array",
+    "BigInt64Array",
+    "Float32Array",
+    "Float64Array",
+  ].map((name) => [name, getBinaryProps(name)] as const),
+  ...["ArrayBuffer", "SharedArrayBuffer"].map((className) => {
+    const info: IClassInfo = {
+      methods: [{ name: "slice", return: className }],
+      properties: [{ name: "byteLength", type: "number" }],
+    };
+    return [className, info] as const;
+  }),
+  ...["Blob", "File"].map(
+    (className) =>
+      [
+        className,
+        {
+          methods: [
+            { name: "arrayBuffer", return: "Promise<ArrayBuffer>" },
+            { name: "slice", return: "Blob" },
+            { name: "text", return: "Promise<string>" },
+          ],
+          properties: [
+            { name: "size", type: "number" },
+            { name: "type", type: "string" },
+          ],
+        },
+      ] satisfies [string, IClassInfo],
+  ),
+  [
+    "DataView",
+    {
+      methods: [
+        "getFloat32",
+        "getFloat64",
+        "getInt8",
+        "getInt16",
+        "getInt32",
+        "getUint8",
+        "getUint16",
+        "getUint32",
+      ].map((name) => ({
+        name,
+        return: "number",
+      })),
+    },
+  ],
+  [
+    "RegExp",
+    {
+      methods: [
+        {
+          name: "test",
+          return: "boolean",
+        },
+      ],
+    },
+  ],
+]);
+const GENERICS: Array<IClassInfo & { name: string }> = [
+  "WeakMap",
+  "WeakSet",
+].map((name) => ({
+  name,
+  methods: ["has", "delete"].map((name) => ({
+    name,
+    return: "boolean",
+  })),
+}));
+
+interface IClassInfo {
+  name?: string;
+  methods?: IMethod[];
+  properties?: IProperty[];
+}
+interface IProperty {
+  name: string;
+  type: string;
+}
+interface IMethod {
+  name: string;
+  return: string;
+}

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

@@ -1,33 +1,33 @@
-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 { 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;
-    }
-
-    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;
-  };
+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 { 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;
+    }
+
+    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;
+  };

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

@@ -1,41 +1,41 @@
-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_set =
-  (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) !== "Set<" || generic?.length !== 1) return false;
-
-    const key: ts.Type = generic[0]!;
-    ArrayUtil.set(
-      meta.sets,
-      explore_metadata(checker)(options)(collection)(errors)(key, {
-        ...explore,
-        escaped: false,
-        aliased: false,
-      }),
-      (elem) => elem.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_set =
+  (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) !== "Set<" || generic?.length !== 1) return false;
+
+    const key: ts.Type = generic[0]!;
+    ArrayUtil.set(
+      meta.sets,
+      explore_metadata(checker)(options)(collection)(errors)(key, {
+        ...explore,
+        escaped: false,
+        aliased: false,
+      }),
+      (elem) => elem.getName(),
+    );
+    return true;
+  };

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

@@ -1,44 +1,44 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataTemplate } from "../../../schemas/metadata/MetadataTemplate";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { MetadataHelper } from "./MetadataHelper";
-import { explore_metadata } from "./explore_metadata";
-
-export const iterate_metadata_template =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (
-    meta: Metadata,
-    type: ts.Type,
-    explore: MetadataFactory.IExplore,
-  ): boolean => {
-    const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
-    if (!filter(ts.TypeFlags.TemplateLiteral)) return false;
-
-    const template: ts.TemplateLiteralType = type as ts.TemplateLiteralType;
-    const row: Metadata[] = [];
-
-    template.texts.forEach((text, i) => {
-      // TEXT LITERAL TYPE
-      if (text !== "") row.push(MetadataHelper.literal_to_metadata(text));
-
-      // BINDED TEMPLATE TYPE
-      const binded: ts.Type | undefined = template.types[i];
-      if (binded)
-        row.push(
-          explore_metadata(checker)(options)(collection)(errors)(binded, {
-            ...explore,
-            escaped: false,
-            aliased: false,
-          }),
-        );
-    });
-    meta.templates.push(MetadataTemplate.create({ row, tags: undefined }));
-    return true;
-  };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataTemplate } from "../../../schemas/metadata/MetadataTemplate";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { MetadataHelper } from "./MetadataHelper";
+import { explore_metadata } from "./explore_metadata";
+
+export const iterate_metadata_template =
+  (checker: ts.TypeChecker) =>
+  (options: MetadataFactory.IOptions) =>
+  (collection: MetadataCollection) =>
+  (errors: MetadataFactory.IError[]) =>
+  (
+    meta: Metadata,
+    type: ts.Type,
+    explore: MetadataFactory.IExplore,
+  ): boolean => {
+    const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
+    if (!filter(ts.TypeFlags.TemplateLiteral)) return false;
+
+    const template: ts.TemplateLiteralType = type as ts.TemplateLiteralType;
+    const row: Metadata[] = [];
+
+    template.texts.forEach((text, i) => {
+      // TEXT LITERAL TYPE
+      if (text !== "") row.push(MetadataHelper.literal_to_metadata(text));
+
+      // BINDED TEMPLATE TYPE
+      const binded: ts.Type | undefined = template.types[i];
+      if (binded)
+        row.push(
+          explore_metadata(checker)(options)(collection)(errors)(binded, {
+            ...explore,
+            escaped: false,
+            aliased: false,
+          }),
+        );
+    });
+    meta.templates.push(MetadataTemplate.create({ row, tags: undefined }));
+    return true;
+  };