typia 7.0.0-dev.20240916 → 7.0.0-dev.20240919

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

@@ -5,38 +5,35 @@ import { MetadataArrayType } from "../../../schemas/metadata/MetadataArrayType";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
 import { explore_metadata } from "./explore_metadata";
 
-export const emplace_metadata_array_type =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (
-    aliasType: ts.Type,
-    arrayType: ts.Type,
-    nullable: boolean,
-    explore: MetadataFactory.IExplore,
-  ): MetadataArrayType => {
-    // CHECK EXISTENCE
-    const [array, newbie, setValue] = collection.emplaceArray(
-      checker,
-      aliasType,
-    );
-    ArrayUtil.add(array.nullables, nullable);
-    if (newbie === false) return array;
+interface IProps extends IMetadataIteratorProps {
+  array: ts.Type;
+}
 
-    // CONSTRUCT VALUE TYPE
-    const value: Metadata = explore_metadata(checker)(options)(collection)(
-      errors,
-    )(arrayType.getNumberIndexType()!, {
-      ...explore,
+export const emplace_metadata_array_type = (
+  props: IProps,
+): MetadataArrayType => {
+  // CHECK EXISTENCE
+  const [array, newbie, setValue] = props.collection.emplaceArray(
+    props.checker,
+    props.type,
+  );
+  ArrayUtil.add(array.nullables, props.metadata.nullable);
+  if (newbie === false) return array;
+
+  // CONSTRUCT VALUE TYPE
+  const value: Metadata = explore_metadata({
+    ...props,
+    type: props.array.getNumberIndexType()!,
+    explore: {
+      ...props.explore,
       escaped: false,
       aliased: false,
-    });
-    setValue(value);
+    },
+  });
+  setValue(value);
 
-    return array;
-  };
+  return array;
+};

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

@@ -9,115 +9,123 @@ import { Writable } from "../../../typings/Writable";
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 import { CommentFactory } from "../../CommentFactory";
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
 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 isProperty = significant(!!options.functional);
-    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 = 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, {
+export const emplace_metadata_object = (
+  props: IMetadataIteratorProps,
+): MetadataObject => {
+  // EMPLACE OBJECT
+  const [obj, newbie] = props.collection.emplace(props.checker, props.type);
+  ArrayUtil.add(
+    obj.nullables,
+    props.metadata.nullable,
+    (elem) => elem === props.metadata.nullable,
+  );
+
+  if (newbie === false) return obj;
+
+  // PREPARE ASSETS
+  const isClass: boolean = props.type.isClass();
+  const isProperty = significant(!!props.options.functional);
+  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 = (props: {
+    key: Metadata;
+    value: Metadata;
+    symbol: ts.Symbol | undefined;
+    filter?: (doc: ts.JSDocTagInfo) => boolean;
+  }): MetadataProperty => {
+    // COMMENTS AND TAGS
+    const description: string | null = props.symbol
+      ? (CommentFactory.description(props.symbol) ?? null)
+      : null;
+    const jsDocTags: ts.JSDocTagInfo[] = (
+      props.symbol?.getJsDocTags() ?? []
+    ).filter(props.filter ?? (() => true));
+
+    // THE PROPERTY
+    const property: MetadataProperty = MetadataProperty.create({
+      key: props.key,
+      value: props.value,
+      description,
+      jsDocTags,
+    });
+    obj.properties.push(property);
+    return property;
+  };
+
+  //----
+  // REGULAR PROPERTIES
+  //----
+  for (const symbol of props.type.getApparentProperties()) {
+    // CHECK INTERNAL TAG
+    if (
+      (symbol.getJsDocTags(props.checker) ?? []).find(
+        (tag) => tag.name === "internal",
+      ) !== undefined
+    )
+      continue;
+
+    // CHECK NODE IS A FORMAL PROPERTY
+    const [node, type] = (() => {
+      const node = symbol.getDeclarations()?.[0] as
+        | ts.PropertyDeclaration
+        | undefined;
+      const type: ts.Type | undefined = node
+        ? props.checker.getTypeOfSymbolAtLocation(symbol, node)
+        : props.checker.getTypeOfPropertyOfType(props.type, symbol.name);
+      return [node, type];
+    })();
+    if ((node && pred(node) === false) || type === undefined) continue;
+
+    // GET EXACT TYPE
+    const key: Metadata = MetadataHelper.literal_to_metadata(symbol.name);
+    const value: Metadata = explore_metadata({
+      ...props,
+      type,
+      explore: {
         top: false,
         object: obj,
-        property: prop.name,
+        property: symbol.name,
         parameter: null,
         nested: null,
         aliased: false,
         escaped: false,
         output: 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, {
+      },
+    });
+    Writable(value).optional = (symbol.flags & ts.SymbolFlags.Optional) !== 0;
+    insert({
+      key,
+      value,
+      symbol,
+    });
+  }
+
+  //----
+  // DYNAMIC PROPERTIES
+  //----
+  for (const index of props.checker.getIndexInfosOfType(props.type)) {
+    // GET EXACT TYPE
+    const analyzer = (type: ts.Type) => (property: {} | null) =>
+      explore_metadata({
+        ...props,
+        type,
+        explore: {
           top: false,
           object: obj,
           property,
@@ -126,48 +134,51 @@ export const emplace_metadata_object =
           aliased: false,
           escaped: false,
           output: 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]",
-            parameter: null,
-            nested: null,
-            aliased: false,
-            escaped: false,
-            output: 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 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()
+    )
+      props.errors.push({
+        name: key.getName(),
+        explore: {
+          top: false,
+          object: obj,
+          property: "[key]",
+          parameter: null,
+          nested: null,
+          aliased: false,
+          escaped: false,
+          output: false,
+        },
+        messages: [],
+      });
+
+    // INSERT WITH REQUIRED CONFIGURATION
+    insert({
+      key,
+      value,
+      symbol: index.declaration?.parent
+        ? props.checker.getSymbolAtLocation(index.declaration.parent)
+        : undefined,
+      filter: (doc) => doc.name !== "default",
+    });
+  }
+  return obj;
+};
 
 const significant = (functional: boolean) =>
   functional
@@ -179,8 +190,16 @@ const significant = (functional: boolean) =>
         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);
+const iterate_optional_coalesce = (props: {
+  metadata: Metadata;
+  type: ts.Type;
+}): void => {
+  if (props.type.isUnionOrIntersection())
+    props.type.types.forEach((child) =>
+      iterate_optional_coalesce({
+        metadata: props.metadata,
+        type: child,
+      }),
+    );
+  else iterate_metadata_coalesce(props);
 };

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

@@ -1,57 +1,56 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-import { MetadataTupleType } from "../../../schemas/metadata/MetadataTupleType";
-
-import { Writable } from "../../../typings/Writable";
-
-import { ArrayUtil } from "../../../utils/ArrayUtil";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
-import { explore_metadata } from "./explore_metadata";
-
-export const emplace_metadata_tuple =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (
-    type: ts.TupleType,
-    nullable: boolean,
-    explore: MetadataFactory.IExplore,
-  ): MetadataTupleType => {
-    // CHECK EXISTENCE
-    const [tuple, newbie, closure] = collection.emplaceTuple(checker, type);
-    ArrayUtil.add(tuple.nullables, nullable);
-    if (newbie === false) return tuple;
-
-    // CONSTRUCT ELEMENT TYPES
-    const flagList: readonly ts.ElementFlags[] =
-      type.elementFlags ?? (type.target as ts.TupleType)?.elementFlags ?? [];
-    const elements: Metadata[] = checker
-      .getTypeArguments(type as ts.TypeReference)
-      .map((elem, i) => {
-        const child: Metadata = explore_metadata(checker)(options)(collection)(
-          errors,
-        )(elem, {
-          ...explore,
-          nested: tuple,
-          aliased: false,
-          escaped: false,
-        });
-
-        // CHECK OPTIONAL
-        const flag: ts.ElementFlags | undefined = flagList[i];
-        if (flag === ts.ElementFlags.Optional) Writable(child).optional = true;
-
-        // REST TYPE
-        if (flag !== ts.ElementFlags.Rest) return child;
-        const wrapper: Metadata = Metadata.initialize();
-        Writable(wrapper).rest = child;
-        return wrapper;
-      });
-    closure(elements);
-
-    return tuple;
-  };
+import ts from "typescript";
+
+import { Metadata } from "../../../schemas/metadata/Metadata";
+import { MetadataTupleType } from "../../../schemas/metadata/MetadataTupleType";
+
+import { Writable } from "../../../typings/Writable";
+
+import { ArrayUtil } from "../../../utils/ArrayUtil";
+
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
+import { explore_metadata } from "./explore_metadata";
+
+export const emplace_metadata_tuple = (
+  props: IMetadataIteratorProps<ts.TupleType>,
+): MetadataTupleType => {
+  // CHECK EXISTENCE
+  const [tuple, newbie, closure] = props.collection.emplaceTuple(
+    props.checker,
+    props.type,
+  );
+  ArrayUtil.add(tuple.nullables, props.metadata.nullable);
+  if (newbie === false) return tuple;
+
+  // CONSTRUCT ELEMENT TYPES
+  const flagList: readonly ts.ElementFlags[] =
+    props.type.elementFlags ??
+    (props.type.target as ts.TupleType)?.elementFlags ??
+    [];
+  const elements: Metadata[] = props.checker
+    .getTypeArguments(props.type as ts.TypeReference)
+    .map((elem, i) => {
+      const child: Metadata = explore_metadata({
+        ...props,
+        type: elem,
+        explore: {
+          ...props.explore,
+          nested: tuple,
+          aliased: false,
+          escaped: false,
+        },
+      });
+
+      // CHECK OPTIONAL
+      const flag: ts.ElementFlags | undefined = flagList[i];
+      if (flag === ts.ElementFlags.Optional) Writable(child).optional = true;
+
+      // REST TYPE
+      if (flag !== ts.ElementFlags.Rest) return child;
+      const wrapper: Metadata = Metadata.initialize();
+      Writable(wrapper).rest = child;
+      return wrapper;
+    });
+  closure(elements);
+
+  return tuple;
+};

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

@@ -2,27 +2,29 @@ import ts from "typescript";
 
 import { Metadata } from "../../../schemas/metadata/Metadata";
 
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
 import { emend_metadata_atomics } from "./emend_metadata_atomics";
 import { iterate_metadata } from "./iterate_metadata";
 
-export const explore_metadata =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (type: ts.Type | null, explore: MetadataFactory.IExplore): Metadata => {
-    // CONSTRUCT METADATA
-    const meta: Metadata = Metadata.initialize(explore.escaped);
-    if (type === null) return meta;
+export const explore_metadata = (props: IProps): Metadata => {
+  // CONSTRUCT METADATA
+  const metadata: Metadata = Metadata.initialize(props.explore.escaped);
+  if (props.type === null) return metadata;
 
-    // ITERATE TYPESCRIPT TYPES
-    iterate_metadata(checker)(options)(collection)(errors)(meta, type, explore);
-    emend_metadata_atomics(meta);
-    if (meta.escaped) {
-      emend_metadata_atomics(meta.escaped.original);
-      emend_metadata_atomics(meta.escaped.returns);
-    }
-    return meta;
-  };
+  // ITERATE TYPESCRIPT TYPES
+  iterate_metadata({
+    ...props,
+    metadata,
+    type: props.type,
+  });
+  emend_metadata_atomics(metadata);
+  if (metadata.escaped) {
+    emend_metadata_atomics(metadata.escaped.original);
+    emend_metadata_atomics(metadata.escaped.returns);
+  }
+  return metadata;
+};
+
+interface IProps extends Omit<IMetadataIteratorProps, "metadata" | "type"> {
+  type: ts.Type | null;
+}