linter-bundle 5.1.0 → 6.1.0

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/selector-pseudo-class-parentheses-space-inside/index.cjs

@@ -0,0 +1,162 @@
+/* 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 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 ruleName = 'plugin/selector-pseudo-class-parentheses-space-inside';
+
+const messages = ruleMessages(ruleName, {
+	expectedOpening: 'Expected single space after "("',
+	rejectedOpening: 'Unexpected whitespace after "("',
+	expectedClosing: 'Expected single space before ")"',
+	rejectedClosing: 'Unexpected whitespace before ")"'
+});
+
+const meta = {
+	url: 'https://github.com/jens-duttke/linter-bundle/blob/main/stylelint/plugins/stylelint-15.11.0-stylistic/rules/selector-pseudo-class-parentheses-space-inside/README.md',
+	fixable: true
+};
+
+/** @type {import('stylelint').Rule} */
+const rule = (primary, _secondaryOptions, context) => (root, result) => {
+	const validOptions = validateOptions(result, ruleName, {
+		actual: primary,
+		possible: ['always', 'never']
+	});
+
+	if (!validOptions) {
+		return;
+	}
+
+	root.walkRules((ruleNode) => {
+		if (!isStandardSyntaxRule(ruleNode)) {
+			return;
+		}
+
+		if (!ruleNode.selector.includes('(')) {
+			return;
+		}
+
+		let hasFixed = false;
+		const selector = ruleNode.raws.selector ? ruleNode.raws.selector.raw : ruleNode.selector;
+		const fixedSelector = parseSelector(selector, result, ruleNode, (selectorTree) => {
+			selectorTree.walkPseudos((pseudoNode) => {
+				if (pseudoNode.length === 0) {
+					return;
+				}
+
+				const paramString = pseudoNode.map((node) => String(node)).join(',');
+				const nextCharIsSpace = paramString.startsWith(' ');
+				const openIndex = pseudoNode.sourceIndex + pseudoNode.value.length + 1;
+
+				if (nextCharIsSpace && primary === 'never') {
+					if (context.fix) {
+						hasFixed = true;
+						setFirstNodeSpaceBefore(pseudoNode, '');
+					}
+					else {
+						complain(messages.rejectedOpening, openIndex);
+					}
+				}
+
+				if (!nextCharIsSpace && primary === 'always') {
+					if (context.fix) {
+						hasFixed = true;
+						setFirstNodeSpaceBefore(pseudoNode, ' ');
+					}
+					else {
+						complain(messages.expectedOpening, openIndex);
+					}
+				}
+
+				const previousCharIsSpace = paramString.endsWith(' ');
+				const closeIndex = openIndex + paramString.length - 1;
+
+				if (previousCharIsSpace && primary === 'never') {
+					if (context.fix) {
+						hasFixed = true;
+						setLastNodeSpaceAfter(pseudoNode, '');
+					}
+					else {
+						complain(messages.rejectedClosing, closeIndex);
+					}
+				}
+
+				if (!previousCharIsSpace && primary === 'always') {
+					if (context.fix) {
+						hasFixed = true;
+						setLastNodeSpaceAfter(pseudoNode, ' ');
+					}
+					else {
+						complain(messages.expectedClosing, closeIndex);
+					}
+				}
+			});
+		});
+
+		if (hasFixed && fixedSelector) {
+			if (!ruleNode.raws.selector) {
+				ruleNode.selector = fixedSelector;
+			}
+			else {
+				ruleNode.raws.selector.raw = fixedSelector;
+			}
+		}
+
+		/**
+		 * @param {string} message
+		 * @param {number} index
+		 */
+		function complain (message, index) {
+			report({
+				message,
+				index,
+				result,
+				ruleName,
+				node: ruleNode
+			});
+		}
+	});
+};
+
+/**
+ * @param {import('postcss-selector-parser').Container} node
+ * @param {string} value
+ * @returns {void}
+ */
+function setFirstNodeSpaceBefore (node, value) {
+	const target = node.first;
+
+	if (target.type === 'selector') {
+		setFirstNodeSpaceBefore(target, value);
+	}
+	else {
+		target.spaces.before = value;
+	}
+}
+
+/**
+ * @param {import('postcss-selector-parser').Container} node
+ * @param {string} value
+ * @returns {void}
+ */
+function setLastNodeSpaceAfter (node, value) {
+	const target = node.last;
+
+	if (target.type === 'selector') {
+		setLastNodeSpaceAfter(target, value);
+	}
+	else {
+		target.spaces.after = value;
+	}
+}
+
+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-element-case/README.md

@@ -0,0 +1,128 @@
+# selector-pseudo-element-case
+
+Specify lowercase or uppercase for pseudo-element selectors.
+
+<!-- prettier-ignore -->
+```css
+  a::before {}
+/**  ↑
+ * This pseudo-element 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:Before {}
+```
+
+<!-- prettier-ignore -->
+```css
+a:bEfOrE {}
+```
+
+<!-- prettier-ignore -->
+```css
+a:BEFORE {}
+```
+
+<!-- prettier-ignore -->
+```css
+a::Before {}
+```
+
+<!-- prettier-ignore -->
+```css
+a::bEfOrE {}
+```
+
+<!-- prettier-ignore -->
+```css
+a::BEFORE {}
+```
+
+<!-- prettier-ignore -->
+```css
+input::-MOZ-PLACEHOLDER {}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a:before {}
+```
+
+<!-- prettier-ignore -->
+```css
+a::before {}
+```
+
+<!-- prettier-ignore -->
+```css
+input::-moz-placeholder {}
+```
+
+### `"upper"`
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a:Before {}
+```
+
+<!-- prettier-ignore -->
+```css
+a:bEfOrE {}
+```
+
+<!-- prettier-ignore -->
+```css
+a:BEFORE {}
+```
+
+<!-- prettier-ignore -->
+```css
+a::Before {}
+```
+
+<!-- prettier-ignore -->
+```css
+a::bEfOrE {}
+```
+
+<!-- prettier-ignore -->
+```css
+a::before {}
+```
+
+<!-- prettier-ignore -->
+```css
+input::-moz-placeholder {}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a:BEFORE {}
+```
+
+<!-- prettier-ignore -->
+```css
+a::BEFORE {}
+```
+
+<!-- prettier-ignore -->
+```css
+input::-MOZ-PLACEHOLDER {}
+```

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

@@ -0,0 +1,90 @@
+/* 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 report = require('stylelint/lib/utils/report.cjs');
+const ruleMessages = require('stylelint/lib/utils/ruleMessages.cjs');
+const transformSelector = require('stylelint/lib/utils/transformSelector.cjs');
+const validateOptions = require('stylelint/lib/utils/validateOptions.cjs');
+
+const { levelOneAndTwoPseudoElements } = require('../../reference/selectors.cjs');
+
+const ruleName = 'plugin/selector-pseudo-element-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-element-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;
+		}
+
+		transformSelector(result, ruleNode, (selectorTree) => {
+			selectorTree.walkPseudos((pseudoNode) => {
+				const pseudoElement = pseudoNode.value;
+
+				if (!isStandardSyntaxSelector(pseudoElement)) {
+					return;
+				}
+
+				if (
+					!pseudoElement.includes('::') &&
+						!levelOneAndTwoPseudoElements.has(pseudoElement.toLowerCase().slice(1))
+				) {
+					return;
+				}
+
+				const expectedPseudoElement =
+						primary === 'lower' ? pseudoElement.toLowerCase() : pseudoElement.toUpperCase();
+
+				if (pseudoElement === expectedPseudoElement) {
+					return;
+				}
+
+				if (context.fix) {
+					pseudoNode.value = expectedPseudoElement;
+
+					return;
+				}
+
+				report({
+					message: messages.expected(pseudoElement, expectedPseudoElement),
+					node: ruleNode,
+					index: pseudoNode.sourceIndex,
+					ruleName,
+					result
+				});
+			});
+		});
+	});
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+module.exports = stylelint.createPlugin(ruleName, rule);

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/selectorAttributeOperatorSpaceChecker.cjs

@@ -0,0 +1,95 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const isStandardSyntaxRule = require('stylelint/lib/utils/isStandardSyntaxRule.cjs');
+const parseSelector = require('stylelint/lib/utils/parseSelector.cjs');
+const report = require('stylelint/lib/utils/report.cjs');
+
+const styleSearch = require('../style-search/index.cjs');
+
+/**
+ * @param {{
+ *   root: import('postcss').Root,
+ *   result: import('stylelint').PostcssResult,
+ *   locationChecker: (opts: { source: string, index: number, err: (msg: string) => void }) => void,
+ *   checkedRuleName: string,
+ *   checkBeforeOperator: boolean,
+ *   fix: ((attributeNode: import('postcss-selector-parser').Attribute) => boolean) | null,
+ * }} options
+ * @returns {void}
+ */
+module.exports = function selectorAttributeOperatorSpaceChecker (options) {
+	options.root.walkRules((rule) => {
+		if (!isStandardSyntaxRule(rule)) {
+			return;
+		}
+
+		if (!rule.selector.includes('[') || !rule.selector.includes('=')) {
+			return;
+		}
+
+		let hasFixed = false;
+		const selector = rule.raws.selector ? rule.raws.selector.raw : rule.selector;
+
+		const fixedSelector = parseSelector(selector, options.result, rule, (selectorTree) => {
+			selectorTree.walkAttributes((attributeNode) => {
+				const operator = attributeNode.operator;
+
+				if (!operator) {
+					return;
+				}
+
+				const attributeNodeString = attributeNode.toString();
+
+				styleSearch({ source: attributeNodeString, target: operator }, (match) => {
+					const index = options.checkBeforeOperator ? match.startIndex : match.endIndex - 1;
+
+					checkOperator(attributeNodeString, index, rule, attributeNode, operator);
+				});
+			});
+		});
+
+		if (hasFixed && fixedSelector) {
+			if (!rule.raws.selector) {
+				rule.selector = fixedSelector;
+			}
+			else {
+				rule.raws.selector.raw = fixedSelector;
+			}
+		}
+
+		/**
+		 * @param {string} source
+		 * @param {number} index
+		 * @param {import('postcss').Node} node
+		 * @param {import('postcss-selector-parser').Attribute} attributeNode
+		 * @param {string} operator
+		 */
+		function checkOperator (source, index, node, attributeNode, operator) {
+			options.locationChecker({
+				source,
+				index,
+				err: (message) => {
+					if (options.fix && options.fix(attributeNode)) {
+						hasFixed = true;
+
+						return;
+					}
+
+					report({
+						message: message.replace(
+							options.checkBeforeOperator ?
+								operator.charAt(0)
+								: operator.charAt(operator.length - 1),
+							operator
+						),
+						node,
+						index: attributeNode.sourceIndex + index,
+						result: options.result,
+						ruleName: options.checkedRuleName
+					});
+				}
+			});
+		}
+	});
+};

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/selectorCombinatorSpaceChecker.cjs

@@ -0,0 +1,113 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const isStandardSyntaxCombinator = require('stylelint/lib/utils/isStandardSyntaxCombinator.cjs');
+const isStandardSyntaxRule = require('stylelint/lib/utils/isStandardSyntaxRule.cjs');
+const parseSelector = require('stylelint/lib/utils/parseSelector.cjs');
+const report = require('stylelint/lib/utils/report.cjs');
+
+/**
+ * @typedef {(args: { source: string, index: number, errTarget: string, err: (message: string) => void }) => void} LocationChecker
+ * @param - - {{
+ * root: import('postcss').Root,
+ * result: import('stylelint').PostcssResult,
+ * locationChecker: LocationChecker,
+ * locationType: 'before' | 'after',
+ * checkedRuleName: string,
+ * fix: ((combinator: import('postcss-selector-parser').Combinator) => boolean) | null,
+ * @param options- 
+ * @param options- 
+ * @param options- 
+ * @param options- 
+ * @param options- 
+ * @param options- 
+ * @param options
+ * }} opts
+ * @returns {void}
+ */
+module.exports = function selectorCombinatorSpaceChecker (options) {
+	let hasFixed;
+
+	options.root.walkRules((rule) => {
+		if (!isStandardSyntaxRule(rule)) {
+			return;
+		}
+
+		hasFixed = false;
+		const selector = rule.raws.selector ? rule.raws.selector.raw : rule.selector;
+
+		const fixedSelector = parseSelector(selector, options.result, rule, (selectorTree) => {
+			selectorTree.walkCombinators((node) => {
+				// Ignore non-standard combinators
+				if (!isStandardSyntaxCombinator(node)) {
+					return;
+				}
+
+				// Ignore spaced descendant combinator
+				if ((/\s/).test(node.value)) {
+					return;
+				}
+
+				// Check the exist of node in prev of the combinator.
+				// in case some that aren't the first begin with combinators (nesting syntax)
+				if (options.locationType === 'before' && !node.prev()) {
+					return;
+				}
+
+				const parentParentNode = node.parent?.parent;
+
+				// Ignore pseudo-classes selector like `.foo:nth-child(2n + 1) {}`
+				if (parentParentNode && parentParentNode.type === 'pseudo') {
+					return;
+				}
+
+				const sourceIndex = node.sourceIndex;
+				const index =
+					node.value.length > 1 && options.locationType === 'before' ?
+						sourceIndex
+						: sourceIndex + node.value.length - 1;
+
+				check(selector, node, index, rule, sourceIndex);
+			});
+		});
+
+		if (hasFixed && fixedSelector) {
+			if (!rule.raws.selector) {
+				rule.selector = fixedSelector;
+			}
+			else {
+				rule.raws.selector.raw = fixedSelector;
+			}
+		}
+	});
+
+	/**
+	 * @param {string} source
+	 * @param {import('postcss-selector-parser').Combinator} combinator
+	 * @param {number} index
+	 * @param {import('postcss').Node} node
+	 * @param {number} sourceIndex
+	 */
+	function check (source, combinator, index, node, sourceIndex) {
+		options.locationChecker({
+			source,
+			index,
+			errTarget: combinator.value,
+			err: (message) => {
+				if (options.fix?.(combinator)) {
+					hasFixed = true;
+
+					return;
+				}
+
+				report({
+					message,
+					node,
+					index: sourceIndex,
+					result: options.result,
+					ruleName: options.checkedRuleName
+				});
+			}
+		});
+	}
+};

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/selectorListCommaWhitespaceChecker.cjs

@@ -0,0 +1,64 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const isStandardSyntaxRule = require('stylelint/lib/utils/isStandardSyntaxRule.cjs');
+const report = require('stylelint/lib/utils/report.cjs');
+
+const styleSearch = require('../style-search/index.cjs');
+
+/**
+ * @param {{
+ *   root: import('postcss').Root,
+ *   result: import('stylelint').PostcssResult,
+ *   locationChecker: (opts: { source: string, index: number, err: (msg: string) => void }) => void,
+ *   checkedRuleName: string,
+ *   fix: ((rule: import('postcss').Rule, index: number) => boolean) | null,
+ * }} opts
+ * @param options
+ * @returns {void}
+ */
+module.exports = function selectorListCommaWhitespaceChecker (options) {
+	options.root.walkRules((rule) => {
+		if (!isStandardSyntaxRule(rule)) {
+			return;
+		}
+
+		const selector = rule.raws.selector ? rule.raws.selector.raw : rule.selector;
+
+		styleSearch(
+			{
+				source: selector,
+				target: ',',
+				functionArguments: 'skip'
+			},
+			(match) => {
+				checkDelimiter(selector, match.startIndex, rule);
+			}
+		);
+	});
+
+	/**
+	 * @param {string} source
+	 * @param {number} index
+	 * @param {import('postcss').Rule} node
+	 */
+	function checkDelimiter (source, index, node) {
+		options.locationChecker({
+			source,
+			index,
+			err: (message) => {
+				if (options.fix?.(node, index)) {
+					return;
+				}
+
+				report({
+					message,
+					node,
+					index,
+					result: options.result,
+					ruleName: options.checkedRuleName
+				});
+			}
+		});
+	}
+};