linter-bundle 5.1.0 → 6.1.0

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/selector-list-comma-newline-after/README.md

@@ -0,0 +1,120 @@
+# selector-list-comma-newline-after
+
+Require a newline or disallow whitespace after the commas of selector lists.
+
+<!-- prettier-ignore -->
+```css
+   a,
+   b↑{ color: pink; }
+/** ↑
+ * The newline after this comma */
+```
+
+End-of-line comments are allowed one space after the comma.
+
+<!-- prettier-ignore -->
+```css
+a, /* comment */
+b { color: pink; }
+```
+
+The [`fix` option](https://stylelint.io/user-guide/options/#fix) can automatically fix all of the problems reported by this rule.
+
+## Options
+
+`string`: `"always"|"always-multi-line"|"never-multi-line"`
+
+### `"always"`
+
+There _must always_ be a newline after the commas.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a, b { color: pink; }
+```
+
+<!-- prettier-ignore -->
+```css
+a
+, b { color: pink; }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a,
+b { color: pink; }
+```
+
+<!-- prettier-ignore -->
+```css
+a
+,
+b { color: pink; }
+```
+
+### `"always-multi-line"`
+
+There _must always_ be a newline after the commas in multi-line selector lists.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a
+, b { color: pink; }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a, b { color: pink; }
+```
+
+<!-- prettier-ignore -->
+```css
+a,
+b { color: pink; }
+```
+
+<!-- prettier-ignore -->
+```css
+a
+,
+b { color: pink; }
+```
+
+### `"never-multi-line"`
+
+There _must never_ be whitespace after the commas in multi-line selector lists.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a
+, b { color: pink; }
+```
+
+<!-- prettier-ignore -->
+```css
+a,
+b { color: pink; }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a,b { color: pink; }
+```
+
+<!-- prettier-ignore -->
+```css
+a
+,b { color: pink; }
+```

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/selector-list-comma-newline-after/index.cjs

@@ -0,0 +1,126 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const stylelint = require('stylelint');
+const isStandardSyntaxRule = require('stylelint/lib/utils/isStandardSyntaxRule.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 styleSearch = require('../../style-search/index.cjs');
+const whitespaceChecker = require('../../utils/whitespaceChecker.cjs');
+
+const ruleName = 'plugin/selector-list-comma-newline-after';
+
+const messages = ruleMessages(ruleName, {
+	expectedAfter: () => 'Expected newline after ","',
+	expectedAfterMultiLine: () => 'Expected newline after "," in a multi-line list',
+	rejectedAfterMultiLine: () => 'Unexpected whitespace after "," in a multi-line list'
+});
+
+const meta = {
+	url: 'https://github.com/jens-duttke/linter-bundle/blob/main/stylelint/plugins/stylelint-15.11.0-stylistic/rules/selector-list-comma-newline-after/README.md',
+	fixable: true
+};
+
+/** @type {import('stylelint').Rule} */
+const rule = (primary, _secondaryOptions, context) => {
+	const checker = whitespaceChecker('newline', primary, messages);
+
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: ['always', 'always-multi-line', 'never-multi-line']
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkRules((ruleNode) => {
+			if (!isStandardSyntaxRule(ruleNode)) {
+				return;
+			}
+
+			// Get raw selector so we can allow end-of-line comments, e.g.
+			// a, /* comment */
+			// b {}
+			const selector = ruleNode.raws.selector ? ruleNode.raws.selector.raw : ruleNode.selector;
+
+			/** @type {number[]} */
+			const fixIndices = [];
+
+			styleSearch(
+				{
+					source: selector,
+					target: ',',
+					functionArguments: 'skip'
+				},
+				(match) => {
+					const nextChars = selector.slice(match.endIndex);
+
+					// If there's a // comment, that means there has to be a newline
+					// ending the comment so we're fine
+					if ((/^\s+\/\//).test(nextChars)) {
+						return;
+					}
+
+					// If there are spaces and then a comment begins, look for the newline
+					const indextoCheckAfter = (/^\s+\/\*/).test(nextChars) ?
+						selector.indexOf('*/', match.endIndex) + 1
+						: match.startIndex;
+
+					checker.afterOneOnly({
+						source: selector,
+						index: indextoCheckAfter,
+						err: (m) => {
+							if (context.fix) {
+								fixIndices.push(indextoCheckAfter + 1);
+
+								return;
+							}
+
+							report({
+								message: m,
+								node: ruleNode,
+								index: match.startIndex,
+								result,
+								ruleName
+							});
+						}
+					});
+				}
+			);
+
+			if (fixIndices.length > 0) {
+				let fixedSelector = selector;
+
+				for (const index of fixIndices.sort((a, b) => b - a)) {
+					const beforeSelector = fixedSelector.slice(0, index);
+					let afterSelector = fixedSelector.slice(index);
+
+					if (primary.startsWith('always')) {
+						afterSelector = context.newline + afterSelector;
+					}
+					else if (primary.startsWith('never-multi-line')) {
+						afterSelector = afterSelector.replace(/^\s*/, '');
+					}
+
+					fixedSelector = beforeSelector + afterSelector;
+				}
+
+				if (ruleNode.raws.selector) {
+					ruleNode.raws.selector.raw = fixedSelector;
+				}
+				else {
+					ruleNode.selector = fixedSelector;
+				}
+			}
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+module.exports = stylelint.createPlugin(ruleName, rule);

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/selector-list-comma-newline-before/README.md

@@ -0,0 +1,112 @@
+# selector-list-comma-newline-before
+
+Require a newline or disallow whitespace before the commas of selector lists.
+
+<!-- prettier-ignore -->
+```css
+    a
+    , b { color: pink; }
+/** ↑
+ * The newline before this comma */
+```
+
+The [`fix` option](https://stylelint.io/user-guide/options/#fix) can automatically fix all of the problems reported by this rule.
+
+## Options
+
+`string`: `"always"|"always-multi-line"|"never-multi-line"`
+
+### `"always"`
+
+There _must always_ be a newline before the commas.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a, b { color: pink; }
+```
+
+<!-- prettier-ignore -->
+```css
+a,
+b { color: pink; }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a
+, b { color: pink; }
+```
+
+<!-- prettier-ignore -->
+```css
+a
+,b { color: pink; }
+```
+
+### `"always-multi-line"`
+
+There _must always_ be a newline before the commas in multi-line selector lists.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a,
+b { color: pink; }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a, b { color: pink; }
+```
+
+<!-- prettier-ignore -->
+```css
+a
+,b { color: pink; }
+```
+
+<!-- prettier-ignore -->
+```css
+a
+,
+b { color: pink; }
+```
+
+### `"never-multi-line"`
+
+There _must never_ be whitespace before the commas in multi-line selector lists.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a
+, b { color: pink; }
+```
+
+<!-- prettier-ignore -->
+```css
+a
+,
+b { color: pink; }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a,b { color: pink; }
+```
+
+<!-- prettier-ignore -->
+```css
+a,
+b { color: pink; }
+```

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/selector-list-comma-newline-before/index.cjs

@@ -0,0 +1,101 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const stylelint = require('stylelint');
+const ruleMessages = require('stylelint/lib/utils/ruleMessages.cjs');
+const validateOptions = require('stylelint/lib/utils/validateOptions.cjs');
+
+const whitespaceChecker = require('../../utils/whitespaceChecker.cjs');
+const selectorListCommaWhitespaceChecker = require('../selectorListCommaWhitespaceChecker.cjs');
+
+const ruleName = 'plugin/selector-list-comma-newline-before';
+
+const messages = ruleMessages(ruleName, {
+	expectedBefore: () => 'Expected newline before ","',
+	expectedBeforeMultiLine: () => 'Expected newline before "," in a multi-line list',
+	rejectedBeforeMultiLine: () => 'Unexpected whitespace before "," in a multi-line list'
+});
+
+const meta = {
+	url: 'https://github.com/jens-duttke/linter-bundle/blob/main/stylelint/plugins/stylelint-15.11.0-stylistic/rules/selector-list-comma-newline-before/README.md',
+	fixable: true
+};
+
+/** @type {import('stylelint').Rule} */
+const rule = (primary, _secondaryOptions, context) => {
+	const checker = whitespaceChecker('newline', primary, messages);
+
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: ['always', 'always-multi-line', 'never-multi-line']
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		/** @type {Map<import('postcss').Rule, number[]> | undefined} */
+		let fixData;
+
+		selectorListCommaWhitespaceChecker({
+			root,
+			result,
+			locationChecker: checker.beforeAllowingIndentation,
+			checkedRuleName: ruleName,
+			fix: context.fix ?
+				(ruleNode, index) => {
+					fixData ||= new Map();
+					const commaIndices = fixData.get(ruleNode) || [];
+
+					commaIndices.push(index);
+					fixData.set(ruleNode, commaIndices);
+
+					return true;
+				  }
+				: null
+		});
+
+		if (fixData) {
+			for (const [ruleNode, commaIndices] of fixData.entries()) {
+				let selector = ruleNode.raws.selector ? ruleNode.raws.selector.raw : ruleNode.selector;
+
+				for (const index of commaIndices.sort((a, b) => b - a)) {
+					let beforeSelector = selector.slice(0, index);
+					const afterSelector = selector.slice(index);
+
+					if (primary.startsWith('always')) {
+						const spaceIndex = beforeSelector.search(/\s+$/);
+
+						if (spaceIndex >= 0) {
+							beforeSelector =
+								beforeSelector.slice(0, spaceIndex) +
+								context.newline +
+								beforeSelector.slice(spaceIndex);
+						}
+						else {
+							beforeSelector += context.newline;
+						}
+					}
+					else if (primary === 'never-multi-line') {
+						beforeSelector = beforeSelector.replace(/\s*$/, '');
+					}
+
+					selector = beforeSelector + afterSelector;
+				}
+
+				if (ruleNode.raws.selector) {
+					ruleNode.raws.selector.raw = selector;
+				}
+				else {
+					ruleNode.selector = selector;
+				}
+			}
+		}
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+module.exports = stylelint.createPlugin(ruleName, rule);

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/selector-list-comma-space-after/README.md

@@ -0,0 +1,110 @@
+# selector-list-comma-space-after
+
+Require a single space or disallow whitespace after the commas of selector lists.
+
+<!-- prettier-ignore -->
+```css
+   a, b { color: pink; }
+/** ↑
+ * The space after this comma */
+```
+
+The [`fix` option](https://stylelint.io/user-guide/options/#fix) can automatically fix all of the problems reported by this rule.
+
+## Options
+
+`string`: `"always"|"never"|"always-single-line"|"never-single-line"`
+
+### `"always"`
+
+There _must always_ be a single space after the commas.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a,b { color: pink; }
+```
+
+<!-- prettier-ignore -->
+```css
+a ,b { color: pink; }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a, b { color: pink; }
+```
+
+<!-- prettier-ignore -->
+```css
+a , b { color: pink; }
+```
+
+### `"never"`
+
+There _must never_ be whitespace after the commas.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a, b { color: pink; }
+```
+
+<!-- prettier-ignore -->
+```css
+a , b { color: pink; }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a,b { color: pink; }
+```
+
+<!-- prettier-ignore -->
+```css
+a ,b { color: pink; }
+```
+
+### `"always-single-line"`
+
+There _must always_ be a single space after the commas in single-line selector lists.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a,b { color: pink; }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a
+,b { color: pink; }
+```
+
+### `"never-single-line"`
+
+There _must never_ be a single space after the commas in single-line selector lists.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a, b { color: pink; }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a
+, b { color: pink; }
+```

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/selector-list-comma-space-after/index.cjs

@@ -0,0 +1,92 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const stylelint = require('stylelint');
+const ruleMessages = require('stylelint/lib/utils/ruleMessages.cjs');
+const validateOptions = require('stylelint/lib/utils/validateOptions.cjs');
+
+const whitespaceChecker = require('../../utils/whitespaceChecker.cjs');
+const selectorListCommaWhitespaceChecker = require('../selectorListCommaWhitespaceChecker.cjs');
+
+const ruleName = 'plugin/selector-list-comma-space-after';
+
+const messages = ruleMessages(ruleName, {
+	expectedAfter: () => 'Expected single space after ","',
+	rejectedAfter: () => 'Unexpected whitespace after ","',
+	expectedAfterSingleLine: () => 'Expected single space after "," in a single-line list',
+	rejectedAfterSingleLine: () => 'Unexpected whitespace after "," in a single-line list'
+});
+
+const meta = {
+	url: 'https://github.com/jens-duttke/linter-bundle/blob/main/stylelint/plugins/stylelint-15.11.0-stylistic/rules/selector-list-comma-space-after/README.md',
+	fixable: true
+};
+
+/** @type {import('stylelint').Rule} */
+const rule = (primary, _secondaryOptions, context) => {
+	const checker = whitespaceChecker('space', primary, messages);
+
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: ['always', 'never', 'always-single-line', 'never-single-line']
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		/** @type {Map<import('postcss').Rule, number[]> | undefined} */
+		let fixData;
+
+		selectorListCommaWhitespaceChecker({
+			root,
+			result,
+			locationChecker: checker.after,
+			checkedRuleName: ruleName,
+			fix: context.fix ?
+				(ruleNode, index) => {
+					fixData ||= new Map();
+					const commaIndices = fixData.get(ruleNode) || [];
+
+					commaIndices.push(index);
+					fixData.set(ruleNode, commaIndices);
+
+					return true;
+				  }
+				: null
+		});
+
+		if (fixData) {
+			for (const [ruleNode, commaIndices] of fixData.entries()) {
+				let selector = ruleNode.raws.selector ? ruleNode.raws.selector.raw : ruleNode.selector;
+
+				for (const index of commaIndices.sort((a, b) => b - a)) {
+					const beforeSelector = selector.slice(0, index + 1);
+					let afterSelector = selector.slice(index + 1);
+
+					if (primary.startsWith('always')) {
+						afterSelector = afterSelector.replace(/^\s*/, ' ');
+					}
+					else if (primary.startsWith('never')) {
+						afterSelector = afterSelector.replace(/^\s*/, '');
+					}
+
+					selector = beforeSelector + afterSelector;
+				}
+
+				if (ruleNode.raws.selector) {
+					ruleNode.raws.selector.raw = selector;
+				}
+				else {
+					ruleNode.selector = selector;
+				}
+			}
+		}
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+module.exports = stylelint.createPlugin(ruleName, rule);