typia 6.10.2-dev.20240920 → 6.10.2

package/src/programmers/functional/FunctionalAssertFunctionProgrammer.ts

@@ -1,141 +1,141 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { IdentifierFactory } from "../../factories/IdentifierFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProject } from "../../transformers/IProject";
-
-import { StringUtil } from "../../utils/StringUtil";
-
-import { AssertProgrammer } from "../AssertProgrammer";
-import { FunctionalAssertParametersProgrammer } from "./FunctionalAssertParametersProgrammer";
-import { FunctionAssertReturnProgrammer } from "./FunctionalAssertReturnProgrammer";
-
-export namespace FunctionalAssertFunctionProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      expression: ts.Expression,
-      declaration: ts.FunctionDeclaration,
-      init?: ts.Expression,
-    ): ts.CallExpression => {
-      const wrapper = errorFactoryWrapper(modulo)(declaration.parameters)(init);
-      const p = FunctionalAssertParametersProgrammer.decompose(project)(modulo)(
-        equals,
-      )(declaration.parameters, wrapper.name);
-      const r = FunctionAssertReturnProgrammer.decompose(project)(modulo)(
-        equals,
-      )(expression, declaration, 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,
-                declaration.parameters,
-                declaration.type,
-                undefined,
-                ts.factory.createBlock([
-                  ...p.expressions.map(ts.factory.createExpressionStatement),
-                  ts.factory.createReturnStatement(r.value),
-                ]),
-              ),
-            ),
-          ],
-          true,
-        ),
-      );
-    };
-
-  export const errorFactoryWrapper =
-    (modulo: ts.LeftHandSideExpression) =>
-    (paramters: readonly ts.ParameterDeclaration[]) =>
-    (
-      init: ts.Expression | undefined,
-    ): {
-      name: string;
-      variable: ts.VariableStatement;
-    } => {
-      const name: string = StringUtil.escapeDuplicate(
-        paramters.map((p) => p.name.getText()),
-      )("errorFactoryWrapper");
-      const variable: ts.VariableStatement = ts.factory.createVariableStatement(
-        undefined,
-        ts.factory.createVariableDeclarationList(
-          [
-            ts.factory.createVariableDeclaration(
-              name,
-              undefined,
-              AssertProgrammer.Guardian.type(),
-              init ??
-                ts.factory.createPropertyAccessExpression(
-                  ts.factory.createAsExpression(
-                    modulo,
-                    TypeFactory.keyword("any"),
-                  ),
-                  "errorFactory",
-                ),
-            ),
-          ],
-          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 { TypeFactory } from "../../factories/TypeFactory";
+
+import { IProject } from "../../transformers/IProject";
+
+import { StringUtil } from "../../utils/StringUtil";
+
+import { AssertProgrammer } from "../AssertProgrammer";
+import { FunctionalAssertParametersProgrammer } from "./FunctionalAssertParametersProgrammer";
+import { FunctionAssertReturnProgrammer } from "./FunctionalAssertReturnProgrammer";
+
+export namespace FunctionalAssertFunctionProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+      init?: ts.Expression,
+    ): ts.CallExpression => {
+      const wrapper = errorFactoryWrapper(modulo)(declaration.parameters)(init);
+      const p = FunctionalAssertParametersProgrammer.decompose(project)(modulo)(
+        equals,
+      )(declaration.parameters, wrapper.name);
+      const r = FunctionAssertReturnProgrammer.decompose(project)(modulo)(
+        equals,
+      )(expression, declaration, 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,
+                declaration.parameters,
+                declaration.type,
+                undefined,
+                ts.factory.createBlock([
+                  ...p.expressions.map(ts.factory.createExpressionStatement),
+                  ts.factory.createReturnStatement(r.value),
+                ]),
+              ),
+            ),
+          ],
+          true,
+        ),
+      );
+    };
+
+  export const errorFactoryWrapper =
+    (modulo: ts.LeftHandSideExpression) =>
+    (paramters: readonly ts.ParameterDeclaration[]) =>
+    (
+      init: ts.Expression | undefined,
+    ): {
+      name: string;
+      variable: ts.VariableStatement;
+    } => {
+      const name: string = StringUtil.escapeDuplicate(
+        paramters.map((p) => p.name.getText()),
+      )("errorFactoryWrapper");
+      const variable: ts.VariableStatement = ts.factory.createVariableStatement(
+        undefined,
+        ts.factory.createVariableDeclarationList(
+          [
+            ts.factory.createVariableDeclaration(
+              name,
+              undefined,
+              AssertProgrammer.Guardian.type(),
+              init ??
+                ts.factory.createPropertyAccessExpression(
+                  ts.factory.createAsExpression(
+                    modulo,
+                    TypeFactory.keyword("any"),
+                  ),
+                  "errorFactory",
+                ),
+            ),
+          ],
+          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,108 +1,108 @@
-import ts from "typescript";
-
-import { ExpressionFactory } from "../../factories/ExpressionFactory";
-import { StatementFactory } from "../../factories/StatementFactory";
-import { TypeFactory } from "../../factories/TypeFactory";
-
-import { IProject } from "../../transformers/IProject";
-
-import { AssertProgrammer } from "../AssertProgrammer";
-import { FunctionalAssertFunctionProgrammer } from "./FunctionalAssertFunctionProgrammer";
-import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
-
-export namespace FunctionalAssertParametersProgrammer {
-  export const write =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      expression: ts.Expression,
-      declaration: ts.FunctionDeclaration,
-      init?: ts.Expression,
-    ): ts.CallExpression => {
-      const wrapper = FunctionalAssertFunctionProgrammer.errorFactoryWrapper(
-        modulo,
-      )(declaration.parameters)(init);
-      const { async } = FunctionalGeneralProgrammer.getReturnType(
-        project.checker,
-      )(declaration);
-      const result = decompose(project)(modulo)(equals)(
-        declaration.parameters,
-        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,
-                declaration.parameters,
-                declaration.type,
-                undefined,
-                ts.factory.createBlock(
-                  [
-                    ...result.expressions.map(
-                      ts.factory.createExpressionStatement,
-                    ),
-                    ts.factory.createReturnStatement(
-                      ts.factory.createCallExpression(
-                        expression,
-                        undefined,
-                        declaration.parameters.map((p) =>
-                          ts.factory.createIdentifier(p.name.getText()),
-                        ),
-                      ),
-                    ),
-                  ],
-                  true,
-                ),
-              ),
-            ),
-          ],
-          true,
-        ),
-      );
-    };
-
-  export const decompose =
-    (project: IProject) =>
-    (modulo: ts.LeftHandSideExpression) =>
-    (equals: boolean) =>
-    (
-      parameters: readonly ts.ParameterDeclaration[],
-      wrapper: string,
-    ): {
-      functions: ts.Statement[];
-      expressions: ts.Expression[];
-    } => ({
-      functions: parameters.map((p, i) =>
-        StatementFactory.constant(
-          `__assert_param_${i}`,
-          AssertProgrammer.write(project)(modulo)(equals)(
-            p.type
-              ? project.checker.getTypeFromTypeNode(p.type)
-              : project.checker.getTypeFromTypeNode(TypeFactory.keyword("any")),
-            undefined,
-            FunctionalAssertFunctionProgrammer.hookPath({
-              wrapper,
-              replacer: `$input.parameters[${i}]`,
-            }),
-          ),
-          // undefined,
-          // [ts.factory.createIdentifier(p.name.getText())],
-        ),
-      ),
-      expressions: 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 { IProject } from "../../transformers/IProject";
+
+import { AssertProgrammer } from "../AssertProgrammer";
+import { FunctionalAssertFunctionProgrammer } from "./FunctionalAssertFunctionProgrammer";
+import { FunctionalGeneralProgrammer } from "./internal/FunctionalGeneralProgrammer";
+
+export namespace FunctionalAssertParametersProgrammer {
+  export const write =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      expression: ts.Expression,
+      declaration: ts.FunctionDeclaration,
+      init?: ts.Expression,
+    ): ts.CallExpression => {
+      const wrapper = FunctionalAssertFunctionProgrammer.errorFactoryWrapper(
+        modulo,
+      )(declaration.parameters)(init);
+      const { async } = FunctionalGeneralProgrammer.getReturnType(
+        project.checker,
+      )(declaration);
+      const result = decompose(project)(modulo)(equals)(
+        declaration.parameters,
+        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,
+                declaration.parameters,
+                declaration.type,
+                undefined,
+                ts.factory.createBlock(
+                  [
+                    ...result.expressions.map(
+                      ts.factory.createExpressionStatement,
+                    ),
+                    ts.factory.createReturnStatement(
+                      ts.factory.createCallExpression(
+                        expression,
+                        undefined,
+                        declaration.parameters.map((p) =>
+                          ts.factory.createIdentifier(p.name.getText()),
+                        ),
+                      ),
+                    ),
+                  ],
+                  true,
+                ),
+              ),
+            ),
+          ],
+          true,
+        ),
+      );
+    };
+
+  export const decompose =
+    (project: IProject) =>
+    (modulo: ts.LeftHandSideExpression) =>
+    (equals: boolean) =>
+    (
+      parameters: readonly ts.ParameterDeclaration[],
+      wrapper: string,
+    ): {
+      functions: ts.Statement[];
+      expressions: ts.Expression[];
+    } => ({
+      functions: parameters.map((p, i) =>
+        StatementFactory.constant(
+          `__assert_param_${i}`,
+          AssertProgrammer.write(project)(modulo)(equals)(
+            p.type
+              ? project.checker.getTypeFromTypeNode(p.type)
+              : project.checker.getTypeFromTypeNode(TypeFactory.keyword("any")),
+            undefined,
+            FunctionalAssertFunctionProgrammer.hookPath({
+              wrapper,
+              replacer: `$input.parameters[${i}]`,
+            }),
+          ),
+          // undefined,
+          // [ts.factory.createIdentifier(p.name.getText())],
+        ),
+      ),
+      expressions: parameters.map((p, i) =>
+        ts.factory.createCallExpression(
+          ts.factory.createIdentifier(`__assert_param_${i}`),
+          undefined,
+          [ts.factory.createIdentifier(p.name.getText())],
+        ),
+      ),
+    });
+}