eslint-plugin-jsdoc 55.3.0 → 56.0.0

package/dist/cjs/rules/convertToJsdocComments.d.ts

@@ -0,0 +1,251 @@
+declare const _default: {
+    create(context: import("eslint").Rule.RuleContext): {
+        [x: string]: ((...args: any[]) => void) | ((codePath: import("eslint").Rule.CodePath, node: import("eslint").Rule.Node) => void) | ((segment: import("eslint").Rule.CodePathSegment, node: import("eslint").Rule.Node) => void) | ((fromSegment: import("eslint").Rule.CodePathSegment, toSegment: import("eslint").Rule.CodePathSegment, node: import("eslint").Rule.Node) => void) | ((node: import("eslint").Rule.Node) => void) | undefined;
+        onCodePathStart?: ((codePath: import("eslint").Rule.CodePath, node: import("eslint").Rule.Node) => void) | undefined;
+        onCodePathEnd?: ((codePath: import("eslint").Rule.CodePath, node: import("eslint").Rule.Node) => void) | undefined;
+        onCodePathSegmentStart?: ((segment: import("eslint").Rule.CodePathSegment, node: import("eslint").Rule.Node) => void) | undefined;
+        onCodePathSegmentEnd?: ((segment: import("eslint").Rule.CodePathSegment, node: import("eslint").Rule.Node) => void) | undefined;
+        onCodePathSegmentLoop?: ((fromSegment: import("eslint").Rule.CodePathSegment, toSegment: import("eslint").Rule.CodePathSegment, node: import("eslint").Rule.Node) => void) | undefined;
+        ArrayExpression?: ((node: import("estree").ArrayExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ArrayExpression:exit"?: ((node: import("estree").ArrayExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        ArrayPattern?: ((node: import("estree").ArrayPattern & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ArrayPattern:exit"?: ((node: import("estree").ArrayPattern & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        ArrowFunctionExpression?: ((node: import("estree").ArrowFunctionExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ArrowFunctionExpression:exit"?: ((node: import("estree").ArrowFunctionExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        AssignmentExpression?: ((node: import("estree").AssignmentExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "AssignmentExpression:exit"?: ((node: import("estree").AssignmentExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        AssignmentPattern?: ((node: import("estree").AssignmentPattern & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "AssignmentPattern:exit"?: ((node: import("estree").AssignmentPattern & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        AwaitExpression?: ((node: import("estree").AwaitExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "AwaitExpression:exit"?: ((node: import("estree").AwaitExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        BinaryExpression?: ((node: import("estree").BinaryExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "BinaryExpression:exit"?: ((node: import("estree").BinaryExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        BlockStatement?: ((node: import("estree").BlockStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "BlockStatement:exit"?: ((node: import("estree").BlockStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        BreakStatement?: ((node: import("estree").BreakStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "BreakStatement:exit"?: ((node: import("estree").BreakStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        CallExpression?: ((node: import("estree").CallExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "CallExpression:exit"?: ((node: import("estree").CallExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        CatchClause?: ((node: import("estree").CatchClause & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "CatchClause:exit"?: ((node: import("estree").CatchClause & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        ChainExpression?: ((node: import("estree").ChainExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ChainExpression:exit"?: ((node: import("estree").ChainExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        ClassBody?: ((node: import("estree").ClassBody & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ClassBody:exit"?: ((node: import("estree").ClassBody & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        ClassDeclaration?: ((node: import("estree").ClassDeclaration & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ClassDeclaration:exit"?: ((node: import("estree").ClassDeclaration & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        ClassExpression?: ((node: import("estree").ClassExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ClassExpression:exit"?: ((node: import("estree").ClassExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        ConditionalExpression?: ((node: import("estree").ConditionalExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ConditionalExpression:exit"?: ((node: import("estree").ConditionalExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        ContinueStatement?: ((node: import("estree").ContinueStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ContinueStatement:exit"?: ((node: import("estree").ContinueStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        DebuggerStatement?: ((node: import("estree").DebuggerStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "DebuggerStatement:exit"?: ((node: import("estree").DebuggerStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        DoWhileStatement?: ((node: import("estree").DoWhileStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "DoWhileStatement:exit"?: ((node: import("estree").DoWhileStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        EmptyStatement?: ((node: import("estree").EmptyStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "EmptyStatement:exit"?: ((node: import("estree").EmptyStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        ExportAllDeclaration?: ((node: import("estree").ExportAllDeclaration & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ExportAllDeclaration:exit"?: ((node: import("estree").ExportAllDeclaration & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        ExportDefaultDeclaration?: ((node: import("estree").ExportDefaultDeclaration & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ExportDefaultDeclaration:exit"?: ((node: import("estree").ExportDefaultDeclaration & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        ExportNamedDeclaration?: ((node: import("estree").ExportNamedDeclaration & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ExportNamedDeclaration:exit"?: ((node: import("estree").ExportNamedDeclaration & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        ExportSpecifier?: ((node: import("estree").ExportSpecifier & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ExportSpecifier:exit"?: ((node: import("estree").ExportSpecifier & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        ExpressionStatement?: ((node: import("estree").ExpressionStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ExpressionStatement:exit"?: ((node: import("estree").ExpressionStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        ForInStatement?: ((node: import("estree").ForInStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ForInStatement:exit"?: ((node: import("estree").ForInStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        ForOfStatement?: ((node: import("estree").ForOfStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ForOfStatement:exit"?: ((node: import("estree").ForOfStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        ForStatement?: ((node: import("estree").ForStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ForStatement:exit"?: ((node: import("estree").ForStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        FunctionDeclaration?: ((node: import("estree").FunctionDeclaration & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "FunctionDeclaration:exit"?: ((node: import("estree").FunctionDeclaration & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        FunctionExpression?: ((node: import("estree").FunctionExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "FunctionExpression:exit"?: ((node: import("estree").FunctionExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        Identifier?: ((node: import("estree").Identifier & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "Identifier:exit"?: ((node: import("estree").Identifier & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        IfStatement?: ((node: import("estree").IfStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "IfStatement:exit"?: ((node: import("estree").IfStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        ImportDeclaration?: ((node: import("estree").ImportDeclaration & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ImportDeclaration:exit"?: ((node: import("estree").ImportDeclaration & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        ImportDefaultSpecifier?: ((node: import("estree").ImportDefaultSpecifier & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ImportDefaultSpecifier:exit"?: ((node: import("estree").ImportDefaultSpecifier & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        ImportExpression?: ((node: import("estree").ImportExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ImportExpression:exit"?: ((node: import("estree").ImportExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        ImportNamespaceSpecifier?: ((node: import("estree").ImportNamespaceSpecifier & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ImportNamespaceSpecifier:exit"?: ((node: import("estree").ImportNamespaceSpecifier & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        ImportSpecifier?: ((node: import("estree").ImportSpecifier & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ImportSpecifier:exit"?: ((node: import("estree").ImportSpecifier & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        LabeledStatement?: ((node: import("estree").LabeledStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "LabeledStatement:exit"?: ((node: import("estree").LabeledStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        Literal?: ((node: import("estree").Literal & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "Literal:exit"?: ((node: import("estree").Literal & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        LogicalExpression?: ((node: import("estree").LogicalExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "LogicalExpression:exit"?: ((node: import("estree").LogicalExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        MemberExpression?: ((node: import("estree").MemberExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "MemberExpression:exit"?: ((node: import("estree").MemberExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        MetaProperty?: ((node: import("estree").MetaProperty & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "MetaProperty:exit"?: ((node: import("estree").MetaProperty & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        MethodDefinition?: ((node: import("estree").MethodDefinition & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "MethodDefinition:exit"?: ((node: import("estree").MethodDefinition & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        NewExpression?: ((node: import("estree").NewExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "NewExpression:exit"?: ((node: import("estree").NewExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        ObjectExpression?: ((node: import("estree").ObjectExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ObjectExpression:exit"?: ((node: import("estree").ObjectExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        ObjectPattern?: ((node: import("estree").ObjectPattern & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ObjectPattern:exit"?: ((node: import("estree").ObjectPattern & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        PrivateIdentifier?: ((node: import("estree").PrivateIdentifier & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "PrivateIdentifier:exit"?: ((node: import("estree").PrivateIdentifier & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        Program?: ((node: import("estree").Program) => void) | undefined;
+        "Program:exit"?: ((node: import("estree").Program) => void) | undefined;
+        Property?: ((node: import("estree").Property & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "Property:exit"?: ((node: import("estree").Property & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        PropertyDefinition?: ((node: import("estree").PropertyDefinition & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "PropertyDefinition:exit"?: ((node: import("estree").PropertyDefinition & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        RestElement?: ((node: import("estree").RestElement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "RestElement:exit"?: ((node: import("estree").RestElement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        ReturnStatement?: ((node: import("estree").ReturnStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ReturnStatement:exit"?: ((node: import("estree").ReturnStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        SequenceExpression?: ((node: import("estree").SequenceExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "SequenceExpression:exit"?: ((node: import("estree").SequenceExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        SpreadElement?: ((node: import("estree").SpreadElement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "SpreadElement:exit"?: ((node: import("estree").SpreadElement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        StaticBlock?: ((node: import("estree").StaticBlock & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "StaticBlock:exit"?: ((node: import("estree").StaticBlock & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        Super?: ((node: import("estree").Super & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "Super:exit"?: ((node: import("estree").Super & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        SwitchCase?: ((node: import("estree").SwitchCase & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "SwitchCase:exit"?: ((node: import("estree").SwitchCase & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        SwitchStatement?: ((node: import("estree").SwitchStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "SwitchStatement:exit"?: ((node: import("estree").SwitchStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        TaggedTemplateExpression?: ((node: import("estree").TaggedTemplateExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "TaggedTemplateExpression:exit"?: ((node: import("estree").TaggedTemplateExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        TemplateElement?: ((node: import("estree").TemplateElement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "TemplateElement:exit"?: ((node: import("estree").TemplateElement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        TemplateLiteral?: ((node: import("estree").TemplateLiteral & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "TemplateLiteral:exit"?: ((node: import("estree").TemplateLiteral & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        ThisExpression?: ((node: import("estree").ThisExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ThisExpression:exit"?: ((node: import("estree").ThisExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        ThrowStatement?: ((node: import("estree").ThrowStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "ThrowStatement:exit"?: ((node: import("estree").ThrowStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        TryStatement?: ((node: import("estree").TryStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "TryStatement:exit"?: ((node: import("estree").TryStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        UnaryExpression?: ((node: import("estree").UnaryExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "UnaryExpression:exit"?: ((node: import("estree").UnaryExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        UpdateExpression?: ((node: import("estree").UpdateExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "UpdateExpression:exit"?: ((node: import("estree").UpdateExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        VariableDeclaration?: ((node: import("estree").VariableDeclaration & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "VariableDeclaration:exit"?: ((node: import("estree").VariableDeclaration & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        VariableDeclarator?: ((node: import("estree").VariableDeclarator & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "VariableDeclarator:exit"?: ((node: import("estree").VariableDeclarator & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        WhileStatement?: ((node: import("estree").WhileStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "WhileStatement:exit"?: ((node: import("estree").WhileStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        WithStatement?: ((node: import("estree").WithStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "WithStatement:exit"?: ((node: import("estree").WithStatement & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        YieldExpression?: ((node: import("estree").YieldExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+        "YieldExpression:exit"?: ((node: import("estree").YieldExpression & import("eslint").Rule.NodeParentExtension) => void) | undefined;
+    };
+    meta: {
+        docs: {
+            description: string;
+            url: string;
+        };
+        fixable: "code";
+        messages: {
+            blockCommentsJsdocStyle: string;
+            lineCommentsJsdocStyle: string;
+        };
+        schema: {
+            additionalProperties: false;
+            properties: {
+                allowedPrefixes: {
+                    items: {
+                        type: "string";
+                    };
+                    type: "array";
+                };
+                contexts: {
+                    items: {
+                        anyOf: ({
+                            type: "string";
+                            additionalProperties?: undefined;
+                            properties?: undefined;
+                        } | {
+                            additionalProperties: false;
+                            properties: {
+                                context: {
+                                    type: "string";
+                                };
+                                inlineCommentBlock: {
+                                    type: "boolean";
+                                };
+                            };
+                            type: "object";
+                        })[];
+                    };
+                    type: "array";
+                };
+                contextsAfter: {
+                    items: {
+                        anyOf: ({
+                            type: "string";
+                            additionalProperties?: undefined;
+                            properties?: undefined;
+                        } | {
+                            additionalProperties: false;
+                            properties: {
+                                context: {
+                                    type: "string";
+                                };
+                                inlineCommentBlock: {
+                                    type: "boolean";
+                                };
+                            };
+                            type: "object";
+                        })[];
+                    };
+                    type: "array";
+                };
+                contextsBeforeAndAfter: {
+                    items: {
+                        anyOf: ({
+                            type: "string";
+                            additionalProperties?: undefined;
+                            properties?: undefined;
+                        } | {
+                            additionalProperties: false;
+                            properties: {
+                                context: {
+                                    type: "string";
+                                };
+                                inlineCommentBlock: {
+                                    type: "boolean";
+                                };
+                            };
+                            type: "object";
+                        })[];
+                    };
+                    type: "array";
+                };
+                enableFixer: {
+                    type: "boolean";
+                };
+                enforceJsdocLineStyle: {
+                    enum: string[];
+                    type: "string";
+                };
+                lineOrBlockStyle: {
+                    enum: string[];
+                    type: "string";
+                };
+            };
+            type: "object";
+        }[];
+        type: "suggestion";
+    };
+};
+export default _default;

package/dist/cjs/rules/convertToJsdocComments.js

@@ -0,0 +1,313 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const iterateJsdoc_js_1 = require("../iterateJsdoc.js");
+const jsdocUtils_js_1 = require("../jsdocUtils.js");
+const jsdoccomment_1 = require("@es-joy/jsdoccomment");
+/** @type {import('eslint').Rule.RuleModule} */
+exports.default = {
+    create(context) {
+        /**
+         * @typedef {import('eslint').AST.Token | import('estree').Comment | {
+         *   type: import('eslint').AST.TokenType|"Line"|"Block"|"Shebang",
+         *   range: [number, number],
+         *   value: string
+         * }} Token
+         */
+        /**
+         * @callback AddComment
+         * @param {boolean|undefined} inlineCommentBlock
+         * @param {Token} comment
+         * @param {string} indent
+         * @param {number} lines
+         * @param {import('eslint').Rule.RuleFixer} fixer
+         */
+        /* c8 ignore next -- Fallback to deprecated method */
+        const { sourceCode = context.getSourceCode(), } = context;
+        const settings = (0, iterateJsdoc_js_1.getSettings)(context);
+        if (!settings) {
+            return {};
+        }
+        const { allowedPrefixes = [
+            '@ts-', 'istanbul ', 'c8 ', 'v8 ', 'eslint', 'prettier-',
+        ], contexts = settings.contexts || [], contextsAfter = /** @type {string[]} */ ([]), contextsBeforeAndAfter = [
+            'VariableDeclarator', 'TSPropertySignature', 'PropertyDefinition',
+        ], enableFixer = true, enforceJsdocLineStyle = 'multi', lineOrBlockStyle = 'both', } = context.options[0] ?? {};
+        let reportingNonJsdoc = false;
+        /**
+         * @param {string} messageId
+         * @param {import('estree').Comment|Token} comment
+         * @param {import('eslint').Rule.Node} node
+         * @param {import('eslint').Rule.ReportFixer} fixer
+         */
+        const report = (messageId, comment, node, fixer) => {
+            const loc = {
+                end: {
+                    column: 0,
+                    /* c8 ignore next 2 -- Guard */
+                    // @ts-expect-error Ok
+                    line: (comment.loc?.start?.line ?? 1),
+                },
+                start: {
+                    column: 0,
+                    /* c8 ignore next 2 -- Guard */
+                    // @ts-expect-error Ok
+                    line: (comment.loc?.start?.line ?? 1),
+                },
+            };
+            context.report({
+                fix: enableFixer ? fixer : null,
+                loc,
+                messageId,
+                node,
+            });
+        };
+        /**
+         * @param {import('eslint').Rule.Node} node
+         * @param {import('eslint').AST.Token | import('estree').Comment | {
+         *   type: import('eslint').AST.TokenType|"Line"|"Block"|"Shebang",
+         *   range: [number, number],
+         *   value: string
+         * }} comment
+         * @param {AddComment} addComment
+         * @param {import('../iterateJsdoc.js').Context[]} ctxts
+         */
+        const getFixer = (node, comment, addComment, ctxts) => {
+            return /** @type {import('eslint').Rule.ReportFixer} */ (fixer) => {
+                // Default to one line break if the `minLines`/`maxLines` settings allow
+                const lines = settings.minLines === 0 && settings.maxLines >= 1 ? 1 : settings.minLines;
+                let baseNode = 
+                /**
+                 * @type {import('@typescript-eslint/types').TSESTree.Node|import('eslint').Rule.Node}
+                 */ ((0, jsdoccomment_1.getReducedASTNode)(node, sourceCode));
+                const decorator = (0, jsdoccomment_1.getDecorator)(
+                /** @type {import('eslint').Rule.Node} */
+                (baseNode));
+                if (decorator) {
+                    baseNode = /** @type {import('@typescript-eslint/types').TSESTree.Decorator} */ (decorator);
+                }
+                const indent = (0, jsdocUtils_js_1.getIndent)({
+                    text: sourceCode.getText(
+                    /** @type {import('eslint').Rule.Node} */ (baseNode), 
+                    /** @type {import('eslint').AST.SourceLocation} */
+                    (
+                    /** @type {import('eslint').Rule.Node} */ (baseNode).loc).start.column),
+                });
+                const { inlineCommentBlock, } = 
+                /**
+                 * @type {{
+                 *     context: string,
+                 *     inlineCommentBlock: boolean,
+                 *     minLineCount: import('../iterateJsdoc.js').Integer
+                 *   }[]}
+                 */ (ctxts).find((contxt) => {
+                    if (typeof contxt === 'string') {
+                        return false;
+                    }
+                    const { context: ctxt, } = contxt;
+                    return ctxt === node.type;
+                }) || {};
+                return addComment(inlineCommentBlock, comment, indent, lines, fixer);
+            };
+        };
+        /**
+         * @param {import('eslint').AST.Token | import('estree').Comment | {
+         *   type: import('eslint').AST.TokenType|"Line"|"Block"|"Shebang",
+         *   range: [number, number],
+         *   value: string
+         * }} comment
+         * @param {import('eslint').Rule.Node} node
+         * @param {AddComment} addComment
+         * @param {import('../iterateJsdoc.js').Context[]} ctxts
+         */
+        const reportings = (comment, node, addComment, ctxts) => {
+            const fixer = getFixer(node, comment, addComment, ctxts);
+            if (comment.type === 'Block') {
+                if (lineOrBlockStyle === 'line') {
+                    return;
+                }
+                report('blockCommentsJsdocStyle', comment, node, fixer);
+                return;
+            }
+            if (comment.type === 'Line') {
+                if (lineOrBlockStyle === 'block') {
+                    return;
+                }
+                report('lineCommentsJsdocStyle', comment, node, fixer);
+            }
+        };
+        /**
+         * @type {import('../iterateJsdoc.js').CheckJsdoc}
+         */
+        const checkNonJsdoc = (_info, _handler, node) => {
+            const comment = (0, jsdoccomment_1.getNonJsdocComment)(sourceCode, node, settings);
+            if (!comment ||
+                /** @type {string[]} */
+                (allowedPrefixes).some((prefix) => {
+                    return comment.value.trimStart().startsWith(prefix);
+                })) {
+                return;
+            }
+            reportingNonJsdoc = true;
+            /** @type {AddComment} */
+            // eslint-disable-next-line unicorn/consistent-function-scoping -- Avoid conflicts
+            const addComment = (inlineCommentBlock, commentToAdd, indent, lines, fixer) => {
+                const insertion = (inlineCommentBlock || enforceJsdocLineStyle === 'single' ?
+                    `/** ${commentToAdd.value.trim()} ` :
+                    `/**\n${indent}*${commentToAdd.value.trimEnd()}\n${indent}`) +
+                    `*/${'\n'.repeat((lines || 1) - 1)}`;
+                return fixer.replaceText(
+                /** @type {import('eslint').AST.Token} */
+                (commentToAdd), insertion);
+            };
+            reportings(comment, node, addComment, contexts);
+        };
+        /**
+         * @param {import('eslint').Rule.Node} node
+         * @param {import('../iterateJsdoc.js').Context[]} ctxts
+         */
+        const checkNonJsdocAfter = (node, ctxts) => {
+            const comment = (0, jsdoccomment_1.getFollowingComment)(sourceCode, node);
+            if (!comment ||
+                comment.value.startsWith('*') ||
+                /** @type {string[]} */
+                (allowedPrefixes).some((prefix) => {
+                    return comment.value.trimStart().startsWith(prefix);
+                })) {
+                return;
+            }
+            /** @type {AddComment} */
+            const addComment = (inlineCommentBlock, commentToAdd, indent, lines, fixer) => {
+                const insertion = (inlineCommentBlock || enforceJsdocLineStyle === 'single' ?
+                    `/** ${commentToAdd.value.trim()} ` :
+                    `/**\n${indent}*${commentToAdd.value.trimEnd()}\n${indent}`) +
+                    `*/${'\n'.repeat((lines || 1) - 1)}${lines ? `\n${indent.slice(1)}` : ' '}`;
+                return [
+                    fixer.remove(
+                    /** @type {import('eslint').AST.Token} */
+                    (commentToAdd)), fixer.insertTextBefore(node.type === 'VariableDeclarator' ? node.parent : node, insertion),
+                ];
+            };
+            reportings(comment, node, addComment, ctxts);
+        };
+        // Todo: add contexts to check after (and handle if want both before and after)
+        return {
+            ...(0, jsdocUtils_js_1.getContextObject)((0, jsdocUtils_js_1.enforcedContexts)(context, true, settings), checkNonJsdoc),
+            ...(0, jsdocUtils_js_1.getContextObject)(contextsAfter, (_info, _handler, node) => {
+                checkNonJsdocAfter(node, contextsAfter);
+            }),
+            ...(0, jsdocUtils_js_1.getContextObject)(contextsBeforeAndAfter, (_info, _handler, node) => {
+                checkNonJsdoc({}, null, node);
+                if (!reportingNonJsdoc) {
+                    checkNonJsdocAfter(node, contextsBeforeAndAfter);
+                }
+            }),
+        };
+    },
+    meta: {
+        docs: {
+            description: 'Converts non-JSDoc comments preceding or following nodes into JSDoc ones',
+            url: 'https://github.com/gajus/eslint-plugin-jsdoc/blob/main/docs/rules/convert-to-jsdoc-comments.md#repos-sticky-header',
+        },
+        fixable: 'code',
+        messages: {
+            blockCommentsJsdocStyle: 'Block comments should be JSDoc-style.',
+            lineCommentsJsdocStyle: 'Line comments should be JSDoc-style.',
+        },
+        schema: [
+            {
+                additionalProperties: false,
+                properties: {
+                    allowedPrefixes: {
+                        items: {
+                            type: 'string',
+                        },
+                        type: 'array',
+                    },
+                    contexts: {
+                        items: {
+                            anyOf: [
+                                {
+                                    type: 'string',
+                                },
+                                {
+                                    additionalProperties: false,
+                                    properties: {
+                                        context: {
+                                            type: 'string',
+                                        },
+                                        inlineCommentBlock: {
+                                            type: 'boolean',
+                                        },
+                                    },
+                                    type: 'object',
+                                },
+                            ],
+                        },
+                        type: 'array',
+                    },
+                    contextsAfter: {
+                        items: {
+                            anyOf: [
+                                {
+                                    type: 'string',
+                                },
+                                {
+                                    additionalProperties: false,
+                                    properties: {
+                                        context: {
+                                            type: 'string',
+                                        },
+                                        inlineCommentBlock: {
+                                            type: 'boolean',
+                                        },
+                                    },
+                                    type: 'object',
+                                },
+                            ],
+                        },
+                        type: 'array',
+                    },
+                    contextsBeforeAndAfter: {
+                        items: {
+                            anyOf: [
+                                {
+                                    type: 'string',
+                                },
+                                {
+                                    additionalProperties: false,
+                                    properties: {
+                                        context: {
+                                            type: 'string',
+                                        },
+                                        inlineCommentBlock: {
+                                            type: 'boolean',
+                                        },
+                                    },
+                                    type: 'object',
+                                },
+                            ],
+                        },
+                        type: 'array',
+                    },
+                    enableFixer: {
+                        type: 'boolean',
+                    },
+                    enforceJsdocLineStyle: {
+                        enum: [
+                            'multi', 'single',
+                        ],
+                        type: 'string',
+                    },
+                    lineOrBlockStyle: {
+                        enum: [
+                            'block', 'line', 'both',
+                        ],
+                        type: 'string',
+                    },
+                },
+                type: 'object',
+            },
+        ],
+        type: 'suggestion',
+    },
+};

package/dist/cjs/rules/emptyTags.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("eslint").Rule.RuleModule;
+export default _default;