typia 7.0.0-dev.20240916 → 7.0.0-dev.20240918

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

@@ -1,41 +1,35 @@
 import ts from "typescript";
 
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
-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_set =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (
-    meta: Metadata,
-    type: ts.Type,
-    explore: MetadataFactory.IExplore,
-  ): boolean => {
-    type = checker.getApparentType(type);
+export const iterate_metadata_set = (
+  props: IMetadataIteratorProps,
+): boolean => {
+  const type: ts.Type = props.checker.getApparentType(props.type);
 
-    const name = TypeFactory.getFullName(checker)(type, type.getSymbol());
-    const generic = type.aliasSymbol
-      ? type.aliasTypeArguments
-      : checker.getTypeArguments(type as ts.TypeReference);
-    if (name.substring(0, 4) !== "Set<" || generic?.length !== 1) return false;
+  const name = TypeFactory.getFullName(props.checker)(type, 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(
-      meta.sets,
-      explore_metadata(checker)(options)(collection)(errors)(key, {
-        ...explore,
+  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;
-  };
+      },
+    }),
+    (elem) => elem.getName(),
+  );
+  return true;
+};

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

@@ -3,72 +3,81 @@ import { MetadataObject } from "../../../schemas/metadata/MetadataObject";
 
 import { MetadataCollection } from "../../MetadataCollection";
 
-export const iterate_metadata_sort =
-  (collection: MetadataCollection) => (meta: Metadata) => {
-    const visited: Set<Metadata> = new Set();
-    for (const array of collection.arrays())
-      iterate(visited)(collection)(array.value);
-    for (const tuple of collection.tuples())
-      for (const element of tuple.elements)
-        iterate(visited)(collection)(element);
-    for (const object of collection.objects())
-      for (const property of object.properties)
-        iterate(visited)(collection)(property.value);
-    iterate(visited)(collection)(meta);
-  };
+export const iterate_metadata_sort = (props: {
+  collection: MetadataCollection;
+  metadata: Metadata;
+}) => {
+  const visited: Set<Metadata> = new Set();
+  const next = (metadata: Metadata) =>
+    iterate({
+      visited,
+      collection: props.collection,
+      metadata,
+    });
+  for (const array of props.collection.arrays()) next(array.value);
+  for (const tuple of props.collection.tuples())
+    for (const element of tuple.elements) next(element);
+  for (const object of props.collection.objects())
+    for (const property of object.properties) next(property.value);
+  next(props.metadata);
+};
 
-const iterate =
-  (visited: Set<Metadata>) =>
-  (collection: MetadataCollection) =>
-  (meta: Metadata) => {
-    if (visited.has(meta)) return;
-    visited.add(meta);
+const iterate = (props: {
+  visited: Set<Metadata>;
+  collection: MetadataCollection;
+  metadata: Metadata;
+}) => {
+  if (props.visited.has(props.metadata)) return;
+  props.visited.add(props.metadata);
 
-    // ITERATE CHILDREN
-    for (const map of meta.maps) iterate(visited)(collection)(map.value);
-    for (const set of meta.sets) iterate(visited)(collection)(set);
-    if (meta.escaped !== null)
-      iterate(visited)(collection)(meta.escaped.returns);
-    if (meta.rest !== null) iterate(visited)(collection)(meta.rest);
+  const next = (metadata: Metadata) =>
+    iterate({
+      ...props,
+      metadata,
+    });
 
-    // SORT OBJECTS
-    if (meta.objects.length > 1) {
-      meta.objects.sort((x, y) =>
-        MetadataObject.covers(x, y) ? -1 : MetadataObject.covers(y, x) ? 1 : 0,
-      );
-      meta.union_index = collection.getUnionIndex(meta);
-    }
+  // ITERATE CHILDREN
+  for (const map of props.metadata.maps) next(map.value);
+  for (const set of props.metadata.sets) next(set);
+  if (props.metadata.escaped !== null) next(props.metadata.escaped.returns);
+  if (props.metadata.rest !== null) next(props.metadata.rest);
 
-    // SORT ARRAYS AND TUPLES
-    if (meta.arrays.length > 1)
-      meta.arrays.sort((x, y) =>
-        Metadata.covers(x.type.value, y.type.value)
-          ? -1
-          : Metadata.covers(y.type.value, x.type.value)
-            ? 1
-            : 0,
-      );
-    if (meta.tuples.length > 1)
-      meta.tuples.sort((x, y) => {
-        const xt = Metadata.initialize();
-        const yt = Metadata.initialize();
+  // SORT OBJECTS
+  if (props.metadata.objects.length > 1) {
+    props.metadata.objects.sort((x, y) =>
+      MetadataObject.covers(x, y) ? -1 : MetadataObject.covers(y, x) ? 1 : 0,
+    );
+    props.metadata.union_index = props.collection.getUnionIndex(props.metadata);
+  }
 
-        xt.tuples.push(x);
-        yt.tuples.push(y);
+  // SORT ARRAYS AND TUPLES
+  if (props.metadata.arrays.length > 1)
+    props.metadata.arrays.sort((x, y) =>
+      Metadata.covers(x.type.value, y.type.value)
+        ? -1
+        : Metadata.covers(y.type.value, x.type.value)
+          ? 1
+          : 0,
+    );
+  if (props.metadata.tuples.length > 1)
+    props.metadata.tuples.sort((x, y) => {
+      const xt = Metadata.initialize();
+      const yt = Metadata.initialize();
 
-        return Metadata.covers(xt, yt) ? -1 : Metadata.covers(yt, xt) ? 1 : 0;
-      });
+      xt.tuples.push(x);
+      yt.tuples.push(y);
 
-    // SORT CONSTANT VALUES
-    for (const constant of meta.constants)
-      if (constant.type === "string") constant.values.sort();
-      else if (constant.type === "number")
-        constant.values.sort(
-          (a, b) => (a.value as number) - (b.value as number),
-        );
-      else if (constant.type === "bigint")
-        constant.values.sort((a, b) =>
-          (a.value as bigint) < (b.value as bigint) ? -1 : 1,
-        );
-      else constant.values.sort((a, _b) => (a.value === false ? -1 : 1));
-  };
+      return Metadata.covers(xt, yt) ? -1 : Metadata.covers(yt, xt) ? 1 : 0;
+    });
+
+  // SORT CONSTANT VALUES
+  for (const constant of props.metadata.constants)
+    if (constant.type === "string") constant.values.sort();
+    else if (constant.type === "number")
+      constant.values.sort((a, b) => (a.value as number) - (b.value as number));
+    else if (constant.type === "bigint")
+      constant.values.sort((a, b) =>
+        (a.value as bigint) < (b.value as bigint) ? -1 : 1,
+      );
+    else constant.values.sort((a, _b) => (a.value === false ? -1 : 1));
+};

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

@@ -3,42 +3,40 @@ import ts from "typescript";
 import { Metadata } from "../../../schemas/metadata/Metadata";
 import { MetadataTemplate } from "../../../schemas/metadata/MetadataTemplate";
 
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
 import { MetadataHelper } from "./MetadataHelper";
 import { explore_metadata } from "./explore_metadata";
 
-export const iterate_metadata_template =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (
-    meta: Metadata,
-    type: ts.Type,
-    explore: MetadataFactory.IExplore,
-  ): boolean => {
-    const filter = (flag: ts.TypeFlags) => (type.getFlags() & flag) !== 0;
-    if (!filter(ts.TypeFlags.TemplateLiteral)) return false;
+export const iterate_metadata_template = (
+  props: IMetadataIteratorProps,
+): boolean => {
+  const filter = (flag: ts.TypeFlags) => (props.type.getFlags() & flag) !== 0;
+  if (!filter(ts.TypeFlags.TemplateLiteral)) return false;
 
-    const template: ts.TemplateLiteralType = type as ts.TemplateLiteralType;
-    const row: Metadata[] = [];
+  const template: ts.TemplateLiteralType = props.type as ts.TemplateLiteralType;
+  const row: Metadata[] = [];
 
-    template.texts.forEach((text, i) => {
-      // TEXT LITERAL TYPE
-      if (text !== "") row.push(MetadataHelper.literal_to_metadata(text));
+  template.texts.forEach((text, i) => {
+    // TEXT LITERAL TYPE
+    if (text !== "") row.push(MetadataHelper.literal_to_metadata(text));
 
-      // BINDED TEMPLATE TYPE
-      const binded: ts.Type | undefined = template.types[i];
-      if (binded)
-        row.push(
-          explore_metadata(checker)(options)(collection)(errors)(binded, {
-            ...explore,
+    // BINDED TEMPLATE TYPE
+    const binded: ts.Type | undefined = template.types[i];
+    if (binded)
+      row.push(
+        explore_metadata({
+          ...props,
+          type: binded,
+          explore: {
+            ...props.explore,
             escaped: false,
             aliased: false,
-          }),
-        );
-    });
-    meta.templates.push(MetadataTemplate.create({ row, tags: undefined }));
-    return true;
-  };
+          },
+        }),
+      );
+  });
+  props.metadata.templates.push(
+    MetadataTemplate.create({ row, tags: undefined }),
+  );
+  return true;
+};

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

@@ -1,37 +1,26 @@
 import ts from "typescript";
 
-import { Metadata } from "../../../schemas/metadata/Metadata";
 import { MetadataTuple } from "../../../schemas/metadata/MetadataTuple";
 import { MetadataTupleType } from "../../../schemas/metadata/MetadataTupleType";
 
 import { ArrayUtil } from "../../../utils/ArrayUtil";
 
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
 import { emplace_metadata_tuple } from "./emplace_metadata_tuple";
 
-export const iterate_metadata_tuple =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (
-    meta: Metadata,
-    type: ts.TupleType,
-    explore: MetadataFactory.IExplore,
-  ): boolean => {
-    if (!checker.isTupleType(type)) return false;
+export const iterate_metadata_tuple = (
+  props: IMetadataIteratorProps<ts.TupleType>,
+): boolean => {
+  if (!props.checker.isTupleType(props.type)) return false;
 
-    const tupleType: MetadataTupleType = emplace_metadata_tuple(checker)(
-      options,
-    )(collection)(errors)(type, meta.nullable, explore);
-    ArrayUtil.add(
-      meta.tuples,
-      MetadataTuple.create({
-        type: tupleType,
-        tags: [],
-      }),
-      (elem) => elem.type.name === tupleType.name,
-    );
-    return true;
-  };
+  const tupleType: MetadataTupleType = emplace_metadata_tuple(props);
+  ArrayUtil.add(
+    props.metadata.tuples,
+    MetadataTuple.create({
+      type: tupleType,
+      tags: [],
+    }),
+    (elem) => elem.type.name === tupleType.name,
+  );
+  return true;
+};

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

@@ -1,27 +1,19 @@
-import ts from "typescript";
-
-import { Metadata } from "../../../schemas/metadata/Metadata";
-
-import { MetadataCollection } from "../../MetadataCollection";
-import { MetadataFactory } from "../../MetadataFactory";
+import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
 import { iterate_metadata } from "./iterate_metadata";
 
-export const iterate_metadata_union =
-  (checker: ts.TypeChecker) =>
-  (options: MetadataFactory.IOptions) =>
-  (collection: MetadataCollection) =>
-  (errors: MetadataFactory.IError[]) =>
-  (
-    meta: Metadata,
-    type: ts.Type,
-    explore: MetadataFactory.IExplore,
-  ): boolean => {
-    if (!type.isUnion()) return false;
-    type.types.forEach((t) =>
-      iterate_metadata(checker)(options)(collection)(errors)(meta, t, {
-        ...explore,
+export const iterate_metadata_union = (
+  props: IMetadataIteratorProps,
+): boolean => {
+  if (!props.type.isUnion()) return false;
+  props.type.types.forEach((t) =>
+    iterate_metadata({
+      ...props,
+      type: t,
+      explore: {
+        ...props.explore,
         aliased: false,
-      }),
-    );
-    return true;
-  };
+      },
+    }),
+  );
+  return true;
+};

package/src/programmers/CheckerProgrammer.ts

@@ -222,14 +222,17 @@ export namespace CheckerProgrammer {
       prefix: config.prefix,
       initializer: (project) => (importer) => (type) => {
         const collection: MetadataCollection = new MetadataCollection();
-        const result = MetadataFactory.analyze(
-          project.checker,
-          project.transformer,
-        )({
-          escape: false,
-          constant: true,
-          absorb: true,
-        })(collection)(type);
+        const result = MetadataFactory.analyze({
+          checker: project.checker,
+          transformer: project.transformer,
+          options: {
+            escape: false,
+            constant: true,
+            absorb: true,
+          },
+          collection,
+          type,
+        });
         if (result.success === false)
           throw TransformerError.from(`typia.${importer.method}`)(
             result.errors,

package/src/programmers/RandomProgrammer.ts

@@ -49,22 +49,25 @@ export namespace RandomProgrammer {
     props: IDecomposeProps,
   ): FeatureProgrammer.IDecomposed => {
     const collection: MetadataCollection = new MetadataCollection();
-    const result = MetadataFactory.analyze(
-      props.context.checker,
-      props.context.transformer,
-    )({
-      escape: false,
-      constant: true,
-      absorb: true,
-      validate: (meta) => {
-        const output: string[] = [];
-        if (meta.natives.some((n) => n === "WeakSet"))
-          output.push(`WeakSet is not supported.`);
-        else if (meta.natives.some((n) => n === "WeakMap"))
-          output.push(`WeakMap is not supported.`);
-        return output;
+    const result = MetadataFactory.analyze({
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      options: {
+        escape: false,
+        constant: true,
+        absorb: true,
+        validate: (meta) => {
+          const output: string[] = [];
+          if (meta.natives.some((n) => n === "WeakSet"))
+            output.push(`WeakSet is not supported.`);
+          else if (meta.natives.some((n) => n === "WeakMap"))
+            output.push(`WeakMap is not supported.`);
+          return output;
+        },
       },
-    })(collection)(props.type);
+      collection,
+      type: props.type,
+    });
     if (result.success === false)
       throw TransformerError.from(`typia.${props.importer.method}`)(
         result.errors,

package/src/programmers/http/HttpFormDataProgrammer.ts

@@ -32,15 +32,18 @@ export namespace HttpFormDataProgrammer {
   }): FeatureProgrammer.IDecomposed => {
     // ANALYZE TYPE
     const collection: MetadataCollection = new MetadataCollection();
-    const result = MetadataFactory.analyze(
-      props.context.checker,
-      props.context.transformer,
-    )({
-      escape: false,
-      constant: true,
-      absorb: true,
-      validate,
-    })(collection)(props.type);
+    const result = MetadataFactory.analyze({
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      options: {
+        escape: false,
+        constant: true,
+        absorb: true,
+        validate,
+      },
+      collection,
+      type: props.type,
+    });
     if (result.success === false)
       throw TransformerError.from(`typia.http.${props.importer.method}`)(
         result.errors,

package/src/programmers/http/HttpHeadersProgrammer.ts

@@ -36,15 +36,18 @@ export namespace HttpHeadersProgrammer {
   }): FeatureProgrammer.IDecomposed => {
     // ANALYZE TYPE
     const collection: MetadataCollection = new MetadataCollection();
-    const result = MetadataFactory.analyze(
-      props.context.checker,
-      props.context.transformer,
-    )({
-      escape: false,
-      constant: true,
-      absorb: true,
-      validate,
-    })(collection)(props.type);
+    const result = MetadataFactory.analyze({
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      options: {
+        escape: false,
+        constant: true,
+        absorb: true,
+        validate,
+      },
+      collection,
+      type: props.type,
+    });
     if (result.success === false)
       throw TransformerError.from(`typia.http.${props.importer.method}`)(
         result.errors,

package/src/programmers/http/HttpParameterProgrammer.ts

@@ -17,15 +17,18 @@ import { HttpMetadataUtil } from "../helpers/HttpMetadataUtil";
 
 export namespace HttpParameterProgrammer {
   export const write = (props: IProgrammerProps): ts.ArrowFunction => {
-    const result = MetadataFactory.analyze(
-      props.context.checker,
-      props.context.transformer,
-    )({
-      escape: false,
-      constant: true,
-      absorb: true,
-      validate,
-    })(new MetadataCollection())(props.type);
+    const result = MetadataFactory.analyze({
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      options: {
+        escape: false,
+        constant: true,
+        absorb: true,
+        validate,
+      },
+      collection: new MetadataCollection(),
+      type: props.type,
+    });
     if (result.success === false)
       throw TransformerError.from(props.modulo.getText())(result.errors);
 

package/src/programmers/http/HttpQueryProgrammer.ts

@@ -39,15 +39,19 @@ export namespace HttpQueryProgrammer {
   }): FeatureProgrammer.IDecomposed => {
     // ANALYZE TYPE
     const collection: MetadataCollection = new MetadataCollection();
-    const result = MetadataFactory.analyze(
-      props.context.checker,
-      props.context.transformer,
-    )({
-      escape: false,
-      constant: true,
-      absorb: true,
-      validate: (meta, explore) => validate(meta, explore, props.allowOptional),
-    })(collection)(props.type);
+    const result = MetadataFactory.analyze({
+      checker: props.context.checker,
+      transformer: props.context.transformer,
+      options: {
+        escape: false,
+        constant: true,
+        absorb: true,
+        validate: (meta, explore) =>
+          validate(meta, explore, props.allowOptional),
+      },
+      collection,
+      type: props.type,
+    });
     if (result.success === false)
       throw TransformerError.from(`typia.http.${props.importer.method}`)(
         result.errors,

package/src/programmers/json/JsonStringifyProgrammer.ts

@@ -871,10 +871,12 @@ export namespace JsonStringifyProgrammer {
 
   const initializer: FeatureProgrammer.IConfig["initializer"] =
     (project) => (importer) => (type) =>
-      JsonMetadataFactory.analyze(`typia.json.${importer.method}`)(
-        project.checker,
-        project.transformer,
-      )(type);
+      JsonMetadataFactory.analyze({
+        method: `typia.json.${importer.method}`,
+        checker: project.checker,
+        transformer: project.transformer,
+        type,
+      });
 
   const create_throw_error =
     (importer: FunctionImporter) =>

package/src/programmers/misc/MiscCloneProgrammer.ts

@@ -722,22 +722,25 @@ export namespace MiscCloneProgrammer {
   const initializer: FeatureProgrammer.IConfig["initializer"] =
     (project) => (importer) => (type) => {
       const collection = new MetadataCollection();
-      const result = MetadataFactory.analyze(
-        project.checker,
-        project.transformer,
-      )({
-        escape: false,
-        constant: true,
-        absorb: true,
-        validate: (meta) => {
-          const output: string[] = [];
-          if (meta.natives.some((n) => n === "WeakSet"))
-            output.push("unable to clone WeakSet");
-          else if (meta.natives.some((n) => n === "WeakMap"))
-            output.push("unable to clone WeakMap");
-          return output;
+      const result = MetadataFactory.analyze({
+        checker: project.checker,
+        transformer: project.transformer,
+        options: {
+          escape: false,
+          constant: true,
+          absorb: true,
+          validate: (meta) => {
+            const output: string[] = [];
+            if (meta.natives.some((n) => n === "WeakSet"))
+              output.push("unable to clone WeakSet");
+            else if (meta.natives.some((n) => n === "WeakMap"))
+              output.push("unable to clone WeakMap");
+            return output;
+          },
         },
-      })(collection)(type);
+        collection,
+        type,
+      });
       if (result.success === false)
         throw TransformerError.from(`typia.misc.${importer.method}`)(
           result.errors,