oxlint-plugin-oxlint-comments 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2016 Toru Nagashima
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,31 @@
+# oxlint-plugin-oxlint-comments
+
+[![npm version](https://img.shields.io/npm/v/oxlint-plugin-oxlint-comments.svg)](https://npmx.dev/oxlint-plugin-oxlint-comments)
+
+Rules for oxlint directive comments (e.g. `//oxlint-disable-line`).
+
+## Usage
+
+-   [Documentation](https://github.com/christopher-buss/eslint-plugin-oxlint-comments)
+
+## Semantic Versioning Policy
+
+`oxlint-plugin-oxlint-comments` follows [semantic versioning](http://semver.org/).
+
+## Changelog
+
+-   [GitHub Releases](https://github.com/christopher-buss/eslint-plugin-oxlint-comments/releases)
+
+## Contributing
+
+Welcome contributing!
+
+Please use GitHub's Issues/PRs.
+
+### Development Tools
+
+-   `npm test` runs tests and measures coverage.
+-   `npm run clean` removes the coverage of the last `npm test` command.
+-   `npm run coverage` shows the coverage of the last `npm test` command.
+-   `npm run lint` runs the linter for this codebase.
+-   `npm run watch` runs tests and measures coverage when source code are changed.

package/index.js

@@ -0,0 +1,12 @@
+import { createRequire } from "node:module"
+import rules from "./lib/rules.js"
+
+const require = createRequire(import.meta.url)
+const { name, version } = require("./package.json")
+
+const plugin = {
+    meta: { name, version },
+    rules,
+}
+
+export default plugin

package/lib/configs.js

@@ -0,0 +1,6 @@
+/** DON'T EDIT THIS FILE; was created by scripts. */
+"use strict"
+
+module.exports = {
+    recommended: require("./configs/recommended"),
+}

package/lib/internal/disabled-area.js

@@ -0,0 +1,181 @@
+/**
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ * See LICENSE file in root directory for full license.
+ */
+
+import { lte, parseDirectiveComment } from "./utils.js"
+
+const DELIMITER = /[\s,]+/gu
+const pool = new WeakMap()
+
+class DisabledArea {
+    constructor() {
+        this.areas = []
+        this.duplicateDisableDirectives = []
+        this.unusedEnableDirectives = []
+        this.numberOfRelatedDisableDirectives = new Map()
+    }
+
+    _disable(comment, location, ruleIds, kind) {
+        if (ruleIds) {
+            for (const ruleId of ruleIds) {
+                if (this._getArea(ruleId, location) != null) {
+                    this.duplicateDisableDirectives.push({ comment, ruleId })
+                }
+
+                this.areas.push({
+                    comment,
+                    ruleId,
+                    kind,
+                    start: location,
+                    end: null,
+                })
+            }
+        } else {
+            if (this._getArea(null, location) != null) {
+                this.duplicateDisableDirectives.push({ comment, ruleId: null })
+            }
+
+            this.areas.push({
+                comment,
+                ruleId: null,
+                kind,
+                start: location,
+                end: null,
+            })
+        }
+    }
+
+    _enable(comment, location, ruleIds, kind) {
+        const relatedDisableDirectives = new Set()
+
+        if (ruleIds) {
+            for (const ruleId of ruleIds) {
+                let used = false
+
+                for (let i = this.areas.length - 1; i >= 0; --i) {
+                    const area = this.areas[i]
+
+                    if (
+                        area.end === null &&
+                        area.kind === kind &&
+                        area.ruleId === ruleId
+                    ) {
+                        relatedDisableDirectives.add(area.comment)
+                        area.end = location
+                        used = true
+                    }
+                }
+
+                if (!used) {
+                    this.unusedEnableDirectives.push({ comment, ruleId })
+                }
+            }
+        } else {
+            let used = false
+
+            for (let i = this.areas.length - 1; i >= 0; --i) {
+                const area = this.areas[i]
+
+                if (area.end === null && area.kind === kind) {
+                    relatedDisableDirectives.add(area.comment)
+                    area.end = location
+                    used = true
+                }
+            }
+
+            if (!used) {
+                this.unusedEnableDirectives.push({ comment, ruleId: null })
+            }
+        }
+
+        this.numberOfRelatedDisableDirectives.set(
+            comment,
+            relatedDisableDirectives.size
+        )
+    }
+
+    _getArea(ruleId, location) {
+        for (let i = this.areas.length - 1; i >= 0; --i) {
+            const area = this.areas[i]
+
+            if (
+                (area.ruleId === null || area.ruleId === ruleId) &&
+                lte(area.start, location) &&
+                (area.end === null || lte(location, area.end))
+            ) {
+                return area
+            }
+        }
+
+        return null
+    }
+
+    _scan(sourceCode) {
+        const comments =
+            typeof sourceCode.getAllComments === "function"
+                ? sourceCode.getAllComments()
+                : []
+
+        for (const comment of comments) {
+            const directiveComment = parseDirectiveComment(comment)
+            if (directiveComment == null) {
+                continue
+            }
+
+            const kind = directiveComment.kind
+            if (
+                ![
+                    "oxlint-disable",
+                    "oxlint-enable",
+                    "oxlint-disable-line",
+                    "oxlint-disable-next-line",
+                ].includes(kind)
+            ) {
+                continue
+            }
+            const ruleIds = directiveComment.value
+                ? directiveComment.value.split(DELIMITER)
+                : null
+
+            if (kind === "oxlint-disable") {
+                this._disable(comment, comment.loc.start, ruleIds, "block")
+            } else if (kind === "oxlint-enable") {
+                this._enable(comment, comment.loc.start, ruleIds, "block")
+            } else if (kind === "oxlint-disable-line") {
+                const line = comment.loc.start.line
+                const start = { line, column: 0 }
+                const end = { line: line + 1, column: -1 }
+
+                this._disable(comment, start, ruleIds, "line")
+                this._enable(comment, end, ruleIds, "line")
+            } else if (kind === "oxlint-disable-next-line") {
+                const line = comment.loc.start.line
+                const start = { line: line + 1, column: 0 }
+                const end = { line: line + 2, column: -1 }
+
+                this._disable(comment, start, ruleIds, "line")
+                this._enable(comment, end, ruleIds, "line")
+            }
+        }
+    }
+}
+
+/**
+ * Get singleton instance for the given rule context.
+ *
+ * @param {object} context - The rule context code to get.
+ * @returns {DisabledArea} The singleton object for the rule context.
+ */
+export function getDisabledArea(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode()
+    let retv = pool.get(sourceCode.ast)
+
+    if (retv == null) {
+        retv = new DisabledArea()
+        retv._scan(sourceCode)
+        pool.set(sourceCode.ast, retv)
+    }
+
+    return retv
+}

package/lib/internal/get-all-directive-comments.js

@@ -0,0 +1,59 @@
+import { parseDirectiveComment } from "./utils.js"
+
+/**
+ * @typedef {object} DirectiveComment
+ * @property {string} kind The kind of directive comment.
+ * @property {string} [value] The directive value if it is `oxlint-` comment.
+ * @property {string} description The description of the directive comment.
+ * @property {object} node The node of the directive comment.
+ * @property {object} range The range of the directive comment.
+ * @property {object} loc The location of the directive comment.
+ */
+
+const pool = new WeakMap()
+
+/**
+ * @param {object} sourceCode - The source code to scan.
+ * @returns {DirectiveComment[]} The directive comments.
+ */
+function getAllDirectiveCommentsFromAllComments(sourceCode) {
+    if (typeof sourceCode.getAllComments !== "function") {
+        return []
+    }
+    return sourceCode
+        .getAllComments()
+        .map((comment) => ({
+            comment,
+            directiveComment: parseDirectiveComment(comment),
+        }))
+        .filter(({ directiveComment }) => Boolean(directiveComment))
+        .map(
+            ({ comment, directiveComment }) =>
+                /** @type {DirectiveComment} */ ({
+                    kind: directiveComment.kind,
+                    value: directiveComment.value,
+                    description: directiveComment.description,
+                    node: comment,
+                    range: comment.range,
+                    loc: comment.loc,
+                })
+        )
+}
+
+/**
+ * Get all directive comments for the given rule context.
+ *
+ * @param {object} context - The rule context to get.
+ * @returns {DirectiveComment[]} The all directive comments object for the rule context.
+ */
+export function getAllDirectiveComments(context) {
+    const sourceCode = context.sourceCode || context.getSourceCode()
+    let result = pool.get(sourceCode.ast)
+
+    if (result == null) {
+        result = getAllDirectiveCommentsFromAllComments(sourceCode)
+        pool.set(sourceCode.ast, result)
+    }
+
+    return result
+}

package/lib/internal/utils.js

@@ -0,0 +1,161 @@
+/**
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ * See LICENSE file in root directory for full license.
+ */
+
+import escapeStringRegexp from "escape-string-regexp"
+
+const LINE_PATTERN = /[^\r\n\u2028\u2029]*(?:\r\n|[\r\n\u2028\u2029]|$)/gu
+
+const DIRECTIVE_PATTERN =
+    /^(oxlint-(?:enable|disable(?:(?:-next)?-line)?))(?:\s|$)/u
+
+/**
+ * Make the location ignoring `oxlint-disable` comments.
+ *
+ * @param {object} location - The location to convert.
+ * @returns {object} Converted location.
+ */
+export function toForceLocation(location) {
+    return {
+        start: {
+            line: location.start.line,
+            column: 0,
+        },
+        end: location.end,
+    }
+}
+
+/**
+ * Calculate the location of the given rule in the given comment token.
+ *
+ * @param {Token} comment - The comment token to calculate.
+ * @param {string|null} ruleId - The rule name to calculate.
+ * @returns {object} The location of the given information.
+ */
+export function toRuleIdLocation(comment, ruleId) {
+    const commentLoc = comment.loc
+    if (ruleId == null) {
+        return toForceLocation(commentLoc)
+    }
+
+    const lines = comment.value.match(LINE_PATTERN)
+    const ruleIdPattern = new RegExp(
+        `([\\s,]|^)${escapeStringRegexp(ruleId)}(?:[\\s,]|$)`,
+        "u"
+    )
+
+    {
+        const m = ruleIdPattern.exec(lines[0])
+        if (m != null) {
+            const start = commentLoc.start
+            return {
+                start: {
+                    line: start.line,
+                    column: 2 + start.column + m.index + m[1].length,
+                },
+                end: {
+                    line: start.line,
+                    column:
+                        2 +
+                        start.column +
+                        m.index +
+                        m[1].length +
+                        ruleId.length,
+                },
+            }
+        }
+    }
+
+    for (let i = 1; i < lines.length; ++i) {
+        const m = ruleIdPattern.exec(lines[i])
+        if (m != null) {
+            const start = commentLoc.start
+            return {
+                start: {
+                    line: start.line + i,
+                    column: m.index + m[1].length,
+                },
+                end: {
+                    line: start.line + i,
+                    column: m.index + m[1].length + ruleId.length,
+                },
+            }
+        }
+    }
+
+    /*istanbul ignore next : foolproof */
+    return commentLoc
+}
+
+/**
+ * Checks `a` is less than `b` or `a` equals `b`.
+ *
+ * @param {{line: number, column: number}} a - A location to compare.
+ * @param {{line: number, column: number}} b - Another location to compare.
+ * @returns {boolean} `true` if `a` is less than `b` or `a` equals `b`.
+ */
+export function lte(a, b) {
+    return a.line < b.line || (a.line === b.line && a.column <= b.column)
+}
+
+/**
+ * Parse the given comment token as a directive comment.
+ *
+ * @param {Token} comment - The comment token to parse.
+ * @returns {{kind: string, value: string, description: string | null}|null} The parsed data of the given comment. If `null`, it is not a directive comment.
+ */
+export function parseDirectiveComment(comment) {
+    const parsed = parseDirectiveText(comment.value)
+    if (!parsed) {
+        return null
+    }
+
+    if (
+        parsed.kind === "oxlint-disable-line" &&
+        comment.loc.start.line !== comment.loc.end.line
+    ) {
+        // disable-line comment should not span multiple lines.
+        return null
+    }
+
+    return parsed
+}
+
+/**
+ * Parse the given text as a directive comment.
+ *
+ * @param {string} textToParse - The text to parse.
+ * @returns {{kind: string, value: string, description: string | null}|null} The parsed data of the given comment. If `null`, it is not a directive comment.
+ */
+export function parseDirectiveText(textToParse) {
+    const { text, description } = divideDirectiveComment(textToParse)
+    const match = DIRECTIVE_PATTERN.exec(text)
+
+    if (!match) {
+        return null
+    }
+    const directiveText = match[1]
+
+    const directiveValue = text.slice(match.index + directiveText.length)
+
+    return {
+        kind: directiveText,
+        value: directiveValue.trim(),
+        description,
+    }
+}
+
+/**
+ * Divides and trims description text and directive comments.
+ * @param {string} value The comment text to strip.
+ * @returns {{text: string, description: string | null}} The stripped text.
+ */
+function divideDirectiveComment(value) {
+    const divided = value.split(/\s-{2,}\s/u)
+    const text = divided[0].trim()
+    return {
+        text,
+        description: divided.length > 1 ? divided[1].trim() : null,
+    }
+}

package/lib/rules/disable-enable-pair.js

@@ -0,0 +1,81 @@
+/**
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ * See LICENSE file in root directory for full license.
+ */
+
+import { getDisabledArea } from "../internal/disabled-area.js"
+import { lte, toRuleIdLocation } from "../internal/utils.js"
+
+export default {
+    meta: {
+        docs: {
+            description:
+                "require a `oxlint-enable` comment for every `oxlint-disable` comment",
+            category: "Best Practices",
+            recommended: true,
+            url: "https://github.com/christopher-buss/eslint-plugin-oxlint-comments/blob/main/docs/rules/disable-enable-pair.md",
+        },
+        fixable: null,
+        messages: {
+            missingPair: "Requires 'oxlint-enable' directive.",
+            missingRulePair:
+                "Requires 'oxlint-enable' directive for '{{ruleId}}'.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    allowWholeFile: {
+                        type: "boolean",
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        type: "suggestion",
+    },
+
+    createOnce(context) {
+        return {
+            Program() {
+                const allowWholeFile =
+                    context.options &&
+                    context.options[0] &&
+                    context.options[0].allowWholeFile
+                const disabledArea = getDisabledArea(context)
+                const sourceCode =
+                    context.sourceCode || context.getSourceCode()
+
+                const firstToken =
+                    sourceCode.ast &&
+                    sourceCode.ast.tokens &&
+                    sourceCode.ast.tokens[0]
+
+                if (allowWholeFile && !firstToken) {
+                    return
+                }
+
+                for (const area of disabledArea.areas) {
+                    if (area.end != null) {
+                        continue
+                    }
+                    if (
+                        allowWholeFile &&
+                        firstToken &&
+                        lte(area.start, firstToken.loc.start)
+                    ) {
+                        continue
+                    }
+
+                    context.report({
+                        loc: toRuleIdLocation(area.comment, area.ruleId),
+                        messageId: area.ruleId
+                            ? "missingRulePair"
+                            : "missingPair",
+                        data: area,
+                    })
+                }
+            },
+        }
+    },
+}

package/lib/rules/no-aggregating-enable.js

@@ -0,0 +1,47 @@
+/**
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ * See LICENSE file in root directory for full license.
+ */
+
+import { getDisabledArea } from "../internal/disabled-area.js"
+import { toForceLocation } from "../internal/utils.js"
+
+export default {
+    meta: {
+        docs: {
+            description:
+                "disallow a `oxlint-enable` comment for multiple `oxlint-disable` comments",
+            category: "Best Practices",
+            recommended: true,
+            url: "https://github.com/christopher-buss/eslint-plugin-oxlint-comments/blob/main/docs/rules/no-aggregating-enable.md",
+        },
+        fixable: null,
+        messages: {
+            aggregatingEnable:
+                "This `oxlint-enable` comment affects {{count}} `oxlint-disable` comments. An `oxlint-enable` comment should be for an `oxlint-disable` comment.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+
+    createOnce(context) {
+        return {
+            Program() {
+                const disabledArea = getDisabledArea(context)
+
+                for (const entry of disabledArea.numberOfRelatedDisableDirectives) {
+                    const comment = entry[0]
+                    const count = entry[1]
+
+                    if (count >= 2) {
+                        context.report({
+                            loc: toForceLocation(comment.loc),
+                            messageId: "aggregatingEnable",
+                            data: { count },
+                        })
+                    }
+                }
+            },
+        }
+    },
+}

package/lib/rules/no-duplicate-disable.js

@@ -0,0 +1,43 @@
+/**
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ * See LICENSE file in root directory for full license.
+ */
+
+import { getDisabledArea } from "../internal/disabled-area.js"
+import { toRuleIdLocation } from "../internal/utils.js"
+
+export default {
+    meta: {
+        docs: {
+            description: "disallow duplicate `oxlint-disable` comments",
+            category: "Best Practices",
+            recommended: true,
+            url: "https://github.com/christopher-buss/eslint-plugin-oxlint-comments/blob/main/docs/rules/no-duplicate-disable.md",
+        },
+        fixable: null,
+        messages: {
+            duplicate: "Oxlint rules have been disabled already.",
+            duplicateRule: "'{{ruleId}}' rule has been disabled already.",
+        },
+        schema: [],
+        type: "problem",
+    },
+
+    createOnce(context) {
+        return {
+            Program() {
+                const disabledArea = getDisabledArea(context)
+
+                for (const item of disabledArea.duplicateDisableDirectives) {
+                    context.report({
+                        loc: toRuleIdLocation(item.comment, item.ruleId),
+                        messageId: item.ruleId
+                            ? "duplicateRule"
+                            : "duplicate",
+                        data: item,
+                    })
+                }
+            },
+        }
+    },
+}

package/lib/rules/no-restricted-disable.js

@@ -0,0 +1,62 @@
+/**
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ * See LICENSE file in root directory for full license.
+ */
+
+import ignore from "ignore"
+import { getDisabledArea } from "../internal/disabled-area.js"
+import { toRuleIdLocation } from "../internal/utils.js"
+
+export default {
+    meta: {
+        docs: {
+            description:
+                "disallow `oxlint-disable` comments about specific rules",
+            category: "Stylistic Issues",
+            recommended: false,
+            url: "https://github.com/christopher-buss/eslint-plugin-oxlint-comments/blob/main/docs/rules/no-restricted-disable.md",
+        },
+        fixable: null,
+        messages: {
+            disallow: "Disabling '{{ruleId}}' is not allowed.",
+        },
+        schema: {
+            type: "array",
+            items: { type: "string" },
+            uniqueItems: true,
+        },
+        type: "suggestion",
+    },
+
+    createOnce(context) {
+        return {
+            Program() {
+                if (!context.options || context.options.length === 0) {
+                    return
+                }
+
+                const ig = ignore()
+                for (const pattern of context.options) {
+                    ig.add(pattern)
+                }
+                const disabledArea = getDisabledArea(context)
+
+                for (const area of disabledArea.areas) {
+                    if (area.ruleId == null || ig.ignores(area.ruleId)) {
+                        context.report({
+                            loc: toRuleIdLocation(
+                                area.comment,
+                                area.ruleId
+                            ),
+                            messageId: "disallow",
+                            data: {
+                                ruleId:
+                                    area.ruleId || String(context.options),
+                            },
+                        })
+                    }
+                }
+            },
+        }
+    },
+}

package/lib/rules/no-unlimited-disable.js

@@ -0,0 +1,52 @@
+/**
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ * See LICENSE file in root directory for full license.
+ */
+
+import { getAllDirectiveComments } from "../internal/get-all-directive-comments.js"
+import { toForceLocation } from "../internal/utils.js"
+
+export default {
+    meta: {
+        docs: {
+            description:
+                "disallow `oxlint-disable` comments without rule names",
+            category: "Best Practices",
+            recommended: true,
+            url: "https://github.com/christopher-buss/eslint-plugin-oxlint-comments/blob/main/docs/rules/no-unlimited-disable.md",
+        },
+        fixable: null,
+        messages: {
+            unexpected:
+                "Unexpected unlimited '{{kind}}' comment. Specify some rule names to disable.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+
+    createOnce(context) {
+        return {
+            Program() {
+                for (const directiveComment of getAllDirectiveComments(
+                    context
+                )) {
+                    const kind = directiveComment.kind
+                    if (
+                        kind !== "oxlint-disable" &&
+                        kind !== "oxlint-disable-line" &&
+                        kind !== "oxlint-disable-next-line"
+                    ) {
+                        continue
+                    }
+                    if (!directiveComment.value) {
+                        context.report({
+                            loc: toForceLocation(directiveComment.loc),
+                            messageId: "unexpected",
+                            data: { kind: directiveComment.kind },
+                        })
+                    }
+                }
+            },
+        }
+    },
+}

package/lib/rules/no-unused-enable.js

@@ -0,0 +1,42 @@
+/**
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ * See LICENSE file in root directory for full license.
+ */
+
+import { getDisabledArea } from "../internal/disabled-area.js"
+import { toRuleIdLocation } from "../internal/utils.js"
+
+export default {
+    meta: {
+        docs: {
+            description: "disallow unused `oxlint-enable` comments",
+            category: "Best Practices",
+            recommended: true,
+            url: "https://github.com/christopher-buss/eslint-plugin-oxlint-comments/blob/main/docs/rules/no-unused-enable.md",
+        },
+        fixable: null,
+        messages: {
+            unused: "Oxlint rules are re-enabled but those have not been disabled.",
+            unusedRule:
+                "'{{ruleId}}' rule is re-enabled but it has not been disabled.",
+        },
+        schema: [],
+        type: "problem",
+    },
+
+    createOnce(context) {
+        return {
+            Program() {
+                const disabledArea = getDisabledArea(context)
+
+                for (const item of disabledArea.unusedEnableDirectives) {
+                    context.report({
+                        loc: toRuleIdLocation(item.comment, item.ruleId),
+                        messageId: item.ruleId ? "unusedRule" : "unused",
+                        data: item,
+                    })
+                }
+            },
+        }
+    },
+}

package/lib/rules/no-use.js

@@ -0,0 +1,64 @@
+/**
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ * See LICENSE file in root directory for full license.
+ */
+
+import { getAllDirectiveComments } from "../internal/get-all-directive-comments.js"
+import { toForceLocation } from "../internal/utils.js"
+
+export default {
+    meta: {
+        docs: {
+            description: "disallow oxlint directive-comments",
+            category: "Stylistic Issues",
+            recommended: false,
+            url: "https://github.com/christopher-buss/eslint-plugin-oxlint-comments/blob/main/docs/rules/no-use.md",
+        },
+        fixable: null,
+        messages: {
+            disallow: "Unexpected oxlint directive comment.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    allow: {
+                        type: "array",
+                        items: {
+                            enum: [
+                                "oxlint-disable",
+                                "oxlint-disable-line",
+                                "oxlint-disable-next-line",
+                                "oxlint-enable",
+                            ],
+                        },
+                        additionalItems: false,
+                        uniqueItems: true,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        type: "suggestion",
+    },
+
+    createOnce(context) {
+        return {
+            Program() {
+                const allowed = new Set(
+                    (context.options && context.options[0] && context.options[0].allow) || []
+                )
+                for (const directiveComment of getAllDirectiveComments(
+                    context
+                )) {
+                    if (!allowed.has(directiveComment.kind)) {
+                        context.report({
+                            loc: toForceLocation(directiveComment.loc),
+                            messageId: "disallow",
+                        })
+                    }
+                }
+            },
+        }
+    },
+}

package/lib/rules/require-description.js

@@ -0,0 +1,69 @@
+/**
+ * @author Yosuke Ota <https://github.com/ota-meshi>
+ * See LICENSE file in root directory for full license.
+ */
+
+import { getAllDirectiveComments } from "../internal/get-all-directive-comments.js"
+import { toForceLocation } from "../internal/utils.js"
+
+export default {
+    meta: {
+        docs: {
+            description:
+                "require include descriptions in oxlint directive-comments",
+            category: "Stylistic Issues",
+            recommended: false,
+            url: "https://github.com/christopher-buss/eslint-plugin-oxlint-comments/blob/main/docs/rules/require-description.md",
+        },
+        fixable: null,
+        messages: {
+            missingDescription:
+                "Unexpected undescribed directive comment. Include descriptions to explain why the comment is necessary.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    ignore: {
+                        type: "array",
+                        items: {
+                            enum: [
+                                "oxlint-disable",
+                                "oxlint-disable-line",
+                                "oxlint-disable-next-line",
+                                "oxlint-enable",
+                            ],
+                        },
+                        additionalItems: false,
+                        uniqueItems: true,
+                    },
+                },
+                additionalProperties: false,
+            },
+        ],
+        type: "suggestion",
+    },
+
+    createOnce(context) {
+        return {
+            Program() {
+                const ignores = new Set(
+                    (context.options && context.options[0] && context.options[0].ignore) || []
+                )
+                for (const directiveComment of getAllDirectiveComments(
+                    context
+                )) {
+                    if (ignores.has(directiveComment.kind)) {
+                        continue
+                    }
+                    if (!directiveComment.description) {
+                        context.report({
+                            loc: toForceLocation(directiveComment.loc),
+                            messageId: "missingDescription",
+                        })
+                    }
+                }
+            },
+        }
+    },
+}

package/lib/rules.js

@@ -0,0 +1,21 @@
+/** DON'T EDIT THIS FILE; was created by scripts. */
+
+import disableEnablePair from "./rules/disable-enable-pair.js"
+import noAggregatingEnable from "./rules/no-aggregating-enable.js"
+import noDuplicateDisable from "./rules/no-duplicate-disable.js"
+import noRestrictedDisable from "./rules/no-restricted-disable.js"
+import noUnlimitedDisable from "./rules/no-unlimited-disable.js"
+import noUnusedEnable from "./rules/no-unused-enable.js"
+import noUse from "./rules/no-use.js"
+import requireDescription from "./rules/require-description.js"
+
+export default {
+    "disable-enable-pair": disableEnablePair,
+    "no-aggregating-enable": noAggregatingEnable,
+    "no-duplicate-disable": noDuplicateDisable,
+    "no-restricted-disable": noRestrictedDisable,
+    "no-unlimited-disable": noUnlimitedDisable,
+    "no-unused-enable": noUnusedEnable,
+    "no-use": noUse,
+    "require-description": requireDescription,
+}

package/package.json

@@ -0,0 +1,66 @@
+{
+  "name": "oxlint-plugin-oxlint-comments",
+  "version": "0.1.0",
+  "description": "Rules for oxlint directive comments.",
+  "keywords": [
+    "oxlint",
+    "plugin",
+    "comment",
+    "comments",
+    "directive",
+    "oxlint-enable",
+    "oxlint-disable",
+    "oxlint-disable-line",
+    "oxlint-disable-next-line"
+  ],
+  "homepage": "https://github.com/christopher-buss/eslint-plugin-oxlint-comments#readme",
+  "bugs": {
+    "url": "https://github.com/christopher-buss/eslint-plugin-oxlint-comments/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/christopher-buss/eslint-plugin-oxlint-comments"
+  },
+  "license": "MIT",
+  "author": "Toru Nagashima",
+  "type": "module",
+  "exports": {
+    ".": "./index.js",
+    "./package.json": "./package.json"
+  },
+  "main": "index.js",
+  "files": [
+    "index.js",
+    "lib"
+  ],
+  "dependencies": {
+    "escape-string-regexp": "^4.0.0",
+    "ignore": "^7.0.5",
+    "oxlint": ">=0.16.7"
+  },
+  "devDependencies": {
+    "bumpp": "^11.0.0",
+    "prettier": "2.8.8",
+    "rimraf": "^3.0.2",
+    "vitepress": "^1.6.4",
+    "vitest": "^3.2.1"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "scripts": {
+    "clean": "rimraf docs/.vitepress/cache",
+    "debug": "vitest",
+    "docs:build": "vitepress build docs",
+    "docs:watch": "vitepress dev docs",
+    "format": "npm run -s format:prettier -- --write",
+    "format:check": "npm run -s format:prettier -- --check",
+    "format:prettier": "prettier .",
+    "postversion": "git push && git push --tags",
+    "preversion": "npm test",
+    "release": "bumpp",
+    "test": "vitest run",
+    "version": "node scripts/update && git add .",
+    "watch": "vitest --watch"
+  }
+}