eslint-plugin-markdown-preferences 0.34.2 → 0.35.0

package/lib/index.d.ts

@@ -545,7 +545,7 @@ declare namespace meta_d_exports {
   export { name, version };
 }
 declare const name: "eslint-plugin-markdown-preferences";
-declare const version: "0.34.2";
+declare const version: "0.35.0";
 //#endregion
 //#region src/language/ast-types.d.ts
 type Node = mdast.Node;

package/lib/index.js

@@ -2,6 +2,7 @@ import { __export } from "./chunk-CTAAG5j7.js";
 import stringWidth from "string-width";
 import emojiRegex from "emoji-regex-xs";
 import path from "node:path";
+import diffSequence from "diff-sequences";
 import markdown from "@eslint/markdown";
 import { fromMarkdown } from "mdast-util-from-markdown";
 import { frontmatterFromMarkdown } from "mdast-util-frontmatter";
@@ -10280,6 +10281,55 @@ var setext_heading_underline_length_default = createRule("setext-heading-underli
 	}
 });
 
+//#endregion
+//#region src/utils/calc-shortest-edit-script.ts
+/**
+* Given the contents of two sequences, returns diff information.
+* @param a The first sequence.
+* @param b The second sequence.
+* @param [options] The options object.
+* @param [options.isEqual] A function that returns true if two elements are equal.
+* @returns An array of diff objects.
+*/
+function calcShortestEditScript(a, b) {
+	let aStartIndex = 0;
+	let bStartIndex = 0;
+	const result = [];
+	(diffSequence.default || diffSequence)(a.length, b.length, (aIndex, bIndex) => a[aIndex] === b[bIndex], (nCommon, aCommon, bCommon) => {
+		pushDelIns(aStartIndex, aCommon, bStartIndex, bCommon);
+		aStartIndex = aCommon + nCommon;
+		bStartIndex = bCommon + nCommon;
+		if (nCommon > 0) for (let index = 0; index < nCommon; index++) {
+			const elementA = a[aCommon + index];
+			const elementB = b[bCommon + index];
+			result.push({
+				type: "common",
+				a: elementA,
+				b: elementB
+			});
+		}
+	});
+	pushDelIns(aStartIndex, a.length, bStartIndex, b.length);
+	return result;
+	/**
+	* Pushes delete and insert sequences to the result.
+	* @param aStart The start index of the delete sequence in `a`.
+	* @param aEnd The end index of the delete sequence in `a`.
+	* @param bStart The start index of the insert sequence in `b`.
+	* @param bEnd The end index of the insert sequence in `b`.
+	*/
+	function pushDelIns(aStart, aEnd, bStart, bEnd) {
+		for (const element of a.slice(aStart, aEnd)) result.push({
+			type: "delete",
+			a: element
+		});
+		for (const element of b.slice(bStart, bEnd)) result.push({
+			type: "insert",
+			b: element
+		});
+	}
+}
+
 //#endregion
 //#region src/rules/sort-definitions.ts
 var sort_definitions_default = createRule("sort-definitions", {
@@ -10327,7 +10377,10 @@ var sort_definitions_default = createRule("sort-definitions", {
 			},
 			additionalProperties: false
 		}],
-		messages: { shouldBefore: "The definition '{{currentKey}}' should be before '{{prevKey}}'." }
+		messages: {
+			shouldBeBefore: "The definition '{{currentKey}}' should be before '{{prevKey}}'.",
+			shouldBeAfter: "The definition '{{currentKey}}' should be after '{{nextKey}}'."
+		}
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
@@ -10348,12 +10401,12 @@ var sort_definitions_default = createRule("sort-definitions", {
 			return `[^${node.identifier}]: ${childrenText}`;
 		}
 		/** Report */
-		function report(node, previousNode, definitions) {
+		function reportFixToMoveUp(node, previousNode, definitions) {
 			const currentKey = getDefinitionText(node);
 			const prevKey = getDefinitionText(previousNode);
 			context.report({
 				node,
-				messageId: "shouldBefore",
+				messageId: "shouldBeBefore",
 				data: {
 					currentKey,
 					prevKey
@@ -10370,33 +10423,146 @@ var sort_definitions_default = createRule("sort-definitions", {
 						...previousNodes,
 						...after
 					];
-					return movedNodes.map((moveNode, index) => {
-						let text = sourceCode.getText(moveNode);
-						if (moveNode.type === "definition" && index > 0) {
-							if (movedNodes[index - 1].type === "footnoteDefinition") {
-								const footnoteLoc = sourceCode.getLoc(definitions[index - 1]);
-								if (sourceCode.getLoc(definitions[index]).start.line - footnoteLoc.end.line <= 1) text = `\n${text}`;
-							}
-						}
-						return fixer.replaceText(definitions[index], text);
-					});
+					return fixReplaceDefinitions(fixer, definitions, movedNodes);
+				}
+			});
+		}
+		/** Report */
+		function reportFixToMoveDown(node, nextNode, definitions) {
+			const currentKey = getDefinitionText(node);
+			const nextKey = getDefinitionText(nextNode);
+			context.report({
+				node,
+				messageId: "shouldBeAfter",
+				data: {
+					currentKey,
+					nextKey
+				},
+				fix(fixer) {
+					const nextNodeIndex = definitions.indexOf(nextNode);
+					const targetNodeIndex = definitions.indexOf(node);
+					const nextNodes = definitions.slice(targetNodeIndex + 1, nextNodeIndex + 1);
+					const before = definitions.slice(0, targetNodeIndex);
+					const after = definitions.slice(nextNodeIndex + 1);
+					const movedNodes = [
+						...before,
+						...nextNodes,
+						node,
+						...after
+					];
+					return fixReplaceDefinitions(fixer, definitions, movedNodes);
 				}
 			});
 		}
 		/**
+		* Fix by replacing the definition array.
+		*/
+		function fixReplaceDefinitions(fixer, definitions, newDefinitions) {
+			const fixes = [];
+			let removeLine = null;
+			for (let index = 0; index < newDefinitions.length; index++) {
+				const newNode = newDefinitions[index];
+				const oldNode = definitions[index];
+				let newText = sourceCode.getText(newNode);
+				if (needLineBreakBetweenKind(index)) {
+					const oldLoc = sourceCode.getLoc(oldNode);
+					newText = `\n${sourceCode.lines[oldLoc.start.line - 1].slice(0, oldLoc.start.column - 1).replaceAll(/[^\s>]/g, " ")}${newText}`;
+				} else if (newNode === oldNode) continue;
+				fixes.push(fixer.replaceText(oldNode, newText));
+				if (removeLine) {
+					fixes.push(fixer.removeRange(removeLine));
+					removeLine = null;
+				}
+			}
+			return fixes;
+			/**
+			* Determine if a line break is needed between different kinds of definitions.
+			*/
+			function needLineBreakBetweenKind(index) {
+				if (index === 0) return false;
+				if (newDefinitions[index].type !== "definition") return false;
+				if (newDefinitions[index - 1].type !== "footnoteDefinition") return false;
+				const oldPrevNode = definitions[index - 1];
+				const oldNode = definitions[index];
+				const footnoteLoc = sourceCode.getLoc(oldPrevNode);
+				const linkLoc = sourceCode.getLoc(oldNode);
+				if (linkLoc.start.line - footnoteLoc.end.line > 1) return false;
+				if (index + 1 < newDefinitions.length) {
+					if (newDefinitions[index + 1].type === "definition") {
+						const oldNextNode = definitions[index + 1];
+						const oldNextLoc = sourceCode.getLoc(oldNextNode);
+						if (oldNextLoc.start.line - linkLoc.end.line > 1) {
+							const parsedLine = getParsedLines(sourceCode).get(oldNextLoc.start.line - 1);
+							if (!parsedLine.text.replaceAll(">", "").trim()) removeLine = parsedLine.range;
+						}
+					}
+				}
+				return true;
+			}
+		}
+		/**
 		* Verify definitions and footnote definitions.
 		*/
 		function verify(definitions) {
 			if (definitions.length === 0) return;
-			const validPreviousNodes = [];
-			for (const definition of definitions) {
-				if (option.ignore(definition)) continue;
-				const invalidPreviousNode = validPreviousNodes.find((previousNode) => option.compare(previousNode, definition) > 0);
-				if (invalidPreviousNode) {
-					report(definition, invalidPreviousNode, definitions);
-					continue;
+			const sorted = [...definitions].sort(option.compare);
+			const editScript = calcShortestEditScript(definitions, sorted);
+			for (let index = 0; index < editScript.length; index++) {
+				const edit = editScript[index];
+				if (edit.type !== "delete") continue;
+				const insertEditIndex = editScript.findIndex((e) => e.type === "insert" && e.b === edit.a);
+				if (insertEditIndex === -1) continue;
+				if (index < insertEditIndex) {
+					const target = findInsertAfterTarget(edit.a, insertEditIndex);
+					if (!target) continue;
+					reportFixToMoveDown(edit.a, target, definitions);
+				} else {
+					const target = findInsertBeforeTarget(edit.a, insertEditIndex);
+					if (!target) continue;
+					reportFixToMoveUp(edit.a, target, definitions);
+				}
+			}
+			/**
+			* Find insert after target
+			*/
+			function findInsertAfterTarget(def, insertEditIndex) {
+				for (let index = insertEditIndex - 1; index >= 0; index--) {
+					const edit = editScript[index];
+					if (edit.type === "delete" && edit.a === def) break;
+					if (edit.type !== "common") continue;
+					return edit.a;
+				}
+				let lastTarget = null;
+				for (let index = definitions.indexOf(def) + 1; index < definitions.length; index++) {
+					const element = definitions[index];
+					if (option.compare(element, def) <= 0) {
+						lastTarget = element;
+						continue;
+					}
+					return lastTarget;
+				}
+				return lastTarget;
+			}
+			/**
+			* Find insert before target
+			*/
+			function findInsertBeforeTarget(def, insertEditIndex) {
+				for (let index = insertEditIndex + 1; index < editScript.length; index++) {
+					const edit = editScript[index];
+					if (edit.type === "delete" && edit.a === def) break;
+					if (edit.type !== "common") continue;
+					return edit.a;
+				}
+				let lastTarget = null;
+				for (let index = definitions.indexOf(def) - 1; index >= 0; index--) {
+					const element = definitions[index];
+					if (option.compare(def, element) <= 0) {
+						lastTarget = element;
+						continue;
+					}
+					return lastTarget;
 				}
-				validPreviousNodes.push(definition);
+				return lastTarget;
 			}
 		}
 		return {
@@ -10412,7 +10578,7 @@ var sort_definitions_default = createRule("sort-definitions", {
 				if (node.type === "definition" || node.type === "footnoteDefinition") group.push(node);
 			},
 			"root:exit"() {
-				verify(group);
+				verify(group.filter((definition) => !option.ignore(definition)));
 			}
 		};
 		/** Parse options */
@@ -11990,7 +12156,7 @@ var meta_exports = /* @__PURE__ */ __export({
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.34.2";
+const version = "0.35.0";
 
 //#endregion
 //#region src/language/extensions/micromark-custom-container.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-markdown-preferences",
-  "version": "0.34.2",
+  "version": "0.35.0",
   "description": "ESLint plugin that enforces our markdown preferences",
   "type": "module",
   "exports": {
@@ -62,6 +62,7 @@
     "eslint": ">=9.0.0"
   },
   "dependencies": {
+    "diff-sequences": "^29.6.3",
     "emoji-regex-xs": "^2.0.1",
     "mdast-util-from-markdown": "^2.0.2",
     "mdast-util-frontmatter": "^2.0.1",
@@ -104,7 +105,7 @@
     "eslint-plugin-json-schema-validator": "^5.3.1",
     "eslint-plugin-jsonc": "^2.19.1",
     "eslint-plugin-markdown": "^5.1.0",
-    "eslint-plugin-markdown-links": "^0.5.0",
+    "eslint-plugin-markdown-links": "^0.6.0",
     "eslint-plugin-n": "^17.16.2",
     "eslint-plugin-node-dependencies": "^1.0.0",
     "eslint-plugin-prettier": "^5.2.3",