eslint-plugin-complete 1.0.9 → 1.0.11

package/dist/comments.js

@@ -18,27 +18,27 @@ export function isEnumBlockLabel(text) {
     text = text.trim();
     return (
     // e.g. CollectibleType.SAD_ONION
-    /^\w+\.\w+$/.test(text) ||
+    /^\w+\.\w+$/.test(text)
         // e.g. CollectibleType.SAD_ONION (1)
-        /^\w+\.\w+ \(\d+\)$/.test(text) ||
+        || /^\w+\.\w+ \(\d+\)$/.test(text)
         // e.g. CacheFlag.FIRE_DELAY (1 << 1)
-        /^\w+\.\w+ \(\d+ << \d+\)$/.test(text) ||
+        || /^\w+\.\w+ \(\d+ << \d+\)$/.test(text)
         // e.g. 1
-        /^\d+$/.test(text) ||
+        || /^\d+$/.test(text)
         // e.g. 1.0
-        /^\d+\.\d+$/.test(text) ||
+        || /^\d+\.\d+$/.test(text)
         // e.g. 1 << 1
-        /^\d+ << \d+$/.test(text) ||
+        || /^\d+ << \d+$/.test(text)
         // e.g. 1, 2, 3, 4, 5
-        /^\d+, \d+$/.test(text) ||
-        /^\d+, \d+, \d+$/.test(text) ||
-        /^(?:\d+, ){3}\d+$/.test(text) ||
-        /^(?:\d+, ){4}\d+$/.test(text) ||
+        || /^\d+, \d+$/.test(text)
+        || /^\d+, \d+, \d+$/.test(text)
+        || /^(?:\d+, ){3}\d+$/.test(text)
+        || /^(?:\d+, ){4}\d+$/.test(text)
         // e.g. 1.0, 2.0, 3.0, 4.0, 5.0
-        /^\d+\.\d+, \d+\.\d+$/.test(text) ||
-        /^(?:\d+\.\d+, ){2}\d+\.\d+$/.test(text) ||
-        /^(?:\d+\.\d+, ){3}\d+\.\d+$/.test(text) ||
-        /^(?:\d+\.\d+, ){4}\d+\.\d+$/.test(text));
+        || /^\d+\.\d+, \d+\.\d+$/.test(text)
+        || /^(?:\d+\.\d+, ){2}\d+\.\d+$/.test(text)
+        || /^(?:\d+\.\d+, ){3}\d+\.\d+$/.test(text)
+        || /^(?:\d+\.\d+, ){4}\d+\.\d+$/.test(text));
 }
 /**
  * A "separator" line is a line with all hyphens like the following:
@@ -54,14 +54,14 @@ export function isSeparatorLine(text) {
 }
 export function isSpecialComment(text) {
     text = text.trim();
-    return (text.startsWith("eslint-") ||
-        text.startsWith("prettier-") ||
-        text.startsWith("cspell:") ||
-        text.startsWith("ts-prune-") || // e.g. ts-prune-ignore-next
-        text.startsWith("@ts-") ||
-        text.startsWith("@template-") || // e.g. @template-customization-start (complete-cli directives)
-        text.startsWith("TODO:") ||
-        text.startsWith("FIXME:") ||
-        text === "TODO" ||
-        text === "FIXME");
+    return (text.startsWith("eslint-")
+        || text.startsWith("prettier-")
+        || text.startsWith("cspell:")
+        || text.startsWith("ts-prune-") // e.g. ts-prune-ignore-next
+        || text.startsWith("@ts-")
+        || text.startsWith("@template-") // e.g. @template-customization-start (complete-cli directives)
+        || text.startsWith("TODO:")
+        || text.startsWith("FIXME:")
+        || text === "TODO"
+        || text === "FIXME");
 }

package/dist/completeCommon.js

@@ -40,9 +40,9 @@ export function isFirstLetterCapitalized(string) {
  * `!Array.isArray(variable)`.
  */
 export function isObject(variable) {
-    return (typeof variable === "object" &&
-        variable !== null &&
-        !Array.isArray(variable));
+    return (typeof variable === "object"
+        && variable !== null
+        && !Array.isArray(variable));
 }
 /**
  * Helper function to trim a prefix from a string, if it exists. Returns the trimmed string.

package/dist/completeSentence.js

@@ -160,28 +160,28 @@ function getIncompleteSentenceKind(sentence, isLoneSentence) {
     // Ignore / whitelist some specific things.
     if (
     // Blank text.
-    text === "" ||
+    text === ""
         // Sentences that do not contain any letters.
-        !/[A-Za-z]/.test(text) ||
+        || !/[A-Za-z]/.test(text)
         // Sentences with an arrow, like: "Alice --> Bob"
-        text.includes("-->") ||
+        || text.includes("-->")
         // Placeholder text.
-        text === "n/a" ||
+        || text === "n/a"
         // Special comments.
-        isSpecialComment(text) ||
+        || isSpecialComment(text)
         // Dates.
-        isDate(text) ||
+        || isDate(text)
         // URLS.
-        hasURL(text) ||
+        || hasURL(text)
         // Single JSDoc tags.
-        /^@\w+$/.test(text) ||
+        || /^@\w+$/.test(text)
         // Lists.
-        text.startsWith(LIST_ELEMENT_IDENTIFIER) ||
+        || text.startsWith(LIST_ELEMENT_IDENTIFIER)
         // Code blocks.
-        text.includes("```") ||
+        || text.includes("```")
         // Sentences that end with a number in parenthesis (which indicates some kind of expression).
         // This must check the original text.
-        / \(\d+\)$/.test(sentence.trimEnd())) {
+        || / \(\d+\)$/.test(sentence.trimEnd())) {
         return undefined;
     }
     // First, check for a double period.
@@ -191,9 +191,11 @@ function getIncompleteSentenceKind(sentence, isLoneSentence) {
             return "doublePeriod";
         }
     }
-    if (isLoneSentence &&
+    if (isLoneSentence
         // Single words, double words, and triple words.
-        (/^\S+$/.test(text) || /^\S+ \S+$/.test(text) || /^\S+ \S+ \S+$/.test(text))) {
+        && (/^\S+$/.test(text)
+            || /^\S+ \S+$/.test(text)
+            || /^\S+ \S+ \S+$/.test(text))) {
         return undefined;
     }
     if (/^[a-z]/.test(text) && !isCapitalizedWordException(text)) {
@@ -201,23 +203,23 @@ function getIncompleteSentenceKind(sentence, isLoneSentence) {
     }
     if (
     // Allow normal end-of-line punctuation.
-    !text.endsWith(".") &&
-        !text.endsWith("!") &&
-        !text.endsWith("?") &&
+    !text.endsWith(".")
+        && !text.endsWith("!")
+        && !text.endsWith("?")
         // Allow ending with a period inside of a single quote or double quote, since it is implied that
         // this is a fully quoted sentence.
-        !text.endsWith('."') &&
-        !text.endsWith('!"') &&
-        !text.endsWith('?"') &&
-        !text.endsWith(".'") &&
-        !text.endsWith("!'") &&
-        !text.endsWith("?'") &&
+        && !text.endsWith('."')
+        && !text.endsWith('!"')
+        && !text.endsWith('?"')
+        && !text.endsWith(".'")
+        && !text.endsWith("!'")
+        && !text.endsWith("?'")
         // Allow ending with a colon, since it is implied that there is an example of something on the
         // subsequent block.
-        !text.endsWith(":") &&
+        && !text.endsWith(":")
         // Allow ending with anything if there is a colon in the middle of the sentence, since it is
         // implied that this is an example of something.
-        !text.includes(": ")) {
+        && !text.includes(": ")) {
         return "missingPeriod";
     }
     return undefined;
@@ -246,20 +248,20 @@ function isDate(text) {
     const match1 = text.match(/^(?<month>\w+) \d+(?<ordinal>\w+)$/);
     if (match1 !== null && match1.groups !== undefined) {
         const { month, ordinal } = match1.groups;
-        if (month !== undefined &&
-            MONTHS_SET.has(month) &&
-            ordinal !== undefined &&
-            ORDINALS_SET.has(ordinal)) {
+        if (month !== undefined
+            && MONTHS_SET.has(month)
+            && ordinal !== undefined
+            && ORDINALS_SET.has(ordinal)) {
             return true;
         }
     }
     const match2 = text.match(/^(?<month>\w+) \d+(?<ordinal>\w+), \d+$/);
     if (match2 !== null && match2.groups !== undefined) {
         const { month, ordinal } = match2.groups;
-        if (month !== undefined &&
-            MONTHS_SET.has(month) &&
-            ordinal !== undefined &&
-            ORDINALS_SET.has(ordinal)) {
+        if (month !== undefined
+            && MONTHS_SET.has(month)
+            && ordinal !== undefined
+            && ORDINALS_SET.has(ordinal)) {
             return true;
         }
     }

package/dist/format.js

@@ -66,26 +66,26 @@ export function formatText(text, maxLength, shouldParseJSDocTags = true) {
             // Append the blank line, but ignore multiple blank lines in a row (unless we are inside of a
             // code block).
             const lastCharacter = formattedText.at(-1);
-            if ((lastCharacter !== undefined && lastCharacter !== "\n") ||
-                insideCodeBlock) {
+            if ((lastCharacter !== undefined && lastCharacter !== "\n")
+                || insideCodeBlock) {
                 formattedText += "\n";
             }
             insideList = undefined;
             continue;
         }
         // Handle code blocks. This case is simple because we need to exactly preserve the text.
-        if (hasCodeBlock ||
-            previousLineHasCodeBlock ||
-            insideCodeBlock ||
-            insideExampleTagBlock) {
+        if (hasCodeBlock
+            || previousLineHasCodeBlock
+            || insideCodeBlock
+            || insideExampleTagBlock) {
             // Append the partial line that we were building, if any.
             [formattedLine, formattedText] = appendLineToText(formattedLine, formattedText);
             // Enforce newlines before the beginning of code blocks. (But not inside of an example code
             // block, because there should not be newlines between tags.)
-            if (hasCodeBlock &&
-                !previousLineInsideCodeBlock &&
-                !previousLineWasBlank &&
-                !insideExampleTagBlock) {
+            if (hasCodeBlock
+                && !previousLineInsideCodeBlock
+                && !previousLineWasBlank
+                && !insideExampleTagBlock) {
                 formattedText += "\n";
             }
             // Copy the line exactly.
@@ -94,10 +94,10 @@ export function formatText(text, maxLength, shouldParseJSDocTags = true) {
             // because there should not be newlines between tags.)
             const nextLine = lines[i + 1];
             const nextLineIsBlank = nextLine === undefined || nextLine.trim() === "";
-            if (hasCodeBlock &&
-                previousLineInsideCodeBlock &&
-                !nextLineIsBlank &&
-                !insideExampleTagBlock) {
+            if (hasCodeBlock
+                && previousLineInsideCodeBlock
+                && !nextLineIsBlank
+                && !insideExampleTagBlock) {
                 // Append the partial line that we were building, if any.
                 [formattedLine, formattedText] = appendLineToText(formattedLine, formattedText);
                 formattedText += "\n";
@@ -131,30 +131,30 @@ export function formatText(text, maxLength, shouldParseJSDocTags = true) {
         }
         // Lists and some other specific text elements indicate that we should always insert a new line,
         // even if the text has no wrapped to the end of the ruler yet.
-        if (list !== undefined ||
-            lineHasURL ||
-            previousLineHadURL ||
-            hasExample ||
-            separatorLine ||
-            previousLineWasSeparatorLine ||
-            enumBlockLabel ||
-            previousLineWasEnumBlockLabel) {
+        if (list !== undefined
+            || lineHasURL
+            || previousLineHadURL
+            || hasExample
+            || separatorLine
+            || previousLineWasSeparatorLine
+            || enumBlockLabel
+            || previousLineWasEnumBlockLabel) {
             // Append the partial line that we were building, if any.
             [formattedLine, formattedText] = appendLineToText(formattedLine, formattedText);
         }
         // Keep track of when we first encounter JSDoc tags. (JSDoc comments can be thought of as having
         // an "description" or "introductory" section at the top, and then a list of JSDoc tags at the
         // bottom.)
-        if (shouldParseJSDocTags &&
-            !encounteredJSDocTags &&
-            list !== undefined &&
-            list.kind === ListKind.JSDocTag) {
+        if (shouldParseJSDocTags
+            && !encounteredJSDocTags
+            && list !== undefined
+            && list.kind === ListKind.JSDocTag) {
             encounteredJSDocTags = true;
             // Enforce a newline between a JSDoc description (i.e. introductory text) and the first JSDoc
             // tag.
-            if (!stringContainsOnlyWhitespace(formattedText) &&
-                !previousLineWasBlank &&
-                !previousLineInsideExampleTagBlock) {
+            if (!stringContainsOnlyWhitespace(formattedText)
+                && !previousLineWasBlank
+                && !previousLineInsideExampleTagBlock) {
                 // Append the partial line that we were building, if any.
                 [formattedLine, formattedText] = appendLineToText(formattedLine, formattedText);
                 formattedText += "\n";
@@ -226,10 +226,10 @@ function appendLineToText(formattedLine, formattedText) {
 }
 function startsWithExample(text) {
     const trimmedText = text.trimStart();
-    return (trimmedText.startsWith("e.g. ") ||
-        trimmedText.startsWith("(e.g. ") ||
-        trimmedText.startsWith("i.e. ") ||
-        trimmedText.startsWith("(i.e. "));
+    return (trimmedText.startsWith("e.g. ")
+        || trimmedText.startsWith("(e.g. ")
+        || trimmedText.startsWith("i.e. ")
+        || trimmedText.startsWith("(i.e. "));
 }
 function stringContainsOnlyWhitespace(string) {
     return string.trim() === "";

package/dist/jsdoc.js

@@ -1,7 +1,7 @@
 import { TSESTree } from "@typescript-eslint/utils";
 export function getJSDocComments(comments) {
-    return comments.filter((comment) => comment.type === TSESTree.AST_TOKEN_TYPES.Block && // i.e. a "/*" comment
-        comment.value.startsWith("*"));
+    return comments.filter((comment) => comment.type === TSESTree.AST_TOKEN_TYPES.Block // i.e. a "/*" comment
+        && comment.value.startsWith("*"));
 }
 export function getTextFromJSDocComment(comment) {
     comment = comment.trim();

package/dist/leadingLineComments.js

@@ -1,10 +1,10 @@
 import { TSESTree } from "@typescript-eslint/utils";
 import { isCommentOnOwnLine, isSeparatorLine } from "./comments.js";
 export function getLeadingLineComments(sourceCode, comments) {
-    return comments.filter((comment) => comment.type === TSESTree.AST_TOKEN_TYPES.Line && // i.e. a "//" comment
-        comment.value.trim() !== "" &&
-        !comment.value.startsWith("/") && // Filter out triple slash directives
-        isCommentOnOwnLine(sourceCode, comment));
+    return comments.filter((comment) => comment.type === TSESTree.AST_TOKEN_TYPES.Line // i.e. a "//" comment
+        && comment.value.trim() !== ""
+        && !comment.value.startsWith("/") // Filter out triple slash directives
+        && isCommentOnOwnLine(sourceCode, comment));
 }
 /**
  * Returns an array of grouped comments. For example, the following code would return an array of

package/dist/list.js

@@ -60,9 +60,9 @@ function getList(line) {
     }
     /** e.g. "1. A bullet point can start with a number and a period." */
     const numberPeriodMatch = line.match(/^(\d+)\. /);
-    if (numberPeriodMatch !== null &&
-        numberPeriodMatch[1] !== undefined &&
-        numberPeriodMatch[1] !== "0") {
+    if (numberPeriodMatch !== null
+        && numberPeriodMatch[1] !== undefined
+        && numberPeriodMatch[1] !== "0") {
         return {
             kind: ListKind.NumberPeriod,
             numLeadingSpaces,
@@ -71,9 +71,9 @@ function getList(line) {
     }
     /** e.g. "1) A bullet point can start with a number and a parenthesis." */
     const numberParenthesisMatch = line.match(/^(\d+)\) /);
-    if (numberParenthesisMatch !== null &&
-        numberParenthesisMatch[1] !== undefined &&
-        numberParenthesisMatch[1] !== "0") {
+    if (numberParenthesisMatch !== null
+        && numberParenthesisMatch[1] !== undefined
+        && numberParenthesisMatch[1] !== "0") {
         return {
             kind: ListKind.NumberParenthesis,
             numLeadingSpaces,
@@ -133,8 +133,8 @@ export function reachedNewList(insideList, list) {
     if (list === undefined) {
         return false;
     }
-    return (insideList === undefined || // Going from a non-list to list
-        insideList.numLeadingSpaces !== list.numLeadingSpaces || // Going from a list to a sub-list
-        insideList.jsDocTagName !== list.jsDocTagName // Going from a JSDoc to a different JSDoc tag
+    return (insideList === undefined // Going from a non-list to list
+        || insideList.numLeadingSpaces !== list.numLeadingSpaces // Going from a list to a sub-list
+        || insideList.jsDocTagName !== list.jsDocTagName // Going from a JSDoc to a different JSDoc tag
     );
 }

package/dist/rules/complete-sentences-line-comments.js

@@ -39,13 +39,13 @@ export const completeSentencesLineComments = createRule({
             }
             // Comments in-between "separator lines" are whitelisted.
             const previousCommentBlock = commentBlocks[i - 1];
-            if (previousCommentBlock !== undefined &&
-                isSeparatorLine(previousCommentBlock.mergedText)) {
+            if (previousCommentBlock !== undefined
+                && isSeparatorLine(previousCommentBlock.mergedText)) {
                 continue;
             }
             const nextCommentBlock = commentBlocks[i + 1];
-            if (nextCommentBlock !== undefined &&
-                isSeparatorLine(nextCommentBlock.mergedText)) {
+            if (nextCommentBlock !== undefined
+                && isSeparatorLine(nextCommentBlock.mergedText)) {
                 continue;
             }
             // Unlike JSDoc comments, we want to whitelist comment blocks that begin with JavaScript

package/dist/rules/format-jsdoc-comments.js

@@ -98,9 +98,9 @@ export const formatJSDocComments = createRule({
  */
 function canFitOnSingleJSDocLine(text, effectiveMaxLength) {
     const textLines = text.split("\n");
-    return (textLines.length === 1 &&
-        text.length + EXTRA_NUM_CHARACTERS_TO_FIT_ON_JSDOC_SINGLE_LINE <=
-            effectiveMaxLength);
+    return (textLines.length === 1
+        && text.length + EXTRA_NUM_CHARACTERS_TO_FIT_ON_JSDOC_SINGLE_LINE
+            <= effectiveMaxLength);
 }
 function getJSDocCommentSingleLine(text, leftWhitespace) {
     return `${leftWhitespace}/** ${text} */`;

package/dist/rules/no-empty-line-comments.js

@@ -23,8 +23,8 @@ export const noEmptyLineComments = createRule({
      */
     create(context) {
         const comments = context.sourceCode.getAllComments();
-        const emptyLeadingLineComments = comments.filter((comment) => comment.type === TSESTree.AST_TOKEN_TYPES.Line && // i.e. a "//" comment
-            comment.value.trim() === "");
+        const emptyLeadingLineComments = comments.filter((comment) => comment.type === TSESTree.AST_TOKEN_TYPES.Line // i.e. a "//" comment
+            && comment.value.trim() === "");
         for (const comment of emptyLeadingLineComments) {
             context.report({
                 loc: {

package/dist/rules/no-mutable-return.js

@@ -53,9 +53,9 @@ function getErrorMessageId(type) {
         return undefined;
     }
     // Handle unwrapping promises.
-    if (typeName === "Promise" &&
-        isTypeReferenceType(type) &&
-        type.typeArguments !== undefined) {
+    if (typeName === "Promise"
+        && isTypeReferenceType(type)
+        && type.typeArguments !== undefined) {
         const typeArgument = type.typeArguments[0];
         if (typeArgument !== undefined) {
             return getErrorMessageId(typeArgument);

package/dist/rules/no-object-methods-with-map-set.js

@@ -46,14 +46,14 @@ export const noObjectMethodsWithMapSet = createRule({
                 }
                 // Second, check if the object is `Object`.
                 const { object } = callee;
-                if (object.type !== AST_NODE_TYPES.Identifier ||
-                    object.name !== "Object") {
+                if (object.type !== AST_NODE_TYPES.Identifier
+                    || object.name !== "Object") {
                     return;
                 }
                 // Third, check if this is one of the problem methods.
                 const { property } = callee;
-                if (property.type !== AST_NODE_TYPES.Identifier ||
-                    !PROBLEM_METHODS.has(property.name)) {
+                if (property.type !== AST_NODE_TYPES.Identifier
+                    || !PROBLEM_METHODS.has(property.name)) {
                     return;
                 }
                 const methodName = property.name;

package/dist/rules/no-string-length-0.js

@@ -24,8 +24,8 @@ export const noStringLength0 = createRule({
             if (node.type !== AST_NODE_TYPES.MemberExpression) {
                 return false;
             }
-            if (node.property.type !== AST_NODE_TYPES.Identifier ||
-                node.property.name !== "length") {
+            if (node.property.type !== AST_NODE_TYPES.Identifier
+                || node.property.name !== "length") {
                 return false;
             }
             const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node.object);
@@ -36,8 +36,8 @@ export const noStringLength0 = createRule({
         }
         return {
             BinaryExpression(node) {
-                if ((is0(node.left) && isStringLength(node.right)) ||
-                    (is0(node.right) && isStringLength(node.left))) {
+                if ((is0(node.left) && isStringLength(node.right))
+                    || (is0(node.right) && isStringLength(node.left))) {
                     context.report({
                         node,
                         messageId: "noStringLength0",

package/dist/rules/no-template-curly-in-string-fix.js

@@ -23,8 +23,8 @@ export const noTemplateCurlyInStringFix = createRule({
     create(context) {
         return {
             Literal(node) {
-                if (typeof node.value === "string" &&
-                    ERRONEOUS_TEMPLATE_STRING_REGEX.test(node.value)) {
+                if (typeof node.value === "string"
+                    && ERRONEOUS_TEMPLATE_STRING_REGEX.test(node.value)) {
                     context.report({
                         node,
                         messageId: "unexpectedTemplateExpression",

package/dist/rules/no-unnecessary-assignment.js

@@ -97,8 +97,8 @@ export const noUnnecessaryAssignment = createRule({
             const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
             const type = checker.getTypeAtLocation(tsNode);
             const types = unionTypeParts(type);
-            return (types.some((t) => isFlagSet(t.flags, ts.TypeFlags.Null)) &&
-                !types.some((t) => isFlagSet(t.flags, ts.TypeFlags.Undefined)));
+            return (types.some((t) => isFlagSet(t.flags, ts.TypeFlags.Null))
+                && !types.some((t) => isFlagSet(t.flags, ts.TypeFlags.Undefined)));
         }
         function hasUndefinedAndNotNull(node) {
             if (isUndefined(node)) {
@@ -107,8 +107,8 @@ export const noUnnecessaryAssignment = createRule({
             const tsNode = parserServices.esTreeNodeToTSNodeMap.get(node);
             const type = checker.getTypeAtLocation(tsNode);
             const types = unionTypeParts(type);
-            return (types.some((t) => isFlagSet(t.flags, ts.TypeFlags.Undefined)) &&
-                !types.some((t) => isFlagSet(t.flags, ts.TypeFlags.Null)));
+            return (types.some((t) => isFlagSet(t.flags, ts.TypeFlags.Undefined))
+                && !types.some((t) => isFlagSet(t.flags, ts.TypeFlags.Null)));
         }
         function checkEqualSign(node) {
             const leftTSNode = parserServices.esTreeNodeToTSNodeMap.get(node.left);
@@ -129,9 +129,9 @@ export const noUnnecessaryAssignment = createRule({
                 if (node.operator === "=") {
                     checkEqualSign(node);
                 }
-                else if (USELESS_ASSIGNMENT_OPERATORS_WITH_ZERO.has(node.operator) &&
-                    isNumber(node.left) &&
-                    isLiteralZero(node.right)) {
+                else if (USELESS_ASSIGNMENT_OPERATORS_WITH_ZERO.has(node.operator)
+                    && isNumber(node.left)
+                    && isLiteralZero(node.right)) {
                     context.report({
                         loc: node.loc,
                         messageId: "unnecessaryZero",
@@ -140,9 +140,9 @@ export const noUnnecessaryAssignment = createRule({
                         },
                     });
                 }
-                else if (node.operator === "+=" &&
-                    isString(node.left) &&
-                    isLiteralEmptyString(node.right)) {
+                else if (node.operator === "+="
+                    && isString(node.left)
+                    && isLiteralEmptyString(node.right)) {
                     context.report({
                         loc: node.loc,
                         messageId: "unnecessaryEmptyString",
@@ -150,9 +150,9 @@ export const noUnnecessaryAssignment = createRule({
                 }
             },
             BinaryExpression(node) {
-                if (USELESS_OPERATORS_WITH_ZERO.has(node.operator) &&
-                    ((isNumber(node.left) && isLiteralZero(node.right)) ||
-                        (isNumber(node.right) && isLiteralZero(node.left)))) {
+                if (USELESS_OPERATORS_WITH_ZERO.has(node.operator)
+                    && ((isNumber(node.left) && isLiteralZero(node.right))
+                        || (isNumber(node.right) && isLiteralZero(node.left)))) {
                     context.report({
                         loc: node.loc,
                         messageId: "unnecessaryZero",
@@ -162,9 +162,9 @@ export const noUnnecessaryAssignment = createRule({
                     });
                 }
                 // Plus is the only operator valid for strings.
-                if (node.operator === "+" &&
-                    ((isString(node.left) && isLiteralEmptyString(node.right)) ||
-                        (isString(node.right) && isLiteralEmptyString(node.left)))) {
+                if (node.operator === "+"
+                    && ((isString(node.left) && isLiteralEmptyString(node.right))
+                        || (isString(node.right) && isLiteralEmptyString(node.left)))) {
                     context.report({
                         loc: node.loc,
                         messageId: "unnecessaryEmptyString",
@@ -173,13 +173,13 @@ export const noUnnecessaryAssignment = createRule({
             },
             LogicalExpression(node) {
                 const { parent } = node;
-                if (parent.type !== AST_NODE_TYPES.AssignmentExpression &&
-                    parent.type !== AST_NODE_TYPES.VariableDeclarator) {
+                if (parent.type !== AST_NODE_TYPES.AssignmentExpression
+                    && parent.type !== AST_NODE_TYPES.VariableDeclarator) {
                     return;
                 }
-                if (node.operator === "||" &&
-                    isBoolean(node.left) &&
-                    isFalse(node.right)) {
+                if (node.operator === "||"
+                    && isBoolean(node.left)
+                    && isFalse(node.right)) {
                     context.report({
                         loc: node.loc,
                         messageId: "unnecessaryShortCircuit",
@@ -188,9 +188,9 @@ export const noUnnecessaryAssignment = createRule({
                         },
                     });
                 }
-                if (node.operator === "&&" &&
-                    isBoolean(node.left) &&
-                    isTrue(node.right)) {
+                if (node.operator === "&&"
+                    && isBoolean(node.left)
+                    && isTrue(node.right)) {
                     context.report({
                         loc: node.loc,
                         messageId: "unnecessaryShortCircuit",
@@ -199,9 +199,9 @@ export const noUnnecessaryAssignment = createRule({
                         },
                     });
                 }
-                if (node.operator === "||" &&
-                    isNumber(node.left) &&
-                    isZero(node.right)) {
+                if (node.operator === "||"
+                    && isNumber(node.left)
+                    && isZero(node.right)) {
                     context.report({
                         loc: node.loc,
                         messageId: "unnecessaryShortCircuit",
@@ -210,9 +210,9 @@ export const noUnnecessaryAssignment = createRule({
                         },
                     });
                 }
-                if (node.operator === "||" &&
-                    isString(node.left) &&
-                    isEmptyString(node.right)) {
+                if (node.operator === "||"
+                    && isString(node.left)
+                    && isEmptyString(node.right)) {
                     context.report({
                         loc: node.loc,
                         messageId: "unnecessaryShortCircuit",
@@ -221,9 +221,9 @@ export const noUnnecessaryAssignment = createRule({
                         },
                     });
                 }
-                if (node.operator === "??" &&
-                    hasNullAndNotUndefined(node.left) &&
-                    isNull(node.right)) {
+                if (node.operator === "??"
+                    && hasNullAndNotUndefined(node.left)
+                    && isNull(node.right)) {
                     context.report({
                         loc: node.loc,
                         messageId: "unnecessaryShortCircuit",
@@ -232,9 +232,9 @@ export const noUnnecessaryAssignment = createRule({
                         },
                     });
                 }
-                if (node.operator === "??" &&
-                    hasUndefinedAndNotNull(node.left) &&
-                    isUndefined(node.right)) {
+                if (node.operator === "??"
+                    && hasUndefinedAndNotNull(node.left)
+                    && isUndefined(node.right)) {
                     context.report({
                         loc: node.loc,
                         messageId: "unnecessaryShortCircuit",

package/dist/rules/no-void-return-type.js

@@ -23,9 +23,9 @@ export const noVoidReturnType = createRule({
                 const { parent } = node;
                 if (
                 // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
-                parent !== undefined &&
-                    (parent.type === AST_NODE_TYPES.ExportNamedDeclaration ||
-                        parent.type === AST_NODE_TYPES.ExportDefaultDeclaration)) {
+                parent !== undefined
+                    && (parent.type === AST_NODE_TYPES.ExportNamedDeclaration
+                        || parent.type === AST_NODE_TYPES.ExportDefaultDeclaration)) {
                     return;
                 }
                 const { returnType } = node;

package/dist/rules/prefer-readonly-parameter-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prefer-readonly-parameter-types.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-readonly-parameter-types.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAY1E,KAAK,OAAO,GAAG;IACb;QACE,KAAK,CAAC,EAAE,oBAAoB,EAAE,CAAC;QAC/B,wBAAwB,CAAC,EAAE,OAAO,CAAC;QACnC,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B,sBAAsB,CAAC,EAAE,OAAO,CAAC;QACjC,wBAAwB,CAAC,EAAE,OAAO,CAAC;KACpC;CACF,CAAC;AAGF,eAAO,MAAM,4BAA4B,6MA4LvC,CAAC"}
+{"version":3,"file":"prefer-readonly-parameter-types.d.ts","sourceRoot":"","sources":["../../src/rules/prefer-readonly-parameter-types.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+BAA+B,CAAC;AAY1E,KAAK,OAAO,GAAG;IACb;QACE,KAAK,CAAC,EAAE,oBAAoB,EAAE,CAAC;QAC/B,wBAAwB,CAAC,EAAE,OAAO,CAAC;QACnC,mBAAmB,CAAC,EAAE,OAAO,CAAC;QAC9B,sBAAsB,CAAC,EAAE,OAAO,CAAC;QACjC,wBAAwB,CAAC,EAAE,OAAO,CAAC;KACpC;CACF,CAAC;AAGF,eAAO,MAAM,4BAA4B,6MA6MvC,CAAC"}

package/dist/rules/prefer-readonly-parameter-types.js

@@ -71,16 +71,28 @@ export const preferReadonlyParameterTypes = createRule({
                 AST_NODE_TYPES.TSFunctionType,
                 AST_NODE_TYPES.TSMethodSignature,
             ].join(", ")](node) {
+                // Early return in the special case of a map method. (This would result in an unfixable lint
+                // error.)
+                if (node.type === AST_NODE_TYPES.ArrowFunctionExpression
+                    || node.type === AST_NODE_TYPES.FunctionExpression) {
+                    const { parent } = node;
+                    if (parent.type === AST_NODE_TYPES.CallExpression
+                        && parent.callee.type === AST_NODE_TYPES.MemberExpression
+                        && parent.callee.property.type === AST_NODE_TYPES.Identifier
+                        && parent.callee.property.name === "map") {
+                        return;
+                    }
+                }
                 for (const param of node.params) {
-                    if (checkParameterProperties === false &&
-                        param.type === AST_NODE_TYPES.TSParameterProperty) {
+                    if (checkParameterProperties === false
+                        && param.type === AST_NODE_TYPES.TSParameterProperty) {
                         continue;
                     }
                     const actualParam = param.type === AST_NODE_TYPES.TSParameterProperty
                         ? param.parameter
                         : param;
-                    if (ignoreInferredTypes === true &&
-                        actualParam.typeAnnotation === undefined) {
+                    if (ignoreInferredTypes === true
+                        && actualParam.typeAnnotation === undefined) {
                         continue;
                     }
                     const type = services.getTypeAtLocation(actualParam);
@@ -89,10 +101,10 @@ export const preferReadonlyParameterTypes = createRule({
                         const parts = unionTypeParts(type);
                         const hasAllBasicDataStructures = parts.every((t) => {
                             const typeName = getTypeName(t);
-                            return (typeName === "Array" ||
-                                typeName === "Map" ||
-                                typeName === "Set" ||
-                                typeName === "Record");
+                            return (typeName === "Array"
+                                || typeName === "Map"
+                                || typeName === "Set"
+                                || typeName === "Record");
                         });
                         if (!hasAllBasicDataStructures) {
                             continue;

package/dist/rules/require-variadic-function-argument.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"require-variadic-function-argument.d.ts","sourceRoot":"","sources":["../../src/rules/require-variadic-function-argument.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAIvE,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,YAAY,CAAC;AAItC,eAAO,MAAM,+BAA+B,0HA8D1C,CAAC"}
+{"version":3,"file":"require-variadic-function-argument.d.ts","sourceRoot":"","sources":["../../src/rules/require-variadic-function-argument.ts"],"names":[],"mappings":"AACA,OAAO,EAAkB,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAIvE,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AACzB,MAAM,MAAM,UAAU,GAAG,YAAY,CAAC;AAatC,eAAO,MAAM,+BAA+B,0HA8D1C,CAAC"}

package/dist/rules/require-variadic-function-argument.js

@@ -2,6 +2,14 @@ import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
 import ts from "typescript";
 import { createRule } from "../utils.js";
 const JSDOC_EXCEPTION_TAG = "allowEmptyVariadic";
+const LOGGER_METHOD_NAMES = new Set([
+    "trace",
+    "debug",
+    "info",
+    "warn",
+    "error",
+    "fatal",
+]);
 export const requireVariadicFunctionArgument = createRule({
     name: "require-variadic-function-argument",
     meta: {
@@ -34,8 +42,8 @@ export const requireVariadicFunctionArgument = createRule({
                 if (declaration === undefined) {
                     return;
                 }
-                if (isHardCodedException(node) ||
-                    hasJSDocExceptionTag(checker, declaration)) {
+                if (isHardCodedException(node)
+                    || hasJSDocExceptionTag(checker, declaration)) {
                     return;
                 }
                 for (let i = 0; i < declaration.parameters.length; i++) {
@@ -43,8 +51,8 @@ export const requireVariadicFunctionArgument = createRule({
                     if (parameter === undefined) {
                         continue;
                     }
-                    if (ts.isRestParameter(parameter) &&
-                        node.arguments[i] === undefined) {
+                    if (ts.isRestParameter(parameter)
+                        && node.arguments[i] === undefined) {
                         context.report({
                             loc: node.loc,
                             messageId: "noArgument",
@@ -57,7 +65,20 @@ export const requireVariadicFunctionArgument = createRule({
 });
 function isHardCodedException(node) {
     const { callee } = node;
-    return isConsoleOrWindowOrLoggerFunction(callee) || isTimeoutFunction(callee);
+    const methodName = getMethodName(callee) ?? "unknown";
+    return (isConsoleOrWindowOrLoggerFunction(callee)
+        || isTimeoutFunction(callee)
+        || LOGGER_METHOD_NAMES.has(methodName));
+}
+function getMethodName(node) {
+    if (node.type !== AST_NODE_TYPES.MemberExpression) {
+        return undefined;
+    }
+    const { property } = node;
+    if (property.type !== AST_NODE_TYPES.Identifier) {
+        return undefined;
+    }
+    return property.name;
 }
 /**
  * This rule has a false positive with any logger function. (Both `console.log` and logger functions
@@ -73,9 +94,9 @@ function isConsoleOrWindowOrLoggerFunction(callee) {
     if (object.type !== AST_NODE_TYPES.Identifier) {
         return false;
     }
-    return (object.name === "console" ||
-        object.name === "window" ||
-        object.name === "logger");
+    return (object.name === "console"
+        || object.name === "window"
+        || object.name === "logger");
 }
 function isTimeoutFunction(callee) {
     if (callee.type !== AST_NODE_TYPES.Identifier) {

package/dist/rules/strict-array-methods.js

@@ -60,9 +60,9 @@ export const strictArrayMethods = createRule({
             for (const callSignature of callSignatures) {
                 const returnType = callSignature.getReturnType();
                 const returnTypeName = getTypeName(returnType);
-                if (returnTypeName !== "boolean" &&
-                    returnTypeName !== "true" &&
-                    returnTypeName !== "false") {
+                if (returnTypeName !== "boolean"
+                    && returnTypeName !== "true"
+                    && returnTypeName !== "false") {
                     return false;
                 }
             }
@@ -70,8 +70,8 @@ export const strictArrayMethods = createRule({
         }
         return {
             CallExpression(node) {
-                if (isArrayMethodInvocationWithBooleanFunction(node) &&
-                    !firstArgumentHasBooleanReturnType(node)) {
+                if (isArrayMethodInvocationWithBooleanFunction(node)
+                    && !firstArgumentHasBooleanReturnType(node)) {
                     context.report({
                         loc: node.loc,
                         messageId: "conditionError",

package/dist/rules/strict-enums.js

@@ -3,10 +3,10 @@ import { ESLintUtils } from "@typescript-eslint/utils";
 import ts from "typescript";
 import { isSymbolFlagSet, isTypeFlagSet, unionTypeParts, } from "../typeUtils.js";
 import { createRule } from "../utils.js";
-const ALLOWED_TYPES_FOR_ANY_ENUM_ARGUMENT = ts.TypeFlags.Any |
-    ts.TypeFlags.Unknown |
-    ts.TypeFlags.Number |
-    ts.TypeFlags.String;
+const ALLOWED_TYPES_FOR_ANY_ENUM_ARGUMENT = ts.TypeFlags.Any
+    | ts.TypeFlags.Unknown
+    | ts.TypeFlags.Number
+    | ts.TypeFlags.String;
 export const strictEnums = createRule({
     name: "strict-enums",
     meta: {
@@ -187,8 +187,8 @@ export const strictEnums = createRule({
                 for (let i = 0; i < leftTypeArguments.length; i++) {
                     const leftTypeArgument = leftTypeArguments[i];
                     const rightTypeArgument = rightTypeArguments[i];
-                    if (leftTypeArgument === undefined ||
-                        rightTypeArgument === undefined) {
+                    if (leftTypeArgument === undefined
+                        || rightTypeArgument === undefined) {
                         continue;
                     }
                     if (isAssigningNonEnumValueToEnumVariable(leftTypeArgument, rightTypeArgument)) {
@@ -235,8 +235,8 @@ export const strictEnums = createRule({
                     for (let i = 0; i < argumentTypeArguments.length; i++) {
                         const argumentTypeArgument = argumentTypeArguments[i];
                         const parameterTypeArgument = parameterTypeArguments[i];
-                        if (argumentTypeArgument === undefined ||
-                            parameterTypeArgument === undefined) {
+                        if (argumentTypeArgument === undefined
+                            || parameterTypeArgument === undefined) {
                             continue;
                         }
                         if (isMismatchedEnumFunctionArgument(argumentTypeArgument, parameterTypeArgument)) {
@@ -286,10 +286,10 @@ export const strictEnums = createRule({
              */
             const argumentSubTypes = unionTypeParts(argumentType);
             for (const argumentSubType of argumentSubTypes) {
-                if (argumentSubType.isLiteral() &&
-                    !isEnum(argumentSubType) &&
+                if (argumentSubType.isLiteral()
+                    && !isEnum(argumentSubType)
                     // Allow passing number literals if there are number literals in the actual function type.
-                    !parameterSubTypes.includes(argumentSubType)) {
+                    && !parameterSubTypes.includes(argumentSubType)) {
                     return true;
                 }
             }
@@ -429,11 +429,11 @@ function isEnum(type) {
     return isTypeFlagSet(type, ts.TypeFlags.EnumLiteral);
 }
 function isNullOrUndefinedOrAnyOrUnknownOrNever(...types) {
-    return types.some((type) => isTypeFlagSet(type, ts.TypeFlags.Null |
-        ts.TypeFlags.Undefined |
-        ts.TypeFlags.Any |
-        ts.TypeFlags.Unknown |
-        ts.TypeFlags.Never));
+    return types.some((type) => isTypeFlagSet(type, ts.TypeFlags.Null
+        | ts.TypeFlags.Undefined
+        | ts.TypeFlags.Any
+        | ts.TypeFlags.Unknown
+        | ts.TypeFlags.Never));
 }
 function setHasAnyElementFromSet(set1, set2) {
     for (const value of set2) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-complete",
-  "version": "1.0.9",
+  "version": "1.0.11",
   "description": "An ESLint plugin that contains useful rules.",
   "keywords": [
     "eslint",
@@ -44,9 +44,9 @@
     "test": "jest"
   },
   "dependencies": {
-    "@typescript-eslint/type-utils": "8.24.1",
-    "@typescript-eslint/utils": "8.24.1",
-    "typescript-eslint": "8.24.1"
+    "@typescript-eslint/type-utils": "8.25.0",
+    "@typescript-eslint/utils": "8.25.0",
+    "typescript-eslint": "8.25.0"
   },
   "devDependencies": {
     "@babel/core": "7.26.9",
@@ -54,10 +54,10 @@
     "@babel/preset-typescript": "7.26.0",
     "@types/jest": "29.5.14",
     "@types/node": "22.13.5",
-    "@typescript-eslint/rule-tester": "8.24.1",
-    "@typescript-eslint/types": "8.24.1",
-    "complete-common": "^1.1.1",
-    "complete-node": "^3.0.1",
+    "@typescript-eslint/rule-tester": "8.25.0",
+    "@typescript-eslint/types": "8.25.0",
+    "complete-common": "1.3.0",
+    "complete-node": "3.1.8",
     "jest": "29.7.0",
     "prettier": "3.5.2",
     "typescript": "5.7.3"