linter-bundle 5.1.0 → 6.1.0

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/property-case/index.cjs

@@ -0,0 +1,95 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const stylelint = require('stylelint');
+const isCustomProperty = require('stylelint/lib/utils/isCustomProperty.cjs');
+const isStandardSyntaxProperty = require('stylelint/lib/utils/isStandardSyntaxProperty.cjs');
+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 { isRule } = require('stylelint/lib/utils/typeGuards.cjs');
+const validateOptions = require('stylelint/lib/utils/validateOptions.cjs');
+const { isRegExp, isString } = require('stylelint/lib/utils/validateTypes.cjs');
+
+const ruleName = 'plugin/property-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/property-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']
+		},
+		{
+			actual: secondaryOptions,
+			possible: {
+				ignoreSelectors: [isString, isRegExp]
+			},
+			optional: true
+		}
+	);
+
+	if (!validOptions) {
+		return;
+	}
+
+	root.walkDecls((decl) => {
+		const property = decl.prop;
+
+		if (!isStandardSyntaxProperty(property)) {
+			return;
+		}
+
+		if (isCustomProperty(property)) {
+			return;
+		}
+
+		const { parent } = decl;
+
+		if (!parent) { throw new Error('A parent node must be present'); }
+
+		if (isRule(parent)) {
+			const { selector } = parent;
+
+			if (selector && optionsMatches(secondaryOptions, 'ignoreSelectors', selector)) {
+				return;
+			}
+		}
+
+		const expectedProperty = primary === 'lower' ? property.toLowerCase() : property.toUpperCase();
+
+		if (property === expectedProperty) {
+			return;
+		}
+
+		if (context.fix) {
+			decl.prop = expectedProperty;
+
+			return;
+		}
+
+		report({
+			message: messages.expected(property, expectedProperty),
+			word: property,
+			node: decl,
+			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/selector-attribute-brackets-space-inside/README.md

@@ -0,0 +1,112 @@
+# selector-attribute-brackets-space-inside
+
+Require a single space or disallow whitespace on the inside of the brackets within attribute selectors.
+
+<!-- prettier-ignore -->
+```css
+    [ target=_blank ]
+/** ↑               ↑
+ * The space inside these two brackets */
+```
+
+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"`
+
+There _must always_ be a single space inside the brackets.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+[target] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[ target] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target ] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target=_blank] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[ target=_blank] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target=_blank ] {}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+[ target ] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[ target=_blank ] {}
+```
+
+### `"never"`
+
+There _must never_ be whitespace on the inside the brackets.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+[ target] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target ] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[ target ] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[ target=_blank] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target=_blank ] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[ target=_blank ] {}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+[target] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target=_blank] {}
+```

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/selector-attribute-brackets-space-inside/index.cjs

@@ -0,0 +1,214 @@
+/* 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 styleSearch = require('../../style-search/index.cjs');
+
+const ruleName = 'plugin/selector-attribute-brackets-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-attribute-brackets-space-inside/README.md',
+	fixable: true
+};
+
+/** @type {import('stylelint').Rule} */
+const rule = (primary, _secondaryOptions, context) => {
+	return (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;
+			}
+
+			const selector = ruleNode.raws.selector ? ruleNode.raws.selector.raw : ruleNode.selector;
+
+			let hasFixed;
+			const fixedSelector = parseSelector(selector, result, ruleNode, (selectorTree) => {
+				selectorTree.walkAttributes((attributeNode) => {
+					const attributeSelectorString = attributeNode.toString();
+
+					styleSearch({ source: attributeSelectorString, target: '[' }, (match) => {
+						const nextCharIsSpace = attributeSelectorString[match.startIndex + 1] === ' ';
+						const index = attributeNode.sourceIndex + match.startIndex + 1;
+
+						if (nextCharIsSpace && primary === 'never') {
+							if (context.fix) {
+								hasFixed = true;
+								fixBefore(attributeNode);
+
+								return;
+							}
+
+							complain(messages.rejectedOpening, index);
+						}
+
+						if (!nextCharIsSpace && primary === 'always') {
+							if (context.fix) {
+								hasFixed = true;
+								fixBefore(attributeNode);
+
+								return;
+							}
+
+							complain(messages.expectedOpening, index);
+						}
+					});
+
+					styleSearch({ source: attributeSelectorString, target: ']' }, (match) => {
+						const previousCharIsSpace = attributeSelectorString[match.startIndex - 1] === ' ';
+						const index = attributeNode.sourceIndex + match.startIndex - 1;
+
+						if (previousCharIsSpace && primary === 'never') {
+							if (context.fix) {
+								hasFixed = true;
+								fixAfter(attributeNode);
+
+								return;
+							}
+
+							complain(messages.rejectedClosing, index);
+						}
+
+						if (!previousCharIsSpace && primary === 'always') {
+							if (context.fix) {
+								hasFixed = true;
+								fixAfter(attributeNode);
+
+								return;
+							}
+
+							complain(messages.expectedClosing, index);
+						}
+					});
+				});
+			});
+
+			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').Attribute} attributeNode
+	 */
+	function fixBefore (attributeNode) {
+		const spacesAttribute = attributeNode.raws.spaces?.attribute;
+		const rawAttributeBefore = spacesAttribute?.before;
+
+		/** @type {{ attrBefore: string, setAttrBefore: (fixed: string) => void }} */
+		const { attrBefore, setAttrBefore } = rawAttributeBefore ?
+			{
+				attrBefore: rawAttributeBefore,
+				setAttrBefore (fixed) {
+					spacesAttribute.before = fixed;
+				}
+			  }
+			: {
+				attrBefore:
+						(attributeNode.spaces.attribute?.before) || '',
+				setAttrBefore (fixed) {
+					if (!attributeNode.spaces.attribute) { attributeNode.spaces.attribute = {}; }
+
+					attributeNode.spaces.attribute.before = fixed;
+				}
+			  };
+
+		if (primary === 'always') {
+			setAttrBefore(attrBefore.replace(/^\s*/, ' '));
+		}
+		else if (primary === 'never') {
+			setAttrBefore(attrBefore.replace(/^\s*/, ''));
+		}
+	}
+
+	/**
+	 * @param {import('postcss-selector-parser').Attribute} attributeNode
+	 */
+	function fixAfter (attributeNode) {
+		const key = attributeNode.operator ?
+			attributeNode.insensitive ?
+				'insensitive'
+				: 'value'
+			: 'attribute';
+
+		const rawSpaces = attributeNode.raws.spaces?.[key];
+		const rawAfter = rawSpaces?.after;
+
+		const spaces = attributeNode.spaces[key];
+
+		/** @type {{ after: string, setAfter: (fixed: string) => void }} */
+		const { after, setAfter } = rawAfter ?
+			{
+				after: rawAfter,
+				setAfter (fixed) {
+					rawSpaces.after = fixed;
+				}
+			  }
+			: {
+				after: (spaces?.after) || '',
+				setAfter (fixed) {
+					if (!attributeNode.spaces[key]) { attributeNode.spaces[key] = {}; }
+
+					// @ts-expect-error -- TS2532: Object is possibly 'undefined'.
+					attributeNode.spaces[key].after = fixed;
+				}
+			  };
+
+		if (primary === 'always') {
+			setAfter(after.replace(/\s*$/, ' '));
+		}
+		else if (primary === 'never') {
+			setAfter(after.replace(/\s*$/, ''));
+		}
+	}
+};
+
+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-attribute-operator-space-after/README.md

@@ -0,0 +1,162 @@
+# selector-attribute-operator-space-after
+
+Require a single space or disallow whitespace after operators within attribute selectors.
+
+<!-- prettier-ignore -->
+```css
+[target= _blank]
+/**    ↑
+ * The space after operator */
+```
+
+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"`
+
+There _must always_ be a single space after the operator.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+[target=_blank] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target =_blank] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target='_blank'] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target="_blank"] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target ='_blank'] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target ="_blank"] {}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+[target] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target= _blank] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target= '_blank'] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target= "_blank"] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target = _blank] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target = '_blank'] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target = "_blank"] {}
+```
+
+### `"never"`
+
+There _must never_ be a single space after the operator.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+[target= _blank] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target = _blank] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target= '_blank'] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target= "_blank"] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target = '_blank'] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target = "_blank"] {}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+[target] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target=_blank] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target='_blank'] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target="_blank"] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target =_blank] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target ='_blank'] {}
+```
+
+<!-- prettier-ignore -->
+```css
+[target ="_blank"] {}
+```

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/selector-attribute-operator-space-after/index.cjs

@@ -0,0 +1,109 @@
+/* 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 selectorAttributeOperatorSpaceChecker = require('../selectorAttributeOperatorSpaceChecker.cjs');
+
+const ruleName = 'plugin/selector-attribute-operator-space-after';
+
+const messages = ruleMessages(ruleName, {
+	expectedAfter: (operator) => `Expected single space after "${operator}"`,
+	rejectedAfter: (operator) => `Unexpected whitespace after "${operator}"`
+});
+
+const meta = {
+	url: 'https://github.com/jens-duttke/linter-bundle/blob/main/stylelint/plugins/stylelint-15.11.0-stylistic/rules/selector-attribute-operator-space-after/README.md',
+	fixable: true
+};
+
+/** @type {import('stylelint').Rule} */
+const rule = (primary, _secondaryOptions, context) => (root, result) => {
+	const checker = whitespaceChecker('space', primary, messages);
+	const validOptions = validateOptions(result, ruleName, {
+		actual: primary,
+		possible: ['always', 'never']
+	});
+
+	if (!validOptions) {
+		return;
+	}
+
+	selectorAttributeOperatorSpaceChecker({
+		root,
+		result,
+		locationChecker: checker.after,
+		checkedRuleName: ruleName,
+		checkBeforeOperator: false,
+		fix: context.fix ?
+				(attributeNode) => {
+					/** @type {{ operatorAfter: string, setOperatorAfter: (fixed: string) => void }} */
+					const { operatorAfter, setOperatorAfter } = (() => {
+						const rawOperator = attributeNode.raws.operator;
+
+						if (rawOperator) {
+							return {
+								operatorAfter: rawOperator.slice(
+										attributeNode.operator ? attributeNode.operator.length : 0
+								),
+								setOperatorAfter (fixed) {
+									delete attributeNode.raws.operator;
+
+									if (!attributeNode.raws.spaces) { attributeNode.raws.spaces = {}; }
+
+									if (!attributeNode.raws.spaces.operator) { attributeNode.raws.spaces.operator = {}; }
+
+									attributeNode.raws.spaces.operator.after = fixed;
+								}
+							};
+						}
+
+						const rawSpacesOperator =
+								attributeNode.raws.spaces?.operator;
+						const rawOperatorAfter = rawSpacesOperator?.after;
+
+						if (rawOperatorAfter) {
+							return {
+								operatorAfter: rawOperatorAfter,
+								setOperatorAfter (fixed) {
+									rawSpacesOperator.after = fixed;
+								}
+							};
+						}
+
+						return {
+							operatorAfter:
+									(attributeNode.spaces.operator?.after) || '',
+							setOperatorAfter (fixed) {
+								if (!attributeNode.spaces.operator) { attributeNode.spaces.operator = {}; }
+
+								attributeNode.spaces.operator.after = fixed;
+							}
+						};
+					})();
+
+					if (primary === 'always') {
+						setOperatorAfter(operatorAfter.replace(/^\s*/, ' '));
+
+						return true;
+					}
+
+					if (primary === 'never') {
+						setOperatorAfter(operatorAfter.replace(/^\s*/, ''));
+
+						return true;
+					}
+
+					return false;
+				  }
+				: null
+	});
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+module.exports = stylelint.createPlugin(ruleName, rule);