@autobe/utils 0.29.2 → 0.30.0-dev.20260315

package/src/test/AutoBeTestExpressionValidator.ts

@@ -1,253 +1,253 @@
-import { AutoBeTest } from "@autobe/interface";
-
-import { AutoBeTestStatementValidator } from "./AutoBeTestStatementValidator";
-import { IAutoBeTextValidateContext } from "./IAutoBeTextValidateContext";
-import { validateTestExpression } from "./validateTestExpression";
-
-export namespace AutoBeTestExpressionValidator {
-  /* -----------------------------------------------------------
-    LITERALS
-  ----------------------------------------------------------- */
-  export const booleanLiteral = (): void => {};
-  export const numericLiteral = (): void => {};
-  export const stringLiteral = (): void => {};
-  export const nullLiteral = (): void => {};
-  export const undefinedKeyword = (): void => {};
-
-  export const arrayLiteralExpression = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.IArrayLiteralExpression,
-    path: string,
-  ): void => {
-    item.elements.forEach((element, i) => {
-      validateTestExpression(ctx, element, `${path}.elements[${i}]`);
-    });
-  };
-
-  export const objectLiteralExpression = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.IObjectLiteralExpression,
-    path: string,
-  ): void => {
-    item.properties.forEach((property, i) => {
-      validateTestExpression(ctx, property.value, `${path}.properties[${i}]`);
-    });
-  };
-
-  /* -----------------------------------------------------------
-    ACCESSORS
-  ----------------------------------------------------------- */
-  export const identifier = (): void => {};
-
-  export const propertyAccessExpression = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.IPropertyAccessExpression,
-    path: string,
-  ): void => {
-    validateTestExpression(ctx, item.expression, `${path}.expression`);
-  };
-
-  export const elementAccessExpression = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.IElementAccessExpression,
-    path: string,
-  ): void => {
-    validateTestExpression(ctx, item.expression, `${path}.expression`);
-    validateTestExpression(
-      ctx,
-      item.argumentExpression,
-      `${path}.argumentExpression`,
-    );
-  };
-
-  /* -----------------------------------------------------------
-    OPERATORS
-  ----------------------------------------------------------- */
-  export const typeOfExpression = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.ITypeOfExpression,
-    path: string,
-  ): void => {
-    validateTestExpression(ctx, item.expression, `${path}.expression`);
-  };
-
-  export const prefixUnaryExpression = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.IPrefixUnaryExpression,
-    path: string,
-  ): void => {
-    validateTestExpression(ctx, item.operand, `${path}.operand`);
-  };
-
-  export const postfixUnaryExpression = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.IPostfixUnaryExpression,
-    path: string,
-  ): void => {
-    validateTestExpression(ctx, item.operand, `${path}.operand`);
-  };
-
-  export const binaryExpression = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.IBinaryExpression,
-    path: string,
-  ): void => {
-    validateTestExpression(ctx, item.left, `${path}.left`);
-    validateTestExpression(ctx, item.right, `${path}.right`);
-  };
-
-  export const conditionalExpression = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.IConditionalExpression,
-    path: string,
-  ): void => {
-    validateTestExpression(ctx, item.condition, `${path}.condition`);
-    validateTestExpression(ctx, item.whenTrue, `${path}.whenTrue`);
-    validateTestExpression(ctx, item.whenFalse, `${path}.whenFalse`);
-  };
-
-  /* -----------------------------------------------------------
-    FUNCTIONAL
-  ----------------------------------------------------------- */
-  export const arrowFunction = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.IArrowFunction,
-    path: string,
-  ): void => {
-    AutoBeTestStatementValidator.block(ctx, item.body, `${path}.body`);
-  };
-
-  export const callExpression = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.ICallExpression,
-    path: string,
-  ): void => {
-    validateTestExpression(ctx, item.expression, `${path}.expression`);
-    item.arguments.forEach((arg, i) => {
-      validateTestExpression(ctx, arg, `${path}.arguments[${i}]`);
-    });
-  };
-
-  export const newExpression = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.INewExpression,
-    path: string,
-  ): void => {
-    validateTestExpression(ctx, item.expression, `${path}.expression`);
-    item.arguments.forEach((arg, i) => {
-      validateTestExpression(ctx, arg, `${path}.arguments[${i}]`);
-    });
-  };
-
-  export const arrayFilterExpression = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.IArrayFilterExpression,
-    path: string,
-  ): void => arrayClosureExpression(ctx, item, path);
-
-  export const arrayForEachExpression = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.IArrayForEachExpression,
-    path: string,
-  ): void => arrayClosureExpression(ctx, item, path);
-
-  export const arrayMapExpression = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.IArrayMapExpression,
-    path: string,
-  ): void => arrayClosureExpression(ctx, item, path);
-
-  export const arrayRepeatExpression = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.IArrayRepeatExpression,
-    path: string,
-  ): void => {
-    validateTestExpression(ctx, item.count, `${path}.length`);
-    arrowFunction(ctx, item.function, `${path}.function`);
-  };
-
-  const arrayClosureExpression = (
-    ctx: IAutoBeTextValidateContext,
-    item: {
-      array: AutoBeTest.IExpression;
-      function: AutoBeTest.IArrowFunction;
-    },
-    path: string,
-  ): void => {
-    validateTestExpression(ctx, item.array, `${path}.expression`);
-    arrowFunction(ctx, item.function, `${path}.function`);
-  };
-
-  /* -----------------------------------------------------------
-    RANDOM GENERATORS
-  ----------------------------------------------------------- */
-  export const pickRandom = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.IPickRandom,
-    path: string,
-  ): void => {
-    validateTestExpression(ctx, item.array, `${path}.expression`);
-  };
-
-  export const sampleRandom = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.ISampleRandom,
-    path: string,
-  ): void => {
-    validateTestExpression(ctx, item.array, `${path}.expression`);
-    validateTestExpression(ctx, item.count, `${path}.length`);
-  };
-
-  export const booleanRandom = (): void => {};
-  export const integerRandom = (): void => {};
-  export const numberRandom = (): void => {};
-  export const stringRandom = (): void => {};
-  export const patternRandom = (): void => {};
-  export const formatRandom = (): void => {};
-  export const keywordRandom = (): void => {};
-
-  /* -----------------------------------------------------------
-    PREDICATORS
-  ----------------------------------------------------------- */
-  export const equalPredicate = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.IEqualPredicate,
-    path: string,
-  ): void => {
-    validateTestExpression(ctx, item.x, `${path}.x`);
-    validateTestExpression(ctx, item.y, `${path}.y`);
-  };
-
-  export const notEqualPredicate = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.INotEqualPredicate,
-    path: string,
-  ): void => {
-    validateTestExpression(ctx, item.x, `${path}.x`);
-    validateTestExpression(ctx, item.y, `${path}.y`);
-  };
-
-  export const conditionalPredicate = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.IConditionalPredicate,
-    path: string,
-  ): void => {
-    validateTestExpression(ctx, item.expression, `${path}.condition`);
-  };
-
-  export const errorPredicate = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.IErrorPredicate,
-    path: string,
-  ): void => {
-    arrowFunction(ctx, item.function, `${path}.function`);
-  };
-
-  // export const httpErrorPredicate = (
-  //   ctx: IAutoBeTextValidateContext,
-  //   item: AutoBeTest.IHttpErrorPredicate,
-  //   path: string,
-  // ): void => {
-  //   arrowFunction(ctx, item.function, `${path}.function`);
-  // };
-}
+import { AutoBeTest } from "@autobe/interface";
+
+import { AutoBeTestStatementValidator } from "./AutoBeTestStatementValidator";
+import { IAutoBeTextValidateContext } from "./IAutoBeTextValidateContext";
+import { validateTestExpression } from "./validateTestExpression";
+
+export namespace AutoBeTestExpressionValidator {
+  /* -----------------------------------------------------------
+    LITERALS
+  ----------------------------------------------------------- */
+  export const booleanLiteral = (): void => {};
+  export const numericLiteral = (): void => {};
+  export const stringLiteral = (): void => {};
+  export const nullLiteral = (): void => {};
+  export const undefinedKeyword = (): void => {};
+
+  export const arrayLiteralExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IArrayLiteralExpression,
+    path: string,
+  ): void => {
+    item.elements.forEach((element, i) => {
+      validateTestExpression(ctx, element, `${path}.elements[${i}]`);
+    });
+  };
+
+  export const objectLiteralExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IObjectLiteralExpression,
+    path: string,
+  ): void => {
+    item.properties.forEach((property, i) => {
+      validateTestExpression(ctx, property.value, `${path}.properties[${i}]`);
+    });
+  };
+
+  /* -----------------------------------------------------------
+    ACCESSORS
+  ----------------------------------------------------------- */
+  export const identifier = (): void => {};
+
+  export const propertyAccessExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IPropertyAccessExpression,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.expression, `${path}.expression`);
+  };
+
+  export const elementAccessExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IElementAccessExpression,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.expression, `${path}.expression`);
+    validateTestExpression(
+      ctx,
+      item.argumentExpression,
+      `${path}.argumentExpression`,
+    );
+  };
+
+  /* -----------------------------------------------------------
+    OPERATORS
+  ----------------------------------------------------------- */
+  export const typeOfExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.ITypeOfExpression,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.expression, `${path}.expression`);
+  };
+
+  export const prefixUnaryExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IPrefixUnaryExpression,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.operand, `${path}.operand`);
+  };
+
+  export const postfixUnaryExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IPostfixUnaryExpression,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.operand, `${path}.operand`);
+  };
+
+  export const binaryExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IBinaryExpression,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.left, `${path}.left`);
+    validateTestExpression(ctx, item.right, `${path}.right`);
+  };
+
+  export const conditionalExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IConditionalExpression,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.condition, `${path}.condition`);
+    validateTestExpression(ctx, item.whenTrue, `${path}.whenTrue`);
+    validateTestExpression(ctx, item.whenFalse, `${path}.whenFalse`);
+  };
+
+  /* -----------------------------------------------------------
+    FUNCTIONAL
+  ----------------------------------------------------------- */
+  export const arrowFunction = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IArrowFunction,
+    path: string,
+  ): void => {
+    AutoBeTestStatementValidator.block(ctx, item.body, `${path}.body`);
+  };
+
+  export const callExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.ICallExpression,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.expression, `${path}.expression`);
+    item.arguments.forEach((arg, i) => {
+      validateTestExpression(ctx, arg, `${path}.arguments[${i}]`);
+    });
+  };
+
+  export const newExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.INewExpression,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.expression, `${path}.expression`);
+    item.arguments.forEach((arg, i) => {
+      validateTestExpression(ctx, arg, `${path}.arguments[${i}]`);
+    });
+  };
+
+  export const arrayFilterExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IArrayFilterExpression,
+    path: string,
+  ): void => arrayClosureExpression(ctx, item, path);
+
+  export const arrayForEachExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IArrayForEachExpression,
+    path: string,
+  ): void => arrayClosureExpression(ctx, item, path);
+
+  export const arrayMapExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IArrayMapExpression,
+    path: string,
+  ): void => arrayClosureExpression(ctx, item, path);
+
+  export const arrayRepeatExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IArrayRepeatExpression,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.count, `${path}.length`);
+    arrowFunction(ctx, item.function, `${path}.function`);
+  };
+
+  const arrayClosureExpression = (
+    ctx: IAutoBeTextValidateContext,
+    item: {
+      array: AutoBeTest.IExpression;
+      function: AutoBeTest.IArrowFunction;
+    },
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.array, `${path}.expression`);
+    arrowFunction(ctx, item.function, `${path}.function`);
+  };
+
+  /* -----------------------------------------------------------
+    RANDOM GENERATORS
+  ----------------------------------------------------------- */
+  export const pickRandom = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IPickRandom,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.array, `${path}.expression`);
+  };
+
+  export const sampleRandom = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.ISampleRandom,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.array, `${path}.expression`);
+    validateTestExpression(ctx, item.count, `${path}.length`);
+  };
+
+  export const booleanRandom = (): void => {};
+  export const integerRandom = (): void => {};
+  export const numberRandom = (): void => {};
+  export const stringRandom = (): void => {};
+  export const patternRandom = (): void => {};
+  export const formatRandom = (): void => {};
+  export const keywordRandom = (): void => {};
+
+  /* -----------------------------------------------------------
+    PREDICATORS
+  ----------------------------------------------------------- */
+  export const equalPredicate = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IEqualPredicate,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.x, `${path}.x`);
+    validateTestExpression(ctx, item.y, `${path}.y`);
+  };
+
+  export const notEqualPredicate = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.INotEqualPredicate,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.x, `${path}.x`);
+    validateTestExpression(ctx, item.y, `${path}.y`);
+  };
+
+  export const conditionalPredicate = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IConditionalPredicate,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.expression, `${path}.condition`);
+  };
+
+  export const errorPredicate = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IErrorPredicate,
+    path: string,
+  ): void => {
+    arrowFunction(ctx, item.function, `${path}.function`);
+  };
+
+  // export const httpErrorPredicate = (
+  //   ctx: IAutoBeTextValidateContext,
+  //   item: AutoBeTest.IHttpErrorPredicate,
+  //   path: string,
+  // ): void => {
+  //   arrowFunction(ctx, item.function, `${path}.function`);
+  // };
+}

package/src/test/AutoBeTestStatementValidator.ts

@@ -1,72 +1,72 @@
-import { AutoBeTest } from "@autobe/interface";
-
-import { IAutoBeTextValidateContext } from "./IAutoBeTextValidateContext";
-import { validateTestApiOperateStatement } from "./validateTestApiOperateStatement";
-import { validateTestExpression } from "./validateTestExpression";
-import { validateTestStatement } from "./validateTestStatement";
-
-export namespace AutoBeTestStatementValidator {
-  export const block = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.IBlock,
-    path: string,
-  ): void => {
-    item.statements.forEach((stmt, i) =>
-      validateTestStatement(ctx, stmt, `${path}.statements[${i}]`),
-    );
-  };
-
-  export const apiOperateStatement = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.IApiOperateStatement,
-    path: string,
-  ): void => {
-    validateTestApiOperateStatement(ctx, item, path);
-  };
-
-  export const expressionStatement = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.IExpressionStatement,
-    path: string,
-  ): void => {
-    validateTestExpression(ctx, item.expression, `${path}.expression`);
-  };
-
-  export const ifStatement = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.IIfStatement,
-    path: string,
-  ): void => {
-    validateTestExpression(ctx, item.condition, `${path}.condition`);
-    block(ctx, item.thenStatement, `${path}.thenStatement`);
-    if (!!item.elseStatement)
-      if (item.elseStatement.type === "block")
-        block(ctx, item.elseStatement, `${path}.elseStatement`);
-      else
-        validateTestStatement(ctx, item.elseStatement, `${path}.elseStatement`);
-  };
-
-  export const returnStatement = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.IReturnStatement,
-    path: string,
-  ): void => {
-    validateTestExpression(ctx, item.expression, `${path}.expression`);
-  };
-
-  export const throwStatement = (
-    ctx: IAutoBeTextValidateContext,
-    item: AutoBeTest.IThrowStatement,
-    path: string,
-  ): void => {
-    validateTestExpression(ctx, item.expression, `${path}.expression`);
-  };
-
-  // export const variableDeclaration = (
-  //   ctx: IAutoBeTextValidateContext,
-  //   item: AutoBeTest.IVariableDeclaration,
-  //   path: string,
-  // ): void => {
-  //   validateTestExpression(ctx, item.initializer, `${path}.initializer`);
-  // };
-}
+import { AutoBeTest } from "@autobe/interface";
+
+import { IAutoBeTextValidateContext } from "./IAutoBeTextValidateContext";
+import { validateTestApiOperateStatement } from "./validateTestApiOperateStatement";
+import { validateTestExpression } from "./validateTestExpression";
+import { validateTestStatement } from "./validateTestStatement";
+
+export namespace AutoBeTestStatementValidator {
+  export const block = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IBlock,
+    path: string,
+  ): void => {
+    item.statements.forEach((stmt, i) =>
+      validateTestStatement(ctx, stmt, `${path}.statements[${i}]`),
+    );
+  };
+
+  export const apiOperateStatement = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IApiOperateStatement,
+    path: string,
+  ): void => {
+    validateTestApiOperateStatement(ctx, item, path);
+  };
+
+  export const expressionStatement = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IExpressionStatement,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.expression, `${path}.expression`);
+  };
+
+  export const ifStatement = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IIfStatement,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.condition, `${path}.condition`);
+    block(ctx, item.thenStatement, `${path}.thenStatement`);
+    if (!!item.elseStatement)
+      if (item.elseStatement.type === "block")
+        block(ctx, item.elseStatement, `${path}.elseStatement`);
+      else
+        validateTestStatement(ctx, item.elseStatement, `${path}.elseStatement`);
+  };
+
+  export const returnStatement = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IReturnStatement,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.expression, `${path}.expression`);
+  };
+
+  export const throwStatement = (
+    ctx: IAutoBeTextValidateContext,
+    item: AutoBeTest.IThrowStatement,
+    path: string,
+  ): void => {
+    validateTestExpression(ctx, item.expression, `${path}.expression`);
+  };
+
+  // export const variableDeclaration = (
+  //   ctx: IAutoBeTextValidateContext,
+  //   item: AutoBeTest.IVariableDeclaration,
+  //   path: string,
+  // ): void => {
+  //   validateTestExpression(ctx, item.initializer, `${path}.initializer`);
+  // };
+}

package/src/test/IAutoBeTextValidateContext.ts

@@ -1,10 +1,10 @@
-import { AutoBeOpenApi, AutoBeTest } from "@autobe/interface";
-import { HashMap } from "tstl";
-import { IValidation } from "typia";
-
-export interface IAutoBeTextValidateContext {
-  function: AutoBeTest.IFunction;
-  document: AutoBeOpenApi.IDocument;
-  endpoints: HashMap<AutoBeOpenApi.IEndpoint, AutoBeOpenApi.IOperation>;
-  errors: IValidation.IError[];
-}
+import { AutoBeOpenApi, AutoBeTest } from "@autobe/interface";
+import { HashMap } from "tstl";
+import { IValidation } from "typia";
+
+export interface IAutoBeTextValidateContext {
+  function: AutoBeTest.IFunction;
+  document: AutoBeOpenApi.IDocument;
+  endpoints: HashMap<AutoBeOpenApi.IEndpoint, AutoBeOpenApi.IOperation>;
+  errors: IValidation.IError[];
+}