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

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,11 +80,15 @@ 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;
     })();
 
-    const duplicates: Map<ts.Type, string> = MapUtil.take(this.names_)(
+    const duplicates: Map<ts.Type, string> = MapUtil.take(
+      this.names_,
       name,
       () => new Map(),
     );
@@ -103,7 +107,7 @@ export class MetadataCollection {
    */
   public getUnionIndex(meta: Metadata): number {
     const key: string = meta.objects.map((obj) => obj.name).join(" | ");
-    MapUtil.take(this.object_unions_)(key, () => meta.objects);
+    MapUtil.take(this.object_unions_, key, () => meta.objects);
     return [...this.object_unions_.keys()].indexOf(key);
   }