linter-bundle 5.1.0 → 6.1.0

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/linebreaks/README.md

@@ -0,0 +1,21 @@
+# linebreaks
+
+Specify unix or windows linebreaks.
+
+The [`fix` option](https://stylelint.io/user-guide/options/#fix) can automatically fix all of the problems reported by this rule.
+
+## Options
+
+`string`: `"unix"|"windows"`
+
+### `"unix"`
+
+Linebreaks _must always_ be LF (`\n`).
+
+Lines with CRLF linebreaks are considered problems.
+
+### `"windows"`
+
+Linebreaks _must always_ be CRLF (`\r\n`).
+
+Lines with LF linebreaks are considered problems.

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/linebreaks/index.cjs

@@ -0,0 +1,132 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const postcss = require('postcss');
+const stylelint = require('stylelint');
+const report = require('stylelint/lib/utils/report.cjs');
+const ruleMessages = require('stylelint/lib/utils/ruleMessages.cjs');
+const validateOptions = require('stylelint/lib/utils/validateOptions.cjs');
+
+const ruleName = 'plugin/linebreaks';
+
+const messages = ruleMessages(ruleName, {
+	expected: (linebreak) => `Expected linebreak to be ${linebreak}`
+});
+
+const meta = {
+	url: 'https://github.com/jens-duttke/linter-bundle/blob/main/stylelint/plugins/stylelint-15.11.0-stylistic/rules/linebreaks/README.md',
+	fixable: true
+};
+
+/** @type {import('stylelint').Rule} */
+const rule = (primary, _secondaryOptions, context) => (root, result) => {
+	const validOptions = validateOptions(result, ruleName, {
+		actual: primary,
+		possible: ['unix', 'windows']
+	});
+
+	if (!validOptions) {
+		return;
+	}
+
+	const shouldHaveCR = primary === 'windows';
+
+	if (context.fix) {
+		root.walk((node) => {
+			if ('selector' in node) {
+				node.selector = fixData(node.selector);
+			}
+
+			if ('value' in node) {
+				node.value = fixData(node.value);
+			}
+
+			if ('text' in node) {
+				node.text = fixData(node.text);
+			}
+
+			if (node.raws.before) {
+				node.raws.before = fixData(node.raws.before);
+			}
+
+			if (typeof node.raws.after === 'string') {
+				node.raws.after = fixData(node.raws.after);
+			}
+		});
+
+		if (typeof root.raws.after === 'string') {
+			root.raws.after = fixData(root.raws.after);
+		}
+	}
+	else {
+		if (root.source == null) { throw new Error('The root node must have a source'); }
+
+		const lines = root.source.input.css.split('\n');
+
+		for (let [i, line] of lines.entries()) {
+			if (i < lines.length - 1 && !line.includes('\r')) {
+				line += '\n';
+			}
+
+			if (hasError(line)) {
+				const lineNum = i + 1;
+				const colNumber = line.length;
+
+				reportNewlineError(lineNum, colNumber);
+			}
+		}
+	}
+
+	/**
+	 * @param {string} dataToCheck
+	 */
+	function hasError (dataToCheck) {
+		const hasNewlineToVerify = (/[\n\r]/).test(dataToCheck);
+		const hasCR = hasNewlineToVerify ? dataToCheck.includes('\r') : false;
+
+		return hasNewlineToVerify && hasCR !== shouldHaveCR;
+	}
+
+	/**
+	 * @param {string} data
+	 */
+	function fixData (data) {
+		if (data) {
+			let res = data.replace(/\r/g, '');
+
+			if (shouldHaveCR) {
+				res = res.replace(/\n/g, '\r\n');
+			}
+
+			return res;
+		}
+
+		return data;
+	}
+
+	/**
+	 * @param {number} line
+	 * @param {number} column
+	 */
+	function reportNewlineError (line, column) {
+		// Creating a node manually helps us to point to empty lines.
+		const node = postcss.rule({
+			source: {
+				start: { line, column, offset: 0 },
+				input: new postcss.Input('')
+			}
+		});
+
+		report({
+			message: messages.expected(primary),
+			node,
+			result,
+			ruleName
+		});
+	}
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+module.exports = stylelint.createPlugin(ruleName, rule);

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/max-empty-lines/README.md

@@ -0,0 +1,116 @@
+# max-empty-lines
+
+Limit the number of adjacent empty lines.
+
+<!-- prettier-ignore -->
+```css
+a {}
+     /* ← */
+     /* ← */
+a {} /* ↑ */
+/**     ↑
+ * These lines */
+```
+
+The [`fix` option](https://stylelint.io/user-guide/options/#fix) can automatically fix all of the problems reported by this rule.
+
+## Options
+
+`int`: Maximum number of adjacent empty lines allowed.
+
+For example, with `2`:
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a {}
+
+
+
+b {}
+```
+
+Comment strings are also checked -- so the following is a problem:
+
+<!-- prettier-ignore -->
+```css
+/*
+ Call me Ishmael.
+
+
+
+ Some years ago--never mind how long precisely-—...
+ */
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a {}
+b {}
+```
+
+<!-- prettier-ignore -->
+```css
+a {}
+
+b {}
+```
+
+<!-- prettier-ignore -->
+```css
+a {}
+
+
+b {}
+```
+
+## Optional secondary options
+
+### `ignore: ["comments"]`
+
+Only enforce the adjacent empty lines limit for lines that are not comments.
+
+For example, with `2` adjacent empty lines:
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+/* horse */
+a {}
+
+
+
+b {}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+/*
+ Call me Ishmael.
+
+
+
+ Some years ago -- never mind how long precisely -- ...
+ */
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+    /*
+     Comment
+
+
+
+
+     inside the declaration with a lot of empty lines...
+    */
+     color: pink;
+}
+```

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/max-empty-lines/index.cjs

@@ -0,0 +1,225 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const stylelint = require('stylelint');
+const optionsMatches = require('stylelint/lib/utils/optionsMatches.cjs');
+const report = require('stylelint/lib/utils/report.cjs');
+const ruleMessages = require('stylelint/lib/utils/ruleMessages.cjs');
+const validateOptions = require('stylelint/lib/utils/validateOptions.cjs');
+const { isNumber } = require('stylelint/lib/utils/validateTypes.cjs');
+
+const styleSearch = require('../../style-search/index.cjs');
+
+const ruleName = 'plugin/max-empty-lines';
+
+const messages = ruleMessages(ruleName, {
+	expected: (max) => `Expected no more than ${max} empty ${max === 1 ? 'line' : 'lines'}`
+});
+
+const meta = {
+	url: 'https://github.com/jens-duttke/linter-bundle/blob/main/stylelint/plugins/stylelint-15.11.0-stylistic/rules/max-empty-lines/README.md',
+	fixable: true
+};
+
+/** @type {import('stylelint').Rule} */
+const rule = (primary, secondaryOptions, context) => {
+	let emptyLines = 0;
+	let lastIndex = -1;
+
+	return (root, result) => {
+		const validOptions = validateOptions(
+			result,
+			ruleName,
+			{
+				actual: primary,
+				possible: isNumber
+			},
+			{
+				actual: secondaryOptions,
+				possible: {
+					ignore: ['comments']
+				},
+				optional: true
+			}
+		);
+
+		if (!validOptions) {
+			return;
+		}
+
+		const ignoreComments = optionsMatches(secondaryOptions, 'ignore', 'comments');
+		const getChars = replaceEmptyLines.bind(null, primary);
+
+		/**
+		 * 1. walk nodes & replace enterchar
+		 * 2. deal with special case.
+		 */
+		if (context.fix) {
+			root.walk((node) => {
+				if (node.type === 'comment' && !ignoreComments) {
+					node.raws.left = getChars(node.raws.left);
+					node.raws.right = getChars(node.raws.right);
+				}
+
+				if (node.raws.before) {
+					node.raws.before = getChars(node.raws.before);
+				}
+			});
+
+			// first node
+			const firstNodeRawsBefore = root.first?.raws.before;
+			// root raws
+			const rootRawsAfter = root.raws.after;
+
+			// not document node
+			// @ts-expect-error -- TS2339: Property 'document' does not exist on type 'Root'.
+			if ((root.document?.constructor.name) !== 'Document') {
+				if (firstNodeRawsBefore) {
+					root.first.raws.before = getChars(firstNodeRawsBefore, true);
+				}
+
+				if (rootRawsAfter) {
+					// when max set 0, should be treated as 1 in this situation.
+					root.raws.after = replaceEmptyLines(primary === 0 ? 1 : primary, rootRawsAfter, true);
+				}
+			}
+			else if (rootRawsAfter) {
+				// `css in js` or `html`
+				root.raws.after = replaceEmptyLines(primary === 0 ? 1 : primary, rootRawsAfter);
+			}
+
+			return;
+		}
+
+		emptyLines = 0;
+		lastIndex = -1;
+		const rootString = root.toString();
+
+		styleSearch(
+			{
+				source: rootString,
+				target: rootString.includes('\r\n') ? '\r\n' : '\n',
+				comments: ignoreComments ? 'skip' : 'check'
+			},
+			(match) => {
+				checkMatch(rootString, match.startIndex, match.endIndex, root);
+			}
+		);
+
+		/**
+		 * @param {string} source
+		 * @param {number} matchStartIndex
+		 * @param {number} matchEndIndex
+		 * @param {import('postcss').Root} node
+		 */
+		function checkMatch (source, matchStartIndex, matchEndIndex, node) {
+			const eof = matchEndIndex === source.length;
+			let problem = false;
+
+			// Additional check for beginning of file
+			if (!matchStartIndex || lastIndex === matchStartIndex) {
+				emptyLines++;
+			}
+			else {
+				emptyLines = 0;
+			}
+
+			lastIndex = matchEndIndex;
+
+			if (emptyLines > primary) { problem = true; }
+
+			if (!eof && !problem) { return; }
+
+			if (problem) {
+				report({
+					message: messages.expected(primary),
+					node,
+					index: matchStartIndex,
+					result,
+					ruleName
+				});
+			}
+
+			// Additional check for end of file
+			if (eof && primary) {
+				emptyLines++;
+
+				if (emptyLines > primary && isEofNode(result.root, node)) {
+					report({
+						message: messages.expected(primary),
+						node,
+						index: matchEndIndex,
+						result,
+						ruleName
+					});
+				}
+			}
+		}
+
+		/**
+		 * @param {number} maxLines
+		 * @param {unknown} str
+		 * @param string_
+		 * @param {boolean?} isSpecialCase
+		 */
+		function replaceEmptyLines (maxLines, string_, isSpecialCase = false) {
+			const repeatTimes = isSpecialCase ? maxLines : maxLines + 1;
+
+			if (repeatTimes === 0 || typeof string_ !== 'string') {
+				return '';
+			}
+
+			const emptyLFLines = '\n'.repeat(repeatTimes);
+			const emptyCRLFLines = '\r\n'.repeat(repeatTimes);
+
+			return (/(?:\r\n)+/).test(string_) ?
+				string_.replace(/(\r\n)+/g, ($1) => {
+					if ($1.length / 2 > repeatTimes) {
+						return emptyCRLFLines;
+					}
+
+					return $1;
+				  })
+				: string_.replace(/(\n)+/g, ($1) => {
+					if ($1.length > repeatTimes) {
+						return emptyLFLines;
+					}
+
+					return $1;
+				  });
+		}
+	};
+};
+
+/**
+ * Checks whether the given node is the last node of file.
+ * @param {import('stylelint').PostcssResult['root']} document - the document node with `postcss-html` and `postcss-jsx`
+ * @param {import('postcss').Root} root - the root node of css
+ */
+function isEofNode (document, root) {
+	if (!document || document.constructor.name !== 'Document' || !('type' in document)) {
+		return true;
+	}
+
+	// In the `postcss-html` and `postcss-jsx` syntax, checks that there is text after the given node.
+	let after;
+
+	if (root === document.last) {
+		after = document.raws?.codeAfter;
+	}
+	else {
+		// @ts-expect-error -- TS2345: Argument of type 'Root' is not assignable to parameter of type 'number | ChildNode'.
+		const rootIndex = document.index(root);
+
+		const nextNode = document.nodes[rootIndex + 1];
+
+		after = nextNode.raws.codeBefore;
+	}
+
+	return !String(after).trim();
+}
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+module.exports = stylelint.createPlugin(ruleName, rule);

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/max-line-length/README.md

@@ -0,0 +1,151 @@
+# max-line-length
+
+Limit the length of a line.
+
+<!-- prettier-ignore -->
+```css
+a { color: red }
+/**            ↑
+ *       The end */
+```
+
+Lines that exceed the maximum length but contain no whitespace (other than at the beginning of the line) are ignored.
+
+When evaluating the line length, the arguments of any `url(...)` functions are excluded from the calculation, because typically you have no control over the length of these arguments. This means that long `url()` functions should not contribute to problems.
+
+## Options
+
+`int`: Maximum number of characters allowed.
+
+For example, with `20`:
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { color: 0; top: 0; }
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  background: linear-gradient(red, blue);
+}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a {
+  color: 0;
+  top: 0;
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  background: url(a-url-that-is-over-20-characters-long);
+}
+```
+
+## Optional secondary options
+
+### `ignore: ["non-comments"]`
+
+Only enforce the line-length limit for lines within comments.
+
+This does not apply to comments that are stuck in between other stuff, only to lines that begin at the beginning or in the middle of a comment.
+
+For example, with a maximum length of `30`.
+
+The following patterns are considered problems:
+
+Each have only one problem.
+
+<!-- prettier-ignore -->
+```css
+/* This line is too long for my rule */
+a { color: pink; background: orange; }
+a { color: pink; /* this comment is also long but not on its own line */ }
+```
+
+<!-- prettier-ignore -->
+```css
+a { color: pink; background: orange; }
+/**
+ * This line is short,
+ * but this line is too long for my liking,
+ * though this one is fine
+ */
+a { color: pink; /* this comment is also long but not on its own line */ }
+```
+
+### `ignore: ["comments"]`
+
+Only enforce the line-length limit for lines that are not comments.
+
+This also applies to comments that are between code on the same line.
+
+For example, with a maximum length of `30`.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { color: pink; } /* comment that is too long */
+```
+
+<!-- prettier-ignore -->
+```css
+a { /* this comment is too long for the max length */ }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+/* comment that is too long for my rule*/
+a { color: pink; }
+```
+
+<!-- prettier-ignore -->
+```css
+/*
+ * comment that is too long the max length
+ * comment that is too long the max length
+ *
+ */
+a { color: pink; }
+```
+
+### `ignorePattern: "/regex/"`
+
+Ignore any line that matches the given regex pattern, regardless of whether it is comment or not. The regex may be passed as a string (for JSON configuration) by enclosing in forward-slashes, or an ordinary JavaScript RegExp may be used.
+
+Given:
+
+```json
+"/^@import\\s+/"
+```
+
+The following pattern is _not_ considered a problem:
+
+<!-- prettier-ignore -->
+```css
+@import "../../../../another/css/or/scss/file/or/something.css";
+```
+
+Given the following, with a maximum length of `20`.
+
+```js
+["/https?://[0-9,a-z]*.*/"];
+```
+
+The following pattern is _not_ considered a problem:
+
+<!-- prettier-ignore -->
+```css
+/* ignore urls https://www.example.com */
+```