@checkdigit/eslint-plugin 7.17.1 → 8.0.0-PR.141-56ee

package/src/no-promise-instance-method.ts

@@ -10,8 +10,10 @@ import getDocumentationUrl from './get-documentation-url.ts';
  */
 
 export const ruleId = 'no-promise-instance-method';
-export const NO_PROMISE_INSTANCE_METHOD_THEN = 'NO_PROMISE_INSTANCE_METHOD_THEN';
-export const NO_PROMISE_INSTANCE_METHOD_CATCH_FINALLY = 'NO_PROMISE_INSTANCE_METHOD_CATCH_FINALLY';
+export const NO_PROMISE_INSTANCE_METHOD_THEN =
+  'NO_PROMISE_INSTANCE_METHOD_THEN';
+export const NO_PROMISE_INSTANCE_METHOD_CATCH_FINALLY =
+  'NO_PROMISE_INSTANCE_METHOD_CATCH_FINALLY';
 
 export default {
   meta: {
@@ -29,7 +31,10 @@ export default {
   create(context) {
     return {
       MemberExpression(node) {
-        if (node.property.type === 'Identifier' && ['then', 'catch', 'finally'].includes(node.property.name)) {
+        if (
+          node.property.type === 'Identifier' &&
+          ['then', 'catch', 'finally'].includes(node.property.name)
+        ) {
           context.report({
             node,
             messageId:

package/src/no-random-v4-uuid.ts

@@ -6,7 +6,12 @@
  * This code is licensed under the MIT license (see LICENSE.txt for details).
  */
 
-import { AST_NODE_TYPES, ESLintUtils, TSESLint, TSESTree } from '@typescript-eslint/utils';
+import {
+  AST_NODE_TYPES,
+  ESLintUtils,
+  TSESLint,
+  TSESTree,
+} from '@typescript-eslint/utils';
 import getDocumentationUrl from './get-documentation-url.ts';
 
 export const ruleId = 'no-random-v4-uuid';
@@ -21,7 +26,10 @@ interface Aliases {
   nodeCryptoRandomUUIDAlias?: string;
 }
 
-const processImportDeclaration = (node: TSESTree.ImportDeclaration, aliases: Aliases) => {
+const processImportDeclaration = (
+  node: TSESTree.ImportDeclaration,
+  aliases: Aliases,
+) => {
   node.specifiers.forEach((specifier) => {
     if (specifier.type === AST_NODE_TYPES.ImportSpecifier) {
       if (
@@ -37,39 +45,54 @@ const processImportDeclaration = (node: TSESTree.ImportDeclaration, aliases: Ali
       ) {
         aliases.nodeCryptoRandomUUIDAlias = specifier.local.name;
       }
-    } else if (specifier.type === AST_NODE_TYPES.ImportDefaultSpecifier && node.source.value === 'uuid') {
+    } else if (
+      specifier.type === AST_NODE_TYPES.ImportDefaultSpecifier &&
+      node.source.value === 'uuid'
+    ) {
       aliases.uuidDefaultAlias = specifier.local.name;
     }
   });
 };
 
-const isUuid4Call = (node: TSESTree.CallExpression, aliases: Aliases): boolean =>
-  (node.callee.type === AST_NODE_TYPES.Identifier && node.callee.name === aliases.uuid4Alias) ||
+const isUuid4Call = (
+  node: TSESTree.CallExpression,
+  aliases: Aliases,
+): boolean =>
+  (node.callee.type === AST_NODE_TYPES.Identifier &&
+    node.callee.name === aliases.uuid4Alias) ||
   (node.callee.type === AST_NODE_TYPES.MemberExpression &&
     node.callee.object.type === AST_NODE_TYPES.Identifier &&
     node.callee.object.name === aliases.uuidDefaultAlias &&
     node.callee.property.type === AST_NODE_TYPES.Identifier &&
     node.callee.property.name === 'v4');
 
-const isCryptoRandomUUIDCall = (node: TSESTree.CallExpression, alias?: string): boolean =>
-  (node.callee.type === AST_NODE_TYPES.Identifier && node.callee.name === alias) ||
+const isCryptoRandomUUIDCall = (
+  node: TSESTree.CallExpression,
+  alias?: string,
+): boolean =>
+  (node.callee.type === AST_NODE_TYPES.Identifier &&
+    node.callee.name === alias) ||
   (node.callee.type === AST_NODE_TYPES.MemberExpression &&
     node.callee.object.type === AST_NODE_TYPES.Identifier &&
     node.callee.object.name === 'crypto' &&
     node.callee.property.type === AST_NODE_TYPES.Identifier &&
     node.callee.property.name === 'randomUUID');
 
-const rule: TSESLint.RuleModule<typeof NO_RANDOM_V4_UUID | typeof NO_UUID_MODULE_FOR_V4> = createRule({
+const rule: TSESLint.RuleModule<
+  typeof NO_RANDOM_V4_UUID | typeof NO_UUID_MODULE_FOR_V4
+> = createRule({
   name: ruleId,
   meta: {
     type: 'problem',
     docs: {
-      description: 'Disallow the use of `uuid.v4` and `crypto.randomUUID` for generating random v4 UUIDs.',
+      description:
+        'Disallow the use of `uuid.v4` and `crypto.randomUUID` for generating random v4 UUIDs.',
     },
     schema: [],
     messages: {
       [NO_RANDOM_V4_UUID]: 'Avoid generating v4 UUIDs',
-      [NO_UUID_MODULE_FOR_V4]: 'Avoid using the `uuid` module for v4 UUID generation',
+      [NO_UUID_MODULE_FOR_V4]:
+        'Avoid using the `uuid` module for v4 UUID generation',
     },
   },
   defaultOptions: [],
@@ -86,7 +109,9 @@ const rule: TSESLint.RuleModule<typeof NO_RANDOM_V4_UUID | typeof NO_UUID_MODULE
             node,
             messageId: NO_UUID_MODULE_FOR_V4,
           });
-        } else if (isCryptoRandomUUIDCall(node, aliases.nodeCryptoRandomUUIDAlias)) {
+        } else if (
+          isCryptoRandomUUIDCall(node, aliases.nodeCryptoRandomUUIDAlias)
+        ) {
           context.report({
             node,
             messageId: NO_RANDOM_V4_UUID,

package/src/no-side-effects.ts

@@ -20,12 +20,15 @@ const NO_SIDE_EFFECTS = 'NO_SIDE_EFFECTS';
 // Type guards
 
 // Checks if a node is an ExpressionStatement
-const isExpressionStatement = (node: TSESTree.Node): node is TSESTree.ExpressionStatement =>
+const isExpressionStatement = (
+  node: TSESTree.Node,
+): node is TSESTree.ExpressionStatement =>
   node.type === TSESTree.AST_NODE_TYPES.ExpressionStatement;
 
 // Checks if a statement is an AwaitExpression
 const isAwaitExpression = (statement: TSESTree.Node): boolean =>
-  isExpressionStatement(statement) && statement.expression.type === TSESTree.AST_NODE_TYPES.AwaitExpression;
+  isExpressionStatement(statement) &&
+  statement.expression.type === TSESTree.AST_NODE_TYPES.AwaitExpression;
 
 // Checks if a node is a VariableDeclaration with an AwaitExpression
 const isVariableDeclarationAwaitExpression = (node: TSESTree.Node): boolean =>
@@ -35,7 +38,9 @@ const isVariableDeclarationAwaitExpression = (node: TSESTree.Node): boolean =>
 
 // Checks if a node is a VariableDeclaration that is not const or using
 const isNotValidVariableDeclaration = (node: TSESTree.Node): boolean =>
-  node.type === TSESTree.AST_NODE_TYPES.VariableDeclaration && node.kind !== 'const' && node.kind !== 'using';
+  node.type === TSESTree.AST_NODE_TYPES.VariableDeclaration &&
+  node.kind !== 'const' &&
+  node.kind !== 'using';
 
 // Checks if a node is a control flow statement
 const isControlFlowStatement = (node: TSESTree.Node): boolean =>
@@ -56,36 +61,59 @@ const isAssignmentExpression = (node: TSESTree.Node): boolean =>
 // Helper functions
 
 // Checks if the callee is an identifier and not excluded
-const isIdentifierCallee = (node: TSESTree.CallExpression, excludedIdentifiers: string[]): boolean =>
-  node.callee.type === TSESTree.AST_NODE_TYPES.Identifier && !excludedIdentifiers.includes(node.callee.name);
+const isIdentifierCallee = (
+  node: TSESTree.CallExpression,
+  excludedIdentifiers: string[],
+): boolean =>
+  node.callee.type === TSESTree.AST_NODE_TYPES.Identifier &&
+  !excludedIdentifiers.includes(node.callee.name);
 
 // Checks if the callee is a member expression and not excluded
-const isMemberExpressionCallee = (node: TSESTree.CallExpression, excludedIdentifiers: string[]): boolean =>
+const isMemberExpressionCallee = (
+  node: TSESTree.CallExpression,
+  excludedIdentifiers: string[],
+): boolean =>
   node.callee.type === TSESTree.AST_NODE_TYPES.MemberExpression &&
   node.callee.object.type === TSESTree.AST_NODE_TYPES.Identifier &&
   node.callee.property.type === TSESTree.AST_NODE_TYPES.Identifier &&
-  !excludedIdentifiers.includes(`${node.callee.object.name}.${node.callee.property.name}`);
+  !excludedIdentifiers.includes(
+    `${node.callee.object.name}.${node.callee.property.name}`,
+  );
 
 // Checks if the callee is a member expression with a non-identifier object
-const isNonIdentifierObjectMemberExpressionCallee = (node: TSESTree.CallExpression): boolean =>
+const isNonIdentifierObjectMemberExpressionCallee = (
+  node: TSESTree.CallExpression,
+): boolean =>
   node.callee.type === TSESTree.AST_NODE_TYPES.MemberExpression &&
   node.callee.object.type !== TSESTree.AST_NODE_TYPES.Identifier;
 
 // Checks if a statement is a CallExpression with a member expression callee
-const isCallExpressionCalleeMemberExpression = (statement: TSESTree.Node, excludedIdentifiers: string[]): boolean =>
+const isCallExpressionCalleeMemberExpression = (
+  statement: TSESTree.Node,
+  excludedIdentifiers: string[],
+): boolean =>
   isExpressionStatement(statement) &&
   statement.expression.type === TSESTree.AST_NODE_TYPES.CallExpression &&
-  statement.expression.callee.type === TSESTree.AST_NODE_TYPES.MemberExpression &&
-  statement.expression.callee.object.type === TSESTree.AST_NODE_TYPES.Identifier &&
-  statement.expression.callee.property.type === TSESTree.AST_NODE_TYPES.Identifier &&
+  statement.expression.callee.type ===
+    TSESTree.AST_NODE_TYPES.MemberExpression &&
+  statement.expression.callee.object.type ===
+    TSESTree.AST_NODE_TYPES.Identifier &&
+  statement.expression.callee.property.type ===
+    TSESTree.AST_NODE_TYPES.Identifier &&
   !excludedIdentifiers.includes(statement.expression.callee.object.name) &&
   !excludedIdentifiers.includes(
     `${statement.expression.callee.object.name}.${statement.expression.callee.property.name}`,
   );
 
 // Checks if a node is a VariableDeclaration with a CallExpression
-const isVariableDeclarationCallExpression = (node: TSESTree.Node, excludedIdentifiers: string[]): boolean => {
-  if (node.type !== TSESTree.AST_NODE_TYPES.VariableDeclaration || node.declarations.length === 0) {
+const isVariableDeclarationCallExpression = (
+  node: TSESTree.Node,
+  excludedIdentifiers: string[],
+): boolean => {
+  if (
+    node.type !== TSESTree.AST_NODE_TYPES.VariableDeclaration ||
+    node.declarations.length === 0
+  ) {
     return false;
   }
 
@@ -110,28 +138,43 @@ const isVariableDeclarationCallExpression = (node: TSESTree.Node, excludedIdenti
 };
 
 // Checks if an ExportNamedDeclaration has side effects
-const isExportNamedDeclarationWithSideEffects = (statement: TSESTree.Node, excludedIdentifiers: string[]): boolean =>
+const isExportNamedDeclarationWithSideEffects = (
+  statement: TSESTree.Node,
+  excludedIdentifiers: string[],
+): boolean =>
   statement.type === TSESTree.AST_NODE_TYPES.ExportNamedDeclaration &&
   statement.declaration !== null &&
   (isVariableDeclarationAwaitExpression(statement.declaration) ||
-    isVariableDeclarationCallExpression(statement.declaration, excludedIdentifiers));
+    isVariableDeclarationCallExpression(
+      statement.declaration,
+      excludedIdentifiers,
+    ));
 
 // Checks if an ExpressionStatement has side effects
-const isExpressionStatementWithSideEffects = (statement: TSESTree.Node, excludedIdentifiers: string[]): boolean =>
+const isExpressionStatementWithSideEffects = (
+  statement: TSESTree.Node,
+  excludedIdentifiers: string[],
+): boolean =>
   statement.type === TSESTree.AST_NODE_TYPES.ExpressionStatement &&
   statement.expression.type === TSESTree.AST_NODE_TYPES.CallExpression &&
   ((statement.expression.callee.type === TSESTree.AST_NODE_TYPES.Identifier &&
     !excludedIdentifiers.includes(statement.expression.callee.name)) ||
-    (statement.expression.callee.type === TSESTree.AST_NODE_TYPES.MemberExpression &&
-      statement.expression.callee.object.type === TSESTree.AST_NODE_TYPES.Identifier &&
-      statement.expression.callee.property.type === TSESTree.AST_NODE_TYPES.Identifier &&
+    (statement.expression.callee.type ===
+      TSESTree.AST_NODE_TYPES.MemberExpression &&
+      statement.expression.callee.object.type ===
+        TSESTree.AST_NODE_TYPES.Identifier &&
+      statement.expression.callee.property.type ===
+        TSESTree.AST_NODE_TYPES.Identifier &&
       !excludedIdentifiers.includes(
         `${statement.expression.callee.object.name}.${statement.expression.callee.property.name}`,
       )));
 
 // Checks if a node is a VariableDeclaration with a NewExpression
 const isVariableDeclarationNewExpression = (node: TSESTree.Node): boolean => {
-  if (node.type !== TSESTree.AST_NODE_TYPES.VariableDeclaration || node.declarations.length === 0) {
+  if (
+    node.type !== TSESTree.AST_NODE_TYPES.VariableDeclaration ||
+    node.declarations.length === 0
+  ) {
     return false;
   }
 
@@ -140,7 +183,10 @@ const isVariableDeclarationNewExpression = (node: TSESTree.Node): boolean => {
 };
 
 // Update the hasSideEffects function to return a string indicating the type of side effect
-const hasSideEffects = (statement: TSESTree.Node, excludedIdentifiers: string[]): string | null => {
+const hasSideEffects = (
+  statement: TSESTree.Node,
+  excludedIdentifiers: string[],
+): string | null => {
   if (isAwaitExpression(statement)) {
     return TSESTree.AST_NODE_TYPES.AwaitExpression;
   }
@@ -174,21 +220,22 @@ const hasSideEffects = (statement: TSESTree.Node, excludedIdentifiers: string[])
   return null;
 };
 
-const createRule: ReturnType<typeof ESLintUtils.RuleCreator> = ESLintUtils.RuleCreator((name) =>
-  getDocumentationUrl(name),
-);
+const createRule: ReturnType<typeof ESLintUtils.RuleCreator> =
+  ESLintUtils.RuleCreator((name) => getDocumentationUrl(name));
 
 const rule: ReturnType<typeof createRule> = createRule({
   name: ruleId,
   meta: {
     type: 'problem',
     docs: {
-      description: 'Ensure no side effects can occur at the module-level only if exporting module',
+      description:
+        'Ensure no side effects can occur at the module-level only if exporting module',
     },
     schema: [
       {
         type: 'object',
         properties: {
+          // eslint-disable-next-line eslint-plugin/require-meta-schema-description
           excludedIdentifiers: {
             type: 'array',
             items: { type: 'string' },
@@ -197,20 +244,22 @@ const rule: ReturnType<typeof createRule> = createRule({
         additionalProperties: false,
       },
     ],
+    defaultOptions: [{ excludedIdentifiers: [''] }],
     messages: {
       [NO_SIDE_EFFECTS]: 'No side effects can occur at the module-level',
     },
   },
-  defaultOptions: [{ excludedIdentifiers: [''] }],
   create(context) {
     const options: RuleOptions = context.options[0] as RuleOptions;
-    const excludedIdentifiers = options.excludedIdentifiers.length > 0 ? options.excludedIdentifiers : [];
+    const excludedIdentifiers =
+      options.excludedIdentifiers.length > 0 ? options.excludedIdentifiers : [];
     return {
       Program(node: TSESTree.Program) {
         const hasExport = node.body.some(
           (statement: TSESTree.Node) =>
             statement.type === TSESTree.AST_NODE_TYPES.ExportNamedDeclaration ||
-            statement.type === TSESTree.AST_NODE_TYPES.ExportDefaultDeclaration ||
+            statement.type ===
+              TSESTree.AST_NODE_TYPES.ExportDefaultDeclaration ||
             statement.type === TSESTree.AST_NODE_TYPES.ExportAllDeclaration,
         );
 

package/src/no-status-code-assert.ts

@@ -7,8 +7,13 @@
  */
 
 import { StatusCodes } from 'http-status-codes';
-import { AST_NODE_TYPES, ESLintUtils, TSESLint, TSESTree } from '@typescript-eslint/utils';
-import getDocumentationUrl from './get-documentation-url';
+import {
+  AST_NODE_TYPES,
+  ESLintUtils,
+  TSESLint,
+  TSESTree,
+} from '@typescript-eslint/utils';
+import getDocumentationUrl from './get-documentation-url.ts';
 
 export const ruleId = 'no-status-code-assert';
 const NO_STATUS_CODE_ASSERT = 'NO_STATUS_CODE_ASSERT';
@@ -31,7 +36,10 @@ const hasStatusCodeOrValue = (arg: TSESTree.Node): boolean => {
       break;
     }
     case AST_NODE_TYPES.Literal:
-      if (typeof arg.value === 'number' && Object.values(StatusCodes).includes(arg.value)) {
+      if (
+        typeof arg.value === 'number' &&
+        Object.values(StatusCodes).includes(arg.value)
+      ) {
         return true;
       }
       break;
@@ -52,19 +60,25 @@ const isAssertMemberExpression = (node: TSESTree.Node): boolean =>
   node.object.name === 'assert' &&
   node.property.type === AST_NODE_TYPES.Identifier;
 
-const isAssertCallWithStatusCode = (callee: TSESTree.Node, args: TSESTree.Node[]): boolean =>
-  (isAssertIdentifier(callee) || isAssertMemberExpression(callee)) && args.some((arg) => hasStatusCodeOrValue(arg));
+const isAssertCallWithStatusCode = (
+  callee: TSESTree.Node,
+  args: TSESTree.Node[],
+): boolean =>
+  (isAssertIdentifier(callee) || isAssertMemberExpression(callee)) &&
+  args.some((arg) => hasStatusCodeOrValue(arg));
 
 const rule: TSESLint.RuleModule<typeof NO_STATUS_CODE_ASSERT> = createRule({
   name: ruleId,
   meta: {
     type: 'problem',
     docs: {
-      description: 'Disallow using status codes in assertions; use error handling instead',
+      description:
+        'Disallow using status codes in assertions; use error handling instead',
     },
     schema: [],
     messages: {
-      [NO_STATUS_CODE_ASSERT]: 'Do not use status codes in assertions; use error handling instead',
+      [NO_STATUS_CODE_ASSERT]:
+        'Do not use status codes in assertions; use error handling instead',
     },
   },
   defaultOptions: [],

package/src/no-test-import.ts

@@ -43,12 +43,18 @@ export default {
     },
   },
   create(context) {
-    const options = { ...DEFAULT_OPTIONS, ...(context.options[0] as NoTestImportRuleOptions) };
+    const options = {
+      ...DEFAULT_OPTIONS,
+      ...(context.options[0] as NoTestImportRuleOptions),
+    };
     const testFileRegexp = new RegExp(options.testFilePattern, 'u');
 
     return {
       ImportDeclaration(node) {
-        if (typeof node.source.value === 'string' && testFileRegexp.test(node.source.value)) {
+        if (
+          typeof node.source.value === 'string' &&
+          testFileRegexp.test(node.source.value)
+        ) {
           context.report({
             node,
             messageId: NO_TEST_IMPORT,

package/src/no-util.ts

@@ -35,7 +35,9 @@ const rule: ESLintUtils.RuleModule<typeof NO_UTIL> = createRule({
           const sourceCode = context.sourceCode;
           const tokens = sourceCode.tokensAndComments;
           const firstNonCommentToken = tokens.find(
-            (token) => token.type !== AST_TOKEN_TYPES.Block && token.type !== AST_TOKEN_TYPES.Line,
+            (token) =>
+              token.type !== AST_TOKEN_TYPES.Block &&
+              token.type !== AST_TOKEN_TYPES.Line,
           );
           if (firstNonCommentToken !== undefined) {
             context.report({

package/src/no-uuid.ts

@@ -11,9 +11,15 @@ import type { Rule } from 'eslint';
 
 const UUID_FOUND = 'UUID_FOUND';
 const UUIDS_FOUND = 'UUIDS_FOUND';
-const uuidRegex = /[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}/gmu;
+const uuidRegex =
+  /[0-9a-fA-F]{8}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{4}\b-[0-9a-fA-F]{12}/gmu;
 
-function checkForUuid(value: string, context: Rule.RuleContext, node?: Node, loc?: SourceLocation) {
+function checkForUuid(
+  value: string,
+  context: Rule.RuleContext,
+  node?: Node,
+  loc?: SourceLocation,
+) {
   const matches = value.match(uuidRegex);
   if (matches === null) {
     return;

package/src/no-wallaby-comment.ts

@@ -9,9 +9,17 @@
 import type { Rule, SourceCode } from 'eslint';
 import type { Comment } from 'estree';
 
+// eslint-disable-next-line sonarjs/slow-regex
 const wallabyRegex = /(?<=(?:^|\*\/)\s*)[?]{1,2}|file\.only|file\.skip/gu;
-const commentRegex = /\s*(?:\/\/|<!--)\s*(?<comment>\?{1,2}\.?\s*|file\.(?:only|skip))\s*/gu;
-function removeWallabyComment(context: Rule.RuleContext, sourceCode: SourceCode, start: number, end: number): void {
+const commentRegex =
+  // eslint-disable-next-line sonarjs/slow-regex
+  /\s*(?:\/\/|<!--)\s*(?:\?{1,2}\.?\s*|file\.(?:only|skip))\s*/gu;
+function removeWallabyComment(
+  context: Rule.RuleContext,
+  sourceCode: SourceCode,
+  start: number,
+  end: number,
+): void {
   context.report({
     loc: {
       start: sourceCode.getLocFromIndex(start),
@@ -22,21 +30,35 @@ function removeWallabyComment(context: Rule.RuleContext, sourceCode: SourceCode,
   });
 }
 
-function processLineComment(context: Rule.RuleContext, sourceCode: SourceCode, comment: Comment): void {
+function processLineComment(
+  context: Rule.RuleContext,
+  sourceCode: SourceCode,
+  comment: Comment,
+): void {
   if (comment.loc) {
     const line = sourceCode.getLines()[comment.loc.start.line - 1];
     if (line !== undefined) {
       let match;
       while ((match = commentRegex.exec(line)) !== null) {
-        const start = sourceCode.getIndexFromLoc({ line: comment.loc.start.line, column: match.index });
-        const end = sourceCode.getIndexFromLoc({ line: comment.loc.start.line, column: comment.loc.end.column });
+        const start = sourceCode.getIndexFromLoc({
+          line: comment.loc.start.line,
+          column: match.index,
+        });
+        const end = sourceCode.getIndexFromLoc({
+          line: comment.loc.start.line,
+          column: comment.loc.end.column,
+        });
         removeWallabyComment(context, sourceCode, start, end);
       }
     }
   }
 }
 
-function processBlockComment(context: Rule.RuleContext, sourceCode: SourceCode, comment: Comment): void {
+function processBlockComment(
+  context: Rule.RuleContext,
+  sourceCode: SourceCode,
+  comment: Comment,
+): void {
   const commentValues = comment.value.split('\n');
   const blockCommentRegex = /^(?:\s*\*\s*)?(?:file\.only|file\.skip)$/gu;
   commentValues.forEach((commentValue) => {
@@ -49,8 +71,14 @@ function processBlockComment(context: Rule.RuleContext, sourceCode: SourceCode,
     while (comment.loc && (match = wallabyRegex.exec(commentValue)) !== null) {
       const removeEntireComment = blockCommentRegex.test(comment.value.trim());
       if (removeEntireComment) {
-        start = sourceCode.getIndexFromLoc({ line: comment.loc.start.line, column: comment.loc.start.column });
-        end = sourceCode.getIndexFromLoc({ line: comment.loc.end.line, column: comment.loc.end.column });
+        start = sourceCode.getIndexFromLoc({
+          line: comment.loc.start.line,
+          column: comment.loc.start.column,
+        });
+        end = sourceCode.getIndexFromLoc({
+          line: comment.loc.end.line,
+          column: comment.loc.end.column,
+        });
       } else {
         let lineNumber = 0;
         while (startLine <= endLine) {
@@ -61,7 +89,10 @@ function processBlockComment(context: Rule.RuleContext, sourceCode: SourceCode,
           }
           startLine++;
         }
-        start = sourceCode.getIndexFromLoc({ line: lineNumber + 1, column: comment.loc.start.column });
+        start = sourceCode.getIndexFromLoc({
+          line: lineNumber + 1,
+          column: comment.loc.start.column,
+        });
         end = sourceCode.getIndexFromLoc({ line: lineNumber + 2, column: 0 });
       }
       removeWallabyComment(context, sourceCode, start, end);

package/src/object-literal-response.ts

@@ -9,10 +9,12 @@
 import type { CallExpression, Property } from 'estree';
 import type { Rule } from 'eslint';
 
-export const REQUIRE_OBJECT_LITERAL_MESSAGE_ID = 'REQUIRE_OBJECT_LITERAL_MESSAGE_ID';
+export const REQUIRE_OBJECT_LITERAL_MESSAGE_ID =
+  'REQUIRE_OBJECT_LITERAL_MESSAGE_ID';
 export const REQUIRE_OBJECT_LITERAL_FOR_ERROR_RESPONSE_MESSAGE_ID =
   'REQUIRE_OBJECT_LITERAL_FOR_ERROR_RESPONSE_MESSAGE_ID';
-export const REQUIRE_OBJECT_LITERAL_FOR_HEADERS_MESSAGE_ID = 'REQUIRE_OBJECT_LITERAL_FOR_HEADERS_MESSAGE_ID';
+export const REQUIRE_OBJECT_LITERAL_FOR_HEADERS_MESSAGE_ID =
+  'REQUIRE_OBJECT_LITERAL_FOR_HEADERS_MESSAGE_ID';
 
 // eslint-disable-next-line no-magic-numbers
 const GOOD_STATUS_VALUES = [200, 201, 202, 203, 204, 205, 206, 207];
@@ -47,7 +49,10 @@ export default {
     return {
       // eslint-disable-next-line sonarjs/cognitive-complexity
       CallExpression(node: CallExpression) {
-        if (node.callee.type === 'Identifier' && node.callee.name === 'setResponse') {
+        if (
+          node.callee.type === 'Identifier' &&
+          node.callee.name === 'setResponse'
+        ) {
           const responseContext = node.arguments[1];
 
           // check top level object literal
@@ -62,9 +67,14 @@ export default {
           if (responseContext?.type === 'ObjectExpression') {
             const headers = responseContext.properties.find(
               (property) =>
-                property.type === 'Property' && property.key.type === 'Identifier' && property.key.name === 'headers',
+                property.type === 'Property' &&
+                property.key.type === 'Identifier' &&
+                property.key.name === 'headers',
             ) as Property | undefined;
-            if (headers !== undefined && headers.value.type !== 'ObjectExpression') {
+            if (
+              headers !== undefined &&
+              headers.value.type !== 'ObjectExpression'
+            ) {
               context.report({
                 node: headers,
                 messageId: REQUIRE_OBJECT_LITERAL_FOR_HEADERS_MESSAGE_ID,
@@ -76,7 +86,9 @@ export default {
           if (responseContext?.type === 'ObjectExpression') {
             const status = responseContext.properties.find(
               (property) =>
-                property.type === 'Property' && property.key.type === 'Identifier' && property.key.name === 'status',
+                property.type === 'Property' &&
+                property.key.type === 'Identifier' &&
+                property.key.name === 'status',
             ) as Property;
             let isSuccessfulResponse;
             if (status.value.type === 'MemberExpression') {
@@ -87,13 +99,16 @@ export default {
                 GOOD_STATUS_ENUM_NAMES.includes(status.value.property.name);
             } else if (status.value.type === 'Literal') {
               isSuccessfulResponse =
-                typeof status.value.value === 'number' && GOOD_STATUS_VALUES.includes(status.value.value);
+                typeof status.value.value === 'number' &&
+                GOOD_STATUS_VALUES.includes(status.value.value);
             }
             if (isSuccessfulResponse === false) {
               // handle error response
               const body = responseContext.properties.find(
                 (property) =>
-                  property.type === 'Property' && property.key.type === 'Identifier' && property.key.name === 'body',
+                  property.type === 'Property' &&
+                  property.key.type === 'Identifier' &&
+                  property.key.name === 'body',
               ) as Property | undefined;
               if (body === undefined) {
                 return; // no body to lint for
@@ -102,7 +117,8 @@ export default {
               if (body.value.type !== 'ObjectExpression') {
                 context.report({
                   node: body,
-                  messageId: REQUIRE_OBJECT_LITERAL_FOR_ERROR_RESPONSE_MESSAGE_ID,
+                  messageId:
+                    REQUIRE_OBJECT_LITERAL_FOR_ERROR_RESPONSE_MESSAGE_ID,
                 });
               }
             }

package/src/regular-expression-comment.ts

@@ -12,7 +12,8 @@ export default {
   meta: {
     type: 'problem',
     docs: {
-      description: 'Require comments for regular expressions before or on the same line',
+      description:
+        'Require comments for regular expressions before or on the same line',
       url: 'https://github.com/checkdigit/eslint-plugin',
     },
   },
@@ -27,7 +28,9 @@ export default {
           const previousLineComment = lines[previousLine - 1];
 
           // Check if the regular expression contains any simple text
-          const isSimpleTextPattern = /^[0-9:./,\sa-zA-Z-]*$/gu.test(node.value.source);
+          const isSimpleTextPattern = /^[0-9:./,\sa-zA-Z-]*$/gu.test(
+            node.value.source,
+          );
           if (isSimpleTextPattern) {
             return;
           }
@@ -40,7 +43,10 @@ export default {
             // This regex is to check if the line starts with or without spaces and followed by two or more consecutive slashes // or start with /* and may have one or more asterisks, continuing until the first occurrence of */.
             const commentRegularExpressionLine = /^\s*(?:\/{2,}|\/\*+)/gu;
             const hasComment = regularExpression.test(comment.value.trim());
-            if (comment.type === 'Line' || comment.loc.start.line === comment.loc.end.line) {
+            if (
+              comment.type === 'Line' ||
+              comment.loc.start.line === comment.loc.end.line
+            ) {
               return (
                 (comment.loc.end.line === previousLine &&
                   previousLineComment !== undefined &&