linter-bundle 5.1.0 → 6.1.0

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/media-feature-name-case/index.cjs

@@ -0,0 +1,93 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const stylelint = require('stylelint');
+const atRuleParamIndex = require('stylelint/lib/utils/atRuleParamIndex.cjs');
+const findMediaFeatureNames = require('stylelint/lib/utils/findMediaFeatureNames.cjs');
+const isCustomMediaQuery = require('stylelint/lib/utils/isCustomMediaQuery.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 { mutateIdent } = require('@csstools/css-tokenizer');
+
+const ruleName = 'plugin/media-feature-name-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/media-feature-name-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.walkAtRules(/^media$/i, (atRule) => {
+		const hasComments = atRule.raws.params?.raw;
+		let mediaRule = hasComments ? hasComments : atRule.params;
+
+		let hasFixes = false;
+
+		mediaRule = findMediaFeatureNames(mediaRule, (mediaFeatureNameToken) => {
+			const [, , startIndex, endIndex, { value: featureName }] = mediaFeatureNameToken;
+
+			if (isCustomMediaQuery(featureName)) {
+				return;
+			}
+
+			const expectedFeatureName =
+					primary === 'lower' ? featureName.toLowerCase() : featureName.toUpperCase();
+
+			if (featureName === expectedFeatureName) {
+				return;
+			}
+
+			if (context.fix) {
+				mutateIdent(mediaFeatureNameToken, expectedFeatureName);
+				hasFixes = true;
+
+				return;
+			}
+
+			const atRuleIndex = atRuleParamIndex(atRule);
+
+			report({
+				message: messages.expected(featureName, expectedFeatureName),
+				node: atRule,
+				index: atRuleIndex + startIndex,
+				endIndex: atRuleIndex + endIndex + 1,
+				ruleName,
+				result
+			});
+		}).stringify();
+
+		if (hasFixes) {
+			if (hasComments) {
+				if (atRule.raws.params == null) {
+					throw new Error('The `AtRuleRaws` node must have a `params` property');
+				}
+
+				atRule.raws.params.raw = mediaRule;
+			}
+			else {
+				atRule.params = mediaRule;
+			}
+		}
+	});
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+module.exports = stylelint.createPlugin(ruleName, rule);

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/media-feature-parentheses-space-inside/README.md

@@ -0,0 +1,62 @@
+# media-feature-parentheses-space-inside
+
+Require a single space or disallow whitespace on the inside of the parentheses within media features.
+
+<!-- prettier-ignore -->
+```css
+@media ( max-width: 300px ) {}
+/**    ↑                  ↑
+ * The space inside these two parentheses */
+```
+
+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 parentheses.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+@media (max-width: 300px) {}
+```
+
+<!-- prettier-ignore -->
+```css
+@media (max-width: 300px ) {}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+@media ( max-width: 300px ) {}
+```
+
+### `"never"`
+
+There _must never_ be whitespace on the inside the parentheses.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+@media ( max-width: 300px ) {}
+```
+
+<!-- prettier-ignore -->
+```css
+@media ( max-width: 300px) {}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+@media (max-width: 300px) {}
+```

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/media-feature-parentheses-space-inside/index.cjs

@@ -0,0 +1,112 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const valueParser = require('postcss-value-parser');
+const stylelint = require('stylelint');
+const atRuleParamIndex = require('stylelint/lib/utils/atRuleParamIndex.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/media-feature-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/media-feature-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.walkAtRules(/^media$/i, (atRule) => {
+		// If there are comments in the params, the complete string
+		// will be at atRule.raws.params.raw
+		const parameters = (atRule.raws.params?.raw) || atRule.params;
+		const indexBoost = atRuleParamIndex(atRule);
+		/** @type {Array<{ message: string, index: number }>} */
+		const problems = [];
+
+		const parsedParameters = valueParser(parameters).walk((node) => {
+			if (node.type === 'function') {
+				const length_ = valueParser.stringify(node).length;
+
+				if (primary === 'never') {
+					if ((/[\t ]/).test(node.before)) {
+						if (context.fix) { node.before = ''; }
+
+						problems.push({
+							message: messages.rejectedOpening,
+							index: node.sourceIndex + 1 + indexBoost
+						});
+					}
+
+					if ((/[\t ]/).test(node.after)) {
+						if (context.fix) { node.after = ''; }
+
+						problems.push({
+							message: messages.rejectedClosing,
+							index: node.sourceIndex - 2 + length_ + indexBoost
+						});
+					}
+				}
+				else if (primary === 'always') {
+					if (node.before === '') {
+						if (context.fix) { node.before = ' '; }
+
+						problems.push({
+							message: messages.expectedOpening,
+							index: node.sourceIndex + 1 + indexBoost
+						});
+					}
+
+					if (node.after === '') {
+						if (context.fix) { node.after = ' '; }
+
+						problems.push({
+							message: messages.expectedClosing,
+							index: node.sourceIndex - 2 + length_ + indexBoost
+						});
+					}
+				}
+			}
+		});
+
+		if (problems.length > 0) {
+			if (context.fix) {
+				atRule.params = parsedParameters.toString();
+
+				return;
+			}
+
+			for (const error of problems) {
+				report({
+					message: error.message,
+					node: atRule,
+					index: error.index,
+					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/media-feature-range-operator-space-after/README.md

@@ -0,0 +1,72 @@
+# media-feature-range-operator-space-after
+
+Require a single space or disallow whitespace after the range operator in media features.
+
+<!-- prettier-ignore -->
+```css
+@media (width >= 600px) {}
+/**           ↑
+ * The space after this 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 range operator.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+@media (width>=600px) {}
+```
+
+<!-- prettier-ignore -->
+```css
+@media (width >=600px) {}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+@media (width>= 600px) {}
+```
+
+<!-- prettier-ignore -->
+```css
+@media (width >= 600px) {}
+```
+
+### `"never"`
+
+There _must never_ be whitespace after the range operator.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+@media (width>= 600px) {}
+```
+
+<!-- prettier-ignore -->
+```css
+@media (width >= 600px) {}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+@media (width>=600px) {}
+```
+
+<!-- prettier-ignore -->
+```css
+@media (width >=600px) {}
+```

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/media-feature-range-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 atRuleParamIndex = require('stylelint/lib/utils/atRuleParamIndex.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 whitespaceChecker = require('../../utils/whitespaceChecker.cjs');
+const findMediaOperator = require('../findMediaOperator.cjs');
+
+const ruleName = 'plugin/media-feature-range-operator-space-after';
+
+const messages = ruleMessages(ruleName, {
+	expectedAfter: () => 'Expected single space after range operator',
+	rejectedAfter: () => 'Unexpected whitespace after range operator'
+});
+
+const meta = {
+	url: 'https://github.com/jens-duttke/linter-bundle/blob/main/stylelint/plugins/stylelint-15.11.0-stylistic/rules/media-feature-range-operator-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']
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkAtRules(/^media$/i, (atRule) => {
+			/** @type {number[]} */
+			const fixOperatorIndices = [];
+			/** @type {((index: number) => void) | null} */
+			const fix = context.fix ? (index) => fixOperatorIndices.push(index) : null;
+
+			findMediaOperator(atRule, (match, parameters, node) => {
+				checkAfterOperator(match, parameters, node, fix);
+			});
+
+			if (fixOperatorIndices.length > 0) {
+				let parameters = atRule.raws.params ? atRule.raws.params.raw : atRule.params;
+
+				for (const index of fixOperatorIndices.sort((a, b) => b - a)) {
+					const beforeOperator = parameters.slice(0, index + 1);
+					const afterOperator = parameters.slice(index + 1);
+
+					if (primary === 'always') {
+						parameters = beforeOperator + afterOperator.replace(/^\s*/, ' ');
+					}
+					else if (primary === 'never') {
+						parameters = beforeOperator + afterOperator.replace(/^\s*/, '');
+					}
+				}
+
+				if (atRule.raws.params) {
+					atRule.raws.params.raw = parameters;
+				}
+				else {
+					atRule.params = parameters;
+				}
+			}
+		});
+
+		/**
+		 * @param {import('style-search').StyleSearchMatch} match
+		 * @param {string} params
+		 * @param parameters
+		 * @param {import('postcss').AtRule} node
+		 * @param {((index: number) => void) | null} fix
+		 */
+		function checkAfterOperator (match, parameters, node, fix) {
+			const endIndex = match.startIndex + match.target.length - 1;
+
+			checker.after({
+				source: parameters,
+				index: endIndex,
+				err: (m) => {
+					if (fix) {
+						fix(endIndex);
+
+						return;
+					}
+
+					report({
+						message: m,
+						node,
+						index: endIndex + atRuleParamIndex(node) + 1,
+						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/media-feature-range-operator-space-before/README.md

@@ -0,0 +1,72 @@
+# media-feature-range-operator-space-before
+
+Require a single space or disallow whitespace before the range operator in media features.
+
+<!-- prettier-ignore -->
+```css
+@media (width >= 600px) {}
+/**           ↑
+ * The space before this 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 before the range operator.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+@media (width>=600px) {}
+```
+
+<!-- prettier-ignore -->
+```css
+@media (width>= 600px) {}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+@media (width >=600px) {}
+```
+
+<!-- prettier-ignore -->
+```css
+@media (width >= 600px) {}
+```
+
+### `"never"`
+
+There _must never_ be whitespace before the range operator.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+@media (width >=600px) {}
+```
+
+<!-- prettier-ignore -->
+```css
+@media (width >= 600px) {}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+@media (width>=600px) {}
+```
+
+<!-- prettier-ignore -->
+```css
+@media (width>= 600px) {}
+```

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/media-feature-range-operator-space-before/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 atRuleParamIndex = require('stylelint/lib/utils/atRuleParamIndex.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 whitespaceChecker = require('../../utils/whitespaceChecker.cjs');
+const findMediaOperator = require('../findMediaOperator.cjs');
+
+const ruleName = 'plugin/media-feature-range-operator-space-before';
+
+const messages = ruleMessages(ruleName, {
+	expectedBefore: () => 'Expected single space before range operator',
+	rejectedBefore: () => 'Unexpected whitespace before range operator'
+});
+
+const meta = {
+	url: 'https://github.com/jens-duttke/linter-bundle/blob/main/stylelint/plugins/stylelint-15.11.0-stylistic/rules/media-feature-range-operator-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']
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		root.walkAtRules(/^media$/i, (atRule) => {
+			/** @type {number[]} */
+			const fixOperatorIndices = [];
+			/** @type {((index: number) => void) | null} */
+			const fix = context.fix ? (index) => fixOperatorIndices.push(index) : null;
+
+			findMediaOperator(atRule, (match, parameters, node) => {
+				checkBeforeOperator(match, parameters, node, fix);
+			});
+
+			if (fixOperatorIndices.length > 0) {
+				let parameters = atRule.raws.params ? atRule.raws.params.raw : atRule.params;
+
+				for (const index of fixOperatorIndices.sort((a, b) => b - a)) {
+					const beforeOperator = parameters.slice(0, index);
+					const afterOperator = parameters.slice(index);
+
+					if (primary === 'always') {
+						parameters = beforeOperator.replace(/\s*$/, ' ') + afterOperator;
+					}
+					else if (primary === 'never') {
+						parameters = beforeOperator.replace(/\s*$/, '') + afterOperator;
+					}
+				}
+
+				if (atRule.raws.params) {
+					atRule.raws.params.raw = parameters;
+				}
+				else {
+					atRule.params = parameters;
+				}
+			}
+		});
+
+		/**
+		 * @param {import('style-search').StyleSearchMatch} match
+		 * @param {string} params
+		 * @param parameters
+		 * @param {import('postcss').AtRule} node
+		 * @param {((index: number) => void) | null} fix
+		 */
+		function checkBeforeOperator (match, parameters, node, fix) {
+			// The extra `+ 1` is because the match itself contains
+			// the character before the operator
+			checker.before({
+				source: parameters,
+				index: match.startIndex,
+				err: (m) => {
+					if (fix) {
+						fix(match.startIndex);
+
+						return;
+					}
+
+					report({
+						message: m,
+						node,
+						index: match.startIndex - 1 + atRuleParamIndex(node),
+						result,
+						ruleName
+					});
+				}
+			});
+		}
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+module.exports = stylelint.createPlugin(ruleName, rule);