eslint-markdown 0.10.0 → 0.11.0

package/README.md

@@ -7,6 +7,7 @@
 
 [![npm package eslint-markdown latest version](https://img.shields.io/npm/v/eslint-markdown?label=eslint-markdown@latest&color=6358d4&labelColor=333333&logo=npm)](https://www.npmjs.com/package/eslint-markdown)
 [![npm package eslint-markdown next version](https://img.shields.io/npm/v/eslint-markdown/next?label=eslint-markdown@next&color=6358d4&labelColor=333333&logo=npm)](https://www.npmjs.com/package/eslint-markdown)
+[![npm package eslint-markdown downloads per month](https://img.shields.io/npm/dm/eslint-markdown?label=downloads&color=6358d4&labelColor=333333&logo=npm)](https://www.npmjs.com/package/eslint-markdown)
 
 > [!IMPORTANT]
 >

package/build/configs/all.d.ts

@@ -24,6 +24,7 @@ export default function all(plugin: ESLint.Plugin): {
         readonly 'md/consistent-strong-style': "error";
         readonly 'md/consistent-thematic-break-style': "error";
         readonly 'md/consistent-unordered-list-style': "error";
+        readonly 'md/no-consecutive-blank-line': "error";
         readonly 'md/no-control-character': "error";
         readonly 'md/no-curly-quote': "error";
         readonly 'md/no-double-punctuation': "error";

package/build/configs/stylistic.d.ts

@@ -21,6 +21,7 @@ export default function stylistic(plugin: ESLint.Plugin): {
         readonly 'md/consistent-strong-style': "error";
         readonly 'md/consistent-thematic-break-style': "error";
         readonly 'md/consistent-unordered-list-style': "error";
+        readonly 'md/no-consecutive-blank-line': "error";
         readonly 'md/no-tab': "error";
     };
 };

package/build/rules/index.d.ts

@@ -9,6 +9,7 @@ declare const _default: {
     'consistent-strong-style': import("../core/types.js").RuleModule<import("./consistent-strong-style.js").RuleOptions, "style">;
     'consistent-thematic-break-style': import("../core/types.js").RuleModule<import("./consistent-thematic-break-style.js").RuleOptions, "style">;
     'consistent-unordered-list-style': import("../core/types.js").RuleModule<import("./consistent-unordered-list-style.js").RuleOptions, "style">;
+    'no-consecutive-blank-line': import("../core/types.js").RuleModule<import("./no-consecutive-blank-line.js").RuleOptions, "noConsecutiveBlankLine">;
     'no-control-character': import("../core/types.js").RuleModule<import("./no-control-character.js").RuleOptions, import("./no-control-character.js").MessageIds>;
     'no-curly-quote': import("../core/types.js").RuleModule<import("./no-curly-quote.js").RuleOptions, "noCurlyQuote">;
     'no-double-punctuation': import("../core/types.js").RuleModule<import("./no-double-punctuation.js").RuleOptions, import("./no-double-punctuation.js").MessageIds>;

package/build/rules/no-consecutive-blank-line.d.ts

@@ -0,0 +1,60 @@
+declare const _default: {
+    meta: {
+        type: "layout";
+        docs: {
+            description: string;
+            url: string;
+            recommended: boolean;
+            stylistic: true;
+        };
+        fixable: "whitespace";
+        schema: {
+            type: "object";
+            properties: {
+                max: {
+                    type: "integer";
+                    minimum: number;
+                };
+                skipCode: {
+                    oneOf: ({
+                        type: "boolean";
+                        items?: never;
+                        uniqueItems?: never;
+                    } | {
+                        type: "array";
+                        items: {
+                            type: "string";
+                        };
+                        uniqueItems: true;
+                    })[];
+                };
+            };
+            additionalProperties: false;
+        }[];
+        defaultOptions: [{
+            max: number;
+            skipCode: true;
+        }];
+        messages: {
+            noConsecutiveBlankLine: string;
+        };
+        language: string;
+        dialects: string[];
+    };
+    create(context: import("@eslint/core").RuleContext<{
+        LangOptions: import("@eslint/markdown").MarkdownLanguageOptions;
+        Code: import("@eslint/markdown").MarkdownSourceCode;
+        RuleOptions: RuleOptions;
+        Node: import("mdast").Node;
+        MessageIds: "noConsecutiveBlankLine";
+    }>): {
+        code(node: import("mdast").Code): void;
+        'root:exit'(): void;
+    };
+};
+export default _default;
+export type RuleOptions = [{
+    max: number;
+    skipCode: boolean | string[];
+}];
+export type MessageIds = "noConsecutiveBlankLine";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-markdown",
-  "version": "0.10.0",
+  "version": "0.11.0",
   "type": "module",
   "sideEffects": false,
   "description": "Lint your Markdown with ESLint. Additional rules for use with `@eslint/markdown`.🛠️",

package/src/configs/all.js

@@ -48,6 +48,7 @@ export default function all(plugin) {
       'md/consistent-strong-style': 'error',
       'md/consistent-thematic-break-style': 'error',
       'md/consistent-unordered-list-style': 'error',
+      'md/no-consecutive-blank-line': 'error',
       'md/no-control-character': 'error',
       'md/no-curly-quote': 'error',
       'md/no-double-punctuation': 'error',

package/src/configs/stylistic.js

@@ -45,6 +45,7 @@ export default function stylistic(plugin) {
       'md/consistent-strong-style': 'error',
       'md/consistent-thematic-break-style': 'error',
       'md/consistent-unordered-list-style': 'error',
+      'md/no-consecutive-blank-line': 'error',
       'md/no-tab': 'error',
     },
   });

package/src/rules/index.js

@@ -15,6 +15,7 @@ import consistentThematicBreakStyle from './consistent-thematic-break-style.js';
 import consistentUnorderedListStyle from './consistent-unordered-list-style.js';
 // import enCapitalization from './en-capitalization.js';
 // import noBoldParagraph from './no-bold-paragraph.js';
+import noConsecutiveBlankLine from './no-consecutive-blank-line.js';
 import noControlCharacter from './no-control-character.js';
 import noCurlyQuote from './no-curly-quote.js';
 import noDoublePunctuation from './no-double-punctuation.js';
@@ -43,6 +44,7 @@ export default {
   'consistent-unordered-list-style': consistentUnorderedListStyle,
   // 'en-capitalization': enCapitalization,
   // 'no-bold-paragraph': noBoldParagraph,
+  'no-consecutive-blank-line': noConsecutiveBlankLine,
   'no-control-character': noControlCharacter,
   'no-curly-quote': noCurlyQuote,
   'no-double-punctuation': noDoublePunctuation,

package/src/rules/no-consecutive-blank-line.js

@@ -0,0 +1,199 @@
+/**
+ * @fileoverview Rule to disallow consecutive blank lines.
+ * @author lumir(lumirlumir)
+ * @see https://github.com/DavidAnson/markdownlint/blob/main/lib/md012.mjs
+ */
+
+// --------------------------------------------------------------------------------
+// Import
+// --------------------------------------------------------------------------------
+
+import { isBlankLine, SkipRanges } from '../core/ast/index.js';
+import { URL_RULE_DOCS } from '../core/constants.js';
+
+// --------------------------------------------------------------------------------
+// Typedef
+// --------------------------------------------------------------------------------
+
+/**
+ * @import { RuleModule } from '../core/types.js';
+ * @typedef {[{ max: number, skipCode: boolean | string[] }]} RuleOptions
+ * @typedef {'noConsecutiveBlankLine'} MessageIds
+ */
+
+// --------------------------------------------------------------------------------
+// Rule Definition
+// --------------------------------------------------------------------------------
+
+/** @type {RuleModule<RuleOptions, MessageIds>} */
+export default {
+  meta: {
+    type: 'layout',
+
+    docs: {
+      description: 'Disallow consecutive blank lines',
+      url: URL_RULE_DOCS('no-consecutive-blank-line'),
+      recommended: false,
+      stylistic: true,
+    },
+
+    fixable: 'whitespace',
+
+    schema: [
+      {
+        type: 'object',
+        properties: {
+          max: {
+            type: 'integer',
+            minimum: 1,
+          },
+          skipCode: {
+            oneOf: [
+              {
+                type: 'boolean',
+              },
+              {
+                type: 'array',
+                items: {
+                  type: 'string',
+                },
+                uniqueItems: true,
+              },
+            ],
+          },
+        },
+        additionalProperties: false,
+      },
+    ],
+
+    defaultOptions: [
+      {
+        max: 1,
+        skipCode: true,
+      },
+    ],
+
+    messages: {
+      noConsecutiveBlankLine:
+        'More than {{ max }} consecutive blank line(s) are not allowed.',
+    },
+
+    language: 'markdown',
+
+    dialects: ['commonmark', 'gfm'],
+  },
+
+  create(context) {
+    const { options, sourceCode } = context;
+    const [{ max, skipCode }] = options;
+    const { lines, text } = sourceCode;
+
+    const skipRanges = new SkipRanges();
+
+    return {
+      code(node) {
+        if (
+          Array.isArray(skipCode) ? node.lang && skipCode.includes(node.lang) : skipCode
+        )
+          skipRanges.push(sourceCode.getRange(node)); // Store range information of `Code`.
+      },
+
+      'root:exit'() {
+        let consecutiveBlankLineCount = 0;
+
+        for (let currentLineIdx = 0; currentLineIdx < lines.length; currentLineIdx++) {
+          const startLoc = /** @type {const} */ ({
+            line: currentLineIdx + 1,
+            column: 1,
+          });
+          const endLoc = /** @type {const} */ ({
+            line: currentLineIdx + 2,
+            column: 1,
+          });
+
+          if (
+            skipRanges.includes(sourceCode.getIndexFromLoc(startLoc)) ||
+            !isBlankLine(lines[currentLineIdx])
+          ) {
+            consecutiveBlankLineCount = 0;
+          } else {
+            consecutiveBlankLineCount++;
+          }
+
+          if (max < consecutiveBlankLineCount) {
+            const lastAllowedBlankLineIdx =
+              currentLineIdx - consecutiveBlankLineCount + max;
+
+            context.report({
+              loc: {
+                start: startLoc,
+                end: endLoc,
+              },
+
+              data: {
+                max,
+              },
+
+              messageId: 'noConsecutiveBlankLine',
+
+              fix(fixer) {
+                /*
+                 * When the consecutive blank-line run reaches EOF, the fixer must remove the
+                 * whole excess tail at once instead of removing only the current line.
+                 *
+                 * `currentLineIdx + 1 === lines.length` means the current line is the final
+                 * logical line in `sourceCode.lines`. In a case like `foo\n\n\n  ` with
+                 * `max: 1`, the final line is still a blank line, but it may contain spaces.
+                 * If we only remove from the current line start, those trailing spaces can
+                 * survive and produce `foo\n  ` instead of the intended `foo\n`.
+                 *
+                 * The start of the removal range is calculated from the last blank line that
+                 * is still allowed by `max`:
+                 *
+                 *   currentLineIdx - consecutiveBlankLineCount
+                 *     -> zero-based index of the first line in the current blank-line run
+                 *
+                 *   + max
+                 *     -> zero-based index of the last blank line we want to keep
+                 *
+                 *   + 1
+                 *     -> convert the zero-based line index to ESLint's one-based loc line
+                 *
+                 * The column is `lines[lastAllowedBlankLineIdx].length + 1`, which points to the
+                 * end of that allowed blank line. The range then ends at `text.length`, so
+                 * everything after the allowed blank line is removed, including remaining blank
+                 * lines, line endings, and any spaces on the final blank line.
+                 *
+                 * Example with `foo\n\n\n  ` and `max: 1`:
+                 *
+                 *   lines = ['foo', '', '', '  ']
+                 *   currentLineIdx = 3
+                 *   consecutiveBlankLineCount = 3
+                 *   max = 1
+                 *
+                 *   lastAllowedBlankLineIdx = 3 - 3 + 1 = 1
+                 *
+                 * So the fixer removes from the end of line 2 to EOF, producing `foo\n`.
+                 */
+                if (currentLineIdx + 1 === lines.length) {
+                  return fixer.removeRange([
+                    sourceCode.getIndexFromLoc({
+                      line: lastAllowedBlankLineIdx + 1,
+                      column: lines[lastAllowedBlankLineIdx].length + 1,
+                    }),
+                    text.length,
+                  ]);
+                } else {
+                  return fixer.removeRange([
+                    sourceCode.getIndexFromLoc(startLoc),
+                    sourceCode.getIndexFromLoc(endLoc),
+                  ]);
+                }
+              },
+            });
+          }
+        }
+      },
+    };
+  },
+};