typia 7.0.0-dev.20241005 → 7.0.0-dev.20241007

package/src/programmers/functional/FunctionalAssertReturnProgrammer.ts

@@ -1,115 +1,115 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { AssertProgrammer } from "../AssertProgrammer";
-import { FunctionalAssertFunctionProgrammer } from "./FunctionalAssertFunctionProgrammer";
-import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
-
-export namespace FunctionAssertReturnProgrammer {
-  export interface IConfig {
-    equals: boolean;
-  }
-  export interface IProps {
-    context: ITypiaContext;
-    modulo: ts.LeftHandSideExpression;
-    config: IConfig;
-    expression: ts.Expression;
-    declaration: ts.FunctionDeclaration;
-    init?: ts.Expression | undefined;
-  }
-  export interface IDecomposeProps {
-    context: ITypiaContext;
-    modulo: ts.LeftHandSideExpression;
-    config: IConfig;
-    expression: ts.Expression;
-    declaration: ts.FunctionDeclaration;
-    wrapper: string;
-  }
-  export interface IDecomposeOutput {
-    async: boolean;
-    functions: ts.Statement[];
-    value: ts.Expression;
-  }
-
-  export const write = (props: IProps): ts.CallExpression => {
-    const wrapper = FunctionalAssertFunctionProgrammer.errorFactoryWrapper({
-      context: props.context,
-      parameters: props.declaration.parameters,
-      init: props.init,
-    });
-    const result = decompose({
-      context: props.context,
-      modulo: props.modulo,
-      config: props.config,
-      expression: props.expression,
-      declaration: props.declaration,
-      wrapper: wrapper.name,
-    });
-    return ExpressionFactory.selfCall(
-      ts.factory.createBlock(
-        [
-          wrapper.variable,
-          ...result.functions,
-          ts.factory.createReturnStatement(
-            ts.factory.createArrowFunction(
-              result.async
-                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
-                : undefined,
-              undefined,
-              props.declaration.parameters,
-              props.declaration.type,
-              undefined,
-              result.value,
-            ),
-          ),
-        ],
-        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()),
-      ),
-    );
-    return {
-      async,
-      functions: [
-        StatementFactory.constant({
-          name: "__assert_return",
-          value: AssertProgrammer.write({
-            context: props.context,
-            modulo: props.modulo,
-            config: {
-              equals: props.config.equals,
-              guard: false,
-            },
-            type,
-            name: undefined,
-            init: FunctionalAssertFunctionProgrammer.hookPath({
-              wrapper: props.wrapper,
-              replacer: "$input.return",
-            }),
-          }),
-        }),
-      ],
-      value: ts.factory.createCallExpression(
-        ts.factory.createIdentifier("__assert_return"),
-        undefined,
-        [async ? ts.factory.createAwaitExpression(caller) : caller],
-      ),
-    };
-  };
-}
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { StatementFactory } from "../../factories/StatementFactory";
+
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { AssertProgrammer } from "../AssertProgrammer";
+import { FunctionalAssertFunctionProgrammer } from "./FunctionalAssertFunctionProgrammer";
+import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
+
+export namespace FunctionAssertReturnProgrammer {
+  export interface IConfig {
+    equals: boolean;
+  }
+  export interface IProps {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    config: IConfig;
+    expression: ts.Expression;
+    declaration: ts.FunctionDeclaration;
+    init?: ts.Expression | undefined;
+  }
+  export interface IDecomposeProps {
+    context: ITypiaContext;
+    modulo: ts.LeftHandSideExpression;
+    config: IConfig;
+    expression: ts.Expression;
+    declaration: ts.FunctionDeclaration;
+    wrapper: string;
+  }
+  export interface IDecomposeOutput {
+    async: boolean;
+    functions: ts.Statement[];
+    value: ts.Expression;
+  }
+
+  export const write = (props: IProps): ts.CallExpression => {
+    const wrapper = FunctionalAssertFunctionProgrammer.errorFactoryWrapper({
+      context: props.context,
+      parameters: props.declaration.parameters,
+      init: props.init,
+    });
+    const result = decompose({
+      context: props.context,
+      modulo: props.modulo,
+      config: props.config,
+      expression: props.expression,
+      declaration: props.declaration,
+      wrapper: wrapper.name,
+    });
+    return ExpressionFactory.selfCall(
+      ts.factory.createBlock(
+        [
+          wrapper.variable,
+          ...result.functions,
+          ts.factory.createReturnStatement(
+            ts.factory.createArrowFunction(
+              result.async
+                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                : undefined,
+              undefined,
+              props.declaration.parameters,
+              props.declaration.type,
+              undefined,
+              result.value,
+            ),
+          ),
+        ],
+        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()),
+      ),
+    );
+    return {
+      async,
+      functions: [
+        StatementFactory.constant({
+          name: "__assert_return",
+          value: AssertProgrammer.write({
+            context: props.context,
+            modulo: props.modulo,
+            config: {
+              equals: props.config.equals,
+              guard: false,
+            },
+            type,
+            name: undefined,
+            init: FunctionalAssertFunctionProgrammer.hookPath({
+              wrapper: props.wrapper,
+              replacer: "$input.return",
+            }),
+          }),
+        }),
+      ],
+      value: ts.factory.createCallExpression(
+        ts.factory.createIdentifier("__assert_return"),
+        undefined,
+        [async ? ts.factory.createAwaitExpression(caller) : caller],
+      ),
+    };
+  };
+}

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(),
+  });
+}