eslint-plugin-markdown-preferences 0.9.0 → 0.10.0

package/README.md

@@ -50,7 +50,7 @@ Example **eslint.config.js**:
 ```js
 import { defineConfig } from "eslint/config";
 // import markdown from "@eslint/markdown";
-import markdownPreferences from 'eslint-plugin-markdown-preferences';
+import markdownPreferences from "eslint-plugin-markdown-preferences";
 export default [
   // add more generic rule sets here, such as:
   // markdown.configs.recommended,
@@ -59,8 +59,8 @@ export default [
     rules: {
       // override/add rules settings here, such as:
       // 'markdown-preferences/prefer-linked-words': 'error'
-    }
-  }
+    },
+  },
 ];
 ```
 
@@ -86,6 +86,8 @@ The rules with the following star ⭐ are included in the configs.
 
 <!--RULES_TABLE_START-->
 
+<!-- prettier-ignore-start -->
+
 ### Preference Rules
 
 | Rule ID | Description | Fixable | RECOMMENDED |
@@ -102,10 +104,14 @@ The rules with the following star ⭐ are included in the configs.
 | [markdown-preferences/definitions-last](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/definitions-last.html) | require link definitions and footnote definitions to be placed at the end of the document | 🔧 |  |
 | [markdown-preferences/hard-linebreak-style](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/hard-linebreak-style.html) | enforce consistent hard linebreak style. | 🔧 | ⭐ |
 | [markdown-preferences/heading-casing](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/heading-casing.html) | enforce consistent casing in headings. | 🔧 |  |
+| [markdown-preferences/no-laziness-blockquotes](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-laziness-blockquotes.html) | disallow laziness in blockquotes |  | ⭐ |
+| [markdown-preferences/no-multiple-empty-lines](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-multiple-empty-lines.html) | disallow multiple empty lines in Markdown files. | 🔧 |  |
 | [markdown-preferences/no-trailing-spaces](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-trailing-spaces.html) | disallow trailing whitespace at the end of lines in Markdown files. | 🔧 |  |
 | [markdown-preferences/prefer-link-reference-definitions](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-link-reference-definitions.html) | enforce using link reference definitions instead of inline links | 🔧 |  |
 | [markdown-preferences/sort-definitions](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/sort-definitions.html) | enforce a specific order for link definitions and footnote definitions | 🔧 |  |
 
+<!-- prettier-ignore-end -->
+
 <!--RULES_TABLE_END-->
 <!--RULES_SECTION_END-->
 <!--DOCS_IGNORE_START-->

package/lib/index.d.ts

@@ -30,6 +30,16 @@ interface RuleOptions {
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/heading-casing.html
    */
   'markdown-preferences/heading-casing'?: Linter.RuleEntry<MarkdownPreferencesHeadingCasing>;
+  /**
+   * disallow laziness in blockquotes
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-laziness-blockquotes.html
+   */
+  'markdown-preferences/no-laziness-blockquotes'?: Linter.RuleEntry<[]>;
+  /**
+   * disallow multiple empty lines in Markdown files.
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-multiple-empty-lines.html
+   */
+  'markdown-preferences/no-multiple-empty-lines'?: Linter.RuleEntry<MarkdownPreferencesNoMultipleEmptyLines>;
   /**
    * disallow text backslash at the end of a line.
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-text-backslash-linebreak.html
@@ -75,6 +85,11 @@ type MarkdownPreferencesHeadingCasing = [] | [{
   ignorePatterns?: string[];
   minorWords?: string[];
 }];
+type MarkdownPreferencesNoMultipleEmptyLines = [] | [{
+  max?: number;
+  maxEOF?: number;
+  maxBOF?: number;
+}];
 type MarkdownPreferencesNoTrailingSpaces = [] | [{
   skipBlankLines?: boolean;
   ignoreComments?: boolean;
@@ -128,7 +143,7 @@ declare namespace meta_d_exports {
   export { name, version };
 }
 declare const name: "eslint-plugin-markdown-preferences";
-declare const version: "0.9.0";
+declare const version: "0.10.0";
 //#endregion
 //#region src/index.d.ts
 declare const configs: {

package/lib/index.js

@@ -978,6 +978,333 @@ var heading_casing_default = createRule("heading-casing", {
 	}
 });
 
+//#endregion
+//#region src/utils/lines.ts
+const cache = /* @__PURE__ */ new WeakMap();
+var ParsedLines = class {
+	lines;
+	constructor(codeText) {
+		let offset = 0;
+		this.lines = codeText.split(/(?<=\n)/u).map((lineText, index) => {
+			const start = offset;
+			offset += lineText.length;
+			const range = [start, offset];
+			let text = lineText;
+			let linebreak = "";
+			if (text.at(-1) === "\n") {
+				text = text.slice(0, -1);
+				linebreak = "\n";
+			}
+			if (text.at(-1) === "\r") {
+				text = text.slice(0, -1);
+				linebreak = `\r${linebreak}`;
+			}
+			return {
+				text,
+				range,
+				line: index + 1,
+				linebreak
+			};
+		});
+	}
+	[Symbol.iterator]() {
+		return this.lines[Symbol.iterator]();
+	}
+	get length() {
+		return this.lines.length;
+	}
+	get(lineNumber) {
+		return this.lines[lineNumber - 1];
+	}
+};
+/**
+* Parse the lines of the source code.
+* @param sourceCode source code to parse
+* @returns parsed lines
+*/
+function parseLines(sourceCode) {
+	const cached = cache.get(sourceCode);
+	if (cached) return cached;
+	const parsedLines = new ParsedLines(sourceCode.text);
+	cache.set(sourceCode, parsedLines);
+	return parsedLines;
+}
+
+//#endregion
+//#region src/rules/no-laziness-blockquotes.ts
+/**
+* Helper function to get blockquote line information.
+*/
+function getBlockquoteLineInfo(line) {
+	const regex = /^\s*(?:>\s*)*/u;
+	const match = regex.exec(line.text);
+	return {
+		line,
+		prefix: match[0],
+		level: (match[0].match(/>/gu) || []).length
+	};
+}
+var no_laziness_blockquotes_default = createRule("no-laziness-blockquotes", {
+	meta: {
+		type: "problem",
+		docs: {
+			description: "disallow laziness in blockquotes",
+			categories: ["recommended"],
+			listCategory: "Stylistic"
+		},
+		fixable: void 0,
+		hasSuggestions: true,
+		schema: [],
+		messages: {
+			lazyBlockquoteLine: "Expected {{level}} '>' marker(s), but found {{actualLevel}}. This line will be interpreted as part of level {{level}} blockquote.",
+			addMarker: "Add {{missingMarkers}} '>' marker(s).",
+			addLineBreak: "Add line break to separate from blockquote."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const checkedLines = /* @__PURE__ */ new Set();
+		const lines = parseLines(sourceCode);
+		/**
+		* Report invalid blockquote lines.
+		*/
+		function reportInvalidLines(invalidLines, base) {
+			const invalidGroups = [];
+			for (const invalidLine of invalidLines) {
+				const currentGroup = invalidGroups.at(-1);
+				if (!currentGroup || currentGroup.level < invalidLine.level) {
+					invalidGroups.push({
+						level: invalidLine.level,
+						lines: [invalidLine]
+					});
+					continue;
+				}
+				if (currentGroup.level === invalidLine.level) {
+					currentGroup.lines.push(invalidLine);
+					continue;
+				}
+				if (invalidLine.level < currentGroup.level) break;
+			}
+			for (const group of invalidGroups) {
+				const first = group.lines[0];
+				const last = group.lines.at(-1);
+				context.report({
+					loc: {
+						start: {
+							line: first.line.line,
+							column: 1
+						},
+						end: {
+							line: last.line.line,
+							column: last.line.text.length + 1
+						}
+					},
+					messageId: "lazyBlockquoteLine",
+					data: {
+						level: `${base.level}`,
+						actualLevel: `${group.level}`
+					},
+					suggest: [{
+						messageId: "addMarker",
+						data: { missingMarkers: `${base.level - group.level}` },
+						*fix(fixer) {
+							for (const invalidLine of group.lines) yield fixer.replaceTextRange([invalidLine.line.range[0], invalidLine.line.range[0] + invalidLine.prefix.length], base.prefix);
+						}
+					}, {
+						messageId: "addLineBreak",
+						fix: (fixer) => {
+							return fixer.insertTextBeforeRange([first.line.range[0], first.line.range[0]], `${first.prefix.trimEnd()}\n`);
+						}
+					}]
+				});
+			}
+		}
+		return { "blockquote:exit"(node) {
+			const loc = sourceCode.getLoc(node);
+			const startLine = loc.start.line;
+			const endLine = loc.end.line;
+			const base = getBlockquoteLineInfo(lines.get(startLine));
+			const invalidLines = [];
+			for (let lineNumber = startLine + 1; lineNumber <= endLine; lineNumber++) {
+				if (checkedLines.has(lineNumber)) {
+					reportInvalidLines(invalidLines, base);
+					invalidLines.length = 0;
+					continue;
+				}
+				checkedLines.add(lineNumber);
+				const line = lines.get(lineNumber);
+				const current = getBlockquoteLineInfo(line);
+				if (base.level <= current.level) {
+					reportInvalidLines(invalidLines, base);
+					invalidLines.length = 0;
+					continue;
+				}
+				invalidLines.push(current);
+			}
+			reportInvalidLines(invalidLines, base);
+		} };
+	}
+});
+
+//#endregion
+//#region src/rules/no-multiple-empty-lines.ts
+var no_multiple_empty_lines_default = createRule("no-multiple-empty-lines", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "disallow multiple empty lines in Markdown files.",
+			categories: null,
+			listCategory: "Stylistic"
+		},
+		fixable: "whitespace",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: {
+				max: {
+					type: "integer",
+					minimum: 0,
+					default: 1
+				},
+				maxEOF: {
+					type: "integer",
+					minimum: 0,
+					default: 0
+				},
+				maxBOF: {
+					type: "integer",
+					minimum: 0,
+					default: 0
+				}
+			},
+			additionalProperties: false
+		}],
+		messages: {
+			blankBeginningOfFile: "Too many blank lines at the beginning of file. Max of {{max}} allowed.",
+			blankEndOfFile: "Too many blank lines at the end of file. Max of {{max}} allowed.",
+			consecutiveBlank: "More than {{max}} blank {{pluralizedLines}} not allowed."
+		}
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const option = context.options[0] || {};
+		const max = typeof option.max === "number" ? option.max : 1;
+		const maxEOF = typeof option.maxEOF === "number" ? option.maxEOF : 0;
+		const maxBOF = typeof option.maxBOF === "number" ? option.maxBOF : 0;
+		const ignoreLocs = [];
+		/**
+		* Register the range of nodes to ignore (code, html, yaml, toml, json)
+		* @param node mdast node
+		*/
+		function addIgnoreLoc(node) {
+			const loc = sourceCode.getLoc(node);
+			ignoreLocs.push({
+				startLine: loc.start.line,
+				endLine: loc.end.line
+			});
+		}
+		return {
+			code: addIgnoreLoc,
+			html: addIgnoreLoc,
+			yaml: addIgnoreLoc,
+			toml: addIgnoreLoc,
+			json: addIgnoreLoc,
+			"root:exit"() {
+				const lines = [...parseLines(sourceCode)];
+				const bofEmptyLines = [];
+				while (lines.length) {
+					if (lines[0].text.trim()) break;
+					bofEmptyLines.push(lines.shift());
+				}
+				const invalidBOFEmptyLines = bofEmptyLines.slice(maxBOF);
+				if (invalidBOFEmptyLines.length > 0) {
+					const first = invalidBOFEmptyLines[0];
+					const last = invalidBOFEmptyLines[invalidBOFEmptyLines.length - 1];
+					context.report({
+						loc: {
+							start: {
+								line: first.line,
+								column: 1
+							},
+							end: {
+								line: last.line,
+								column: last.text.length + 1
+							}
+						},
+						messageId: "blankBeginningOfFile",
+						data: { max: maxBOF },
+						fix(fixer) {
+							return fixer.removeRange([first.range[0], last.range[1]]);
+						}
+					});
+				}
+				const eofEmptyLines = [];
+				while (lines.length) {
+					if (lines[lines.length - 1].text.trim()) break;
+					eofEmptyLines.unshift(lines.pop());
+				}
+				const invalidEOFEmptyLines = eofEmptyLines.slice(maxEOF);
+				if (invalidEOFEmptyLines.length > 0) {
+					const first = invalidEOFEmptyLines[0];
+					const last = invalidEOFEmptyLines[invalidEOFEmptyLines.length - 1];
+					context.report({
+						loc: {
+							start: {
+								line: first.line,
+								column: 1
+							},
+							end: {
+								line: last.line,
+								column: last.text.length + 1
+							}
+						},
+						messageId: "blankEndOfFile",
+						data: { max: maxEOF },
+						fix(fixer) {
+							return fixer.removeRange([first.range[0], last.range[1]]);
+						}
+					});
+				}
+				const emptyLines = [];
+				for (const lineInfo of lines) {
+					if (!lineInfo.text.trim() && !ignoreLocs.some(({ startLine, endLine }) => {
+						return lineInfo.line > startLine && lineInfo.line < endLine;
+					})) {
+						emptyLines.push(lineInfo);
+						continue;
+					}
+					const invalidEmptyLines = emptyLines.slice(max);
+					emptyLines.length = 0;
+					if (invalidEmptyLines.length) {
+						const first = invalidEmptyLines[0];
+						const last = invalidEmptyLines[invalidEmptyLines.length - 1];
+						context.report({
+							loc: {
+								start: {
+									line: first.line,
+									column: 1
+								},
+								end: {
+									line: last.line,
+									column: last.text.length + 1
+								}
+							},
+							messageId: "consecutiveBlank",
+							data: {
+								max,
+								pluralizedLines: max === 1 ? "line" : "lines"
+							},
+							fix(fixer) {
+								return fixer.removeRange([first.range[0], last.range[1]]);
+							}
+						});
+					}
+				}
+			}
+		};
+	}
+});
+
 //#endregion
 //#region src/rules/no-text-backslash-linebreak.ts
 var no_text_backslash_linebreak_default = createRule("no-text-backslash-linebreak", {
@@ -1109,45 +1436,28 @@ var no_trailing_spaces_default = createRule("no-trailing-spaces", {
 			"root:exit"() {
 				const re = /[^\S\n\r]+$/u;
 				const skipMatch = /^[^\S\n\r]*$/u;
-				const lines = sourceCode.lines;
-				const linebreaks = sourceCode.text.match(/\r?\n/gu);
+				const lines = parseLines(sourceCode);
 				const commentLineNumbers = getCommentLineNumbers();
-				let totalLength = 0;
-				for (let i = 0, ii = lines.length; i < ii; i++) {
-					const lineNumber = i + 1;
-					const linebreakLength = linebreaks && linebreaks[i] ? linebreaks[i].length : 1;
-					const lineLength = lines[i].length + linebreakLength;
-					const matches = re.exec(lines[i]);
-					if (!matches) {
-						totalLength += lineLength;
-						continue;
-					}
+				for (const lineInfo of lines) {
+					const matches = re.exec(lineInfo.text);
+					if (!matches) continue;
 					const location = {
 						start: {
-							line: lineNumber,
+							line: lineInfo.line,
 							column: matches.index + 1
 						},
 						end: {
-							line: lineNumber,
-							column: lineLength + 1 - linebreakLength
+							line: lineInfo.line,
+							column: matches.index + 1 + matches[0].length
 						}
 					};
-					const rangeStart = totalLength + location.start.column - 1;
-					const rangeEnd = totalLength + location.end.column - 1;
+					const range = [lineInfo.range[0] + location.start.column - 1, lineInfo.range[0] + location.end.column - 1];
 					if (ignoreNodes.some((node) => {
-						const range = sourceCode.getRange(node);
-						return range[0] <= rangeStart && rangeEnd <= range[1];
-					})) {
-						totalLength += lineLength;
-						continue;
-					}
-					if (skipBlankLines && skipMatch.test(lines[i])) {
-						totalLength += lineLength;
-						continue;
-					}
-					const fixRange = [rangeStart, rangeEnd];
-					if (!ignoreComments || !commentLineNumbers.has(lineNumber)) report(location, fixRange);
-					totalLength += lineLength;
+						const nodeRange = sourceCode.getRange(node);
+						return nodeRange[0] <= range[0] && range[1] <= nodeRange[1];
+					})) continue;
+					if (skipBlankLines && skipMatch.test(lineInfo.text)) continue;
+					if (!ignoreComments || !commentLineNumbers.has(lineInfo.line)) report(location, range);
 				}
 			}
 		};
@@ -1488,25 +1798,6 @@ var prefer_link_reference_definitions_default = createRule("prefer-link-referenc
 	}
 });
 
-//#endregion
-//#region src/utils/url.ts
-/**
-* Utility function to check if a string is a valid URL.
-*/
-function isValidURL(url) {
-	return Boolean(createURLSafe(url));
-}
-/**
-* Utility function to create a URL object safely.
-*/
-function createURLSafe(url) {
-	try {
-		return new URL(url);
-	} catch {
-		return null;
-	}
-}
-
 //#endregion
 //#region src/rules/prefer-linked-words.ts
 var prefer_linked_words_default = createRule("prefer-linked-words", {
@@ -1608,7 +1899,7 @@ var prefer_linked_words_default = createRule("prefer-linked-words", {
 		* Adjust link to be relative to the file.
 		*/
 		function adjustLink(link) {
-			if (isValidURL(link)) return link;
+			if (URL.canParse(link)) return link;
 			if (link.startsWith("#")) return link;
 			const absoluteLink = path.isAbsolute(link) || path.posix.isAbsolute(link) ? link : path.join(context.cwd, link);
 			return `./${path.relative(path.dirname(context.filename), absoluteLink)}`;
@@ -1789,14 +2080,14 @@ var sort_definitions_default = createRule("sort-definitions", {
 		}
 		/** Compile order option */
 		function compileOption(orderOption) {
-			const cache = /* @__PURE__ */ new Map();
+			const cache$1 = /* @__PURE__ */ new Map();
 			const compiled = compileOptionWithoutCache(orderOption);
 			return {
 				match: (node) => {
-					const cached = cache.get(node);
+					const cached = cache$1.get(node);
 					if (cached != null) return cached;
 					const result = compiled.match(node);
-					cache.set(node, result);
+					cache$1.set(node, result);
 					return result;
 				},
 				sort: compiled.sort
@@ -1847,7 +2138,7 @@ var sort_definitions_default = createRule("sort-definitions", {
 						if (node.label === patternStr || node.identifier === patternStr) return true;
 						if (node.type === "definition") {
 							if (node.url === patternStr) return true;
-							if (isValidURL(patternStr)) {
+							if (URL.canParse(patternStr) && URL.canParse(node.url)) {
 								const normalizedPattern = normalizedURL(patternStr);
 								const normalizedUrl = normalizedURL(node.url);
 								if (normalizedUrl.startsWith(normalizedPattern)) return true;
@@ -1894,7 +2185,7 @@ function getQuote(text) {
 * Normalize a URL by ensuring it ends with a slash.
 */
 function normalizedURL(url) {
-	const urlObj = createURLSafe(url);
+	const urlObj = new URL(url);
 	if (!urlObj) return url;
 	return urlObj.href.endsWith("/") ? urlObj.href : `${urlObj.href}/`;
 }
@@ -1906,6 +2197,8 @@ const rules$1 = [
 	definitions_last_default,
 	hard_linebreak_style_default,
 	heading_casing_default,
+	no_laziness_blockquotes_default,
+	no_multiple_empty_lines_default,
 	no_text_backslash_linebreak_default,
 	no_trailing_spaces_default,
 	prefer_inline_code_words_default,
@@ -1935,6 +2228,7 @@ const plugins = {
 };
 const rules$2 = {
 	"markdown-preferences/hard-linebreak-style": "error",
+	"markdown-preferences/no-laziness-blockquotes": "error",
 	"markdown-preferences/no-text-backslash-linebreak": "error"
 };
 
@@ -1946,7 +2240,7 @@ __export(meta_exports, {
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.9.0";
+const version = "0.10.0";
 
 //#endregion
 //#region src/index.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-markdown-preferences",
-  "version": "0.9.0",
+  "version": "0.10.0",
   "description": "ESLint plugin that enforces our markdown preferences",
   "type": "module",
   "exports": {