typia 6.10.1-dev.20240914 → 7.0.0-dev.20240918

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

@@ -1,76 +1,76 @@
 import ts from "typescript";
 
-import { Metadata } from "../../../schemas/metadata/Metadata";
 import { MetadataConstant } from "../../../schemas/metadata/MetadataConstant";
 import { MetadataConstantValue } from "../../../schemas/metadata/MetadataConstantValue";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
 import { CommentFactory } from "../../CommentFactory";
-import { MetadataFactory } from "../../MetadataFactory";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
 
-export const iterate_metadata_constant =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (meta: Metadata, type: ts.Type): boolean => {
-    if (!options.constant) return false;
+export const iterate_metadata_constant = (
+  props: IMetadataIteratorProps,
+): boolean => {
+  if (!props.options.constant) return false;
 
-    const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
-    const comment = () => {
-      if (!filter(ts.TypeFlags.EnumLiteral)) return {};
-      return {
-        jsDocTags: type.symbol?.getJsDocTags(),
-        description: type.symbol
-          ? CommentFactory.description(type.symbol) ?? null
-          : undefined,
-      };
+  const filter = (flag: ts.TypeFlags) => (props.type.getFlags() & flag) !== 0;
+  const comment = () => {
+    if (!filter(ts.TypeFlags.EnumLiteral)) return {};
+    return {
+      jsDocTags: props.type.symbol?.getJsDocTags(),
+      description: props.type.symbol
+        ? (CommentFactory.description(props.type.symbol) ?? null)
+        : undefined,
     };
-    if (type.isLiteral()) {
-      const value: string | number | bigint =
-        typeof type.value === "object"
-          ? BigInt(`${type.value.negative ? "-" : ""}${type.value.base10Value}`)
-          : type.value;
-      const constant: MetadataConstant = ArrayUtil.take(
-        meta.constants,
-        (elem) => elem.type === typeof value,
-        () =>
-          MetadataConstant.create({
-            type: typeof value as "number",
-            values: [],
-          }),
-      );
-      ArrayUtil.add(
-        constant.values,
-        MetadataConstantValue.create({
-          value,
-          tags: [],
-          ...comment(),
+  };
+  if (props.type.isLiteral()) {
+    const value: string | number | bigint =
+      typeof props.type.value === "object"
+        ? BigInt(
+            `${props.type.value.negative ? "-" : ""}${props.type.value.base10Value}`,
+          )
+        : props.type.value;
+    const constant: MetadataConstant = ArrayUtil.take(
+      props.metadata.constants,
+      (elem) => elem.type === typeof value,
+      () =>
+        MetadataConstant.create({
+          type: typeof value as "number",
+          values: [],
         }),
-        (a, b) => a.value === b.value,
-      );
-      return true;
-    } else if (filter(ts.TypeFlags.BooleanLiteral)) {
-      comment();
-      const value: boolean = checker.typeToString(type) === "true";
-      const constant: MetadataConstant = ArrayUtil.take(
-        meta.constants,
-        (elem) => elem.type === "boolean",
-        () =>
-          MetadataConstant.create({
-            type: "boolean",
-            values: [],
-          }),
-      );
-      ArrayUtil.add(
-        constant.values,
-        MetadataConstantValue.create({
-          value,
-          tags: [],
-          ...comment(),
+    );
+    ArrayUtil.add(
+      constant.values,
+      MetadataConstantValue.create({
+        value,
+        tags: [],
+        ...comment(),
+      }),
+      (a, b) => a.value === b.value,
+    );
+    return true;
+  } else if (filter(ts.TypeFlags.BooleanLiteral)) {
+    comment();
+    const value: boolean = props.checker.typeToString(props.type) === "true";
+    const constant: MetadataConstant = ArrayUtil.take(
+      props.metadata.constants,
+      (elem) => elem.type === "boolean",
+      () =>
+        MetadataConstant.create({
+          type: "boolean",
+          values: [],
         }),
-        (a, b) => a.value === b.value,
-      );
-      return true;
-    }
-    return false;
-  };
+    );
+    ArrayUtil.add(
+      constant.values,
+      MetadataConstantValue.create({
+        value,
+        tags: [],
+        ...comment(),
+      }),
+      (a, b) => a.value === b.value,
+    );
+    return true;
+  }
+  return false;
+};

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

@@ -5,48 +5,43 @@ import { MetadataEscaped } from "../../../schemas/metadata/MetadataEscaped";
 
 import { Writable } from "../../../typings/Writable";
 
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
 import { TypeFactory } from "../../TypeFactory";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
 import { iterate_metadata } from "./iterate_metadata";
 
-export const iterate_metadata_escape =
-  (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;
+export const iterate_metadata_escape = (
+  props: IMetadataIteratorProps,
+): boolean => {
+  if (props.options.escape === false || props.explore.escaped === true)
+    return false;
 
-    const escaped: ts.Type | null =
-      TypeFactory.getReturnType(checker)(type)("toJSON");
-    if (escaped === null) return false;
+  const escaped: ts.Type | null = TypeFactory.getReturnType(props.checker)(
+    props.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;
-  };
+  if (props.metadata.escaped === null) {
+    Writable(props.metadata).escaped = MetadataEscaped.create({
+      original: Metadata.initialize(),
+      returns: Metadata.initialize(),
+    });
+  }
+  iterate_metadata({
+    ...props,
+    metadata: props.metadata.escaped!.original,
+    explore: {
+      ...props.explore,
+      escaped: true,
+    },
+  });
+  iterate_metadata({
+    ...props,
+    metadata: props.metadata.escaped!.returns,
+    type: escaped,
+    explore: {
+      ...props.explore,
+      escaped: true,
+    },
+  });
+  return true;
+};

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

@@ -7,81 +7,80 @@ import { MetadataFunction } from "../../../schemas/metadata/MetadataFunction";
 import { MetadataParameter } from "../../../schemas/metadata/MetadataParameter";
 
 import { CommentFactory } from "../../CommentFactory";
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
 import { TypeFactory } from "../../TypeFactory";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
 import { explore_metadata } from "./explore_metadata";
 
-export const iterate_metadata_function =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (
-    metadata: Metadata,
-    type: ts.Type,
-    explore: MetadataFactory.IExplore,
-  ): boolean => {
-    const declaration: ts.SignatureDeclaration | null =
-      TypeFactory.getFunction(type);
-    if (declaration === null) return false;
-    else if (!options.functional) {
-      if (metadata.functions.length === 0)
-        metadata.functions.push(
-          MetadataFunction.create({
-            parameters: [],
-            output: Metadata.initialize(),
-            async: false,
-          }),
-        );
-    } else {
-      const [signature] = type.getCallSignatures();
-      if (signature === undefined || signature.declaration === undefined)
-        metadata.functions.push(
-          MetadataFunction.create({
-            parameters: [],
-            output: Metadata.initialize(),
-            async: false,
-          }),
-        );
-      else {
-        const { async }: FunctionalGeneralProgrammer.IOutput =
-          FunctionalGeneralProgrammer.getReturnType(checker)(declaration);
-        metadata.functions.push(
-          MetadataFunction.create({
-            parameters: signature.parameters.map((p) =>
-              MetadataParameter.create({
-                name: p.name,
-                type: explore_metadata(checker)(options)(collection)(errors)(
-                  checker.getTypeOfSymbol(p),
-                  {
-                    ...explore,
-                    top: false,
-                    parameter: p.name,
-                  },
-                ),
-                description: CommentFactory.description(p) ?? null,
-                jsDocTags: p?.getJsDocTags() ?? [],
+export const iterate_metadata_function = (
+  props: IMetadataIteratorProps,
+): boolean => {
+  const declaration: ts.SignatureDeclaration | null = TypeFactory.getFunction(
+    props.type,
+  );
+  if (declaration === null) return false;
+  else if (!props.options.functional) {
+    if (props.metadata.functions.length === 0)
+      props.metadata.functions.push(
+        MetadataFunction.create({
+          parameters: [],
+          output: Metadata.initialize(),
+          async: false,
+        }),
+      );
+  } else {
+    const [signature] = props.type.getCallSignatures();
+    if (signature === undefined || signature.declaration === undefined)
+      props.metadata.functions.push(
+        MetadataFunction.create({
+          parameters: [],
+          output: Metadata.initialize(),
+          async: false,
+        }),
+      );
+    else {
+      const { async }: FunctionalGeneralProgrammer.IOutput =
+        FunctionalGeneralProgrammer.getReturnType({
+          checker: props.checker,
+          declaration,
+        });
+      props.metadata.functions.push(
+        MetadataFunction.create({
+          parameters: signature.parameters.map((p) =>
+            MetadataParameter.create({
+              name: p.name,
+              type: explore_metadata({
+                ...props,
+                type: props.checker.getTypeOfSymbol(p),
+                explore: {
+                  ...props.explore,
+                  top: false,
+                  parameter: p.name,
+                },
               }),
-            ),
-            async,
-            output: explore_metadata(checker)({
-              ...options,
+              description: CommentFactory.description(p) ?? null,
+              jsDocTags: p?.getJsDocTags() ?? [],
+            }),
+          ),
+          async,
+          output: explore_metadata({
+            ...props,
+            options: {
+              ...props.options,
               functional: false,
-            })(collection)(errors)(
-              async
-                ? (signature.getReturnType().aliasTypeArguments?.[0] ??
-                    checker.getTypeFromTypeNode(TypeFactory.keyword("any")))
-                : signature.getReturnType(),
-              {
-                ...explore,
-                top: false,
-                output: true,
-              },
-            ),
+            },
+            type: async
+              ? (signature.getReturnType().aliasTypeArguments?.[0] ??
+                props.checker.getTypeFromTypeNode(TypeFactory.keyword("any")))
+              : signature.getReturnType(),
+            explore: {
+              ...props.explore,
+              top: false,
+              output: true,
+            },
           }),
-        );
-      }
+        }),
+      );
     }
-    return true;
-  };
+  }
+  return true;
+};