eslint-plugin-markdown-preferences 0.38.0 → 0.40.0

package/README.md

@@ -223,8 +223,9 @@ The rules with the following 💄 are included in the `standard` config.
 | [markdown-preferences/atx-heading-closing-sequence-length](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/atx-heading-closing-sequence-length.html) | enforce consistent length for the closing sequence (trailing #s) in ATX headings.         |   🔧    |   💄   |
 | [markdown-preferences/atx-heading-closing-sequence](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/atx-heading-closing-sequence.html)               | enforce consistent use of closing sequence in ATX headings.                               |   🔧    |   💄   |
 | [markdown-preferences/code-fence-length](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/code-fence-length.html)                                     | enforce consistent code fence length in fenced code blocks.                               |   🔧    |   💄   |
+| [markdown-preferences/max-len](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/max-len.html)                                                         | enforce maximum length for various Markdown entities                                      |         |        |
 | [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/ordered-list-marker-sequence](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/ordered-list-marker-sequence.html)               | enforce that ordered list markers use sequential numbers                                  |   🔧    |   💄   |
+| [markdown-preferences/ordered-list-marker-sequence](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/ordered-list-marker-sequence.html)               | enforce consistent ordered list marker numbering (sequential or flat)                     |   🔧    |   💄   |
 | [markdown-preferences/setext-heading-underline-length](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/setext-heading-underline-length.html)         | enforce setext heading underline length                                                   |   🔧    |   💄   |
 | [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                    |   🔧    |   💄   |
 | [markdown-preferences/table-leading-trailing-pipes](https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/table-leading-trailing-pipes.html)               | enforce consistent use of leading and trailing pipes in tables.                           |   🔧    |   💄   |

package/lib/index.d.ts

@@ -140,6 +140,11 @@ interface RuleOptions {
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/list-marker-alignment.html
    */
   'markdown-preferences/list-marker-alignment'?: Linter.RuleEntry<MarkdownPreferencesListMarkerAlignment>;
+  /**
+   * enforce maximum length for various Markdown entities
+   * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/max-len.html
+   */
+  'markdown-preferences/max-len'?: Linter.RuleEntry<MarkdownPreferencesMaxLen>;
   /**
    * disallow trailing punctuation in headings.
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/no-heading-trailing-punctuation.html
@@ -181,10 +186,10 @@ interface RuleOptions {
    */
   'markdown-preferences/no-trailing-spaces'?: Linter.RuleEntry<MarkdownPreferencesNoTrailingSpaces>;
   /**
-   * enforce that ordered list markers use sequential numbers
+   * enforce consistent ordered list marker numbering (sequential or flat)
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/ordered-list-marker-sequence.html
    */
-  'markdown-preferences/ordered-list-marker-sequence'?: Linter.RuleEntry<[]>;
+  'markdown-preferences/ordered-list-marker-sequence'?: Linter.RuleEntry<MarkdownPreferencesOrderedListMarkerSequence>;
   /**
    * enforce that ordered list markers start with 1 or 0
    * @see https://ota-meshi.github.io/eslint-plugin-markdown-preferences/rules/ordered-list-marker-start.html
@@ -403,6 +408,59 @@ type MarkdownPreferencesLinkTitleStyle = [] | [{
 type MarkdownPreferencesListMarkerAlignment = [] | [{
   align?: ("left" | "right");
 }];
+type MarkdownPreferencesMaxLen = [] | [{
+  heading?: (number | "ignore");
+  paragraph?: (number | "ignore");
+  table?: (number | "ignore");
+  html?: (number | "ignore");
+  math?: (number | "ignore");
+  code?: ((number | "ignore") | {
+    [k: string]: (number | "ignore");
+  });
+  frontmatter?: ((number | "ignore") | {
+    [k: string]: (number | "ignore");
+  });
+  list?: ((number | "ignore") | {
+    heading?: (number | "ignore");
+    paragraph?: (number | "ignore");
+    table?: (number | "ignore");
+    html?: (number | "ignore");
+    math?: (number | "ignore");
+    code?: ((number | "ignore") | {
+      [k: string]: (number | "ignore");
+    });
+    frontmatter?: ((number | "ignore") | {
+      [k: string]: (number | "ignore");
+    });
+  });
+  blockquote?: ((number | "ignore") | {
+    heading?: (number | "ignore");
+    paragraph?: (number | "ignore");
+    table?: (number | "ignore");
+    html?: (number | "ignore");
+    math?: (number | "ignore");
+    code?: ((number | "ignore") | {
+      [k: string]: (number | "ignore");
+    });
+    frontmatter?: ((number | "ignore") | {
+      [k: string]: (number | "ignore");
+    });
+  });
+  footnoteDefinition?: ((number | "ignore") | {
+    heading?: (number | "ignore");
+    paragraph?: (number | "ignore");
+    table?: (number | "ignore");
+    html?: (number | "ignore");
+    math?: (number | "ignore");
+    code?: ((number | "ignore") | {
+      [k: string]: (number | "ignore");
+    });
+    frontmatter?: ((number | "ignore") | {
+      [k: string]: (number | "ignore");
+    });
+  });
+  ignoreUrls?: boolean;
+}];
 type MarkdownPreferencesNoHeadingTrailingPunctuation = [] | [{
   punctuation?: (string | {
     "1"?: string;
@@ -443,6 +501,9 @@ type MarkdownPreferencesNoTrailingSpaces = [] | [{
   skipBlankLines?: boolean;
   ignoreComments?: boolean;
 }];
+type MarkdownPreferencesOrderedListMarkerSequence = [] | [{
+  increment?: ("always" | "never");
+}];
 type MarkdownPreferencesOrderedListMarkerStart = [] | [{
   start?: (1 | 0);
 }];
@@ -584,7 +645,7 @@ declare namespace meta_d_exports {
   export { name, version };
 }
 declare const name: "eslint-plugin-markdown-preferences";
-declare const version: "0.38.0";
+declare const version: "0.40.0";
 //#endregion
 //#region src/language/ast-types.d.ts
 type Node = mdast.Node;

package/lib/index.js

@@ -732,7 +732,7 @@ function getOtherMarker(unavailableMarker) {
 /**
 * Parse rule options.
 */
-function parseOptions$8(options) {
+function parseOptions$9(options) {
 	const primary = options.primary || "-";
 	const secondary = options.secondary || getOtherMarker(primary);
 	if (primary === secondary) throw new Error(`\`primary\` and \`secondary\` cannot be the same (primary: "${primary}", secondary: "${secondary}").`);
@@ -800,7 +800,7 @@ var bullet_list_marker_style_default = createRule("bullet-list-marker-style", {
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const options = parseOptions$8(context.options[0] || {});
+		const options = parseOptions$9(context.options[0] || {});
 		let containerStack = {
 			node: sourceCode.ast,
 			level: 1,
@@ -1418,7 +1418,7 @@ var custom_container_marker_spacing_default = createRule("custom-container-marke
 /**
 * Parse options with defaults.
 */
-function parseOptions$7(options) {
+function parseOptions$8(options) {
 	return {
 		linkDefinitionPlacement: {
 			referencedFromSingleSection: options?.linkDefinitionPlacement?.referencedFromSingleSection || "document-last",
@@ -1490,7 +1490,7 @@ var definitions_last_default = createRule("definitions-last", {
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const options = parseOptions$7(context.options[0]);
+		const options = parseOptions$8(context.options[0]);
 		/**
 		* Determine whether a node can be placed as the last node of the document or a section.
 		*/
@@ -5464,7 +5464,7 @@ function parseMathClosingSequenceFromText(text) {
 /**
 * Parse options.
 */
-function parseOptions$6(options) {
+function parseOptions$7(options) {
 	const listItems = options?.listItems;
 	return { listItems: {
 		first: listItems?.first ?? 1,
@@ -5517,7 +5517,7 @@ var indent_default = createRule("indent", {
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const options = parseOptions$6(context.options[0]);
+		const options = parseOptions$7(context.options[0]);
 		class AbsBlockStack {
 			violations = [];
 			getCurrentBlockquote() {
@@ -6723,11 +6723,11 @@ var link_bracket_newline_default = createRule("link-bracket-newline", {
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const optionProvider = parseOptions$9(context.options[0]);
+		const optionProvider = parseOptions$10(context.options[0]);
 		/**
 		* Parse the options.
 		*/
-		function parseOptions$9(option) {
+		function parseOptions$10(option) {
 			const newline = option?.newline ?? "never";
 			const multiline = option?.multiline ?? false;
 			return (bracketsRange) => {
@@ -6869,7 +6869,7 @@ var link_bracket_newline_default = createRule("link-bracket-newline", {
 /**
 * The basic option for links and images.
 */
-function parseOptions$5(option) {
+function parseOptions$6(option) {
 	const space = option?.space ?? "never";
 	const imagesInLinks = option?.imagesInLinks;
 	return {
@@ -6919,7 +6919,7 @@ var link_bracket_spacing_default = createRule("link-bracket-spacing", {
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const options = parseOptions$5(context.options[0]);
+		const options = parseOptions$6(context.options[0]);
 		/**
 		* Verify the space after the opening bracket and before the closing bracket.
 		*/
@@ -7228,11 +7228,11 @@ var link_paren_newline_default = createRule("link-paren-newline", {
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
-		const optionProvider = parseOptions$9(context.options[0]);
+		const optionProvider = parseOptions$10(context.options[0]);
 		/**
 		* Parse the options.
 		*/
-		function parseOptions$9(option) {
+		function parseOptions$10(option) {
 			const newline = option?.newline ?? "never";
 			const multiline = option?.multiline ?? false;
 			return (openingParenIndex, closingParenIndex) => {
@@ -7690,6 +7690,209 @@ var list_marker_alignment_default = createRule("list-marker-alignment", {
 	}
 });
 
+//#endregion
+//#region src/rules/max-len.ts
+const URL_PATTERN = /https?:\/\/(?:w{3}\.)?[\w#%+\-.:=@~]{1,256}\.[\w()]{1,6}\b[\w#%&()+\-./:=?@~]*/gu;
+const maxLengthSchema = { oneOf: [{
+	type: "integer",
+	minimum: 1
+}, { enum: ["ignore"] }] };
+const maxLengthParLangSchema = { oneOf: [maxLengthSchema, {
+	type: "object",
+	patternProperties: { ".*": maxLengthSchema },
+	additionalProperties: false
+}] };
+const maxLengthParPhrasingNodeOptionsSchema = {
+	type: "object",
+	properties: {
+		heading: maxLengthSchema,
+		paragraph: maxLengthSchema,
+		table: maxLengthSchema,
+		html: maxLengthSchema,
+		math: maxLengthSchema,
+		code: maxLengthParLangSchema,
+		frontmatter: maxLengthParLangSchema
+	},
+	additionalProperties: false
+};
+const maxLengthOptionForContainerSchema = { oneOf: [maxLengthSchema, maxLengthParPhrasingNodeOptionsSchema] };
+/**
+* Parse options
+*/
+function parseOptions$5(options, sourceCode) {
+	const ignoreUrls = options.ignoreUrls ?? true;
+	const maxLengthForNode = parseOptionsParNode({
+		heading: options.heading ?? 80,
+		paragraph: options.paragraph ?? 120,
+		table: options.table ?? 120,
+		html: options.html ?? 120,
+		math: options.math ?? 120,
+		code: options.code ?? "ignore",
+		frontmatter: options.frontmatter ?? "ignore"
+	});
+	const maxLengthForInBlockquote = parseContainerOption(options.blockquote ?? {});
+	const maxLengthForInList = parseContainerOption(options.list ?? {});
+	const maxLengthForInFootnoteDefinition = parseContainerOption(options.footnoteDefinition ?? {});
+	return {
+		maxLength: (node) => {
+			let maxLength = null;
+			let parent = getParent(sourceCode, node);
+			while (parent) {
+				const len = parent.type === "blockquote" ? maxLengthForInBlockquote(node) : parent.type === "listItem" ? maxLengthForInList(node) : parent.type === "footnoteDefinition" ? maxLengthForInFootnoteDefinition(node) : null;
+				if (len === "ignore") return "ignore";
+				if (len && (maxLength == null || len < maxLength)) maxLength = len;
+				parent = getParent(sourceCode, parent);
+			}
+			return maxLength ?? maxLengthForNode(node);
+		},
+		ignoreUrls
+	};
+}
+/**
+* Parse code option
+*/
+function parseCodeOption(option) {
+	if (typeof option === "number" || option === "ignore") return () => option;
+	return (node) => {
+		if (node.lang && option[node.lang] != null) return option[node.lang];
+		return "ignore";
+	};
+}
+/**
+* Parse frontmatter option
+*/
+function parseFrontmatterOption(option) {
+	if (typeof option === "number" || option === "ignore") return () => option;
+	return (node) => {
+		if (option[node.type] != null) return option[node.type];
+		return "ignore";
+	};
+}
+/**
+* Parse container option
+*/
+function parseContainerOption(option) {
+	if (typeof option === "number" || option === "ignore") return () => option;
+	return parseOptionsParNode(option);
+}
+/**
+* Parse options for phrasing nodes
+*/
+function parseOptionsParNode(option) {
+	const headingMax = option.heading;
+	const paragraphMax = option.paragraph;
+	const tableMax = option.table;
+	const htmlMax = option.html;
+	const mathMax = option.math;
+	const maxLengthForCode = option.code ? parseCodeOption(option.code) : null;
+	const maxLengthForFrontmatter = option.frontmatter ? parseFrontmatterOption(option.frontmatter) : null;
+	/**
+	* Get max length for a specific node type
+	*/
+	function getMaxLength(node) {
+		switch (node.type) {
+			case "heading": return headingMax ?? null;
+			case "paragraph": return paragraphMax ?? null;
+			case "table": return tableMax ?? null;
+			case "html": return htmlMax ?? null;
+			case "math": return mathMax ?? null;
+			case "code": return maxLengthForCode?.(node) ?? null;
+			case "yaml":
+			case "toml": return maxLengthForFrontmatter?.(node) ?? null;
+		}
+		return null;
+	}
+	return (node) => getMaxLength(node);
+}
+var max_len_default = createRule("max-len", {
+	meta: {
+		type: "layout",
+		docs: {
+			description: "enforce maximum length for various Markdown entities",
+			categories: [],
+			listCategory: "Decorative"
+		},
+		fixable: void 0,
+		hasSuggestions: false,
+		schema: [{
+			type: "object",
+			properties: {
+				...maxLengthParPhrasingNodeOptionsSchema.properties,
+				list: maxLengthOptionForContainerSchema,
+				blockquote: maxLengthOptionForContainerSchema,
+				footnoteDefinition: maxLengthOptionForContainerSchema,
+				ignoreUrls: { type: "boolean" }
+			},
+			additionalProperties: false
+		}],
+		messages: { maxLenExceeded: "Line length of {{actual}} exceeds the maximum of {{max}}." }
+	},
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const options = parseOptions$5(context.options[0] ?? {}, sourceCode);
+		const checkedLines = /* @__PURE__ */ new Set();
+		/**
+		* Check if a line contains a URL (following @stylistic/max-len behavior)
+		* URLs are identified by the URL_PATTERN
+		*/
+		function containsUrl(line) {
+			URL_PATTERN.lastIndex = 0;
+			return URL_PATTERN.test(line);
+		}
+		/**
+		* Check lines in a node against a maximum length
+		*/
+		function checkLines(node) {
+			const maxLength = options.maxLength(node);
+			if (maxLength === "ignore") return;
+			const nodeLoc = sourceCode.getLoc(node);
+			const startLine = nodeLoc.start.line;
+			const endLine = nodeLoc.end.line;
+			for (let lineNumber = startLine; lineNumber <= endLine; lineNumber++) {
+				if (checkedLines.has(lineNumber)) continue;
+				const line = sourceCode.lines[lineNumber - 1];
+				const width = getTextWidth(line);
+				if (width > maxLength) {
+					if (options.ignoreUrls && containsUrl(line)) continue;
+					context.report({
+						node,
+						loc: {
+							start: {
+								line: lineNumber,
+								column: 1
+							},
+							end: {
+								line: lineNumber,
+								column: line.length + 1
+							}
+						},
+						messageId: "maxLenExceeded",
+						data: {
+							actual: String(width),
+							max: String(maxLength)
+						}
+					});
+					checkedLines.add(lineNumber);
+				}
+			}
+		}
+		return {
+			heading: checkLines,
+			paragraph: checkLines,
+			table: checkLines,
+			html(node) {
+				const parent = getParent(sourceCode, node);
+				if (parent.type !== "root" && parent.type !== "blockquote" && parent.type !== "listItem" && parent.type !== "footnoteDefinition" && parent.type !== "customContainer") return;
+				checkLines(node);
+			},
+			code: checkLines,
+			yaml: checkLines,
+			toml: checkLines,
+			math: checkLines
+		};
+	}
+});
+
 //#endregion
 //#region src/rules/no-heading-trailing-punctuation.ts
 const DEFAULT_PUNCTUATION = ".,;:!。、，；：！｡､";
@@ -8971,13 +9174,17 @@ var ordered_list_marker_sequence_default = createRule("ordered-list-marker-seque
 	meta: {
 		type: "layout",
 		docs: {
-			description: "enforce that ordered list markers use sequential numbers",
+			description: "enforce consistent ordered list marker numbering (sequential or flat)",
 			categories: ["standard"],
 			listCategory: "Decorative"
 		},
 		fixable: "code",
 		hasSuggestions: true,
-		schema: [],
+		schema: [{
+			type: "object",
+			properties: { increment: { enum: ["always", "never"] } },
+			additionalProperties: false
+		}],
 		messages: {
 			inconsistent: "Ordered list marker should be '{{expected}}' but found '{{actual}}'.",
 			inconsistentStart: "Ordered list start should be {{expected}} but found '{{actual}}'.",
@@ -8986,6 +9193,7 @@ var ordered_list_marker_sequence_default = createRule("ordered-list-marker-seque
 	},
 	create(context) {
 		const sourceCode = context.sourceCode;
+		const incrementMode = (context.options[0] || {}).increment ?? "always";
 		let scope = {
 			node: sourceCode.ast,
 			upper: null,
@@ -8996,9 +9204,13 @@ var ordered_list_marker_sequence_default = createRule("ordered-list-marker-seque
 		*/
 		function verifyStartSequence(node, marker) {
 			if (node.start == null || node.start <= 1) return true;
-			if (scope.last != null && scope.last.sequence + 1 === node.start && marker.kind === scope.last.kind) return true;
 			const expected = [0, 1];
-			if (scope.last != null && marker.kind === scope.last.kind) expected.push(scope.last.sequence + 1);
+			if (incrementMode !== "never") {
+				if (scope.last != null && marker.kind === scope.last.kind) {
+					if (scope.last.sequence + 1 === node.start) return true;
+					if (scope.last.sequence + 1 > 1) expected.push(scope.last.sequence + 1);
+				}
+			}
 			const suggest = [];
 			for (const n of [...expected].sort((a, b) => Math.abs(node.start - a) - Math.abs(node.start - b))) suggest.push({
 				messageId: "suggestStartFromN",
@@ -9016,7 +9228,7 @@ var ordered_list_marker_sequence_default = createRule("ordered-list-marker-seque
 					expected: new Intl.ListFormat("en-US", { type: "disjunction" }).format(expected.map((n) => `'${n}'`)),
 					actual: marker.sequence.raw
 				},
-				fix: scope.last == null ? (fixer) => {
+				fix: scope.last == null || incrementMode === "never" ? (fixer) => {
 					const expectedMarker = `1${marker.kind}`;
 					const range = sourceCode.getRange(node);
 					return fixer.replaceTextRange([range[0], range[0] + marker.raw.length], expectedMarker);
@@ -9030,11 +9242,11 @@ var ordered_list_marker_sequence_default = createRule("ordered-list-marker-seque
 		*/
 		function verifyListItems(node) {
 			if (node.start == null) return;
-			for (let i = 0; i < node.children.length; i++) {
+			for (let i = 1; i < node.children.length; i++) {
 				const item = node.children[i];
 				const marker = getListItemMarker(sourceCode, item);
 				if (marker.kind !== "." && marker.kind !== ")") continue;
-				const expectedSequence = node.start + i;
+				const expectedSequence = incrementMode === "never" ? node.start : node.start + i;
 				if (marker.sequence.value !== expectedSequence) {
 					const expectedMarker = `${expectedSequence}${marker.kind}`;
 					context.report({
@@ -12407,6 +12619,7 @@ const rules$1 = [
 	link_paren_spacing_default,
 	link_title_style_default,
 	list_marker_alignment_default,
+	max_len_default,
 	no_heading_trailing_punctuation_default,
 	no_implicit_block_closing_default,
 	no_laziness_blockquotes_default,
@@ -12541,7 +12754,7 @@ var meta_exports = /* @__PURE__ */ __export({
 	version: () => version
 });
 const name = "eslint-plugin-markdown-preferences";
-const version = "0.38.0";
+const version = "0.40.0";
 
 //#endregion
 //#region src/language/extensions/micromark-custom-container.ts

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-markdown-preferences",
-  "version": "0.38.0",
+  "version": "0.40.0",
   "description": "ESLint plugin that enforces our markdown preferences",
   "type": "module",
   "exports": {
@@ -105,7 +105,7 @@
     "eslint-plugin-json-schema-validator": "^5.5.0",
     "eslint-plugin-jsonc": "^2.19.1",
     "eslint-plugin-markdown": "^5.1.0",
-    "eslint-plugin-markdown-links": "^0.6.0",
+    "eslint-plugin-markdown-links": "^0.7.0",
     "eslint-plugin-n": "^17.16.2",
     "eslint-plugin-node-dependencies": "^1.0.0",
     "eslint-plugin-prettier": "^5.2.3",