eslint-plugin-markdown-preferences 0.4.0 → 0.5.0

package/README.md

@@ -92,7 +92,7 @@ The rules with the following star ⭐ are included in the configs.
 |:--------|:------------|:-------:|:-----------:|
 | [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/no-text-backslash-linebreak](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-text-backslash-linebreak.html) | disallow text backslash at the end of a line. |  | ⭐ |
-| [markdown-preferences/no-trailing-spaces](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-trailing-spaces.html) | trailing whitespace at the end of 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-inline-code-words](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-inline-code-words.html) | enforce the use of inline code for specific words. | 🔧 |  |
 | [markdown-preferences/prefer-linked-words](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-linked-words.html) | enforce the specified word to be a link. | 🔧 |  |
 

package/lib/index.d.ts

@@ -3,7 +3,70 @@ import * as _eslint_core0 from "@eslint/core";
 import { RuleDefinition } from "@eslint/core";
 import { ESLint, Linter } from "eslint";
 
-//#region src/configs/recommended.d.ts
+//#region src/rule-types.d.ts
+declare module 'eslint' {
+  namespace Linter {
+    interface RulesRecord extends RuleOptions {}
+  }
+}
+interface RuleOptions {
+  /**
+   * enforce consistent hard linebreak style.
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/hard-linebreak-style.html
+   */
+  'markdown-preferences/hard-linebreak-style'?: Linter.RuleEntry<MarkdownPreferencesHardLinebreakStyle>;
+  /**
+   * 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
+   */
+  'markdown-preferences/no-text-backslash-linebreak'?: Linter.RuleEntry<[]>;
+  /**
+   * disallow trailing whitespace at the end of lines in Markdown files.
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-trailing-spaces.html
+   */
+  'markdown-preferences/no-trailing-spaces'?: Linter.RuleEntry<MarkdownPreferencesNoTrailingSpaces>;
+  /**
+   * enforce the use of inline code for specific words.
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-inline-code-words.html
+   */
+  'markdown-preferences/prefer-inline-code-words'?: Linter.RuleEntry<MarkdownPreferencesPreferInlineCodeWords>;
+  /**
+   * enforce the specified word to be a link.
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/prefer-linked-words.html
+   */
+  'markdown-preferences/prefer-linked-words'?: Linter.RuleEntry<MarkdownPreferencesPreferLinkedWords>;
+}
+type MarkdownPreferencesHardLinebreakStyle = [] | [{
+  style?: ("backslash" | "spaces");
+}];
+type MarkdownPreferencesNoTrailingSpaces = [] | [{
+  skipBlankLines?: boolean;
+  ignoreComments?: boolean;
+}];
+type MarkdownPreferencesPreferInlineCodeWords = [] | [{
+  words: string[];
+  ignores?: {
+    words?: (string | string[]);
+    node?: {
+      [k: string]: unknown | undefined;
+    };
+    [k: string]: unknown | undefined;
+  }[];
+  [k: string]: unknown | undefined;
+}];
+type MarkdownPreferencesPreferLinkedWords = [] | [{
+  words: ({
+    [k: string]: (string | null);
+  } | string[]);
+  ignores?: {
+    words?: (string | string[]);
+    node?: {
+      [k: string]: unknown | undefined;
+    };
+    [k: string]: unknown | undefined;
+  }[];
+  [k: string]: unknown | undefined;
+}];
 declare namespace recommended_d_exports {
   export { files, language, name$1 as name, plugins, rules$1 as rules };
 }
@@ -19,7 +82,7 @@ declare namespace meta_d_exports {
   export { name, version };
 }
 declare const name: "eslint-plugin-markdown-preferences";
-declare const version: "0.4.0";
+declare const version: "0.5.0";
 //#endregion
 //#region src/index.d.ts
 declare const configs: {
@@ -34,4 +97,4 @@ declare const _default: {
   rules: Record<string, RuleDefinition<_eslint_core0.RuleDefinitionTypeOptions>>;
 };
 //#endregion
-export { configs, _default as default, meta_d_exports as meta, rules };
+export { RuleOptions, configs, _default as default, meta_d_exports as meta, rules };

package/lib/index.js

@@ -131,7 +131,7 @@ var no_trailing_spaces_default = createRule("no-trailing-spaces", {
 	meta: {
 		type: "layout",
 		docs: {
-			description: "trailing whitespace at the end of lines in Markdown files.",
+			description: "disallow trailing whitespace at the end of lines in Markdown files.",
 			categories: []
 		},
 		fixable: "whitespace",
@@ -249,9 +249,10 @@ const RE_BOUNDARY = /^[\s\p{Letter_Number}\p{Modifier_Letter}\p{Modifier_Symbol}
 /**
 * Iterate through words in a text node that match the specified words.
 */
-function* iterateSearchWords(sourceCode, node, words) {
+function* iterateSearchWords({ sourceCode, node, words, ignores }) {
 	const text = sourceCode.getText(node);
 	for (const word of words) {
+		if (ignores.ignore(word)) continue;
 		let startPosition = 0;
 		while (true) {
 			const index = text.indexOf(word, startPosition);
@@ -280,6 +281,57 @@ function* iterateSearchWords(sourceCode, node, words) {
 		}
 	}
 }
+const IGNORES_SCHEMA = {
+	type: "array",
+	items: {
+		type: "object",
+		properties: {
+			words: { anyOf: [{ type: "string" }, {
+				type: "array",
+				items: { type: "string" }
+			}] },
+			node: { type: "object" }
+		},
+		additionalProperties: true
+	}
+};
+/**
+* Create a context for ignoring specific words or nodes.
+*/
+function createSearchWordsIgnoreContext(ignores) {
+	if (!ignores || ignores.length === 0) return {
+		enter: () => void 0,
+		exit: () => void 0,
+		ignore: () => false
+	};
+	const conditions = ignores.map((ignore) => {
+		const isIgnoreWord = ignore.words == null ? () => true : Array.isArray(ignore.words) ? (word) => ignore.words.includes(word) : (word) => ignore.words === word;
+		const node = ignore.node || {};
+		const keys = Object.keys(node);
+		return {
+			isIgnoreWord,
+			isIgnoreNode: (nodeToCheck) => {
+				return keys.every((key) => nodeToCheck[key] === node[key]);
+			}
+		};
+	});
+	const currentIgnores = /* @__PURE__ */ new Set();
+	return {
+		enter(node) {
+			for (const ignore of conditions) if (ignore.isIgnoreNode(node)) currentIgnores.add({
+				node,
+				condition: ignore
+			});
+		},
+		exit(node) {
+			for (const element of [...currentIgnores]) if (element.node === node) currentIgnores.delete(element);
+		},
+		ignore(word) {
+			for (const { condition } of currentIgnores) if (condition.isIgnoreWord(word)) return true;
+			return false;
+		}
+	};
+}
 
 //#endregion
 //#region src/rules/prefer-inline-code-words.ts
@@ -294,19 +346,30 @@ var prefer_inline_code_words_default = createRule("prefer-inline-code-words", {
 		hasSuggestions: false,
 		schema: [{
 			type: "object",
-			properties: { words: {
-				type: "array",
-				items: { type: "string" }
-			} },
-			required: ["words"]
+			properties: {
+				words: {
+					type: "array",
+					items: { type: "string" }
+				},
+				ignores: IGNORES_SCHEMA
+			},
+			required: ["words"],
+			additionalProperties: true
 		}],
 		messages: { requireInlineCode: "The word \"{{name}}\" should be in inline code." }
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
 		const words = context.options[0]?.words || [];
+		const ignores = createSearchWordsIgnoreContext(context.options[0]?.ignores);
 		let shortcutLinkReference = null;
 		return {
+			"*"(node) {
+				ignores.enter(node);
+			},
+			"*:exit"(node) {
+				ignores.exit(node);
+			},
 			linkReference(node) {
 				if (node.referenceType !== "shortcut") return;
 				if (shortcutLinkReference) return;
@@ -316,7 +379,12 @@ var prefer_inline_code_words_default = createRule("prefer-inline-code-words", {
 				if (shortcutLinkReference === node) shortcutLinkReference = null;
 			},
 			text(node) {
-				for (const { word, loc, range } of iterateSearchWords(sourceCode, node, words)) {
+				for (const { word, loc, range } of iterateSearchWords({
+					sourceCode,
+					node,
+					words,
+					ignores
+				})) {
 					const shortcutLinkReferenceToReport = shortcutLinkReference;
 					context.report({
 						node,
@@ -348,20 +416,25 @@ var prefer_linked_words_default = createRule("prefer-linked-words", {
 		hasSuggestions: false,
 		schema: [{
 			type: "object",
-			properties: { words: { anyOf: [{
-				type: "object",
-				patternProperties: { "^[\\s\\S]+$": { type: ["string", "null"] } }
-			}, {
-				type: "array",
-				items: { type: "string" }
-			}] } },
-			required: ["words"]
+			properties: {
+				words: { anyOf: [{
+					type: "object",
+					patternProperties: { "^[\\s\\S]+$": { type: ["string", "null"] } }
+				}, {
+					type: "array",
+					items: { type: "string" }
+				}] },
+				ignores: IGNORES_SCHEMA
+			},
+			required: ["words"],
+			additionalProperties: true
 		}],
 		messages: { requireLink: "The word \"{{name}}\" should be a link." }
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
 		const wordsOption = context.options[0]?.words || {};
+		const ignores = createSearchWordsIgnoreContext(context.options[0]?.ignores);
 		const links = Object.create(null);
 		const words = [];
 		if (Array.isArray(wordsOption)) words.push(...wordsOption);
@@ -373,18 +446,29 @@ var prefer_linked_words_default = createRule("prefer-linked-words", {
 			}
 			words.push(word);
 		}
-		let ignore = null;
+		let linkedNode = null;
 		return {
-			"link, linkReference, heading, footnoteDefinition"(node) {
-				if (ignore) return;
-				ignore = node;
+			"*"(node) {
+				ignores.enter(node);
+			},
+			"*:exit"(node) {
+				ignores.exit(node);
 			},
-			"link, linkReference, heading, footnoteDefinition:exit"(node) {
-				if (ignore === node) ignore = null;
+			"link, linkReference"(node) {
+				if (linkedNode) return;
+				linkedNode = node;
+			},
+			"link, linkReference:exit"(node) {
+				if (linkedNode === node) linkedNode = null;
 			},
 			text(node) {
-				if (ignore) return;
-				for (const { word, loc, range } of iterateSearchWords(sourceCode, node, words)) {
+				if (linkedNode) return;
+				for (const { word, loc, range } of iterateSearchWords({
+					sourceCode,
+					node,
+					words,
+					ignores
+				})) {
 					const link = links[word];
 					context.report({
 						node,
@@ -398,17 +482,20 @@ var prefer_linked_words_default = createRule("prefer-linked-words", {
 				}
 			},
 			inlineCode(node) {
-				if (ignore) return;
-				for (const word of words) if (node.value === word) {
-					const link = links[word];
-					context.report({
-						node,
-						messageId: "requireLink",
-						data: { name: word },
-						fix: link ? (fixer) => {
-							return fixer.replaceText(node, `[\`${word}\`](${link})`);
-						} : null
-					});
+				if (linkedNode) return;
+				for (const word of words) {
+					if (ignores.ignore(word)) continue;
+					if (node.value === word) {
+						const link = links[word];
+						context.report({
+							node,
+							messageId: "requireLink",
+							data: { name: word },
+							fix: link ? (fixer) => {
+								return fixer.replaceText(node, `[\`${word}\`](${link})`);
+							} : null
+						});
+					}
 				}
 			}
 		};
@@ -466,7 +553,7 @@ __export(meta_exports, {
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.4.0";
+const version = "0.5.0";
 
 //#endregion
 //#region src/index.ts

package/package.json

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