typia 7.2.1 → 7.3.0-dev.20241213

package/src/programmers/functional/FunctionalAssertFunctionProgrammer.ts

@@ -1,153 +1,153 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-
-import { ITypiaContext } from "../../transformers/ITypiaContext";
-
-import { StringUtil } from "../../utils/StringUtil";
-
-import { AssertProgrammer } from "../AssertProgrammer";
-import { FunctionalAssertParametersProgrammer } from "./FunctionalAssertParametersProgrammer";
-import { FunctionAssertReturnProgrammer } from "./FunctionalAssertReturnProgrammer";
-
-export namespace FunctionalAssertFunctionProgrammer {
-  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 wrapper = errorFactoryWrapper({
-      context: props.context,
-      parameters: props.declaration.parameters,
-      init: props.init,
-    });
-    const p = FunctionalAssertParametersProgrammer.decompose({
-      context: props.context,
-      modulo: props.modulo,
-      config: props.config,
-      parameters: props.declaration.parameters,
-      wrapper: wrapper.name,
-    });
-    const r = FunctionAssertReturnProgrammer.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,
-          ...p.functions,
-          ...r.functions,
-          ts.factory.createReturnStatement(
-            ts.factory.createArrowFunction(
-              r.async
-                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
-                : undefined,
-              undefined,
-              props.declaration.parameters,
-              props.declaration.type,
-              undefined,
-              ts.factory.createBlock([
-                ...p.expressions.map(ts.factory.createExpressionStatement),
-                ts.factory.createReturnStatement(r.value),
-              ]),
-            ),
-          ),
-        ],
-        true,
-      ),
-    );
-  };
-
-  export const errorFactoryWrapper = (props: {
-    context: ITypiaContext;
-    parameters: readonly ts.ParameterDeclaration[];
-    init: ts.Expression | undefined;
-  }): {
-    name: string;
-    variable: ts.VariableStatement;
-  } => {
-    const name: string = StringUtil.escapeDuplicate({
-      keep: props.parameters.map((p) => p.name.getText()),
-      input: "errorFactoryWrapper",
-    });
-    const variable: ts.VariableStatement = ts.factory.createVariableStatement(
-      undefined,
-      ts.factory.createVariableDeclarationList(
-        [
-          ts.factory.createVariableDeclaration(
-            name,
-            undefined,
-            AssertProgrammer.Guardian.type(props.context),
-            props.init ??
-              props.context.importer.internal(
-                "functionalTypeGuardErrorFactory",
-              ),
-          ),
-        ],
-        ts.NodeFlags.Const,
-      ),
-    );
-    return { name, variable };
-  };
-
-  export const hookPath = (props: {
-    wrapper: string;
-    replacer: string;
-  }): ts.ArrowFunction =>
-    ts.factory.createArrowFunction(
-      undefined,
-      undefined,
-      [IdentifierFactory.parameter("p")],
-      undefined,
-      undefined,
-      ts.factory.createCallExpression(
-        ts.factory.createIdentifier(props.wrapper),
-        undefined,
-        [
-          ts.factory.createObjectLiteralExpression([
-            ts.factory.createSpreadAssignment(ts.factory.createIdentifier("p")),
-            ts.factory.createPropertyAssignment(
-              "path",
-              ts.factory.createConditionalExpression(
-                ts.factory.createPropertyAccessExpression(
-                  ts.factory.createIdentifier("p"),
-                  "path",
-                ),
-                undefined,
-                ts.factory.createCallExpression(
-                  ts.factory.createPropertyAccessExpression(
-                    ts.factory.createPropertyAccessExpression(
-                      ts.factory.createIdentifier("p"),
-                      "path",
-                    ),
-                    "replace",
-                  ),
-                  undefined,
-                  [
-                    ts.factory.createStringLiteral("$input"),
-                    ts.factory.createStringLiteral(props.replacer),
-                  ],
-                ),
-                undefined,
-                ts.factory.createIdentifier("undefined"),
-              ),
-            ),
-          ]),
-        ],
-      ),
-    );
-}
+import ts from "typescript";
+
+import { ExpressionFactory } from "../../factories/ExpressionFactory";
+import { IdentifierFactory } from "../../factories/IdentifierFactory";
+
+import { ITypiaContext } from "../../transformers/ITypiaContext";
+
+import { StringUtil } from "../../utils/StringUtil";
+
+import { AssertProgrammer } from "../AssertProgrammer";
+import { FunctionalAssertParametersProgrammer } from "./FunctionalAssertParametersProgrammer";
+import { FunctionAssertReturnProgrammer } from "./FunctionalAssertReturnProgrammer";
+
+export namespace FunctionalAssertFunctionProgrammer {
+  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 wrapper = errorFactoryWrapper({
+      context: props.context,
+      parameters: props.declaration.parameters,
+      init: props.init,
+    });
+    const p = FunctionalAssertParametersProgrammer.decompose({
+      context: props.context,
+      modulo: props.modulo,
+      config: props.config,
+      parameters: props.declaration.parameters,
+      wrapper: wrapper.name,
+    });
+    const r = FunctionAssertReturnProgrammer.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,
+          ...p.functions,
+          ...r.functions,
+          ts.factory.createReturnStatement(
+            ts.factory.createArrowFunction(
+              r.async
+                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                : undefined,
+              undefined,
+              props.declaration.parameters,
+              props.declaration.type,
+              undefined,
+              ts.factory.createBlock([
+                ...p.expressions.map(ts.factory.createExpressionStatement),
+                ts.factory.createReturnStatement(r.value),
+              ]),
+            ),
+          ),
+        ],
+        true,
+      ),
+    );
+  };
+
+  export const errorFactoryWrapper = (props: {
+    context: ITypiaContext;
+    parameters: readonly ts.ParameterDeclaration[];
+    init: ts.Expression | undefined;
+  }): {
+    name: string;
+    variable: ts.VariableStatement;
+  } => {
+    const name: string = StringUtil.escapeDuplicate({
+      keep: props.parameters.map((p) => p.name.getText()),
+      input: "errorFactoryWrapper",
+    });
+    const variable: ts.VariableStatement = ts.factory.createVariableStatement(
+      undefined,
+      ts.factory.createVariableDeclarationList(
+        [
+          ts.factory.createVariableDeclaration(
+            name,
+            undefined,
+            AssertProgrammer.Guardian.type(props.context),
+            props.init ??
+              props.context.importer.internal(
+                "functionalTypeGuardErrorFactory",
+              ),
+          ),
+        ],
+        ts.NodeFlags.Const,
+      ),
+    );
+    return { name, variable };
+  };
+
+  export const hookPath = (props: {
+    wrapper: string;
+    replacer: string;
+  }): ts.ArrowFunction =>
+    ts.factory.createArrowFunction(
+      undefined,
+      undefined,
+      [IdentifierFactory.parameter("p")],
+      undefined,
+      undefined,
+      ts.factory.createCallExpression(
+        ts.factory.createIdentifier(props.wrapper),
+        undefined,
+        [
+          ts.factory.createObjectLiteralExpression([
+            ts.factory.createSpreadAssignment(ts.factory.createIdentifier("p")),
+            ts.factory.createPropertyAssignment(
+              "path",
+              ts.factory.createConditionalExpression(
+                ts.factory.createPropertyAccessExpression(
+                  ts.factory.createIdentifier("p"),
+                  "path",
+                ),
+                undefined,
+                ts.factory.createCallExpression(
+                  ts.factory.createPropertyAccessExpression(
+                    ts.factory.createPropertyAccessExpression(
+                      ts.factory.createIdentifier("p"),
+                      "path",
+                    ),
+                    "replace",
+                  ),
+                  undefined,
+                  [
+                    ts.factory.createStringLiteral("$input"),
+                    ts.factory.createStringLiteral(props.replacer),
+                  ],
+                ),
+                undefined,
+                ts.factory.createIdentifier("undefined"),
+              ),
+            ),
+          ]),
+        ],
+      ),
+    );
+}

package/src/programmers/functional/FunctionalAssertParametersProgrammer.ts

@@ -1,125 +1,125 @@
-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 { AssertProgrammer } from "../AssertProgrammer";
-import { FunctionalAssertFunctionProgrammer } from "./FunctionalAssertFunctionProgrammer";
-import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
-
-export namespace FunctionalAssertParametersProgrammer {
-  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;
-    parameters: readonly ts.ParameterDeclaration[];
-    wrapper: string;
-  }
-  export interface IDecomposeOutput {
-    functions: ts.Statement[];
-    expressions: ts.Expression[];
-  }
-
-  export const write = (props: IProps): ts.CallExpression => {
-    const wrapper = FunctionalAssertFunctionProgrammer.errorFactoryWrapper({
-      context: props.context,
-      parameters: props.declaration.parameters,
-      init: props.init,
-    });
-    const { async } = FunctionalGeneralProgrammer.getReturnType({
-      checker: props.context.checker,
-      declaration: props.declaration,
-    });
-    const result = decompose({
-      context: props.context,
-      modulo: props.modulo,
-      config: props.config,
-      parameters: props.declaration.parameters,
-      wrapper: wrapper.name,
-    });
-    return ExpressionFactory.selfCall(
-      ts.factory.createBlock(
-        [
-          wrapper.variable,
-          ...result.functions,
-          ts.factory.createReturnStatement(
-            ts.factory.createArrowFunction(
-              async
-                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
-                : undefined,
-              undefined,
-              props.declaration.parameters,
-              props.declaration.type,
-              undefined,
-              ts.factory.createBlock(
-                [
-                  ...result.expressions.map(
-                    ts.factory.createExpressionStatement,
-                  ),
-                  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.parameters.map((p, i) =>
-      StatementFactory.constant({
-        name: `__assert_param_${i}`,
-        value: AssertProgrammer.write({
-          context: props.context,
-          modulo: props.modulo,
-          config: {
-            equals: props.config.equals,
-            guard: false,
-          },
-          type: p.type
-            ? props.context.checker.getTypeFromTypeNode(p.type)
-            : props.context.checker.getTypeFromTypeNode(
-                TypeFactory.keyword("any"),
-              ),
-          name: undefined,
-          init: FunctionalAssertFunctionProgrammer.hookPath({
-            wrapper: props.wrapper,
-            replacer: `$input.parameters[${i}]`,
-          }),
-        }),
-      }),
-    ),
-    expressions: props.parameters.map((p, i) =>
-      ts.factory.createCallExpression(
-        ts.factory.createIdentifier(`__assert_param_${i}`),
-        undefined,
-        [ts.factory.createIdentifier(p.name.getText())],
-      ),
-    ),
-  });
-}
+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 { AssertProgrammer } from "../AssertProgrammer";
+import { FunctionalAssertFunctionProgrammer } from "./FunctionalAssertFunctionProgrammer";
+import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
+
+export namespace FunctionalAssertParametersProgrammer {
+  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;
+    parameters: readonly ts.ParameterDeclaration[];
+    wrapper: string;
+  }
+  export interface IDecomposeOutput {
+    functions: ts.Statement[];
+    expressions: ts.Expression[];
+  }
+
+  export const write = (props: IProps): ts.CallExpression => {
+    const wrapper = FunctionalAssertFunctionProgrammer.errorFactoryWrapper({
+      context: props.context,
+      parameters: props.declaration.parameters,
+      init: props.init,
+    });
+    const { async } = FunctionalGeneralProgrammer.getReturnType({
+      checker: props.context.checker,
+      declaration: props.declaration,
+    });
+    const result = decompose({
+      context: props.context,
+      modulo: props.modulo,
+      config: props.config,
+      parameters: props.declaration.parameters,
+      wrapper: wrapper.name,
+    });
+    return ExpressionFactory.selfCall(
+      ts.factory.createBlock(
+        [
+          wrapper.variable,
+          ...result.functions,
+          ts.factory.createReturnStatement(
+            ts.factory.createArrowFunction(
+              async
+                ? [ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword)]
+                : undefined,
+              undefined,
+              props.declaration.parameters,
+              props.declaration.type,
+              undefined,
+              ts.factory.createBlock(
+                [
+                  ...result.expressions.map(
+                    ts.factory.createExpressionStatement,
+                  ),
+                  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.parameters.map((p, i) =>
+      StatementFactory.constant({
+        name: `__assert_param_${i}`,
+        value: AssertProgrammer.write({
+          context: props.context,
+          modulo: props.modulo,
+          config: {
+            equals: props.config.equals,
+            guard: false,
+          },
+          type: p.type
+            ? props.context.checker.getTypeFromTypeNode(p.type)
+            : props.context.checker.getTypeFromTypeNode(
+                TypeFactory.keyword("any"),
+              ),
+          name: undefined,
+          init: FunctionalAssertFunctionProgrammer.hookPath({
+            wrapper: props.wrapper,
+            replacer: `$input.parameters[${i}]`,
+          }),
+        }),
+      }),
+    ),
+    expressions: props.parameters.map((p, i) =>
+      ts.factory.createCallExpression(
+        ts.factory.createIdentifier(`__assert_param_${i}`),
+        undefined,
+        [ts.factory.createIdentifier(p.name.getText())],
+      ),
+    ),
+  });
+}