typia 7.0.0-dev.20241011 → 7.0.0-dev.20241012

package/src/programmers/functional/FunctionalIsFunctionProgrammer.ts

@@ -1,72 +1,72 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { FunctionalIsParametersProgrammer } from "./FunctionalIsParametersProgrammer";
-import { FunctionalIsReturnProgrammer } from "./FunctionalIsReturnProgrammer";
-
-export namespace FunctionalIsFunctionProgrammer {
-  export interface IConfig {
-    equals: boolean;
-  }
-  export interface IProps {
-    context: ITypiaContext;
-    modulo: ts.LeftHandSideExpression;
-    config: IConfig;
-    declaration: ts.FunctionDeclaration;
-    expression: ts.Expression;
-    init?: ts.Expression | undefined;
-  }
-
-  export const write = (props: IProps): ts.CallExpression => {
-    const p = FunctionalIsParametersProgrammer.decompose(props);
-    const r = FunctionalIsReturnProgrammer.decompose(props);
-    return ExpressionFactory.selfCall(
-      ts.factory.createBlock(
-        [
-          ...p.functions,
-          ...r.functions,
-          ts.factory.createReturnStatement(
-            ts.factory.createArrowFunction(
-              r.async
-                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
-                : undefined,
-              undefined,
-              props.declaration.parameters,
-              getReturnTypeNode({
-                declaration: props.declaration,
-                async: r.async,
-              }),
-              undefined,
-              ts.factory.createBlock([...p.statements, ...r.statements], true),
-            ),
-          ),
-        ],
-        true,
-      ),
-    );
-  };
-
-  export const getReturnTypeNode = (props: {
-    declaration: ts.FunctionDeclaration;
-    async: boolean;
-  }): ts.TypeNode | undefined =>
-    props.declaration.type
-      ? props.async
-        ? !!(props.declaration.type! as ts.TypeReferenceNode).typeArguments?.[0]
-          ? ts.factory.createTypeReferenceNode("Promise", [
-              ts.factory.createUnionTypeNode([
-                (props.declaration.type! as ts.TypeReferenceNode)
-                  .typeArguments![0]!,
-                ts.factory.createTypeReferenceNode("null"),
-              ]),
-            ])
-          : undefined
-        : ts.factory.createUnionTypeNode([
-            props.declaration.type,
-            ts.factory.createTypeReferenceNode("null"),
-          ])
-      : undefined;
-}
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { FunctionalIsParametersProgrammer } from "./FunctionalIsParametersProgrammer";
+import { FunctionalIsReturnProgrammer } from "./FunctionalIsReturnProgrammer";
+
+export namespace FunctionalIsFunctionProgrammer {
+  export interface IConfig {
+    equals: boolean;
+  }
+  export interface IProps {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    config: IConfig;
+    declaration: ts.FunctionDeclaration;
+    expression: ts.Expression;
+    init?: ts.Expression | undefined;
+  }
+
+  export const write = (props: IProps): ts.CallExpression => {
+    const p = FunctionalIsParametersProgrammer.decompose(props);
+    const r = FunctionalIsReturnProgrammer.decompose(props);
+    return ExpressionFactory.selfCall(
+      ts.factory.createBlock(
+        [
+          ...p.functions,
+          ...r.functions,
+          ts.factory.createReturnStatement(
+            ts.factory.createArrowFunction(
+              r.async
+                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                : undefined,
+              undefined,
+              props.declaration.parameters,
+              getReturnTypeNode({
+                declaration: props.declaration,
+                async: r.async,
+              }),
+              undefined,
+              ts.factory.createBlock([...p.statements, ...r.statements], true),
+            ),
+          ),
+        ],
+        true,
+      ),
+    );
+  };
+
+  export const getReturnTypeNode = (props: {
+    declaration: ts.FunctionDeclaration;
+    async: boolean;
+  }): ts.TypeNode | undefined =>
+    props.declaration.type
+      ? props.async
+        ? !!(props.declaration.type! as ts.TypeReferenceNode).typeArguments?.[0]
+          ? ts.factory.createTypeReferenceNode("Promise", [
+              ts.factory.createUnionTypeNode([
+                (props.declaration.type! as ts.TypeReferenceNode)
+                  .typeArguments![0]!,
+                ts.factory.createTypeReferenceNode("null"),
+              ]),
+            ])
+          : undefined
+        : ts.factory.createUnionTypeNode([
+            props.declaration.type,
+            ts.factory.createTypeReferenceNode("null"),
+          ])
+      : undefined;
+}

package/src/programmers/functional/FunctionalIsParametersProgrammer.ts

@@ -1,113 +1,113 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { IsProgrammer } from "../IsProgrammer";
-import { FunctionalIsFunctionProgrammer } from "./FunctionalIsFunctionProgrammer";
-import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
-
-export namespace FunctionalIsParametersProgrammer {
-  export interface IConfig {
-    equals: boolean;
-  }
-  export interface IProps {
-    context: ITypiaContext;
-    modulo: ts.LeftHandSideExpression;
-    config: IConfig;
-    declaration: ts.FunctionDeclaration;
-    expression: ts.Expression;
-    init?: ts.Expression | undefined;
-  }
-  export interface IDecomposeProps {
-    context: ITypiaContext;
-    config: IConfig;
-    modulo: ts.LeftHandSideExpression;
-    declaration: ts.FunctionDeclaration;
-  }
-  export interface IDecomposeOutput {
-    functions: ts.Statement[];
-    statements: ts.Statement[];
-  }
-
-  export const write = (props: IProps): ts.CallExpression => {
-    const { async } = FunctionalGeneralProgrammer.getReturnType({
-      checker: props.context.checker,
-      declaration: props.declaration,
-    });
-    const result = decompose(props);
-    return ExpressionFactory.selfCall(
-      ts.factory.createBlock(
-        [
-          ...result.functions,
-          ts.factory.createReturnStatement(
-            ts.factory.createArrowFunction(
-              async
-                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
-                : undefined,
-              undefined,
-              props.declaration.parameters,
-              FunctionalIsFunctionProgrammer.getReturnTypeNode({
-                declaration: props.declaration,
-                async,
-              }),
-              undefined,
-              ts.factory.createBlock(
-                [
-                  ...result.statements,
-                  ts.factory.createReturnStatement(
-                    ts.factory.createCallExpression(
-                      props.expression,
-                      undefined,
-                      props.declaration.parameters.map((p) =>
-                        ts.factory.createIdentifier(p.name.getText()),
-                      ),
-                    ),
-                  ),
-                ],
-                true,
-              ),
-            ),
-          ),
-        ],
-        true,
-      ),
-    );
-  };
-
-  export const decompose = (props: IDecomposeProps): IDecomposeOutput => ({
-    functions: props.declaration.parameters.map((p, i) =>
-      StatementFactory.constant({
-        name: `__is_param_${i}`,
-        value: IsProgrammer.write({
-          context: props.context,
-          modulo: props.modulo,
-          config: props.config,
-          type: props.context.checker.getTypeFromTypeNode(
-            p.type ?? TypeFactory.keyword("any"),
-          ),
-          init: undefined,
-          name: undefined,
-        }),
-      }),
-    ),
-    statements: props.declaration.parameters
-      .map((p, i) => [
-        ts.factory.createIfStatement(
-          ts.factory.createStrictEquality(
-            ts.factory.createFalse(),
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier(`__is_param_${i}`),
-              undefined,
-              [ts.factory.createIdentifier(p.name.getText())],
-            ),
-          ),
-          ts.factory.createReturnStatement(ts.factory.createNull()),
-        ),
-      ])
-      .flat(),
-  });
-}
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+import { TypeFactory } from "../../factories/TypeFactory";
+
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { IsProgrammer } from "../IsProgrammer";
+import { FunctionalIsFunctionProgrammer } from "./FunctionalIsFunctionProgrammer";
+import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
+
+export namespace FunctionalIsParametersProgrammer {
+  export interface IConfig {
+    equals: boolean;
+  }
+  export interface IProps {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    config: IConfig;
+    declaration: ts.FunctionDeclaration;
+    expression: ts.Expression;
+    init?: ts.Expression | undefined;
+  }
+  export interface IDecomposeProps {
+    context: ITypiaContext;
+    config: IConfig;
+    modulo: ts.LeftHandSideExpression;
+    declaration: ts.FunctionDeclaration;
+  }
+  export interface IDecomposeOutput {
+    functions: ts.Statement[];
+    statements: ts.Statement[];
+  }
+
+  export const write = (props: IProps): ts.CallExpression => {
+    const { async } = FunctionalGeneralProgrammer.getReturnType({
+      checker: props.context.checker,
+      declaration: props.declaration,
+    });
+    const result = decompose(props);
+    return ExpressionFactory.selfCall(
+      ts.factory.createBlock(
+        [
+          ...result.functions,
+          ts.factory.createReturnStatement(
+            ts.factory.createArrowFunction(
+              async
+                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                : undefined,
+              undefined,
+              props.declaration.parameters,
+              FunctionalIsFunctionProgrammer.getReturnTypeNode({
+                declaration: props.declaration,
+                async,
+              }),
+              undefined,
+              ts.factory.createBlock(
+                [
+                  ...result.statements,
+                  ts.factory.createReturnStatement(
+                    ts.factory.createCallExpression(
+                      props.expression,
+                      undefined,
+                      props.declaration.parameters.map((p) =>
+                        ts.factory.createIdentifier(p.name.getText()),
+                      ),
+                    ),
+                  ),
+                ],
+                true,
+              ),
+            ),
+          ),
+        ],
+        true,
+      ),
+    );
+  };
+
+  export const decompose = (props: IDecomposeProps): IDecomposeOutput => ({
+    functions: props.declaration.parameters.map((p, i) =>
+      StatementFactory.constant({
+        name: `__is_param_${i}`,
+        value: IsProgrammer.write({
+          context: props.context,
+          modulo: props.modulo,
+          config: props.config,
+          type: props.context.checker.getTypeFromTypeNode(
+            p.type ?? TypeFactory.keyword("any"),
+          ),
+          init: undefined,
+          name: undefined,
+        }),
+      }),
+    ),
+    statements: props.declaration.parameters
+      .map((p, i) => [
+        ts.factory.createIfStatement(
+          ts.factory.createStrictEquality(
+            ts.factory.createFalse(),
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier(`__is_param_${i}`),
+              undefined,
+              [ts.factory.createIdentifier(p.name.getText())],
+            ),
+          ),
+          ts.factory.createReturnStatement(ts.factory.createNull()),
+        ),
+      ])
+      .flat(),
+  });
+}

package/src/programmers/functional/FunctionalIsReturnProgrammer.ts

@@ -1,116 +1,116 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { StringUtil } from "../../utils/StringUtil";
-
-import { IsProgrammer } from "../IsProgrammer";
-import { FunctionalIsFunctionProgrammer } from "./FunctionalIsFunctionProgrammer";
-import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
-
-export namespace FunctionalIsReturnProgrammer {
-  export interface IConfig {
-    equals: boolean;
-  }
-  export interface IProps {
-    context: ITypiaContext;
-    modulo: ts.LeftHandSideExpression;
-    config: IConfig;
-    declaration: ts.FunctionDeclaration;
-    expression: ts.Expression;
-    init?: ts.Expression | undefined;
-  }
-  export interface IDecomposeProps {
-    context: ITypiaContext;
-    modulo: ts.LeftHandSideExpression;
-    config: IConfig;
-    expression: ts.Expression;
-    declaration: ts.FunctionDeclaration;
-  }
-  export interface IDecomposeOutput {
-    async: boolean;
-    functions: ts.Statement[];
-    statements: ts.Statement[];
-  }
-
-  export const write = (props: IProps): ts.CallExpression => {
-    const result = decompose(props);
-    return ExpressionFactory.selfCall(
-      ts.factory.createBlock(
-        [
-          ...result.functions,
-          ts.factory.createReturnStatement(
-            ts.factory.createArrowFunction(
-              result.async
-                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
-                : undefined,
-              undefined,
-              props.declaration.parameters,
-              FunctionalIsFunctionProgrammer.getReturnTypeNode({
-                declaration: props.declaration,
-                async: result.async,
-              }),
-              undefined,
-              ts.factory.createBlock(result.statements, true),
-            ),
-          ),
-        ],
-        true,
-      ),
-    );
-  };
-
-  export const decompose = (props: IDecomposeProps): IDecomposeOutput => {
-    const { type, async } = FunctionalGeneralProgrammer.getReturnType({
-      checker: props.context.checker,
-      declaration: props.declaration,
-    });
-    const caller: ts.CallExpression = ts.factory.createCallExpression(
-      props.expression,
-      undefined,
-      props.declaration.parameters.map((p) =>
-        ts.factory.createIdentifier(p.name.getText()),
-      ),
-    );
-    const name: string = StringUtil.escapeDuplicate({
-      keep: props.declaration.parameters.map((p) => p.name.getText()),
-      input: "result",
-    });
-    return {
-      async,
-      functions: [
-        StatementFactory.constant({
-          name: "__is_return",
-          value: IsProgrammer.write({
-            ...props,
-            type,
-            name: undefined,
-            init: undefined,
-          }),
-        }),
-      ],
-      statements: [
-        StatementFactory.constant({
-          name,
-          value: async ? ts.factory.createAwaitExpression(caller) : caller,
-        }),
-        ts.factory.createReturnStatement(
-          ts.factory.createConditionalExpression(
-            ts.factory.createCallExpression(
-              ts.factory.createIdentifier("__is_return"),
-              undefined,
-              [ts.factory.createIdentifier(name)],
-            ),
-            undefined,
-            ts.factory.createIdentifier(name),
-            undefined,
-            ts.factory.createNull(),
-          ),
-        ),
-      ],
-    };
-  };
-}
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { StringUtil } from "../../utils/StringUtil";
+
+import { IsProgrammer } from "../IsProgrammer";
+import { FunctionalIsFunctionProgrammer } from "./FunctionalIsFunctionProgrammer";
+import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
+
+export namespace FunctionalIsReturnProgrammer {
+  export interface IConfig {
+    equals: boolean;
+  }
+  export interface IProps {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    config: IConfig;
+    declaration: ts.FunctionDeclaration;
+    expression: ts.Expression;
+    init?: ts.Expression | undefined;
+  }
+  export interface IDecomposeProps {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    config: IConfig;
+    expression: ts.Expression;
+    declaration: ts.FunctionDeclaration;
+  }
+  export interface IDecomposeOutput {
+    async: boolean;
+    functions: ts.Statement[];
+    statements: ts.Statement[];
+  }
+
+  export const write = (props: IProps): ts.CallExpression => {
+    const result = decompose(props);
+    return ExpressionFactory.selfCall(
+      ts.factory.createBlock(
+        [
+          ...result.functions,
+          ts.factory.createReturnStatement(
+            ts.factory.createArrowFunction(
+              result.async
+                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                : undefined,
+              undefined,
+              props.declaration.parameters,
+              FunctionalIsFunctionProgrammer.getReturnTypeNode({
+                declaration: props.declaration,
+                async: result.async,
+              }),
+              undefined,
+              ts.factory.createBlock(result.statements, true),
+            ),
+          ),
+        ],
+        true,
+      ),
+    );
+  };
+
+  export const decompose = (props: IDecomposeProps): IDecomposeOutput => {
+    const { type, async } = FunctionalGeneralProgrammer.getReturnType({
+      checker: props.context.checker,
+      declaration: props.declaration,
+    });
+    const caller: ts.CallExpression = ts.factory.createCallExpression(
+      props.expression,
+      undefined,
+      props.declaration.parameters.map((p) =>
+        ts.factory.createIdentifier(p.name.getText()),
+      ),
+    );
+    const name: string = StringUtil.escapeDuplicate({
+      keep: props.declaration.parameters.map((p) => p.name.getText()),
+      input: "result",
+    });
+    return {
+      async,
+      functions: [
+        StatementFactory.constant({
+          name: "__is_return",
+          value: IsProgrammer.write({
+            ...props,
+            type,
+            name: undefined,
+            init: undefined,
+          }),
+        }),
+      ],
+      statements: [
+        StatementFactory.constant({
+          name,
+          value: async ? ts.factory.createAwaitExpression(caller) : caller,
+        }),
+        ts.factory.createReturnStatement(
+          ts.factory.createConditionalExpression(
+            ts.factory.createCallExpression(
+              ts.factory.createIdentifier("__is_return"),
+              undefined,
+              [ts.factory.createIdentifier(name)],
+            ),
+            undefined,
+            ts.factory.createIdentifier(name),
+            undefined,
+            ts.factory.createNull(),
+          ),
+        ),
+      ],
+    };
+  };
+}

package/src/programmers/functional/internal/FunctionalGeneralProgrammer.ts

@@ -1,34 +1,34 @@
-import ts from "typescript";
-
-import { TypeFactory } from "../../../factories/TypeFactory";
-
-export namespace FunctionalGeneralProgrammer {
-  export interface IProps {
-    checker: ts.TypeChecker;
-    declaration: ts.FunctionDeclaration | ts.SignatureDeclaration;
-  }
-  export interface IOutput {
-    type: ts.Type;
-    async: boolean;
-  }
-  export const getReturnType = (props: IProps): IOutput => {
-    const signature: ts.Signature | undefined =
-      props.checker.getSignatureFromDeclaration(props.declaration);
-    const type: ts.Type =
-      signature?.getReturnType() ??
-      props.checker.getTypeFromTypeNode(TypeFactory.keyword("any"));
-
-    if (type.symbol?.name === "Promise") {
-      const generic: readonly ts.Type[] = props.checker.getTypeArguments(
-        type as ts.TypeReference,
-      );
-      return generic.length === 1
-        ? { type: generic[0]!, async: true }
-        : {
-            type: props.checker.getTypeFromTypeNode(TypeFactory.keyword("any")),
-            async: false,
-          };
-    }
-    return { type, async: false };
-  };
-}
+import ts from "typescript";
+
+import { TypeFactory } from "../../../factories/TypeFactory";
+
+export namespace FunctionalGeneralProgrammer {
+  export interface IProps {
+    checker: ts.TypeChecker;
+    declaration: ts.FunctionDeclaration | ts.SignatureDeclaration;
+  }
+  export interface IOutput {
+    type: ts.Type;
+    async: boolean;
+  }
+  export const getReturnType = (props: IProps): IOutput => {
+    const signature: ts.Signature | undefined =
+      props.checker.getSignatureFromDeclaration(props.declaration);
+    const type: ts.Type =
+      signature?.getReturnType() ??
+      props.checker.getTypeFromTypeNode(TypeFactory.keyword("any"));
+
+    if (type.symbol?.name === "Promise") {
+      const generic: readonly ts.Type[] = props.checker.getTypeArguments(
+        type as ts.TypeReference,
+      );
+      return generic.length === 1
+        ? { type: generic[0]!, async: true }
+        : {
+            type: props.checker.getTypeFromTypeNode(TypeFactory.keyword("any")),
+            async: false,
+          };
+    }
+    return { type, async: false };
+  };
+}