linter-bundle 5.1.0 → 6.1.0

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

@@ -0,0 +1,110 @@
+# selector-list-comma-space-before
+
+Require a single space or disallow whitespace before the commas of selector lists.
+
+<!-- prettier-ignore -->
+```css
+   a ,b { color: pink; }
+/**  ↑
+ * The space 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"|"never"|"always-single-line"|"never-single-line"`
+
+### `"always"`
+
+There _must always_ be a single space 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; }
+```
+
+### `"never"`
+
+There _must never_ be whitespace 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-single-line"`
+
+There _must always_ be a single space before 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 before 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-before/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-before';
+
+const messages = ruleMessages(ruleName, {
+	expectedBefore: () => 'Expected single space before ","',
+	rejectedBefore: () => 'Unexpected whitespace before ","',
+	expectedBeforeSingleLine: () => 'Expected single space before "," in a single-line list',
+	rejectedBeforeSingleLine: () => 'Unexpected whitespace before "," 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-before/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.before,
+			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.includes('always')) {
+						beforeSelector = beforeSelector.replace(/\s*$/, ' ');
+					}
+					else if (primary.includes('never')) {
+						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-max-empty-lines/README.md

@@ -0,0 +1,103 @@
+# selector-max-empty-lines
+
+Limit the number of adjacent empty lines within selectors.
+
+<!-- prettier-ignore -->
+```css
+a,
+              /* ← */
+b {        /* ↑ */
+  color: red; /* ↑ */
+}             /* ↑ */
+/**              ↑
+ *        This empty line */
+```
+
+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 `0`:
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a
+
+b {
+  color: red;
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a,
+
+b {
+  color: red;
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a
+
+>
+b {
+  color: red;
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a
+>
+
+b {
+  color: red;
+}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a b {
+  color: red;
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a
+b {
+  color: red;
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a,
+b {
+  color: red;
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a > b {
+  color: red;
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a
+>
+b {
+  color: red;
+}
+```

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

@@ -0,0 +1,74 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+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 { isNumber } = require('stylelint/lib/utils/validateTypes.cjs');
+
+const ruleName = 'plugin/selector-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/selector-max-empty-lines/README.md',
+	fixable: true
+};
+
+/** @type {import('stylelint').Rule} */
+const rule = (primary, _secondaryOptions, context) => {
+	const maxAdjacentNewlines = primary + 1;
+
+	return (root, result) => {
+		const validOptions = validateOptions(result, ruleName, {
+			actual: primary,
+			possible: isNumber
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		const violatedCRLFNewLinesRegex = new RegExp(`(?:\r\n){${maxAdjacentNewlines + 1},}`);
+		const violatedLFNewLinesRegex = new RegExp(`\n{${maxAdjacentNewlines + 1},}`);
+		const allowedLFNewLinesString = context.fix ? '\n'.repeat(maxAdjacentNewlines) : '';
+		const allowedCRLFNewLinesString = context.fix ? '\r\n'.repeat(maxAdjacentNewlines) : '';
+
+		root.walkRules((ruleNode) => {
+			const selector = ruleNode.raws.selector ? ruleNode.raws.selector.raw : ruleNode.selector;
+
+			if (context.fix) {
+				const newSelectorString = selector
+					.replace(new RegExp(violatedLFNewLinesRegex, 'gm'), allowedLFNewLinesString)
+					.replace(new RegExp(violatedCRLFNewLinesRegex, 'gm'), allowedCRLFNewLinesString);
+
+				if (ruleNode.raws.selector) {
+					ruleNode.raws.selector.raw = newSelectorString;
+				}
+				else {
+					ruleNode.selector = newSelectorString;
+				}
+			}
+			else if (
+				violatedLFNewLinesRegex.test(selector) ||
+				violatedCRLFNewLinesRegex.test(selector)
+			) {
+				report({
+					message: messages.expected(primary),
+					node: ruleNode,
+					index: 0,
+					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/selector-pseudo-class-case/README.md

@@ -0,0 +1,108 @@
+# selector-pseudo-class-case
+
+Specify lowercase or uppercase for pseudo-class selectors.
+
+<!-- prettier-ignore -->
+```css
+  a:hover {}
+/** ↑
+ * This pseudo-class selector */
+```
+
+The [`fix` option](https://stylelint.io/user-guide/options/#fix) can automatically fix all of the problems reported by this rule.
+
+## Options
+
+`string`: `"lower"|"upper"`
+
+### `"lower"`
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a:Hover {}
+```
+
+<!-- prettier-ignore -->
+```css
+a:hOvEr {}
+```
+
+<!-- prettier-ignore -->
+```css
+a:HOVER {}
+```
+
+<!-- prettier-ignore -->
+```css
+:ROOT {}
+```
+
+<!-- prettier-ignore -->
+```css
+:-MS-INPUT-PLACEHOLDER {}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a:hover {}
+```
+
+<!-- prettier-ignore -->
+```css
+:root {}
+```
+
+<!-- prettier-ignore -->
+```css
+:-ms-input-placeholder {}
+```
+
+### `"upper"`
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a:Hover {}
+```
+
+<!-- prettier-ignore -->
+```css
+a:hOvEr {}
+```
+
+<!-- prettier-ignore -->
+```css
+a:hover {}
+```
+
+<!-- prettier-ignore -->
+```css
+:root {}
+```
+
+<!-- prettier-ignore -->
+```css
+:-ms-input-placeholder {}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a:HOVER {}
+```
+
+<!-- prettier-ignore -->
+```css
+:ROOT {}
+```
+
+<!-- prettier-ignore -->
+```css
+:-MS-INPUT-PLACEHOLDER {}
+```

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/selector-pseudo-class-case/index.cjs

@@ -0,0 +1,104 @@
+/* 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 isStandardSyntaxSelector = require('stylelint/lib/utils/isStandardSyntaxSelector.cjs');
+const parseSelector = require('stylelint/lib/utils/parseSelector.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 { levelOneAndTwoPseudoElements } = require('../../reference/selectors.cjs');
+
+const ruleName = 'plugin/selector-pseudo-class-case';
+
+const messages = ruleMessages(ruleName, {
+	expected: (actual, expected) => `Expected "${actual}" to be "${expected}"`
+});
+
+const meta = {
+	url: 'https://github.com/jens-duttke/linter-bundle/blob/main/stylelint/plugins/stylelint-15.11.0-stylistic/rules/selector-pseudo-class-case/README.md',
+	fixable: true
+};
+
+/** @type {import('stylelint').Rule} */
+const rule = (primary, _secondaryOptions, context) => (root, result) => {
+	const validOptions = validateOptions(result, ruleName, {
+		actual: primary,
+		possible: ['lower', 'upper']
+	});
+
+	if (!validOptions) {
+		return;
+	}
+
+	root.walkRules((ruleNode) => {
+		if (!isStandardSyntaxRule(ruleNode)) {
+			return;
+		}
+
+		const selector = ruleNode.selector;
+
+		if (!selector.includes(':')) {
+			return;
+		}
+
+		const fixedSelector = parseSelector(
+				ruleNode.raws.selector ? ruleNode.raws.selector.raw : ruleNode.selector,
+				result,
+				ruleNode,
+				(selectorTree) => {
+					selectorTree.walkPseudos((pseudoNode) => {
+						const pseudo = pseudoNode.value;
+
+						if (!isStandardSyntaxSelector(pseudo)) {
+							return;
+						}
+
+						if (
+							pseudo.includes('::') ||
+							levelOneAndTwoPseudoElements.has(pseudo.toLowerCase().slice(1))
+						) {
+							return;
+						}
+
+						const expectedPseudo =
+							primary === 'lower' ? pseudo.toLowerCase() : pseudo.toUpperCase();
+
+						if (pseudo === expectedPseudo) {
+							return;
+						}
+
+						if (context.fix) {
+							pseudoNode.value = expectedPseudo;
+
+							return;
+						}
+
+						report({
+							message: messages.expected(pseudo, expectedPseudo),
+							node: ruleNode,
+							index: pseudoNode.sourceIndex,
+							ruleName,
+							result
+						});
+					});
+				}
+		);
+
+		if (context.fix && fixedSelector) {
+			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-pseudo-class-parentheses-space-inside/README.md

@@ -0,0 +1,62 @@
+# selector-pseudo-class-parentheses-space-inside
+
+Require a single space or disallow whitespace on the inside of the parentheses within pseudo-class selectors.
+
+<!-- prettier-ignore -->
+```css
+input:not( [type="submit"] ) {}
+/**      ↑                 ↑
+ * The space inside these two parentheses */
+```
+
+The [`fix` option](https://stylelint.io/user-guide/options/#fix) can automatically fix most of the problems reported by this rule. It won't fix pseudo elements containing comments.
+
+## Options
+
+`string`: `"always"|"never"`
+
+### `"always"`
+
+There _must always_ be a single space inside the parentheses.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+input:not([type="submit"]) {}
+```
+
+<!-- prettier-ignore -->
+```css
+input:not([type="submit"] ) {}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+input:not( [type="submit"] ) {}
+```
+
+### `"never"`
+
+There _must never_ be whitespace on the inside the parentheses.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+input:not( [type="submit"] ) {}
+```
+
+<!-- prettier-ignore -->
+```css
+input:not( [type="submit"]) {}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+input:not([type="submit"]) {}
+```