typia 5.3.5-dev.20231206 → 5.3.5

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

@@ -1,208 +1,208 @@
-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;
-  }),
-  [
-    "DataView",
-    {
-      methods: [
-        "getFloat32",
-        "getFloat64",
-        "getInt8",
-        "getInt16",
-        "getInt32",
-        "getUint8",
-        "getUint16",
-        "getUint32",
-      ].map((name) => ({
-        name,
-        return: "number",
-      })),
-    },
-  ],
-]);
-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;
+  }),
+  [
+    "DataView",
+    {
+      methods: [
+        "getFloat32",
+        "getFloat64",
+        "getInt8",
+        "getInt16",
+        "getInt32",
+        "getUint8",
+        "getUint16",
+        "getUint32",
+      ].map((name) => ({
+        name,
+        return: "number",
+      })),
+    },
+  ],
+]);
+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,43 +1,43 @@
-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;
-      // else if (
-      //     type.isIntersection() &&
-      //     !type.types.every(
-      //         (child) =>
-      //             (child.getFlags() & ts.TypeFlags.Object) !== 0 &&
-      //             !checker.isArrayType(child) &&
-      //             !checker.isTupleType(child),
-      //     )
-      // )
-      //     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;
+      // else if (
+      //     type.isIntersection() &&
+      //     !type.types.every(
+      //         (child) =>
+      //             (child.getFlags() & ts.TypeFlags.Object) !== 0 &&
+      //             !checker.isArrayType(child) &&
+      //             !checker.isTupleType(child),
+      //     )
+      // )
+      //     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_resolve.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_resolve =
-  (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_resolve =
+  (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;
+  };