typia 6.7.2 → 6.8.0-dev.20240811

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

@@ -1,176 +1,176 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
-import { MetadataProperty } from "../../../schemas/metadata/MetadataProperty";
-
-import { Writable } from "../../../typings/Writable";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { CommentFactory } from "../../CommentFactory";
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { MetadataHelper } from "./MetadataHelper";
-import { explore_metadata } from "./explore_metadata";
-import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
-
-export const emplace_metadata_object =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (parent: ts.Type, nullable: boolean): MetadataObject => {
-    // EMPLACE OBJECT
-    const [obj, newbie] = collection.emplace(checker, parent);
-    ArrayUtil.add(obj.nullables, nullable, (elem) => elem === nullable);
-
-    if (newbie === false) return obj;
-
-    // PREPARE ASSETS
-    const isClass: boolean = parent.isClass();
-    const pred: (node: ts.Declaration) => boolean = isClass
-      ? (node) => {
-          const kind: ts.SyntaxKind | undefined = node
-            .getChildren()[0]
-            ?.getChildren()[0]?.kind;
-          return (
-            kind !== ts.SyntaxKind.PrivateKeyword &&
-            kind !== ts.SyntaxKind.ProtectedKeyword &&
-            isProperty(node)
-          );
-        }
-      : (node) => isProperty(node);
-
-    const insert =
-      (key: Metadata) =>
-      (value: Metadata) =>
-      (
-        symbol: ts.Symbol | undefined,
-        filter?: (doc: ts.JSDocTagInfo) => boolean,
-      ): MetadataProperty => {
-        // COMMENTS AND TAGS
-        const description: string | null = symbol
-          ? CommentFactory.description(symbol) ?? null
-          : null;
-        const jsDocTags: ts.JSDocTagInfo[] = (
-          symbol?.getJsDocTags() ?? []
-        ).filter(filter ?? (() => true));
-
-        // THE PROPERTY
-        const property = MetadataProperty.create({
-          key,
-          value,
-          description,
-          jsDocTags,
-        });
-        obj.properties.push(property);
-        return property;
-      };
-
-    //----
-    // REGULAR PROPERTIES
-    //----
-    for (const prop of parent.getApparentProperties()) {
-      // CHECK INTERNAL TAG
-      if (
-        (prop.getJsDocTags(checker) ?? []).find(
-          (tag) => tag.name === "internal",
-        ) !== undefined
-      )
-        continue;
-
-      // CHECK NODE IS A FORMAL PROPERTY
-      const [node, type] = (() => {
-        const node = prop.getDeclarations()?.[0] as
-          | ts.PropertyDeclaration
-          | undefined;
-        const type: ts.Type | undefined = node
-          ? checker.getTypeOfSymbolAtLocation(prop, node)
-          : checker.getTypeOfPropertyOfType(parent, prop.name);
-        return [node, type];
-      })();
-      if ((node && pred(node) === false) || type === undefined) continue;
-
-      // GET EXACT TYPE
-      const key: Metadata = MetadataHelper.literal_to_metadata(prop.name);
-      const value: Metadata = explore_metadata(checker)(options)(collection)(
-        errors,
-      )(type, {
-        top: false,
-        object: obj,
-        property: prop.name,
-        nested: null,
-        escaped: false,
-        aliased: false,
-      });
-      Writable(value).optional = (prop.flags & ts.SymbolFlags.Optional) !== 0;
-      insert(key)(value)(prop);
-    }
-
-    //----
-    // DYNAMIC PROPERTIES
-    //----
-    for (const index of checker.getIndexInfosOfType(parent)) {
-      // GET EXACT TYPE
-      const analyzer = (type: ts.Type) => (property: {} | null) =>
-        explore_metadata(checker)(options)(collection)(errors)(type, {
-          top: false,
-          object: obj,
-          property,
-          nested: null,
-          escaped: false,
-          aliased: false,
-        });
-      const key: Metadata = analyzer(index.keyType)(null);
-      const value: Metadata = analyzer(index.type)({});
-
-      if (
-        key.atomics.length +
-          key.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0) +
-          key.templates.length +
-          key.natives.filter(
-            (type) =>
-              type === "Boolean" ||
-              type === "BigInt" ||
-              type === "Number" ||
-              type === "String",
-          ).length !==
-        key.size()
-      )
-        errors.push({
-          name: key.getName(),
-          explore: {
-            top: false,
-            object: obj,
-            property: "[key]",
-            nested: null,
-            escaped: false,
-            aliased: false,
-          },
-          messages: [],
-        });
-
-      // INSERT WITH REQUIRED CONFIGURATION
-      insert(key)(value)(
-        index.declaration?.parent
-          ? checker.getSymbolAtLocation(index.declaration.parent)
-          : undefined,
-        (doc) => doc.name !== "default",
-      );
-    }
-    return obj;
-  };
-
-const isProperty = (node: ts.Declaration) =>
-  ts.isParameter(node) ||
-  ts.isPropertyDeclaration(node) ||
-  ts.isPropertyAssignment(node) ||
-  ts.isPropertySignature(node) ||
-  ts.isTypeLiteralNode(node);
-
-const iterate_optional_coalesce = (meta: Metadata, type: ts.Type): void => {
-  if (type.isUnionOrIntersection())
-    type.types.forEach((child) => iterate_optional_coalesce(meta, child));
-  else iterate_metadata_coalesce(meta, type);
-};
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
+import { MetadataProperty } from "../../../schemas/metadata/MetadataProperty";
+
+import { Writable } from "../../../typings/Writable";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { CommentFactory } from "../../CommentFactory";
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { MetadataHelper } from "./MetadataHelper";
+import { explore_metadata } from "./explore_metadata";
+import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
+
+export const emplace_metadata_object =
+  (checker: ts.TypeChecker) =>
+  (options: MetadataFactory.IOptions) =>
+  (collection: MetadataCollection) =>
+  (errors: MetadataFactory.IError[]) =>
+  (parent: ts.Type, nullable: boolean): MetadataObject => {
+    // EMPLACE OBJECT
+    const [obj, newbie] = collection.emplace(checker, parent);
+    ArrayUtil.add(obj.nullables, nullable, (elem) => elem === nullable);
+
+    if (newbie === false) return obj;
+
+    // PREPARE ASSETS
+    const isClass: boolean = parent.isClass();
+    const pred: (node: ts.Declaration) => boolean = isClass
+      ? (node) => {
+          const kind: ts.SyntaxKind | undefined = node
+            .getChildren()[0]
+            ?.getChildren()[0]?.kind;
+          return (
+            kind !== ts.SyntaxKind.PrivateKeyword &&
+            kind !== ts.SyntaxKind.ProtectedKeyword &&
+            isProperty(node)
+          );
+        }
+      : (node) => isProperty(node);
+
+    const insert =
+      (key: Metadata) =>
+      (value: Metadata) =>
+      (
+        symbol: ts.Symbol | undefined,
+        filter?: (doc: ts.JSDocTagInfo) => boolean,
+      ): MetadataProperty => {
+        // COMMENTS AND TAGS
+        const description: string | null = symbol
+          ? CommentFactory.description(symbol) ?? null
+          : null;
+        const jsDocTags: ts.JSDocTagInfo[] = (
+          symbol?.getJsDocTags() ?? []
+        ).filter(filter ?? (() => true));
+
+        // THE PROPERTY
+        const property = MetadataProperty.create({
+          key,
+          value,
+          description,
+          jsDocTags,
+        });
+        obj.properties.push(property);
+        return property;
+      };
+
+    //----
+    // REGULAR PROPERTIES
+    //----
+    for (const prop of parent.getApparentProperties()) {
+      // CHECK INTERNAL TAG
+      if (
+        (prop.getJsDocTags(checker) ?? []).find(
+          (tag) => tag.name === "internal",
+        ) !== undefined
+      )
+        continue;
+
+      // CHECK NODE IS A FORMAL PROPERTY
+      const [node, type] = (() => {
+        const node = prop.getDeclarations()?.[0] as
+          | ts.PropertyDeclaration
+          | undefined;
+        const type: ts.Type | undefined = node
+          ? checker.getTypeOfSymbolAtLocation(prop, node)
+          : checker.getTypeOfPropertyOfType(parent, prop.name);
+        return [node, type];
+      })();
+      if ((node && pred(node) === false) || type === undefined) continue;
+
+      // GET EXACT TYPE
+      const key: Metadata = MetadataHelper.literal_to_metadata(prop.name);
+      const value: Metadata = explore_metadata(checker)(options)(collection)(
+        errors,
+      )(type, {
+        top: false,
+        object: obj,
+        property: prop.name,
+        nested: null,
+        escaped: false,
+        aliased: false,
+      });
+      Writable(value).optional = (prop.flags & ts.SymbolFlags.Optional) !== 0;
+      insert(key)(value)(prop);
+    }
+
+    //----
+    // DYNAMIC PROPERTIES
+    //----
+    for (const index of checker.getIndexInfosOfType(parent)) {
+      // GET EXACT TYPE
+      const analyzer = (type: ts.Type) => (property: {} | null) =>
+        explore_metadata(checker)(options)(collection)(errors)(type, {
+          top: false,
+          object: obj,
+          property,
+          nested: null,
+          escaped: false,
+          aliased: false,
+        });
+      const key: Metadata = analyzer(index.keyType)(null);
+      const value: Metadata = analyzer(index.type)({});
+
+      if (
+        key.atomics.length +
+          key.constants.map((c) => c.values.length).reduce((a, b) => a + b, 0) +
+          key.templates.length +
+          key.natives.filter(
+            (type) =>
+              type === "Boolean" ||
+              type === "BigInt" ||
+              type === "Number" ||
+              type === "String",
+          ).length !==
+        key.size()
+      )
+        errors.push({
+          name: key.getName(),
+          explore: {
+            top: false,
+            object: obj,
+            property: "[key]",
+            nested: null,
+            escaped: false,
+            aliased: false,
+          },
+          messages: [],
+        });
+
+      // INSERT WITH REQUIRED CONFIGURATION
+      insert(key)(value)(
+        index.declaration?.parent
+          ? checker.getSymbolAtLocation(index.declaration.parent)
+          : undefined,
+        (doc) => doc.name !== "default",
+      );
+    }
+    return obj;
+  };
+
+const isProperty = (node: ts.Declaration) =>
+  ts.isParameter(node) ||
+  ts.isPropertyDeclaration(node) ||
+  ts.isPropertyAssignment(node) ||
+  ts.isPropertySignature(node) ||
+  ts.isTypeLiteralNode(node);
+
+const iterate_optional_coalesce = (meta: Metadata, type: ts.Type): void => {
+  if (type.isUnionOrIntersection())
+    type.types.forEach((child) => iterate_optional_coalesce(meta, child));
+  else iterate_metadata_coalesce(meta, type);
+};

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

@@ -1,94 +1,94 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { TypeFactory } from "../../TypeFactory";
-import { iterate_metadata_alias } from "./iterate_metadata_alias";
-import { iterate_metadata_array } from "./iterate_metadata_array";
-import { iterate_metadata_atomic } from "./iterate_metadata_atomic";
-import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
-import { iterate_metadata_constant } from "./iterate_metadata_constant";
-import { iterate_metadata_escape } from "./iterate_metadata_escape";
-import { iterate_metadata_intersection } from "./iterate_metadata_intersection";
-import { iterate_metadata_map } from "./iterate_metadata_map";
-import { iterate_metadata_native } from "./iterate_metadata_native";
-import { iterate_metadata_object } from "./iterate_metadata_object";
-import { iterate_metadata_set } from "./iterate_metadata_set";
-import { iterate_metadata_template } from "./iterate_metadata_template";
-import { iterate_metadata_tuple } from "./iterate_metadata_tuple";
-import { iterate_metadata_union } from "./iterate_metadata_union";
-
-export const iterate_metadata =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (meta: Metadata, type: ts.Type, explore: MetadataFactory.IExplore): void => {
-    if (type.isTypeParameter() === true) {
-      errors.push({
-        name: TypeFactory.getFullName(checker)(type),
-        explore: { ...explore },
-        messages: ["non-specified generic argument found."],
-      });
-      return;
-    }
-    // CHECK SPECIAL CASES
-    else if (
-      (explore.aliased !== true &&
-        iterate_metadata_alias(checker)(options)(collection)(errors)(
-          meta,
-          type,
-          explore,
-        )) ||
-      iterate_metadata_intersection(checker)(options)(collection)(errors)(
-        meta,
-        type,
-        explore,
-      ) ||
-      iterate_metadata_union(checker)(options)(collection)(errors)(
-        meta,
-        type,
-        explore,
-      ) ||
-      iterate_metadata_escape(checker)(options)(collection)(errors)(
-        meta,
-        type,
-        explore,
-      )
-    )
-      return;
-
-    // ITERATE CASES
-    iterate_metadata_coalesce(meta, type) ||
-      iterate_metadata_constant(checker)(options)(meta, type) ||
-      iterate_metadata_template(checker)(options)(collection)(errors)(
-        meta,
-        type,
-        explore,
-      ) ||
-      iterate_metadata_atomic(meta, type) ||
-      iterate_metadata_tuple(checker)(options)(collection)(errors)(
-        meta,
-        type as ts.TupleType,
-        explore,
-      ) ||
-      iterate_metadata_array(checker)(options)(collection)(errors)(
-        meta,
-        type,
-        explore,
-      ) ||
-      iterate_metadata_native(checker)(meta, type) ||
-      iterate_metadata_map(checker)(options)(collection)(errors)(
-        meta,
-        type,
-        explore,
-      ) ||
-      iterate_metadata_set(checker)(options)(collection)(errors)(
-        meta,
-        type,
-        explore,
-      ) ||
-      iterate_metadata_object(checker)(options)(collection)(errors)(meta, type);
-  };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { TypeFactory } from "../../TypeFactory";
+import { iterate_metadata_alias } from "./iterate_metadata_alias";
+import { iterate_metadata_array } from "./iterate_metadata_array";
+import { iterate_metadata_atomic } from "./iterate_metadata_atomic";
+import { iterate_metadata_coalesce } from "./iterate_metadata_coalesce";
+import { iterate_metadata_constant } from "./iterate_metadata_constant";
+import { iterate_metadata_escape } from "./iterate_metadata_escape";
+import { iterate_metadata_intersection } from "./iterate_metadata_intersection";
+import { iterate_metadata_map } from "./iterate_metadata_map";
+import { iterate_metadata_native } from "./iterate_metadata_native";
+import { iterate_metadata_object } from "./iterate_metadata_object";
+import { iterate_metadata_set } from "./iterate_metadata_set";
+import { iterate_metadata_template } from "./iterate_metadata_template";
+import { iterate_metadata_tuple } from "./iterate_metadata_tuple";
+import { iterate_metadata_union } from "./iterate_metadata_union";
+
+export const iterate_metadata =
+  (checker: ts.TypeChecker) =>
+  (options: MetadataFactory.IOptions) =>
+  (collection: MetadataCollection) =>
+  (errors: MetadataFactory.IError[]) =>
+  (meta: Metadata, type: ts.Type, explore: MetadataFactory.IExplore): void => {
+    if (type.isTypeParameter() === true) {
+      errors.push({
+        name: TypeFactory.getFullName(checker)(type),
+        explore: { ...explore },
+        messages: ["non-specified generic argument found."],
+      });
+      return;
+    }
+    // CHECK SPECIAL CASES
+    else if (
+      (explore.aliased !== true &&
+        iterate_metadata_alias(checker)(options)(collection)(errors)(
+          meta,
+          type,
+          explore,
+        )) ||
+      iterate_metadata_intersection(checker)(options)(collection)(errors)(
+        meta,
+        type,
+        explore,
+      ) ||
+      iterate_metadata_union(checker)(options)(collection)(errors)(
+        meta,
+        type,
+        explore,
+      ) ||
+      iterate_metadata_escape(checker)(options)(collection)(errors)(
+        meta,
+        type,
+        explore,
+      )
+    )
+      return;
+
+    // ITERATE CASES
+    iterate_metadata_coalesce(meta, type) ||
+      iterate_metadata_constant(checker)(options)(meta, type) ||
+      iterate_metadata_template(checker)(options)(collection)(errors)(
+        meta,
+        type,
+        explore,
+      ) ||
+      iterate_metadata_atomic(meta, type) ||
+      iterate_metadata_tuple(checker)(options)(collection)(errors)(
+        meta,
+        type as ts.TupleType,
+        explore,
+      ) ||
+      iterate_metadata_array(checker)(options)(collection)(errors)(
+        meta,
+        type,
+        explore,
+      ) ||
+      iterate_metadata_native(checker)(meta, type) ||
+      iterate_metadata_map(checker)(options)(collection)(errors)(
+        meta,
+        type,
+        explore,
+      ) ||
+      iterate_metadata_set(checker)(options)(collection)(errors)(
+        meta,
+        type,
+        explore,
+      ) ||
+      iterate_metadata_object(checker)(options)(collection)(errors)(meta, type);
+  };

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

@@ -1,63 +1,63 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataArray } from "../../../schemas/metadata/MetadataArray";
-import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { emplace_metadata_array_type } from "./emplace_metadata_array_type";
-
-export const iterate_metadata_array =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (
-    meta: Metadata,
-    alias: ts.Type,
-    explore: MetadataFactory.IExplore,
-  ): boolean => {
-    const array: ts.Type | null =
-      checker.isArrayType(alias) === false
-        ? find_array_extended(checker)(new Map())(alias)
-        : alias;
-    if (array === null) return false;
-
-    const arrayType: MetadataArrayType = emplace_metadata_array_type(checker)(
-      options,
-    )(collection)(errors)(alias, array, meta.nullable, explore);
-    ArrayUtil.add(
-      meta.arrays,
-      MetadataArray.create({
-        type: arrayType,
-        tags: [],
-      }),
-      (elem) => elem.type.name === arrayType.name,
-    );
-    return true;
-  };
-
-const find_array_extended =
-  (checker: ts.TypeChecker) =>
-  (memory: Map<ts.Type, ts.Type | null>) =>
-  (type: ts.Type): ts.Type | null => {
-    const cached = memory.get(type);
-    if (cached !== undefined) return null;
-
-    memory.set(type, null);
-    const res: ts.Type | null = (() => {
-      if (type.isClassOrInterface() === false) return null;
-      for (const t of type.resolvedBaseTypes ?? [])
-        if (checker.isArrayType(t)) return t;
-        else {
-          const res: ts.Type | null = find_array_extended(checker)(memory)(t);
-          if (res !== null) return res;
-        }
-      return null;
-    })();
-    memory.set(type, res);
-    return res;
-  };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataArray } from "../../../schemas/metadata/MetadataArray";
+import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { MetadataCollection } from "../../MetadataCollection";
+import { MetadataFactory } from "../../MetadataFactory";
+import { emplace_metadata_array_type } from "./emplace_metadata_array_type";
+
+export const iterate_metadata_array =
+  (checker: ts.TypeChecker) =>
+  (options: MetadataFactory.IOptions) =>
+  (collection: MetadataCollection) =>
+  (errors: MetadataFactory.IError[]) =>
+  (
+    meta: Metadata,
+    alias: ts.Type,
+    explore: MetadataFactory.IExplore,
+  ): boolean => {
+    const array: ts.Type | null =
+      checker.isArrayType(alias) === false
+        ? find_array_extended(checker)(new Map())(alias)
+        : alias;
+    if (array === null) return false;
+
+    const arrayType: MetadataArrayType = emplace_metadata_array_type(checker)(
+      options,
+    )(collection)(errors)(alias, array, meta.nullable, explore);
+    ArrayUtil.add(
+      meta.arrays,
+      MetadataArray.create({
+        type: arrayType,
+        tags: [],
+      }),
+      (elem) => elem.type.name === arrayType.name,
+    );
+    return true;
+  };
+
+const find_array_extended =
+  (checker: ts.TypeChecker) =>
+  (memory: Map<ts.Type, ts.Type | null>) =>
+  (type: ts.Type): ts.Type | null => {
+    const cached = memory.get(type);
+    if (cached !== undefined) return null;
+
+    memory.set(type, null);
+    const res: ts.Type | null = (() => {
+      if (type.isClassOrInterface() === false) return null;
+      for (const t of type.resolvedBaseTypes ?? [])
+        if (checker.isArrayType(t)) return t;
+        else {
+          const res: ts.Type | null = find_array_extended(checker)(memory)(t);
+          if (res !== null) return res;
+        }
+      return null;
+    })();
+    memory.set(type, res);
+    return res;
+  };