eslint-plugin-markdown-preferences 0.3.3 → 0.5.0

package/README.md

@@ -92,7 +92,8 @@ 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. | 🔧 |  |
 
 <!--RULES_TABLE_END-->

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.3.3";
+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",
@@ -244,8 +244,167 @@ var no_trailing_spaces_default = createRule("no-trailing-spaces", {
 });
 
 //#endregion
-//#region src/rules/prefer-linked-words.ts
+//#region src/utils/search-words.ts
 const RE_BOUNDARY = /^[\s\p{Letter_Number}\p{Modifier_Letter}\p{Modifier_Symbol}\p{Nonspacing_Mark}\p{Other_Letter}\p{Other_Symbol}\p{Script=Han}!"#$%&'(),./:;<=>?\\{|}~\u{2ffc}-\u{303d}\u{30a0}-\u{30fb}\u{3192}-\u{32bf}\u{fe10}-\u{fe1f}\u{fe30}-\u{fe6f}\u{ff00}-\u{ffef}\u{2ebf0}-\u{2ee5d}]*$/u;
+/**
+* Iterate through words in a text node that match the specified 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);
+			if (index < 0) break;
+			startPosition = index + word.length;
+			if (!RE_BOUNDARY.test(text[index - 1] || "") || !RE_BOUNDARY.test(text[index + word.length] || "")) continue;
+			const loc = sourceCode.getLoc(node);
+			const beforeLines = text.slice(0, index).split(/\n/u);
+			const line = loc.start.line + beforeLines.length - 1;
+			const column = (beforeLines.length === 1 ? loc.start.column : 1) + (beforeLines.at(-1) || "").length;
+			const range = sourceCode.getRange(node);
+			yield {
+				loc: {
+					start: {
+						line,
+						column
+					},
+					end: {
+						line,
+						column: column + word.length
+					}
+				},
+				range: [range[0] + index, range[0] + index + word.length],
+				word
+			};
+		}
+	}
+}
+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
+var prefer_inline_code_words_default = createRule("prefer-inline-code-words", {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "enforce the use of inline code for specific words.",
+			categories: []
+		},
+		fixable: "code",
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			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;
+				shortcutLinkReference = node;
+			},
+			"linkReference:exit"(node) {
+				if (shortcutLinkReference === node) shortcutLinkReference = null;
+			},
+			text(node) {
+				for (const { word, loc, range } of iterateSearchWords({
+					sourceCode,
+					node,
+					words,
+					ignores
+				})) {
+					const shortcutLinkReferenceToReport = shortcutLinkReference;
+					context.report({
+						node,
+						loc,
+						messageId: "requireInlineCode",
+						data: { name: word },
+						*fix(fixer) {
+							yield fixer.insertTextBeforeRange(range, "`");
+							yield fixer.insertTextAfterRange(range, "`");
+							if (shortcutLinkReferenceToReport) yield fixer.insertTextAfter(shortcutLinkReferenceToReport, `[${shortcutLinkReferenceToReport.label}]`);
+						}
+					});
+				}
+			}
+		};
+	}
+});
+
+//#endregion
+//#region src/rules/prefer-linked-words.ts
 var prefer_linked_words_default = createRule("prefer-linked-words", {
 	meta: {
 		type: "suggestion",
@@ -257,76 +416,87 @@ 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 words = context.options[0]?.words || {};
-		const wordEntries = (Array.isArray(words) ? words.map((word) => [word, void 0]) : Object.entries(words)).map(([word, link]) => [word, link ? adjustLink(link) : void 0]).filter(([, link]) => link !== `./${path.basename(context.filename)}`);
-		let ignore = null;
+		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);
+		else for (const [word, link] of Object.entries(wordsOption)) {
+			if (link) {
+				const adjustedLink = adjustLink(link);
+				if (adjustedLink === `./${path.basename(context.filename)}`) continue;
+				links[word] = adjustedLink;
+			}
+			words.push(word);
+		}
+		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"(node) {
+				if (linkedNode) return;
+				linkedNode = node;
 			},
-			"link, linkReference, heading, footnoteDefinition:exit"(node) {
-				if (ignore === node) ignore = null;
+			"link, linkReference:exit"(node) {
+				if (linkedNode === node) linkedNode = null;
 			},
 			text(node) {
-				if (ignore) return;
-				const text = sourceCode.getText(node);
-				for (const [word, link] of wordEntries) {
-					let startPosition = 0;
-					while (true) {
-						const index = text.indexOf(word, startPosition);
-						if (index < 0) break;
-						startPosition = index + word.length;
-						if (!RE_BOUNDARY.test(text[index - 1] || "") || !RE_BOUNDARY.test(text[index + word.length] || "")) continue;
-						const loc = sourceCode.getLoc(node);
-						const beforeLines = text.slice(0, index).split(/\n/u);
-						const line = loc.start.line + beforeLines.length - 1;
-						const column = (beforeLines.length === 1 ? loc.start.column : 1) + (beforeLines.at(-1) || "").length;
+				if (linkedNode) return;
+				for (const { word, loc, range } of iterateSearchWords({
+					sourceCode,
+					node,
+					words,
+					ignores
+				})) {
+					const link = links[word];
+					context.report({
+						node,
+						loc,
+						messageId: "requireLink",
+						data: { name: word },
+						fix: link ? (fixer) => {
+							return fixer.replaceTextRange(range, `[${word}](${link})`);
+						} : null
+					});
+				}
+			},
+			inlineCode(node) {
+				if (linkedNode) return;
+				for (const word of words) {
+					if (ignores.ignore(word)) continue;
+					if (node.value === word) {
+						const link = links[word];
 						context.report({
 							node,
-							loc: {
-								start: {
-									line,
-									column
-								},
-								end: {
-									line,
-									column: column + word.length
-								}
-							},
 							messageId: "requireLink",
 							data: { name: word },
 							fix: link ? (fixer) => {
-								const [start] = sourceCode.getRange(node);
-								return fixer.replaceTextRange([start + index, start + index + word.length], `[${word}](${link})`);
+								return fixer.replaceText(node, `[\`${word}\`](${link})`);
 							} : null
 						});
 					}
 				}
-			},
-			inlineCode(node) {
-				if (ignore) return;
-				for (const [word, link] of wordEntries) if (node.value === word) context.report({
-					node,
-					messageId: "requireLink",
-					data: { name: word },
-					fix: link ? (fixer) => {
-						return fixer.replaceText(node, `[\`${word}\`](${link})`);
-					} : null
-				});
 			}
 		};
 		/**
@@ -347,6 +517,7 @@ const rules$1 = [
 	hard_linebreak_style_default,
 	no_text_backslash_linebreak_default,
 	no_trailing_spaces_default,
+	prefer_inline_code_words_default,
 	prefer_linked_words_default
 ];
 
@@ -382,7 +553,7 @@ __export(meta_exports, {
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.3.3";
+const version = "0.5.0";
 
 //#endregion
 //#region src/index.ts

package/package.json

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