typia 7.0.0-dev.20241001 → 7.0.0-dev.20241002

package/src/executable/setup/ArgumentParser.ts

@@ -11,33 +11,32 @@ export namespace ArgumentParser {
     action: (closure: (options: Partial<T>) => Promise<T>) => Promise<T>,
   ) => Promise<T>;
 
-  export const parse =
-    (pack: PackageManager) =>
-    async <T>(
-      inquiry: (
-        pack: PackageManager,
-        command: commander.Command,
-        prompt: (opt?: inquirer.StreamOptions) => inquirer.PromptModule,
-        action: (closure: (options: Partial<T>) => Promise<T>) => Promise<T>,
-      ) => Promise<T>,
-    ): Promise<T> => {
-      // TAKE OPTIONS
-      const action = (closure: (options: Partial<T>) => Promise<T>) =>
-        new Promise<T>((resolve, reject) => {
-          commander.program.action(async (options) => {
-            try {
-              resolve(await closure(options));
-            } catch (exp) {
-              reject(exp);
-            }
-          });
-          commander.program.parseAsync().catch(reject);
+  export const parse = async <T>(
+    pack: PackageManager,
+    inquiry: (
+      pack: PackageManager,
+      command: commander.Command,
+      prompt: (opt?: inquirer.StreamOptions) => inquirer.PromptModule,
+      action: (closure: (options: Partial<T>) => Promise<T>) => Promise<T>,
+    ) => Promise<T>,
+  ): Promise<T> => {
+    // TAKE OPTIONS
+    const action = (closure: (options: Partial<T>) => Promise<T>) =>
+      new Promise<T>((resolve, reject) => {
+        commander.program.action(async (options) => {
+          try {
+            resolve(await closure(options));
+          } catch (exp) {
+            reject(exp);
+          }
         });
-      return inquiry(
-        pack,
-        commander.program,
-        inquirer.createPromptModule,
-        action,
-      );
-    };
+        commander.program.parseAsync().catch(reject);
+      });
+    return inquiry(
+      pack,
+      commander.program,
+      inquirer.createPromptModule,
+      action,
+    );
+  };
 }

package/src/executable/setup/FileRetriever.ts

@@ -2,21 +2,18 @@ import fs from "fs";
 import path from "path";
 
 export namespace FileRetriever {
-  export const directory =
-    (name: string) =>
-    (dir: string, depth: number = 0): string | null => {
-      const location: string = path.join(dir, name);
-      if (fs.existsSync(location)) return dir;
-      else if (depth > 2) return null;
-      return directory(name)(path.join(dir, ".."), depth + 1);
-    };
-
-  export const file =
-    (name: string) =>
-    (directory: string, depth: number = 0): string | null => {
-      const location: string = path.join(directory, name);
-      if (fs.existsSync(location)) return location;
-      else if (depth > 2) return null;
-      return file(name)(path.join(directory, ".."), depth + 1);
-    };
+  export const directory = (props: {
+    file: string;
+    location: string;
+    depth?: number;
+  }): string | null => {
+    const location: string = path.join(props.location, props.file);
+    if (fs.existsSync(location)) return props.location;
+    else if ((props.depth ?? 0) > 2) return null;
+    return directory({
+      file: props.file,
+      location: path.join(props.location, ".."),
+      depth: (props.depth ?? 0) + 1,
+    });
+  };
 }

package/src/executable/setup/PackageManager.ts

@@ -11,9 +11,10 @@ export class PackageManager {
   }
 
   public static async mount(): Promise<PackageManager> {
-    const location: string | null = await FileRetriever.directory(
-      "package.json",
-    )(process.cwd());
+    const location: string | null = await FileRetriever.directory({
+      file: "package.json",
+      location: process.cwd(),
+    });
     if (location === null)
       throw new URIError(`Unable to find "package.json" file`);
 

package/src/factories/ExpressionFactory.ts

@@ -31,68 +31,75 @@ export namespace ExpressionFactory {
       [input],
     );
 
-  export const isObject =
-    (options: { checkNull: boolean; checkArray: boolean }) =>
-    (input: ts.Expression): ts.Expression => {
-      const conditions: ts.Expression[] = [
+  export const isObject = (props: {
+    checkNull: boolean;
+    checkArray: boolean;
+    input: ts.Expression;
+  }): ts.Expression => {
+    const conditions: ts.Expression[] = [
+      ts.factory.createStrictEquality(
+        ts.factory.createStringLiteral("object"),
+        ts.factory.createTypeOfExpression(props.input),
+      ),
+    ];
+    if (props.checkNull === true)
+      conditions.push(
+        ts.factory.createStrictInequality(ts.factory.createNull(), props.input),
+      );
+    if (props.checkArray === true)
+      conditions.push(
         ts.factory.createStrictEquality(
-          ts.factory.createStringLiteral("object"),
-          ts.factory.createTypeOfExpression(input),
-        ),
-      ];
-      if (options.checkNull === true)
-        conditions.push(
-          ts.factory.createStrictInequality(ts.factory.createNull(), input),
-        );
-      if (options.checkArray === true)
-        conditions.push(
-          ts.factory.createStrictEquality(
-            ts.factory.createFalse(),
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("Array.isArray"),
-              undefined,
-              [input],
-            ),
+          ts.factory.createFalse(),
+          ts.factory.createCallExpression(
+            ts.factory.createIdentifier("Array.isArray"),
+            undefined,
+            [props.input],
           ),
-        );
+        ),
+      );
 
-      return conditions.length === 1
-        ? conditions[0]!
-        : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
-    };
+    return conditions.length === 1
+      ? conditions[0]!
+      : conditions.reduce((x, y) => ts.factory.createLogicalAnd(x, y));
+  };
 
-  export const isInstanceOf =
-    (type: string) =>
-    (input: ts.Expression): ts.Expression => {
-      return ts.factory.createBinaryExpression(
-        input,
-        ts.factory.createToken(ts.SyntaxKind.InstanceOfKeyword),
-        ts.factory.createIdentifier(type),
-      );
-    };
+  export const isInstanceOf = (
+    type: string,
+    input: ts.Expression,
+  ): ts.Expression => {
+    return ts.factory.createBinaryExpression(
+      input,
+      ts.factory.createToken(ts.SyntaxKind.InstanceOfKeyword),
+      ts.factory.createIdentifier(type),
+    );
+  };
 
-  export const coalesce =
-    (x: ts.Expression) =>
-    (y: ts.Expression): ts.Expression =>
-      ts.factory.createBinaryExpression(
-        x,
-        ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken),
-        y,
-      );
+  export const coalesce = (x: ts.Expression, y: ts.Expression): ts.Expression =>
+    ts.factory.createBinaryExpression(
+      x,
+      ts.factory.createToken(ts.SyntaxKind.QuestionQuestionToken),
+      y,
+    );
 
-  export const currying =
-    (target: ts.Expression) => (parameters: ts.Expression[]) => {
-      if (parameters.length === 0)
-        return ts.factory.createCallExpression(target, undefined, undefined);
-      let prev: ts.CallExpression = ts.factory.createCallExpression(
-        target,
+  export const currying = (props: {
+    function: ts.Expression;
+    arguments: ts.Expression[];
+  }) => {
+    if (props.arguments.length === 0)
+      return ts.factory.createCallExpression(
+        props.function,
+        undefined,
         undefined,
-        [parameters[0]!],
       );
-      for (const param of parameters.slice(1))
-        prev = ts.factory.createCallExpression(prev, undefined, [param]);
-      return prev;
-    };
+    let prev: ts.CallExpression = ts.factory.createCallExpression(
+      props.function,
+      undefined,
+      [props.arguments[0]!],
+    );
+    for (const param of props.arguments.slice(1))
+      prev = ts.factory.createCallExpression(prev, undefined, [param]);
+    return prev;
+  };
 
   export const selfCall = (body: ts.ConciseBody) =>
     ts.isCallExpression(body)
@@ -112,39 +119,46 @@ export namespace ExpressionFactory {
           undefined,
         );
 
-  export const getEscapedText =
-    (printer: ts.Printer) =>
-    (input: ts.Expression): string =>
-      printer.printNode(ts.EmitHint.Expression, input, input.getSourceFile());
+  export const getEscapedText = (props: {
+    printer: ts.Printer;
+    input: ts.Expression;
+  }): string =>
+    props.printer.printNode(
+      ts.EmitHint.Expression,
+      props.input,
+      props.input.getSourceFile(),
+    );
 
-  export const transpile =
-    (context: ts.TransformationContext) => (script: string) => {
-      const file: ts.SourceFile = ts.createSourceFile(
-        `${RandomGenerator.uuid()}.ts`,
-        script,
-        ts.ScriptTarget.ESNext,
-        true,
-        ts.ScriptKind.TS,
+  export const transpile = (
+    transformer: ts.TransformationContext,
+    script: string,
+  ) => {
+    const file: ts.SourceFile = ts.createSourceFile(
+      `${RandomGenerator.uuid()}.ts`,
+      script,
+      ts.ScriptTarget.ESNext,
+      true,
+      ts.ScriptKind.TS,
+    );
+    const statement: ts.Statement | undefined = file.statements[0];
+    if (statement === undefined)
+      throw new ReferenceError(
+        "Error on ExpressionFactory.transpile(): no statement exists.",
       );
-      const statement: ts.Statement | undefined = file.statements[0];
-      if (statement === undefined)
-        throw new ReferenceError(
-          "Error on ExpressionFactory.transpile(): no statement exists.",
-        );
-      else if (!ts.isExpressionStatement(statement))
-        throw new TypeError(
-          "Error on ExpressionFactory.transpile(): statement is not an expression statement.",
+    else if (!ts.isExpressionStatement(statement))
+      throw new TypeError(
+        "Error on ExpressionFactory.transpile(): statement is not an expression statement.",
+      );
+    return (input: ts.Expression): ts.Expression => {
+      const visitor = (node: ts.Node): ts.Node => {
+        if (ts.isIdentifier(node) && node.text === "$input") return input;
+        return ts.visitEachChild(
+          (ts.factory as any).cloneNode(node),
+          visitor,
+          transformer,
         );
-      return (input: ts.Expression): ts.Expression => {
-        const visitor = (node: ts.Node): ts.Node => {
-          if (ts.isIdentifier(node) && node.text === "$input") return input;
-          return ts.visitEachChild(
-            (ts.factory as any).cloneNode(node),
-            visitor,
-            context,
-          );
-        };
-        return visitor(statement.expression) as ts.Expression;
       };
+      return visitor(statement.expression) as ts.Expression;
     };
+  };
 }

package/src/factories/IdentifierFactory.ts

@@ -10,11 +10,27 @@ export namespace IdentifierFactory {
       ? ts.factory.createIdentifier(name)
       : ts.factory.createStringLiteral(name);
 
-  export const access = (target: ts.Expression) => (property: string) => {
-    const postfix = identifier(property);
+  export const access = (
+    input: ts.Expression,
+    key: string,
+    chain?: boolean,
+  ) => {
+    const postfix = identifier(key);
     return ts.isStringLiteral(postfix)
-      ? ts.factory.createElementAccessExpression(target, postfix)
-      : ts.factory.createPropertyAccessExpression(target, postfix);
+      ? chain === true
+        ? ts.factory.createElementAccessChain(
+            input,
+            ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
+            postfix,
+          )
+        : ts.factory.createElementAccessExpression(input, postfix)
+      : chain === true
+        ? ts.factory.createPropertyAccessChain(
+            input,
+            ts.factory.createToken(ts.SyntaxKind.QuestionDotToken),
+            postfix,
+          )
+        : ts.factory.createPropertyAccessExpression(input, postfix);
   };
 
   export const getName = (input: ts.Expression): string => {
@@ -29,7 +45,7 @@ export namespace IdentifierFactory {
       return `${getName(input.expression)}[${getName(
         input.argumentExpression,
       )}]`;
-    return "uknown";
+    return "unknown";
   };
 
   export const postfix = (str: string): string =>
@@ -39,8 +55,11 @@ export namespace IdentifierFactory {
 
   export const parameter = (
     name: string | ts.BindingName,
-    type?: ts.TypeNode,
-    init?: ts.Expression | ts.PunctuationToken<ts.SyntaxKind.QuestionToken>,
+    type?: ts.TypeNode | undefined,
+    init?:
+      | ts.Expression
+      | ts.PunctuationToken<ts.SyntaxKind.QuestionToken>
+      | undefined,
   ): ts.ParameterDeclaration => {
     // instead of ts.version >= "4.8"
     if (ts.getDecorators !== undefined)

package/src/factories/MetadataCollection.ts

@@ -80,7 +80,10 @@ export class MetadataCollection {
 
   private getName(checker: ts.TypeChecker, type: ts.Type): string {
     const name: string = (() => {
-      const str: string = TypeFactory.getFullName(checker)(type);
+      const str: string = TypeFactory.getFullName({
+        checker,
+        type,
+      });
       return this.options?.replace ? this.options.replace(str) : str;
     })();
 

package/src/factories/MetadataCommentTagFactory.ts

@@ -15,103 +15,112 @@ import { MetadataTypeTagFactory } from "./MetadataTypeTagFactory";
  * @internal
  */
 export namespace MetadataCommentTagFactory {
-  export const analyze =
-    (errors: MetadataFactory.IError[]) =>
-    (metadata: Metadata) =>
-    (
-      commentList: ts.JSDocTagInfo[],
-      explore: MetadataFactory.IExplore,
-    ): void => {
-      // PREPARE MESSAGE CONTAINER
-      const messages: string[] = [];
-      const report = (msg: string) => {
-        messages.push(msg);
-        return null;
-      };
-      const validateReport =
-        (property: string | null) =>
-        (msg: string): false => {
-          messages.push(
-            `the property ${
-              property === null ? `["typia.tag"]` : `["typia.tag.${property}"]`
-            } ${msg}.`,
-          );
-          return false;
-        };
+  export const analyze = (props: {
+    errors: MetadataFactory.IError[];
+    metadata: Metadata;
+    tags: ts.JSDocTagInfo[];
+    explore: MetadataFactory.IExplore;
+  }): void => {
+    // PREPARE MESSAGE CONTAINER
+    const messages: string[] = [];
+    const report = (msg: string) => {
+      messages.push(msg);
+      return null;
+    };
+    const validateReport = (next: {
+      property: string | null;
+      message: string;
+    }): false => {
+      messages.push(
+        `the property ${
+          next.property === null
+            ? `["typia.tag"]`
+            : `["typia.tag.${next.property}"]`
+        } ${next.message}.`,
+      );
+      return false;
+    };
 
-      // VALIDATE AND CONSTRUCT COMMENT TAGS
-      for (const comment of commentList) {
-        const tagger: TagRecord | null = parse(report)(comment);
-        if (tagger === null) continue;
-        for (const [key, value] of Object.entries(tagger)) {
-          const filtered: IMetadataTypeTag[] = value.filter(
-            (v) => v.validate !== null,
-          ) as IMetadataTypeTag[];
-          if (key === "array") {
-            if (metadata.arrays.length === 0) {
-              report(`requires array type`);
-              continue;
-            }
-            for (const a of metadata.arrays) {
-              Writable(a).tags = a.tags.filter((x) =>
-                MetadataTypeTagFactory.validate(validateReport)("array")([
-                  ...x,
-                  ...filtered,
-                ]),
-              );
-              if (a.tags.length === 0) a.tags.push(filtered);
-              else for (const tags of a.tags) tags.push(...filtered);
-            }
-          } else {
-            const atomic = metadata.atomics.find((a) => a.type == key);
-            if (atomic === undefined)
-              if (key === "bigint" || key === "number") {
-                const opposite = key === "bigint" ? "number" : "bigint";
-                if (
-                  tagger[opposite] !== undefined &&
-                  metadata.atomics.some((a) => a.type === opposite)
-                )
-                  continue;
-              } else if (
-                key === "string" &&
-                value[0]?.kind === "format" &&
-                value[0]?.value === "date-time"
+    // VALIDATE AND CONSTRUCT COMMENT TAGS
+    for (const tag of props.tags) {
+      const tagger: TagRecord | null = parse({
+        report,
+        tag,
+      });
+      if (tagger === null) continue;
+      for (const [key, value] of Object.entries(tagger)) {
+        const filtered: IMetadataTypeTag[] = value.filter(
+          (v) => v.validate !== null,
+        ) as IMetadataTypeTag[];
+        if (key === "array") {
+          if (props.metadata.arrays.length === 0) {
+            report(`requires array type`);
+            continue;
+          }
+          for (const a of props.metadata.arrays) {
+            Writable(a).tags = a.tags.filter((x) =>
+              MetadataTypeTagFactory.validate({
+                report: validateReport,
+                type: "array",
+                tags: [...x, ...filtered],
+              }),
+            );
+            if (a.tags.length === 0) a.tags.push(filtered);
+            else for (const tags of a.tags) tags.push(...filtered);
+          }
+        } else {
+          const atomic = props.metadata.atomics.find((a) => a.type == key);
+          if (atomic === undefined)
+            if (key === "bigint" || key === "number") {
+              const opposite = key === "bigint" ? "number" : "bigint";
+              if (
+                tagger[opposite] !== undefined &&
+                props.metadata.atomics.some((a) => a.type === opposite)
               )
                 continue;
-              else report(`requires ${key} type`);
-            else {
-              Writable(atomic).tags = atomic.tags.filter((x) =>
-                MetadataTypeTagFactory.validate(validateReport)(
-                  key as "string",
-                )([...x, ...filtered]),
-              );
-              if (atomic.tags.length === 0) atomic.tags.push(filtered);
-              else for (const tags of atomic.tags) tags.push(...filtered);
-            }
+            } else if (
+              key === "string" &&
+              value[0]?.kind === "format" &&
+              value[0]?.value === "date-time"
+            )
+              continue;
+            else report(`requires ${key} type`);
+          else {
+            Writable(atomic).tags = atomic.tags.filter((x) =>
+              MetadataTypeTagFactory.validate({
+                report: validateReport,
+                type: key as "string",
+                tags: [...x, ...filtered],
+              }),
+            );
+            if (atomic.tags.length === 0) atomic.tags.push(filtered);
+            else for (const tags of atomic.tags) tags.push(...filtered);
           }
         }
       }
+    }
 
-      // DO REPORT
-      if (messages.length !== 0)
-        errors.push({
-          name: "comment tag(s)",
-          explore,
-          messages,
-        });
-    };
+    // DO REPORT
+    if (messages.length !== 0)
+      props.errors.push({
+        name: "comment tag(s)",
+        explore: props.explore,
+        messages,
+      });
+  };
 
-  const parse =
-    (report: (msg: string) => null) =>
-    (comment: ts.JSDocTagInfo): TagRecord | null => {
-      const parser = PARSER[comment.name];
-      if (parser === undefined) return {};
+  const parse = (props: {
+    report: (msg: string) => null;
+    tag: ts.JSDocTagInfo;
+  }): TagRecord | null => {
+    const next = PARSER[props.tag.name];
+    if (next === undefined) return {};
 
-      const text = (comment.text || [])[0]?.text;
-      if (text === undefined && comment.name !== "uniqueItems")
-        return report(`no comment tag value`);
-      return parser(report)(text!);
-    };
+    const text = (props.tag.text || [])[0]?.text;
+    if (text === undefined && props.tag.name !== "uniqueItems")
+      return props.report(`no comment tag value`);
+    return next(props.report)(text!);
+  };
 }
 
 type TagRecord = {

package/src/factories/MetadataFactory.ts

@@ -162,7 +162,8 @@ export namespace MetadataFactory {
             (t) => t.validate !== undefined && t.predicate === undefined,
           ))
             try {
-              tag.predicate = ExpressionFactory.transpile(props.transformer)(
+              tag.predicate = ExpressionFactory.transpile(
+                props.transformer,
                 tag.validate!,
               );
             } catch {