eslint-plugin-complete 1.0.0

package/dist/leadingLineComments.js

@@ -0,0 +1,77 @@
+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));
+}
+/**
+ * Returns an array of grouped comments. For example, the following code would return an array of
+ * three comment blocks:
+ *
+ * ```ts
+ * // This is the first block.
+ *
+ * // This is the second block.
+ * // We are still in the second block, because there has not been a newline separator yet.
+ *
+ * // This is the third block.
+ * ```
+ */
+export function getCommentBlocks(comments) {
+    const commentBlocks = [];
+    // We cannot use the `comments.entries` method because we mutate `i`.
+    for (let i = 0; i < comments.length; i++) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+        const comment = comments[i];
+        /**
+         * Remove the initial space that will always live in front of comment line.
+         *
+         * For example, the comment of:
+         *
+         * ```ts
+         * // Foo.
+         * ```
+         *
+         * Has a comment value of: " Foo."
+         */
+        const firstCharacter = comment.value[0];
+        const firstCharacterIsSpace = firstCharacter !== undefined && firstCharacter === " ";
+        const text = firstCharacterIsSpace ? comment.value.slice(1) : comment.value;
+        const commentBlock = {
+            mergedText: text,
+            originalComments: [comment],
+        };
+        const commentIndex = i; // Make a copy of the comment index since we will mutate i later.
+        const firstCommentStartLine = comment.loc.start.line;
+        // Look for one or more "connecting" comments on the next subsequent lines.
+        for (let j = i + 1; j < comments.length; j++) {
+            const nextComment = comments[j];
+            if (nextComment === undefined) {
+                break;
+            }
+            // Break if we are on a non-contiguous line.
+            const nextCommentStartLine = nextComment.loc.start.line;
+            const lineDelta = j - commentIndex;
+            if (nextCommentStartLine !== firstCommentStartLine + lineDelta) {
+                break;
+            }
+            // Break if this is a "separator" line.
+            if (isSeparatorLine(nextComment.value)) {
+                break;
+            }
+            commentBlock.mergedText += "\n";
+            const nextText = nextComment.value.slice(1);
+            commentBlock.mergedText += nextText;
+            commentBlock.originalComments.push(nextComment);
+            // Since we merged this comment, we can skip over examining it in the parent loop.
+            i++;
+        }
+        commentBlocks.push(commentBlock);
+    }
+    return commentBlocks;
+}
+export function allCommentsInBlockAreCommentedOutArrayElements(commentBlock) {
+    return commentBlock.originalComments.every((comment) => comment.value.match(/^\s*"[^"]*",\s*$/) !== null);
+}

package/dist/list.d.ts

@@ -0,0 +1,49 @@
+/**
+ * A description of the kind of list that is currently being iterated over. For example, the
+ * following text is a list:
+ *
+ * ```text
+ * 1. Apple
+ * 2. Banana
+ * 3. Pear
+ * ```
+ */
+export interface List {
+    kind: ListKind;
+    /** The size of the whitespace prior to the marker. For example, " 1. Foo" would be 2. */
+    numLeadingSpaces: number;
+    /**
+     * The size of the characters that make up the bullet point.
+     * e.g. "1. Foo" would be 3.
+     */
+    markerSize: number;
+    /**
+     * The contents of JSDoc tag header, if any.
+     * e.g. "@param foo This is foo." would be "@param foo".
+     */
+    jsDocTagName?: string;
+}
+export declare enum ListKind {
+    Hyphen = "Hyphen",
+    NumberParenthesis = "NumberParenthesis",
+    NumberPeriod = "NumberPeriod",
+    JSDocTag = "JSDocTag"
+}
+/**
+ * When using the `getList` function, the returned list may not be accurate if this is a line that
+ * is continuing from the previous line. For example:
+ *
+ * ```text
+ * This method will crash the game if you provide it an invalid number, such as 10000000000000000 or
+ * 43. (Using 0 will not cause a crash.)
+ * ```
+ *
+ * Here, "43. " is incorrectly interpreted as the beginning of a list. In order to work around this
+ * problem, use the `getAdjustedList` function instead.
+ */
+export declare function getAdjustedList(line: string, previousLineWasBlank: boolean, previousLineEndedInColon: boolean, insideList: List | undefined): List | undefined;
+/**
+ * When iterating over lines of text, by default, we want to keep the existing list object, if any.
+ */
+export declare function reachedNewList(insideList: List | undefined, list: List | undefined): boolean;
+//# sourceMappingURL=list.d.ts.map

package/dist/list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["../src/list.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AACH,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,QAAQ,CAAC;IAEf,yFAAyF;IACzF,gBAAgB,EAAE,MAAM,CAAC;IAEzB;;;OAGG;IACH,UAAU,EAAE,MAAM,CAAC;IAEnB;;;OAGG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;CACvB;AAED,oBAAY,QAAQ;IAClB,MAAM,WAAW;IACjB,iBAAiB,sBAAsB;IACvC,YAAY,iBAAiB;IAC7B,QAAQ,aAAa;CACtB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,eAAe,CAC7B,IAAI,EAAE,MAAM,EACZ,oBAAoB,EAAE,OAAO,EAC7B,wBAAwB,EAAE,OAAO,EACjC,UAAU,EAAE,IAAI,GAAG,SAAS,GAC3B,IAAI,GAAG,SAAS,CAgClB;AAqGD;;GAEG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,IAAI,GAAG,SAAS,EAC5B,IAAI,EAAE,IAAI,GAAG,SAAS,GACrB,OAAO,CAUT"}

package/dist/list.js

@@ -0,0 +1,140 @@
+export var ListKind;
+(function (ListKind) {
+    ListKind["Hyphen"] = "Hyphen";
+    ListKind["NumberParenthesis"] = "NumberParenthesis";
+    ListKind["NumberPeriod"] = "NumberPeriod";
+    ListKind["JSDocTag"] = "JSDocTag";
+})(ListKind || (ListKind = {}));
+/**
+ * When using the `getList` function, the returned list may not be accurate if this is a line that
+ * is continuing from the previous line. For example:
+ *
+ * ```text
+ * This method will crash the game if you provide it an invalid number, such as 10000000000000000 or
+ * 43. (Using 0 will not cause a crash.)
+ * ```
+ *
+ * Here, "43. " is incorrectly interpreted as the beginning of a list. In order to work around this
+ * problem, use the `getAdjustedList` function instead.
+ */
+export function getAdjustedList(line, previousLineWasBlank, previousLineEndedInColon, insideList) {
+    const list = getList(line);
+    if (list === undefined) {
+        return undefined;
+    }
+    switch (list.kind) {
+        case ListKind.Hyphen: {
+            return list;
+        }
+        case ListKind.NumberPeriod:
+        case ListKind.NumberParenthesis: {
+            // If we are already inside of a numbered list, then do not require blank lines in between the
+            // bullets.
+            if (list.kind === insideList?.kind) {
+                return list;
+            }
+            // If the previous line had a colon, then do not require blank lines in between the bullets.
+            if (previousLineEndedInColon) {
+                return list;
+            }
+            // Otherwise, only interpret this as a bulleted list if the previous line was blank.
+            return previousLineWasBlank ? list : undefined;
+        }
+        case ListKind.JSDocTag: {
+            return list;
+        }
+    }
+}
+function getList(line) {
+    const originalLength = line.length;
+    line = line.trimStart();
+    const trimmedLength = line.length;
+    const numLeadingSpaces = originalLength - trimmedLength;
+    // e.g. "- A bullet point can start with a hyphen."
+    if (line.startsWith("- ")) {
+        return {
+            kind: ListKind.Hyphen,
+            numLeadingSpaces,
+            markerSize: "- ".length,
+        };
+    }
+    /** 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") {
+        return {
+            kind: ListKind.NumberPeriod,
+            numLeadingSpaces,
+            markerSize: numberPeriodMatch[1].length + ". ".length,
+        };
+    }
+    /** 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") {
+        return {
+            kind: ListKind.NumberParenthesis,
+            numLeadingSpaces,
+            markerSize: numberParenthesisMatch[1].length + ") ".length,
+        };
+    }
+    const jsDocTagName = getJSDocTagName(line);
+    if (jsDocTagName !== undefined) {
+        return {
+            kind: ListKind.JSDocTag,
+            numLeadingSpaces,
+            markerSize: jsDocTagName.length + " ".length,
+            jsDocTagName,
+        };
+    }
+    return undefined;
+}
+/**
+ * Returns a string containing the param header, if any. For example, "@returns Foo" would return
+ * "@returns".
+ *
+ * For "@param" tags, the returned tag string will include the variable name, if any. For example,
+ * "@param foo Foo" would return "@param foo".
+ */
+function getJSDocTagName(text) {
+    text = text.trimStart();
+    if (!text.startsWith("@")) {
+        return undefined;
+    }
+    const tagMatch = text.match(/^@(?<tagName>\w+)/);
+    if (tagMatch === null || tagMatch.groups === undefined) {
+        return undefined;
+    }
+    const { tagName } = tagMatch.groups;
+    if (tagName === undefined) {
+        return undefined;
+    }
+    // Specific JSDoc tags have words after them that should be part of the tag for indenting
+    // purposes.
+    if (tagName === "param") {
+        const paramMatch = text.match(/^(?<tagWithVariableName>@\w+ \w+)/);
+        if (paramMatch === null || paramMatch.groups === undefined) {
+            return "@param";
+        }
+        const { tagWithVariableName } = paramMatch.groups;
+        if (tagWithVariableName === undefined) {
+            return "@param";
+        }
+        return tagWithVariableName;
+    }
+    return `@${tagName}`;
+}
+/**
+ * When iterating over lines of text, by default, we want to keep the existing list object, if any.
+ */
+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
+    );
+}

package/dist/rules/complete-sentences-jsdoc.d.ts

@@ -0,0 +1,4 @@
+import type { CompleteSentenceMessageIds } from "../completeSentence.js";
+export type Options = [];
+export declare const completeSentencesJSDoc: import("@typescript-eslint/utils/ts-eslint").RuleModule<CompleteSentenceMessageIds, [], import("../interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+//# sourceMappingURL=complete-sentences-jsdoc.d.ts.map

package/dist/rules/complete-sentences-jsdoc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complete-sentences-jsdoc.d.ts","sourceRoot":"","sources":["../../src/rules/complete-sentences-jsdoc.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,wBAAwB,CAAC;AAKzE,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AAEzB,eAAO,MAAM,sBAAsB,0MAuDjC,CAAC"}

package/dist/rules/complete-sentences-jsdoc.js

@@ -0,0 +1,48 @@
+import { getIncompleteSentences } from "../completeSentence.js";
+import { getJSDocComments, getTextFromJSDocComment } from "../jsdoc.js";
+import { createRule } from "../utils.js";
+export const completeSentencesJSDoc = createRule({
+    name: "complete-sentences-jsdoc",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Requires complete sentences for JSDoc comments",
+            recommended: true,
+            requiresTypeChecking: false,
+        },
+        schema: [],
+        messages: {
+            missingCapital: "JSDoc comments must contain complete sentences with a capital letter.\n{{ sentence }}",
+            missingPeriod: "JSDoc comments must contain complete sentences with a trailing period.\n{{ sentence }}",
+            doublePeriod: "JSDoc comments must not end with a double period. Did you make a typo?.\n{{ sentence }}",
+        },
+    },
+    defaultOptions: [],
+    /**
+     * We need to write the rule in such a way that it operates on the entire source code instead of
+     * individual AST nodes:
+     * https://stackoverflow.com/questions/47429792/is-it-possible-to-get-comments-as-nodes-in-the-ast-using-the-typescript-compiler
+     */
+    create(context) {
+        const comments = context.sourceCode.getAllComments();
+        // We only look at `/**` style comments.
+        const jsDocComments = getJSDocComments(comments);
+        for (const comment of jsDocComments) {
+            const text = getTextFromJSDocComment(comment.value);
+            const incompleteSentences = getIncompleteSentences(text);
+            for (const incompleteSentence of incompleteSentences) {
+                context.report({
+                    loc: {
+                        start: comment.loc.start,
+                        end: comment.loc.end,
+                    },
+                    messageId: incompleteSentence.messageId,
+                    data: {
+                        sentence: incompleteSentence.sentence,
+                    },
+                });
+            }
+        }
+        return {};
+    },
+});

package/dist/rules/complete-sentences-line-comments.d.ts

@@ -0,0 +1,4 @@
+import type { CompleteSentenceMessageIds } from "../completeSentence.js";
+export type Options = [];
+export declare const completeSentencesLineComments: import("@typescript-eslint/utils/ts-eslint").RuleModule<CompleteSentenceMessageIds, [], import("../interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+//# sourceMappingURL=complete-sentences-line-comments.d.ts.map

package/dist/rules/complete-sentences-line-comments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"complete-sentences-line-comments.d.ts","sourceRoot":"","sources":["../../src/rules/complete-sentences-line-comments.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,0BAA0B,EAAE,MAAM,wBAAwB,CAAC;AAUzE,MAAM,MAAM,OAAO,GAAG,EAAE,CAAC;AAEzB,eAAO,MAAM,6BAA6B,0MAuFxC,CAAC"}

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

@@ -0,0 +1,88 @@
+import { isSeparatorLine } from "../comments.js";
+import { assertDefined } from "../completeCommon.js";
+import { getIncompleteSentences } from "../completeSentence.js";
+import { JAVASCRIPT_RESERVED_WORDS_SET } from "../constants.js";
+import { allCommentsInBlockAreCommentedOutArrayElements, getCommentBlocks, getLeadingLineComments, } from "../leadingLineComments.js";
+import { createRule } from "../utils.js";
+export const completeSentencesLineComments = createRule({
+    name: "complete-sentences-line-comments",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Requires complete sentences for multi-line leading line comments",
+            recommended: true,
+            requiresTypeChecking: false,
+        },
+        schema: [],
+        messages: {
+            missingCapital: "Leading line comments must contain complete sentences with a capital letter.\n{{ sentence }}",
+            missingPeriod: "Leading line comments must contain complete sentences with a trailing period.\n{{ sentence }}",
+            doublePeriod: "Leading line comments must not end with a double period. Did you make a typo?\n{{ sentence }}",
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const { sourceCode } = context;
+        const comments = sourceCode.getAllComments();
+        // We only look at `//` style comments on their own line.
+        const leadingLineComments = getLeadingLineComments(sourceCode, comments);
+        // Sort the comments by blocks.
+        const commentBlocks = getCommentBlocks(leadingLineComments);
+        for (const [i, commentBlock] of commentBlocks.entries()) {
+            const firstComment = commentBlock.originalComments.at(0);
+            assertDefined(firstComment, "Failed to get the first comment.");
+            const lastComment = commentBlock.originalComments.at(-1);
+            assertDefined(lastComment, "Failed to get the last comment.");
+            // Commented out array elements are whitelisted.
+            if (allCommentsInBlockAreCommentedOutArrayElements(commentBlock)) {
+                continue;
+            }
+            // Comments in-between "separator lines" are whitelisted.
+            const previousCommentBlock = commentBlocks[i - 1];
+            if (previousCommentBlock !== undefined &&
+                isSeparatorLine(previousCommentBlock.mergedText)) {
+                continue;
+            }
+            const nextCommentBlock = commentBlocks[i + 1];
+            if (nextCommentBlock !== undefined &&
+                isSeparatorLine(nextCommentBlock.mergedText)) {
+                continue;
+            }
+            // Unlike JSDoc comments, we want to whitelist comment blocks that begin with JavaScript
+            // keywords. This is to make commenting out code less painful. e.g. `// const foo = 123;`
+            const text = commentBlock.mergedText;
+            const firstWord = getFirstWord(text);
+            if (JAVASCRIPT_RESERVED_WORDS_SET.has(firstWord)) {
+                continue;
+            }
+            const incompleteSentences = getIncompleteSentences(text);
+            for (const incompleteSentence of incompleteSentences) {
+                context.report({
+                    loc: {
+                        start: firstComment.loc.start,
+                        end: lastComment.loc.end,
+                    },
+                    messageId: incompleteSentence.messageId,
+                    data: {
+                        sentence: incompleteSentence.sentence,
+                    },
+                });
+            }
+        }
+        return {};
+    },
+});
+function getFirstWord(text) {
+    const words = text.split(" ");
+    const firstWord = words[0];
+    if (firstWord === undefined) {
+        return "";
+    }
+    // We want to match e.g. `console.log`.
+    const parts = firstWord.split(".");
+    const firstPart = parts[0];
+    if (firstPart === undefined) {
+        return "";
+    }
+    return firstPart;
+}

package/dist/rules/consistent-enum-values.d.ts

@@ -0,0 +1,2 @@
+export declare const consistentEnumValues: import("@typescript-eslint/utils/ts-eslint").RuleModule<"inconsistentValue", [], import("../interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+//# sourceMappingURL=consistent-enum-values.d.ts.map

package/dist/rules/consistent-enum-values.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consistent-enum-values.d.ts","sourceRoot":"","sources":["../../src/rules/consistent-enum-values.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,oBAAoB,mMAgD/B,CAAC"}

package/dist/rules/consistent-enum-values.js

@@ -0,0 +1,46 @@
+import { createRule } from "../utils.js";
+export const consistentEnumValues = createRule({
+    name: "consistent-enum-values",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Requires consistent enum values",
+            recommended: true,
+            requiresTypeChecking: false,
+        },
+        schema: [],
+        messages: {
+            inconsistentValue: "The value of an enum member must be a string that exactly matches the enum name.",
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            TSEnumMember(node) {
+                // Ignore computed enums; those are intended to be checked with the
+                // `@typescript-eslint/prefer-enum-initializers` rule.
+                const { initializer } = node;
+                if (initializer === undefined || !("value" in initializer)) {
+                    return;
+                }
+                // Ignore number enums; those are intended to be checked with the `complete/no-number-enums`
+                // rule.
+                const enumValue = initializer.value;
+                if (typeof enumValue !== "string") {
+                    return;
+                }
+                const { id } = node;
+                if (!("name" in id)) {
+                    return;
+                }
+                const enumName = id.name;
+                if (enumValue !== enumName) {
+                    context.report({
+                        node,
+                        messageId: "inconsistentValue",
+                    });
+                }
+            },
+        };
+    },
+});

package/dist/rules/consistent-named-tuples.d.ts

@@ -0,0 +1,2 @@
+export declare const consistentNamedTuples: import("@typescript-eslint/utils/ts-eslint").RuleModule<"notNamed", [], import("../interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+//# sourceMappingURL=consistent-named-tuples.d.ts.map

package/dist/rules/consistent-named-tuples.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consistent-named-tuples.d.ts","sourceRoot":"","sources":["../../src/rules/consistent-named-tuples.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,qBAAqB,0LAqChC,CAAC"}

package/dist/rules/consistent-named-tuples.js

@@ -0,0 +1,34 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { createRule } from "../utils.js";
+export const consistentNamedTuples = createRule({
+    name: "consistent-named-tuples",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Requires that if one or more tuple elements are named, all of them are named",
+            recommended: true,
+            requiresTypeChecking: false,
+        },
+        schema: [],
+        messages: {
+            notNamed: "If one element in a tuple has a label, then all of them must have a label.",
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        return {
+            TSTupleType(node) {
+                const hasNamedElements = node.elementTypes.some((typeNode) => typeNode.type === AST_NODE_TYPES.TSNamedTupleMember);
+                if (hasNamedElements) {
+                    const hasAllNamedElements = node.elementTypes.every((typeNode) => typeNode.type === AST_NODE_TYPES.TSNamedTupleMember);
+                    if (!hasAllNamedElements) {
+                        context.report({
+                            loc: node.loc,
+                            messageId: "notNamed",
+                        });
+                    }
+                }
+            },
+        };
+    },
+});

package/dist/rules/eqeqeq-fix.d.ts

@@ -0,0 +1,2 @@
+export declare const eqeqeqFix: import("@typescript-eslint/utils/ts-eslint").RuleModule<"unexpected", [], import("../interfaces/MyPluginDocs.js").MyPluginDocs, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+//# sourceMappingURL=eqeqeq-fix.d.ts.map

package/dist/rules/eqeqeq-fix.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"eqeqeq-fix.d.ts","sourceRoot":"","sources":["../../src/rules/eqeqeq-fix.ts"],"names":[],"mappings":"AA0CA,eAAO,MAAM,SAAS,4LAkKpB,CAAC"}