@autobe/compiler 0.30.0-dev.20260315 → 0.30.0

package/src/test/programmers/AutoBeTestStatementProgrammer.ts

@@ -1,154 +1,154 @@
-import { AutoBeTest } from "@autobe/interface";
-import ts from "typescript";
-
-import { FilePrinter } from "../../utils/FilePrinter";
-import { IAutoBeTestApiFunction } from "./IAutoBeTestApiFunction";
-import { IAutoBeTestProgrammerContext } from "./IAutoBeTestProgrammerContext";
-import { writeTestExpression } from "./writeTestExpression";
-import { writeTestStatement } from "./writeTestStatement";
-
-export namespace AutoBeTestStatementProgrammer {
-  export const block = (
-    ctx: IAutoBeTestProgrammerContext,
-    stmt: AutoBeTest.IBlock,
-  ): ts.Block =>
-    ts.factory.createBlock(
-      stmt.statements
-        .map((child, i) => [
-          ...writeTestStatement(ctx, child).filter((childStmt, j) =>
-            j === 0
-              ? ts.addSyntheticLeadingComment(
-                  childStmt,
-                  ts.SyntaxKind.SingleLineCommentTrivia,
-                  JSON.stringify(child),
-                  true,
-                )
-              : childStmt,
-          ),
-          ...(i !== 0 ? [FilePrinter.newLine()] : []),
-        ])
-        .flat(),
-      true,
-    );
-
-  export const expressionStatement = (
-    ctx: IAutoBeTestProgrammerContext,
-    stmt: AutoBeTest.IExpressionStatement,
-  ): ts.ExpressionStatement =>
-    ts.factory.createExpressionStatement(
-      writeTestExpression(ctx, stmt.expression),
-    );
-
-  // export const variableDeclaration = (
-  //   ctx: IAutoBeTestProgrammerContext,
-  //   stmt: AutoBeTest.IVariableDeclaration,
-  // ): ts.VariableStatement => {
-  //   const typeNode: ts.TypeNode = NestiaMigrateSchemaProgrammer.write({
-  //     components: ctx.document.components,
-  //     importer: ctx.importer,
-  //     schema: OpenApiV3_1Emender.convertSchema(ctx.document.components)(
-  //       stmt.schema,
-  //     ),
-  //   });
-  //   return ts.factory.createVariableStatement(
-  //     undefined,
-  //     ts.factory.createVariableDeclarationList(
-  //       [
-  //         ts.factory.createVariableDeclaration(
-  //           stmt.name,
-  //           undefined,
-  //           typeNode,
-  //           undefined,
-  //         ),
-  //       ],
-  //       stmt.mutability === "const" ? ts.NodeFlags.Constant : ts.NodeFlags.Let,
-  //     ),
-  //   );
-  // };
-
-  export const ifStatement = (
-    ctx: IAutoBeTestProgrammerContext,
-    stmt: AutoBeTest.IIfStatement,
-  ): ts.IfStatement =>
-    ts.factory.createIfStatement(
-      writeTestExpression(ctx, stmt.condition),
-      block(ctx, stmt.thenStatement),
-      stmt.elseStatement
-        ? stmt.elseStatement.type === "ifStatement"
-          ? ifStatement(ctx, stmt.elseStatement)
-          : block(ctx, stmt.elseStatement)
-        : undefined,
-    );
-
-  export const returnStatement = (
-    ctx: IAutoBeTestProgrammerContext,
-    stmt: AutoBeTest.IReturnStatement,
-  ): ts.ReturnStatement =>
-    ts.factory.createReturnStatement(writeTestExpression(ctx, stmt.expression));
-
-  export const throwStatement = (
-    ctx: IAutoBeTestProgrammerContext,
-    stmt: AutoBeTest.IThrowStatement,
-  ): ts.ThrowStatement =>
-    ts.factory.createThrowStatement(writeTestExpression(ctx, stmt.expression));
-
-  export const apiOperateStatement = (
-    ctx: IAutoBeTestProgrammerContext,
-    stmt: AutoBeTest.IApiOperateStatement,
-  ): ts.Statement[] => {
-    // find the function
-    const func: IAutoBeTestApiFunction = ctx.endpoints.get(stmt.endpoint);
-    if (!!stmt.variableName?.length && !!func.operation.responseBody)
-      ctx.importer.dto(func.operation.responseBody.typeName);
-
-    // make await function call expression
-    const initializer: ts.AwaitExpression = ts.factory.createAwaitExpression(
-      ts.factory.createCallExpression(
-        ts.factory.createIdentifier(func.accessor),
-        [],
-        [
-          ts.factory.createIdentifier("connection"),
-          ...(stmt.argument ? [writeTestExpression(ctx, stmt.argument)] : []),
-        ],
-      ),
-    );
-    if (stmt.variableName === null || stmt.variableName === undefined)
-      return [ts.factory.createExpressionStatement(initializer)];
-
-    const variable: ts.VariableStatement = ts.factory.createVariableStatement(
-      undefined,
-      ts.factory.createVariableDeclarationList(
-        [
-          ts.factory.createVariableDeclaration(
-            stmt.variableName,
-            undefined,
-            !!func.operation.responseBody
-              ? ts.factory.createTypeReferenceNode(
-                  func.operation.responseBody.typeName,
-                )
-              : ts.factory.createKeywordTypeNode(
-                  ts.SyntaxKind.UndefinedKeyword,
-                ),
-            initializer,
-          ),
-        ],
-        ts.NodeFlags.Const,
-      ),
-    );
-    const assertion = ts.factory.createCallExpression(
-      ts.factory.createPropertyAccessExpression(
-        ts.factory.createIdentifier(
-          ctx.importer.external({
-            type: "default",
-            library: "typia",
-            name: "typia",
-          }),
-        ),
-        "assert",
-      ),
-      undefined,
-      [ts.factory.createIdentifier(stmt.variableName)],
-    );
-    return [variable, ts.factory.createExpressionStatement(assertion)];
-  };
-}
+import { AutoBeTest } from "@autobe/interface";
+import ts from "typescript";
+
+import { FilePrinter } from "../../utils/FilePrinter";
+import { IAutoBeTestApiFunction } from "./IAutoBeTestApiFunction";
+import { IAutoBeTestProgrammerContext } from "./IAutoBeTestProgrammerContext";
+import { writeTestExpression } from "./writeTestExpression";
+import { writeTestStatement } from "./writeTestStatement";
+
+export namespace AutoBeTestStatementProgrammer {
+  export const block = (
+    ctx: IAutoBeTestProgrammerContext,
+    stmt: AutoBeTest.IBlock,
+  ): ts.Block =>
+    ts.factory.createBlock(
+      stmt.statements
+        .map((child, i) => [
+          ...writeTestStatement(ctx, child).filter((childStmt, j) =>
+            j === 0
+              ? ts.addSyntheticLeadingComment(
+                  childStmt,
+                  ts.SyntaxKind.SingleLineCommentTrivia,
+                  JSON.stringify(child),
+                  true,
+                )
+              : childStmt,
+          ),
+          ...(i !== 0 ? [FilePrinter.newLine()] : []),
+        ])
+        .flat(),
+      true,
+    );
+
+  export const expressionStatement = (
+    ctx: IAutoBeTestProgrammerContext,
+    stmt: AutoBeTest.IExpressionStatement,
+  ): ts.ExpressionStatement =>
+    ts.factory.createExpressionStatement(
+      writeTestExpression(ctx, stmt.expression),
+    );
+
+  // export const variableDeclaration = (
+  //   ctx: IAutoBeTestProgrammerContext,
+  //   stmt: AutoBeTest.IVariableDeclaration,
+  // ): ts.VariableStatement => {
+  //   const typeNode: ts.TypeNode = NestiaMigrateSchemaProgrammer.write({
+  //     components: ctx.document.components,
+  //     importer: ctx.importer,
+  //     schema: OpenApiV3_1Emender.convertSchema(ctx.document.components)(
+  //       stmt.schema,
+  //     ),
+  //   });
+  //   return ts.factory.createVariableStatement(
+  //     undefined,
+  //     ts.factory.createVariableDeclarationList(
+  //       [
+  //         ts.factory.createVariableDeclaration(
+  //           stmt.name,
+  //           undefined,
+  //           typeNode,
+  //           undefined,
+  //         ),
+  //       ],
+  //       stmt.mutability === "const" ? ts.NodeFlags.Constant : ts.NodeFlags.Let,
+  //     ),
+  //   );
+  // };
+
+  export const ifStatement = (
+    ctx: IAutoBeTestProgrammerContext,
+    stmt: AutoBeTest.IIfStatement,
+  ): ts.IfStatement =>
+    ts.factory.createIfStatement(
+      writeTestExpression(ctx, stmt.condition),
+      block(ctx, stmt.thenStatement),
+      stmt.elseStatement
+        ? stmt.elseStatement.type === "ifStatement"
+          ? ifStatement(ctx, stmt.elseStatement)
+          : block(ctx, stmt.elseStatement)
+        : undefined,
+    );
+
+  export const returnStatement = (
+    ctx: IAutoBeTestProgrammerContext,
+    stmt: AutoBeTest.IReturnStatement,
+  ): ts.ReturnStatement =>
+    ts.factory.createReturnStatement(writeTestExpression(ctx, stmt.expression));
+
+  export const throwStatement = (
+    ctx: IAutoBeTestProgrammerContext,
+    stmt: AutoBeTest.IThrowStatement,
+  ): ts.ThrowStatement =>
+    ts.factory.createThrowStatement(writeTestExpression(ctx, stmt.expression));
+
+  export const apiOperateStatement = (
+    ctx: IAutoBeTestProgrammerContext,
+    stmt: AutoBeTest.IApiOperateStatement,
+  ): ts.Statement[] => {
+    // find the function
+    const func: IAutoBeTestApiFunction = ctx.endpoints.get(stmt.endpoint);
+    if (!!stmt.variableName?.length && !!func.operation.responseBody)
+      ctx.importer.dto(func.operation.responseBody.typeName);
+
+    // make await function call expression
+    const initializer: ts.AwaitExpression = ts.factory.createAwaitExpression(
+      ts.factory.createCallExpression(
+        ts.factory.createIdentifier(func.accessor),
+        [],
+        [
+          ts.factory.createIdentifier("connection"),
+          ...(stmt.argument ? [writeTestExpression(ctx, stmt.argument)] : []),
+        ],
+      ),
+    );
+    if (stmt.variableName === null || stmt.variableName === undefined)
+      return [ts.factory.createExpressionStatement(initializer)];
+
+    const variable: ts.VariableStatement = ts.factory.createVariableStatement(
+      undefined,
+      ts.factory.createVariableDeclarationList(
+        [
+          ts.factory.createVariableDeclaration(
+            stmt.variableName,
+            undefined,
+            !!func.operation.responseBody
+              ? ts.factory.createTypeReferenceNode(
+                  func.operation.responseBody.typeName,
+                )
+              : ts.factory.createKeywordTypeNode(
+                  ts.SyntaxKind.UndefinedKeyword,
+                ),
+            initializer,
+          ),
+        ],
+        ts.NodeFlags.Const,
+      ),
+    );
+    const assertion = ts.factory.createCallExpression(
+      ts.factory.createPropertyAccessExpression(
+        ts.factory.createIdentifier(
+          ctx.importer.external({
+            type: "default",
+            library: "typia",
+            name: "typia",
+          }),
+        ),
+        "assert",
+      ),
+      undefined,
+      [ts.factory.createIdentifier(stmt.variableName)],
+    );
+    return [variable, ts.factory.createExpressionStatement(assertion)];
+  };
+}

package/src/test/programmers/IAutoBeTestApiFunction.ts

@@ -1,6 +1,6 @@
-import { AutoBeOpenApi } from "@autobe/interface";
-
-export interface IAutoBeTestApiFunction {
-  operation: AutoBeOpenApi.IOperation;
-  accessor: string;
-}
+import { AutoBeOpenApi } from "@autobe/interface";
+
+export interface IAutoBeTestApiFunction {
+  operation: AutoBeOpenApi.IOperation;
+  accessor: string;
+}

package/src/test/programmers/IAutoBeTestProgrammerContext.ts

@@ -1,11 +1,11 @@
-import { AutoBeOpenApi } from "@autobe/interface";
-import { NestiaMigrateImportProgrammer } from "@nestia/migrate";
-import { HashMap } from "tstl";
-
-import { IAutoBeTestApiFunction } from "./IAutoBeTestApiFunction";
-
-export interface IAutoBeTestProgrammerContext {
-  importer: NestiaMigrateImportProgrammer;
-  document: AutoBeOpenApi.IDocument;
-  endpoints: HashMap<AutoBeOpenApi.IEndpoint, IAutoBeTestApiFunction>;
-}
+import { AutoBeOpenApi } from "@autobe/interface";
+import { NestiaMigrateImportProgrammer } from "@nestia/migrate";
+import { HashMap } from "tstl";
+
+import { IAutoBeTestApiFunction } from "./IAutoBeTestApiFunction";
+
+export interface IAutoBeTestProgrammerContext {
+  importer: NestiaMigrateImportProgrammer;
+  document: AutoBeOpenApi.IDocument;
+  endpoints: HashMap<AutoBeOpenApi.IEndpoint, IAutoBeTestApiFunction>;
+}

package/src/test/programmers/writeTestExpression.ts

@@ -1,29 +1,29 @@
-import { AutoBeTest } from "@autobe/interface";
-import ts from "typescript";
-
-import { AutoBeTestAccessorProgrammer } from "./AutoBeTestAccessorProgrammer";
-import { AutoBeTestFunctionalProgrammer } from "./AutoBeTestFunctionalProgrammer";
-import { AutoBeTestLiteralProgrammer } from "./AutoBeTestLiteralProgrammer";
-import { AutoBeTestOperatorProgrammer } from "./AutoBeTestOperatorProgrammer";
-import { AutoBeTestPredicateProgrammer } from "./AutoBeTestPredicateProgrammer";
-import { AutoBeTestRandomProgrammer } from "./AutoBeTestRandomProgrammer";
-import { IAutoBeTestProgrammerContext } from "./IAutoBeTestProgrammerContext";
-
-export const writeTestExpression = (
-  ctx: IAutoBeTestProgrammerContext,
-  expr: AutoBeTest.IExpression,
-): ts.Expression =>
-  factory[expr.type](
-    ctx,
-    // biome-ignore lint: intended
-    expr as any,
-  );
-
-const factory = {
-  ...AutoBeTestLiteralProgrammer,
-  ...AutoBeTestOperatorProgrammer,
-  ...AutoBeTestAccessorProgrammer,
-  ...AutoBeTestFunctionalProgrammer,
-  ...AutoBeTestRandomProgrammer,
-  ...AutoBeTestPredicateProgrammer,
-};
+import { AutoBeTest } from "@autobe/interface";
+import ts from "typescript";
+
+import { AutoBeTestAccessorProgrammer } from "./AutoBeTestAccessorProgrammer";
+import { AutoBeTestFunctionalProgrammer } from "./AutoBeTestFunctionalProgrammer";
+import { AutoBeTestLiteralProgrammer } from "./AutoBeTestLiteralProgrammer";
+import { AutoBeTestOperatorProgrammer } from "./AutoBeTestOperatorProgrammer";
+import { AutoBeTestPredicateProgrammer } from "./AutoBeTestPredicateProgrammer";
+import { AutoBeTestRandomProgrammer } from "./AutoBeTestRandomProgrammer";
+import { IAutoBeTestProgrammerContext } from "./IAutoBeTestProgrammerContext";
+
+export const writeTestExpression = (
+  ctx: IAutoBeTestProgrammerContext,
+  expr: AutoBeTest.IExpression,
+): ts.Expression =>
+  factory[expr.type](
+    ctx,
+    // biome-ignore lint: intended
+    expr as any,
+  );
+
+const factory = {
+  ...AutoBeTestLiteralProgrammer,
+  ...AutoBeTestOperatorProgrammer,
+  ...AutoBeTestAccessorProgrammer,
+  ...AutoBeTestFunctionalProgrammer,
+  ...AutoBeTestRandomProgrammer,
+  ...AutoBeTestPredicateProgrammer,
+};

package/src/test/programmers/writeTestFunction.ts

@@ -1,103 +1,103 @@
-import { AutoBeOpenApi, IAutoBeTestWriteProps } from "@autobe/interface";
-import {
-  AutoBeOpenApiEndpointComparator,
-  transformOpenApiDocument,
-} from "@autobe/utils";
-import { NestiaMigrateImportProgrammer } from "@nestia/migrate";
-import { IHttpMigrateApplication } from "@typia/interface";
-import { HttpMigration } from "@typia/utils";
-import { HashMap, Pair } from "tstl";
-import ts, { FunctionDeclaration } from "typescript";
-
-import { FilePrinter } from "../../utils/FilePrinter";
-import { AutoBeTestStatementProgrammer } from "./AutoBeTestStatementProgrammer";
-import { IAutoBeTestApiFunction } from "./IAutoBeTestApiFunction";
-import { IAutoBeTestProgrammerContext } from "./IAutoBeTestProgrammerContext";
-
-export function writeTestFunction(props: IAutoBeTestWriteProps): string {
-  const ctx: IAutoBeTestProgrammerContext = {
-    importer: new NestiaMigrateImportProgrammer(),
-    document: props.document,
-    endpoints: associate(props.document),
-  };
-  const decla: FunctionDeclaration = ts.factory.createFunctionDeclaration(
-    [
-      ts.factory.createModifier(ts.SyntaxKind.ExportKeyword),
-      ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword),
-    ],
-    undefined,
-    props.scenario.functionName,
-    undefined,
-    [
-      ts.factory.createParameterDeclaration(
-        undefined,
-        undefined,
-        "connection",
-        undefined,
-        ts.factory.createTypeReferenceNode(
-          `${ctx.importer.external({
-            type: "default",
-            name: "api",
-            library: `@ORGANIZATION/PROJECT-api`,
-          })}.IConnection`,
-        ),
-      ),
-    ],
-    undefined,
-    AutoBeTestStatementProgrammer.block(ctx, {
-      type: "block",
-      statements: props.function.statements,
-    }),
-  );
-  return FilePrinter.write({
-    statements: [
-      ...ctx.importer.toStatements(
-        (key) => `@ORGANIZATION/PROJECT-api/lib/structures/${key}`,
-      ),
-      FilePrinter.newLine(),
-      FilePrinter.description(decla, props.scenario.draft),
-    ],
-  });
-}
-
-function associate(
-  document: AutoBeOpenApi.IDocument,
-): HashMap<AutoBeOpenApi.IEndpoint, IAutoBeTestApiFunction> {
-  // associate operations and functions
-  const operations: HashMap<AutoBeOpenApi.IEndpoint, AutoBeOpenApi.IOperation> =
-    new HashMap(
-      document.operations.map(
-        (o) =>
-          new Pair(
-            {
-              method: o.method,
-              path: o.path,
-            },
-            o,
-          ),
-      ),
-      AutoBeOpenApiEndpointComparator.hashCode,
-      AutoBeOpenApiEndpointComparator.equals,
-    );
-  const functions: HashMap<AutoBeOpenApi.IEndpoint, IAutoBeTestApiFunction> =
-    new HashMap(
-      AutoBeOpenApiEndpointComparator.hashCode,
-      AutoBeOpenApiEndpointComparator.equals,
-    );
-
-  // from migrate application
-  const migrate: IHttpMigrateApplication = HttpMigration.application(
-    transformOpenApiDocument(document),
-  );
-  for (const route of migrate.routes) {
-    const endpoint: AutoBeOpenApi.IEndpoint = {
-      path: route.path,
-      method: route.method as "get",
-    };
-    functions.emplace(endpoint, {
-      accessor: "api.functional." + route.accessor.join("."),
-      operation: operations.get(endpoint),
-    });
-  }
-  return functions;
-}
+import { AutoBeOpenApi, IAutoBeTestWriteProps } from "@autobe/interface";
+import {
+  AutoBeOpenApiEndpointComparator,
+  transformOpenApiDocument,
+} from "@autobe/utils";
+import { NestiaMigrateImportProgrammer } from "@nestia/migrate";
+import { IHttpMigrateApplication } from "@typia/interface";
+import { HttpMigration } from "@typia/utils";
+import { HashMap, Pair } from "tstl";
+import ts, { FunctionDeclaration } from "typescript";
+
+import { FilePrinter } from "../../utils/FilePrinter";
+import { AutoBeTestStatementProgrammer } from "./AutoBeTestStatementProgrammer";
+import { IAutoBeTestApiFunction } from "./IAutoBeTestApiFunction";
+import { IAutoBeTestProgrammerContext } from "./IAutoBeTestProgrammerContext";
+
+export function writeTestFunction(props: IAutoBeTestWriteProps): string {
+  const ctx: IAutoBeTestProgrammerContext = {
+    importer: new NestiaMigrateImportProgrammer(),
+    document: props.document,
+    endpoints: associate(props.document),
+  };
+  const decla: FunctionDeclaration = ts.factory.createFunctionDeclaration(
+    [
+      ts.factory.createModifier(ts.SyntaxKind.ExportKeyword),
+      ts.factory.createModifier(ts.SyntaxKind.AsyncKeyword),
+    ],
+    undefined,
+    props.scenario.functionName,
+    undefined,
+    [
+      ts.factory.createParameterDeclaration(
+        undefined,
+        undefined,
+        "connection",
+        undefined,
+        ts.factory.createTypeReferenceNode(
+          `${ctx.importer.external({
+            type: "default",
+            name: "api",
+            library: `@ORGANIZATION/PROJECT-api`,
+          })}.IConnection`,
+        ),
+      ),
+    ],
+    undefined,
+    AutoBeTestStatementProgrammer.block(ctx, {
+      type: "block",
+      statements: props.function.statements,
+    }),
+  );
+  return FilePrinter.write({
+    statements: [
+      ...ctx.importer.toStatements(
+        (key) => `@ORGANIZATION/PROJECT-api/lib/structures/${key}`,
+      ),
+      FilePrinter.newLine(),
+      FilePrinter.description(decla, props.scenario.draft),
+    ],
+  });
+}
+
+function associate(
+  document: AutoBeOpenApi.IDocument,
+): HashMap<AutoBeOpenApi.IEndpoint, IAutoBeTestApiFunction> {
+  // associate operations and functions
+  const operations: HashMap<AutoBeOpenApi.IEndpoint, AutoBeOpenApi.IOperation> =
+    new HashMap(
+      document.operations.map(
+        (o) =>
+          new Pair(
+            {
+              method: o.method,
+              path: o.path,
+            },
+            o,
+          ),
+      ),
+      AutoBeOpenApiEndpointComparator.hashCode,
+      AutoBeOpenApiEndpointComparator.equals,
+    );
+  const functions: HashMap<AutoBeOpenApi.IEndpoint, IAutoBeTestApiFunction> =
+    new HashMap(
+      AutoBeOpenApiEndpointComparator.hashCode,
+      AutoBeOpenApiEndpointComparator.equals,
+    );
+
+  // from migrate application
+  const migrate: IHttpMigrateApplication = HttpMigration.application(
+    transformOpenApiDocument(document),
+  );
+  for (const route of migrate.routes) {
+    const endpoint: AutoBeOpenApi.IEndpoint = {
+      path: route.path,
+      method: route.method as "get",
+    };
+    functions.emplace(endpoint, {
+      accessor: "api.functional." + route.accessor.join("."),
+      operation: operations.get(endpoint),
+    });
+  }
+  return functions;
+}

package/src/test/programmers/writeTestStatement.ts

@@ -1,19 +1,19 @@
-import { AutoBeTest } from "@autobe/interface";
-import ts from "typescript";
-
-import { AutoBeTestStatementProgrammer } from "./AutoBeTestStatementProgrammer";
-import { IAutoBeTestProgrammerContext } from "./IAutoBeTestProgrammerContext";
-
-export const writeTestStatement = (
-  ctx: IAutoBeTestProgrammerContext,
-  stmt: AutoBeTest.IStatement,
-): ts.Statement[] => {
-  const next: ts.Statement | ts.Statement[] = AutoBeTestStatementProgrammer[
-    stmt.type
-  ](
-    ctx,
-    // biome-ignore lint: intended
-    stmt as any,
-  );
-  return Array.isArray(next) ? next : [next];
-};
+import { AutoBeTest } from "@autobe/interface";
+import ts from "typescript";
+
+import { AutoBeTestStatementProgrammer } from "./AutoBeTestStatementProgrammer";
+import { IAutoBeTestProgrammerContext } from "./IAutoBeTestProgrammerContext";
+
+export const writeTestStatement = (
+  ctx: IAutoBeTestProgrammerContext,
+  stmt: AutoBeTest.IStatement,
+): ts.Statement[] => {
+  const next: ts.Statement | ts.Statement[] = AutoBeTestStatementProgrammer[
+    stmt.type
+  ](
+    ctx,
+    // biome-ignore lint: intended
+    stmt as any,
+  );
+  return Array.isArray(next) ? next : [next];
+};