typia 7.0.0-dev.20240930 → 7.0.0-dev.20241002

package/src/factories/MetadataTypeTagSchemaFactory.ts

@@ -2,58 +2,81 @@ import { Metadata } from "../schemas/metadata/Metadata";
 import { MetadataObject } from "../schemas/metadata/MetadataObject";
 
 export namespace MetadataTypeTagSchemaFactory {
-  export const object =
-    (report: (msg: string) => false) =>
-    (obj: MetadataObject): object | undefined => {
-      if (obj.recursive) {
-        report(`${obj.name} has recursive type`);
-        return undefined;
+  export const object = (props: {
+    report: (msg: string) => false;
+    object: MetadataObject;
+  }): object | undefined => {
+    if (props.object.recursive) {
+      props.report(`${props.object.name} has recursive type`);
+      return undefined;
+    }
+    const output: any = {};
+    for (const p of props.object.properties) {
+      const key: string | null = p.key.getSoleLiteral()!;
+      if (key === null) {
+        props.report(
+          `${props.object.name} has non-literal key type: ${p.key.getName()}`,
+        );
+        continue;
       }
-      const output: any = {};
-      for (const p of obj.properties) {
-        const key: string | null = p.key.getSoleLiteral()!;
-        if (key === null) {
-          report(`${obj.name} has non-literal key type: ${p.key.getName()}`);
-          continue;
-        }
-        output[key] = iterate(report)({ object: obj, key })(p.value);
-      }
-      return output;
-    };
+      output[key] = iterate({
+        report: props.report,
+        object: props.object,
+        key,
+        metadata: p.value,
+      });
+    }
+    return output;
+  };
 
-  const iterate =
-    (report: (msg: string) => false) =>
-    (parent: { object: MetadataObject; key: string }) =>
-    (meta: Metadata): any => {
-      if (
-        meta.any ||
-        meta.atomics.length ||
-        meta.arrays.length ||
-        meta.natives.length ||
-        meta.functions.length
-      )
-        report(`${parent.object.name}.${parent.key} has non-literal type`);
-      else if (meta.size() > 1)
-        report(`${parent.object.name}.${parent.key} has union type`);
-      else if (meta.size() === 0)
-        if (meta.nullable) return null;
-        else if (meta.isRequired() === true)
-          report(`${parent.object.name}.${parent.key} has non-literal type`);
-        else return undefined;
-      else if (meta.constants.length)
-        return meta.constants[0]!.values[0]!.value;
-      else if (meta.tuples.length) {
-        const tuple = meta.tuples[0]!;
-        if (tuple.type.isRest())
-          report(`${parent.object.name}.${parent.key} has rest tuple type`);
-        else if (tuple.type.recursive)
-          report(
-            `${parent.object.name}.${parent.key} has recursive tuple type`,
-          );
-        else if (tuple.type.elements.some((e) => e.required === false))
-          report(`${parent.object.name}.${parent.key} has optional tuple type`);
-        return tuple.type.elements.map(iterate(report)(parent));
-      } else if (meta.objects.length) return object(report)(meta.objects[0]!);
-      else report(`${parent.object.name}.${parent.key} has non-literal type`);
-    };
+  const iterate = (props: {
+    report: (message: string) => false;
+    object: MetadataObject;
+    key: string;
+    metadata: Metadata;
+  }): any => {
+    if (
+      props.metadata.any ||
+      props.metadata.atomics.length ||
+      props.metadata.arrays.length ||
+      props.metadata.natives.length ||
+      props.metadata.functions.length
+    )
+      props.report(`${props.object.name}.${props.key} has non-literal type`);
+    else if (props.metadata.size() > 1)
+      props.report(`${props.object.name}.${props.key} has union type`);
+    else if (props.metadata.size() === 0)
+      if (props.metadata.nullable) return null;
+      else if (props.metadata.isRequired() === true)
+        props.report(`${props.object.name}.${props.key} has non-literal type`);
+      else return undefined;
+    else if (props.metadata.constants.length)
+      return props.metadata.constants[0]!.values[0]!.value;
+    else if (props.metadata.tuples.length) {
+      const tuple = props.metadata.tuples[0]!;
+      if (tuple.type.isRest())
+        props.report(`${props.object.name}.${props.key} has rest tuple type`);
+      else if (tuple.type.recursive)
+        props.report(
+          `${props.object.name}.${props.key} has recursive tuple type`,
+        );
+      else if (tuple.type.elements.some((e) => e.required === false))
+        props.report(
+          `${props.object.name}.${props.key} has optional tuple type`,
+        );
+      return tuple.type.elements.map((elem) =>
+        iterate({
+          report: props.report,
+          object: props.object,
+          key: props.key,
+          metadata: elem,
+        }),
+      );
+    } else if (props.metadata.objects.length)
+      return object({
+        report: props.report,
+        object: props.metadata.objects[0]!,
+      });
+    else props.report(`${props.object.name}.${props.key} has non-literal type`);
+  };
 }

package/src/factories/NumericRangeFactory.ts

@@ -5,15 +5,15 @@ import { ProtobufAtomic } from "../typings/ProtobufAtomic";
 import { ExpressionFactory } from "./ExpressionFactory";
 
 export namespace NumericRangeFactory {
-  export const number =
-    (type: ProtobufAtomic.Numeric) =>
-    (input: ts.Expression): ts.Expression =>
-      NumberPredicator[type](input);
+  export const number = (
+    type: ProtobufAtomic.Numeric,
+    input: ts.Expression,
+  ): ts.Expression => NumberPredicator[type](input);
 
-  export const bigint =
-    (type: ProtobufAtomic.BigNumeric) =>
-    (input: ts.Expression): ts.Expression =>
-      BigIntPredicator[type](input);
+  export const bigint = (
+    type: ProtobufAtomic.BigNumeric,
+    input: ts.Expression,
+  ): ts.Expression => BigIntPredicator[type](input);
 }
 
 namespace NumberPredicator {

package/src/factories/StatementFactory.ts

@@ -3,39 +3,55 @@ import ts from "typescript";
 import { TypeFactory } from "./TypeFactory";
 
 export namespace StatementFactory {
-  export const mut = (name: string, initializer?: ts.Expression) =>
+  export const mut = (props: {
+    name: string;
+    type?: ts.TypeNode | undefined;
+    initializer?: ts.Expression | undefined;
+  }) =>
     ts.factory.createVariableStatement(
       undefined,
       ts.factory.createVariableDeclarationList(
         [
           ts.factory.createVariableDeclaration(
-            name,
+            props.name,
             undefined,
-            initializer === undefined ? TypeFactory.keyword("any") : undefined,
-            initializer,
+            props.type !== undefined
+              ? props.type
+              : props.initializer === undefined
+                ? TypeFactory.keyword("any")
+                : undefined,
+            props.initializer,
           ),
         ],
         ts.NodeFlags.Let,
       ),
     );
 
-  export const constant = (name: string, initializer?: ts.Expression) =>
+  export const constant = (props: {
+    name: string;
+    type?: ts.TypeNode | undefined;
+    value?: ts.Expression | undefined;
+  }) =>
     ts.factory.createVariableStatement(
       undefined,
       ts.factory.createVariableDeclarationList(
         [
           ts.factory.createVariableDeclaration(
-            name,
+            props.name,
             undefined,
-            undefined,
-            initializer,
+            props.type !== undefined
+              ? props.type
+              : props.value === undefined
+                ? TypeFactory.keyword("any")
+                : undefined,
+            props.value,
           ),
         ],
         ts.NodeFlags.Const,
       ),
     );
 
-  export const entry = (key: string) => (value: string) =>
+  export const entry = (props: { key: string; value: string }) =>
     ts.factory.createVariableDeclarationList(
       [
         ts.factory.createVariableDeclaration(
@@ -43,13 +59,13 @@ export namespace StatementFactory {
             ts.factory.createBindingElement(
               undefined,
               undefined,
-              ts.factory.createIdentifier(key),
+              ts.factory.createIdentifier(props.key),
               undefined,
             ),
             ts.factory.createBindingElement(
               undefined,
               undefined,
-              ts.factory.createIdentifier(value),
+              ts.factory.createIdentifier(props.value),
               undefined,
             ),
           ]),

package/src/factories/TemplateFactory.ts

@@ -7,26 +7,32 @@ export namespace TemplateFactory {
         (expressions as ts.StringLiteral[]).map((str) => str.text).join(""),
       );
 
-    const it: IIterator = {
+    const iterator: IIterator = {
       value: "",
       index: 0,
     };
-    gather(expressions)(it);
+    gather({
+      expressions,
+      iterator,
+    });
 
-    const head: ts.TemplateHead = ts.factory.createTemplateHead(it.value);
+    const head: ts.TemplateHead = ts.factory.createTemplateHead(iterator.value);
     const spans: ts.TemplateSpan[] = [];
 
     while (true) {
-      const elem: ts.Expression = expressions[it.index++]!;
-      gather(expressions)(it);
+      const elem: ts.Expression = expressions[iterator.index++]!;
+      gather({
+        expressions,
+        iterator,
+      });
 
-      const broken: boolean = it.index === expressions.length;
+      const broken: boolean = iterator.index === expressions.length;
       spans.push(
         ts.factory.createTemplateSpan(
           elem,
           broken
-            ? ts.factory.createTemplateTail(it.value)
-            : ts.factory.createTemplateMiddle(it.value),
+            ? ts.factory.createTemplateTail(iterator.value)
+            : ts.factory.createTemplateMiddle(iterator.value),
         ),
       );
       if (broken === true) break;
@@ -34,20 +40,22 @@ export namespace TemplateFactory {
     return ts.factory.createTemplateExpression(head, spans);
   };
 
-  const gather =
-    (expressions: ts.Expression[]) =>
-    (it: IIterator): void => {
-      const found: number = expressions.findIndex(
-        (elem, index) => index >= it.index && !ts.isStringLiteral(elem),
-      );
+  const gather = (props: {
+    expressions: ts.Expression[];
+    iterator: IIterator;
+  }): void => {
+    const found: number = props.expressions.findIndex(
+      (elem, index) =>
+        index >= props.iterator.index && !ts.isStringLiteral(elem),
+    );
 
-      const last: number = found !== -1 ? found : expressions.length;
-      it.value = expressions
-        .slice(it.index, last)
-        .map((elem) => (elem as ts.StringLiteral).text)
-        .reduce((x, y) => x + y, "");
-      it.index = last;
-    };
+    const last: number = found !== -1 ? found : props.expressions.length;
+    props.iterator.value = props.expressions
+      .slice(props.iterator.index, last)
+      .map((elem) => (elem as ts.StringLiteral).text)
+      .reduce((x, y) => x + y, "");
+    props.iterator.index = last;
+  };
 
   interface IIterator {
     value: string;

package/src/factories/TypeFactory.ts

@@ -17,75 +17,97 @@ export namespace TypeFactory {
         : null;
   };
 
-  export const getReturnType =
-    (checker: ts.TypeChecker) =>
-    (type: ts.Type) =>
-    (name: string): ts.Type | null => {
-      // FIND TO-JSON METHOD
-      const symbol: ts.Symbol | undefined = type.getProperty(name);
-      if (!symbol) return null;
-      else if (!symbol.valueDeclaration) return null;
+  export const getReturnTypeOfClassMethod = (props: {
+    checker: ts.TypeChecker;
+    class: ts.Type;
+    function: string;
+  }): ts.Type | null => {
+    // FIND TO-JSON METHOD
+    const symbol: ts.Symbol | undefined = props.class.getProperty(
+      props.function,
+    );
+    if (!symbol) return null;
+    else if (!symbol.valueDeclaration) return null;
 
-      // GET FUNCTION DECLARATION
-      const functor: ts.Type = checker.getTypeOfSymbolAtLocation(
-        symbol,
-        symbol.valueDeclaration,
-      );
+    // GET FUNCTION DECLARATION
+    const functor: ts.Type = props.checker.getTypeOfSymbolAtLocation(
+      symbol,
+      symbol.valueDeclaration,
+    );
 
-      // RETURNS THE RETURN-TYPE
-      const signature: ts.Signature | undefined = checker.getSignaturesOfType(
-        functor,
-        ts.SignatureKind.Call,
-      )[0];
-      return signature ? signature.getReturnType() : null;
-    };
+    // RETURNS THE RETURN-TYPE
+    const signature: ts.Signature | undefined =
+      props.checker.getSignaturesOfType(functor, ts.SignatureKind.Call)[0];
+    return signature ? signature.getReturnType() : null;
+  };
 
-  export const getFullName =
-    (checker: ts.TypeChecker) =>
-    (type: ts.Type, symbol?: ts.Symbol): string => {
-      // PRIMITIVE
-      symbol ??= type.aliasSymbol ?? type.getSymbol();
-      if (symbol === undefined) return checker.typeToString(type);
+  export const getFullName = (props: {
+    checker: ts.TypeChecker;
+    type: ts.Type;
+    symbol?: ts.Symbol;
+  }): string => {
+    // PRIMITIVE
+    const symbol =
+      props.symbol ?? props.type.aliasSymbol ?? props.type.getSymbol();
+    if (symbol === undefined) return props.checker.typeToString(props.type);
 
-      // UNION OR INTERSECT
-      if (type.aliasSymbol === undefined && type.isUnionOrIntersection()) {
-        const joiner: string = type.isIntersection() ? " & " : " | ";
-        return type.types
-          .map((child) => getFullName(checker)(child))
-          .join(joiner);
-      }
+    // UNION OR INTERSECT
+    if (
+      props.type.aliasSymbol === undefined &&
+      props.type.isUnionOrIntersection()
+    ) {
+      const joiner: string = props.type.isIntersection() ? " & " : " | ";
+      return props.type.types
+        .map((child) =>
+          getFullName({
+            checker: props.checker,
+            type: child,
+          }),
+        )
+        .join(joiner);
+    }
 
-      //----
-      // SPECIALIZATION
-      //----
-      const name: string = get_name(symbol);
+    //----
+    // SPECIALIZATION
+    //----
+    const name: string = get_name(symbol);
 
-      // CHECK GENERIC
-      const generic: readonly ts.Type[] = type.aliasSymbol
-        ? type.aliasTypeArguments || []
-        : checker.getTypeArguments(type as ts.TypeReference);
-      return generic.length
-        ? name === "Promise"
-          ? getFullName(checker)(generic[0]!)
-          : `${name}<${generic
-              .map((child) => getFullName(checker)(child))
-              .join(", ")}>`
-        : name;
-    };
+    // CHECK GENERIC
+    const generic: readonly ts.Type[] = props.type.aliasSymbol
+      ? (props.type.aliasTypeArguments ?? [])
+      : props.checker.getTypeArguments(props.type as ts.TypeReference);
+    return generic.length
+      ? name === "Promise"
+        ? getFullName({
+            checker: props.checker,
+            type: generic[0]!,
+          })
+        : `${name}<${generic
+            .map((child) =>
+              getFullName({
+                checker: props.checker,
+                type: child,
+              }),
+            )
+            .join(", ")}>`
+      : name;
+  };
 
-  const explore_name =
-    (decl: ts.Node) =>
-    (name: string): string =>
-      ts.isModuleBlock(decl)
-        ? explore_name(decl.parent.parent)(
-            `${decl.parent.name.getFullText().trim()}.${name}`,
-          )
-        : name;
+  const explore_name = (props: { node: ts.Node; name: string }): string =>
+    ts.isModuleBlock(props.node)
+      ? explore_name({
+          node: props.node.parent.parent,
+          name: `${props.node.parent.name.getFullText().trim()}.${props.name}`,
+        })
+      : props.name;
 
   const get_name = (symbol: ts.Symbol): string => {
     const parent = symbol.getDeclarations()?.[0]?.parent;
     return parent
-      ? explore_name(parent)(symbol.escapedName.toString())
+      ? explore_name({
+          node: parent,
+          name: symbol.escapedName.toString(),
+        })
       : "__type";
   };
 

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

@@ -21,7 +21,10 @@ import { iterate_metadata_union } from "./iterate_metadata_union";
 export const iterate_metadata = (props: IMetadataIteratorProps): void => {
   if (props.type.isTypeParameter() === true) {
     props.errors.push({
-      name: TypeFactory.getFullName(props.checker)(props.type),
+      name: TypeFactory.getFullName({
+        checker: props.checker,
+        type: props.type,
+      }),
       explore: { ...props.explore },
       messages: ["non-specified generic argument found."],
     });

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

@@ -11,9 +11,11 @@ export const iterate_metadata_comment_tags = (props: {
   props.object.tagged_ = true;
 
   for (const property of props.object.properties) {
-    MetadataCommentTagFactory.analyze(props.errors)(property.value)(
-      property.jsDocTags,
-      {
+    MetadataCommentTagFactory.analyze({
+      errors: props.errors,
+      metadata: property.value,
+      tags: property.jsDocTags,
+      explore: {
         top: false,
         object: props.object,
         property: property.key.isSoleLiteral()
@@ -25,6 +27,6 @@ export const iterate_metadata_comment_tags = (props: {
         escaped: false,
         output: false,
       },
-    );
+    });
   }
 };

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

@@ -15,9 +15,11 @@ export const iterate_metadata_escape = (
   if (props.options.escape === false || props.explore.escaped === true)
     return false;
 
-  const escaped: ts.Type | null = TypeFactory.getReturnType(props.checker)(
-    props.type,
-  )("toJSON");
+  const escaped: ts.Type | null = TypeFactory.getReturnTypeOfClassMethod({
+    checker: props.checker,
+    class: props.type,
+    function: "toJSON",
+  });
   if (escaped === null) return false;
 
   if (props.metadata.escaped === null) {

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

@@ -69,11 +69,11 @@ export const iterate_metadata_function = (
               functional: false,
             },
             type: async
-            ? (props.checker.getTypeArguments(
-                signature.getReturnType() as ts.TypeReference,
-              )?.[0] ??
+              ? (props.checker.getTypeArguments(
+                  signature.getReturnType() as ts.TypeReference,
+                )?.[0] ??
                 props.checker.getTypeFromTypeNode(TypeFactory.keyword("any")))
-            : signature.getReturnType(),
+              : signature.getReturnType(),
             explore: {
               ...props.explore,
               top: false,

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

@@ -185,9 +185,12 @@ export const iterate_metadata_intersection = (
 
   // ASSIGN TAGS
   if (objects.length) {
-    const tags: IMetadataTypeTag[] = MetadataTypeTagFactory.analyze(
-      props.errors,
-    )(target)(objects.map((om) => om.objects).flat(), props.explore);
+    const tags: IMetadataTypeTag[] = MetadataTypeTagFactory.analyze({
+      errors: props.errors,
+      type: target,
+      objects: objects.map((om) => om.objects).flat(),
+      explore: props.explore,
+    });
     if (tags.length)
       if (target === "array") props.metadata.arrays.at(-1)!.tags.push(tags);
       else if (atomics.size)

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

@@ -11,10 +11,11 @@ export const iterate_metadata_map = (
 ): boolean => {
   const type: ts.Type = props.checker.getApparentType(props.type);
 
-  const name: string = TypeFactory.getFullName(props.checker)(
+  const name: string = TypeFactory.getFullName({
+    checker: props.checker,
     type,
-    type.getSymbol(),
-  );
+    symbol: type.getSymbol(),
+  });
   const generic: readonly ts.Type[] | undefined = type.aliasSymbol
     ? type.aliasTypeArguments
     : props.checker.getTypeArguments(type as ts.TypeReference);

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

@@ -8,13 +8,14 @@ import { IMetadataIteratorProps } from "./IMetadataIteratorProps";
 export const iterate_metadata_native = (
   props: IMetadataIteratorProps,
 ): boolean => {
-  const name: string = TypeFactory.getFullName(props.checker)(
-    props.type,
-    props.type.getSymbol(),
-  );
-  const simple = SIMPLES.get(name);
+  const name: string = TypeFactory.getFullName({
+    checker: props.checker,
+    type: props.type,
+    symbol: props.type.getSymbol(),
+  });
+  const simple: IClassInfo | undefined = SIMPLES.get(name);
   if (
-    simple &&
+    simple !== undefined &&
     validate({
       checker: props.checker,
       type: props.type,
@@ -46,9 +47,11 @@ const validate = (props: {
   info: IClassInfo;
 }) =>
   (props.info.methods ?? []).every((method) => {
-    const returnType = TypeFactory.getReturnType(props.checker)(props.type)(
-      method.name,
-    );
+    const returnType = TypeFactory.getReturnTypeOfClassMethod({
+      checker: props.checker,
+      class: props.type,
+      function: method.name,
+    });
     return (
       returnType !== null &&
       props.checker.typeToString(returnType) === method.return

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

@@ -11,7 +11,11 @@ export const iterate_metadata_set = (
 ): boolean => {
   const type: ts.Type = props.checker.getApparentType(props.type);
 
-  const name = TypeFactory.getFullName(props.checker)(type, type.getSymbol());
+  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);