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

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

@@ -1,236 +1,236 @@
-import ts from "typescript";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { TypeFactory } from "../../TypeFactory";
-import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
-
-export const iterate_metadata_native = (
-  props: IMetadataIteratorProps,
-): boolean => {
-  const name: string = TypeFactory.getFullName({
-    checker: props.checker,
-    type: props.type,
-    symbol: props.type.getSymbol(),
-  });
-  const simple: IClassInfo | undefined = SIMPLES.get(name);
-  if (
-    simple !== undefined &&
-    validate({
-      checker: props.checker,
-      type: props.type,
-      info: simple,
-    })
-  ) {
-    ArrayUtil.set(props.metadata.natives, name, (str) => str);
-    return true;
-  }
-
-  for (const generic of GENERICS)
-    if (
-      name.substring(0, generic.name.length) === generic.name &&
-      validate({
-        checker: props.checker,
-        type: props.type,
-        info: generic,
-      })
-    ) {
-      ArrayUtil.set(props.metadata.natives, generic.name ?? name, (str) => str);
-      return true;
-    }
-  return false;
-};
-
-const validate = (props: {
-  checker: ts.TypeChecker;
-  type: ts.Type;
-  info: IClassInfo;
-}) =>
-  (props.info.methods ?? []).every((method) => {
-    const returnType = TypeFactory.getReturnTypeOfClassMethod({
-      checker: props.checker,
-      class: props.type,
-      function: method.name,
-    });
-    return (
-      returnType !== null &&
-      props.checker.typeToString(returnType) === method.return
-    );
-  }) &&
-  (props.info.properties ?? []).every((property) => {
-    const prop = props.checker.getPropertyOfType(props.type, property.name);
-    const propType = prop?.valueDeclaration
-      ? props.checker.getTypeAtLocation(prop?.valueDeclaration)
-      : undefined;
-    return (
-      propType !== undefined &&
-      props.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 { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { TypeFactory } from "../../TypeFactory";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+
+export const iterate_metadata_native = (
+  props: IMetadataIteratorProps,
+): boolean => {
+  const name: string = TypeFactory.getFullName({
+    checker: props.checker,
+    type: props.type,
+    symbol: props.type.getSymbol(),
+  });
+  const simple: IClassInfo | undefined = SIMPLES.get(name);
+  if (
+    simple !== undefined &&
+    validate({
+      checker: props.checker,
+      type: props.type,
+      info: simple,
+    })
+  ) {
+    ArrayUtil.set(props.metadata.natives, name, (str) => str);
+    return true;
+  }
+
+  for (const generic of GENERICS)
+    if (
+      name.substring(0, generic.name.length) === generic.name &&
+      validate({
+        checker: props.checker,
+        type: props.type,
+        info: generic,
+      })
+    ) {
+      ArrayUtil.set(props.metadata.natives, generic.name ?? name, (str) => str);
+      return true;
+    }
+  return false;
+};
+
+const validate = (props: {
+  checker: ts.TypeChecker;
+  type: ts.Type;
+  info: IClassInfo;
+}) =>
+  (props.info.methods ?? []).every((method) => {
+    const returnType = TypeFactory.getReturnTypeOfClassMethod({
+      checker: props.checker,
+      class: props.type,
+      function: method.name,
+    });
+    return (
+      returnType !== null &&
+      props.checker.typeToString(returnType) === method.return
+    );
+  }) &&
+  (props.info.properties ?? []).every((property) => {
+    const prop = props.checker.getPropertyOfType(props.type, property.name);
+    const propType = prop?.valueDeclaration
+      ? props.checker.getTypeAtLocation(prop?.valueDeclaration)
+      : undefined;
+    return (
+      propType !== undefined &&
+      props.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,27 +1,35 @@
-import ts from "typescript";
-
-import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
-import { emplace_metadata_object } from "./emplace_metadata_object";
-
-export const iterate_metadata_object = (
-  props: IMetadataIteratorProps,
-  ensure: boolean = false,
-): boolean => {
-  if (ensure === false) {
-    const filter = (flag: ts.TypeFlags) => (props.type.getFlags() & flag) !== 0;
-    if (
-      !filter(ts.TypeFlags.Object) &&
-      !props.type.isIntersection() &&
-      (props.type as any).intrinsicName !== "object"
-    )
-      return false;
-  }
-
-  const obj: MetadataObject = emplace_metadata_object(props);
-  ArrayUtil.add(props.metadata.objects, obj, (elem) => elem.name === obj.name);
-  return true;
-};
+import ts from "typescript";
+
+import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
+import { MetadataObjectType } from "../../../schemas/metadata/MetadataObjectType";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+import { emplace_metadata_object } from "./emplace_metadata_object";
+
+export const iterate_metadata_object = (
+  props: IMetadataIteratorProps,
+  ensure: boolean = false,
+): boolean => {
+  if (ensure === false) {
+    const filter = (flag: ts.TypeFlags) => (props.type.getFlags() & flag) !== 0;
+    if (
+      !filter(ts.TypeFlags.Object) &&
+      !props.type.isIntersection() &&
+      (props.type as any).intrinsicName !== "object"
+    )
+      return false;
+  }
+
+  const obj: MetadataObjectType = emplace_metadata_object(props);
+  ArrayUtil.add(
+    props.metadata.objects,
+    MetadataObject.create({
+      type: obj,
+      tags: [],
+    }),
+    (elem) => elem.type.name === obj.name,
+  );
+  return true;
+};

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

@@ -1,39 +1,39 @@
-import ts from "typescript";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { TypeFactory } from "../../TypeFactory";
-import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
-import { explore_metadata } from "./explore_metadata";
-
-export const iterate_metadata_set = (
-  props: IMetadataIteratorProps,
-): boolean => {
-  const type: ts.Type = props.checker.getApparentType(props.type);
-
-  const name = TypeFactory.getFullName({
-    checker: props.checker,
-    type: type,
-    symbol: type.getSymbol(),
-  });
-  const generic = type.aliasSymbol
-    ? type.aliasTypeArguments
-    : props.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(
-    props.metadata.sets,
-    explore_metadata({
-      ...props,
-      type: key,
-      explore: {
-        ...props.explore,
-        escaped: false,
-        aliased: false,
-      },
-    }),
-    (elem) => elem.getName(),
-  );
-  return true;
-};
+import ts from "typescript";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { TypeFactory } from "../../TypeFactory";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+import { explore_metadata } from "./explore_metadata";
+
+export const iterate_metadata_set = (
+  props: IMetadataIteratorProps,
+): boolean => {
+  const type: ts.Type = props.checker.getApparentType(props.type);
+
+  const name = TypeFactory.getFullName({
+    checker: props.checker,
+    type: type,
+    symbol: type.getSymbol(),
+  });
+  const generic = type.aliasSymbol
+    ? type.aliasTypeArguments
+    : props.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(
+    props.metadata.sets,
+    explore_metadata({
+      ...props,
+      type: key,
+      explore: {
+        ...props.explore,
+        escaped: false,
+        aliased: false,
+      },
+    }),
+    (elem) => elem.getName(),
+  );
+  return true;
+};