linter-bundle 5.1.0 → 6.1.0

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

@@ -0,0 +1,133 @@
+/* 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 declarationValueIndex = require('stylelint/lib/utils/declarationValueIndex.cjs');
+const getDimension = require('stylelint/lib/utils/getDimension.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/unit-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/unit-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;
+	}
+
+	/**
+	 * @template {import('postcss').AtRule | import('postcss').Declaration} T
+	 * @param {T} node
+	 * @param {string} checkedValue
+	 * @param {(node: T) => number} getIndex
+	 * @returns {void}
+	 */
+	function check (node, checkedValue, getIndex) {
+		/** @type {Array<{ index: number, endIndex: number, message: string }>} */
+		const problems = [];
+
+		/**
+		 * @param {import('postcss-value-parser').Node} valueNode
+		 * @returns {boolean}
+		 */
+		function processValue (valueNode) {
+			const { number, unit } = getDimension(valueNode);
+
+			if (!number || !unit) { return false; }
+
+			const expectedUnit = primary === 'lower' ? unit.toLowerCase() : unit.toUpperCase();
+
+			if (unit === expectedUnit) {
+				return false;
+			}
+
+			const index = getIndex(node);
+
+			problems.push({
+				index: index + valueNode.sourceIndex + number.length,
+				endIndex: index + valueNode.sourceEndIndex,
+				message: messages.expected(unit, expectedUnit)
+			});
+
+			return true;
+		}
+
+		const parsedValue = valueParser(checkedValue).walk((valueNode) => {
+			// Ignore wrong units within `url` function
+			let needFix = false;
+			const value = valueNode.value;
+
+			if (valueNode.type === 'function' && value.toLowerCase() === 'url') {
+				return false;
+			}
+
+			if (value.includes('*')) {
+				value.split('*').some((value_) => processValue({
+					...valueNode,
+					sourceIndex: value.indexOf(value_) + value_.length + 1,
+					value: value_
+				}));
+			}
+
+			needFix = processValue(valueNode);
+
+			if (needFix && context.fix) {
+				valueNode.value = primary === 'lower' ? value.toLowerCase() : value.toUpperCase();
+			}
+		});
+
+		if (problems.length > 0) {
+			if (context.fix) {
+				if ('name' in node && node.name === 'media') {
+					node.params = parsedValue.toString();
+				}
+				else if ('value' in node) {
+					node.value = parsedValue.toString();
+				}
+			}
+			else {
+				for (const error of problems) {
+					report({
+						index: error.index,
+						endIndex: error.endIndex,
+						message: error.message,
+						node,
+						result,
+						ruleName
+					});
+				}
+			}
+		}
+	}
+
+	root.walkAtRules((atRule) => {
+		if (!(/^media$/i).test(atRule.name) && !('variable' in atRule)) {
+			return;
+		}
+
+		check(atRule, atRule.params, atRuleParamIndex);
+	});
+	root.walkDecls((decl) => check(decl, decl.value, declarationValueIndex));
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+module.exports = stylelint.createPlugin(ruleName, rule);

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

@@ -0,0 +1,102 @@
+# value-list-comma-newline-after
+
+Require a newline or disallow whitespace after the commas of value lists.
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0,
+      0; }            ↑
+/**                   ↑
+ * The newline after this comma */
+```
+
+The [`fix` option](https://stylelint.io/user-guide/options/#fix) can automatically fix most 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 { background-size: 0,0; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0
+      , 0; }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0,
+      0; }
+```
+
+### `"always-multi-line"`
+
+There _must always_ be a newline after the commas in multi-line value lists.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0
+    , 0; }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0, 0; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0,0; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0,
+      0; }
+```
+
+### `"never-multi-line"`
+
+There _must never_ be whitespace after the commas in multi-line value lists.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0
+      , 0; }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0,0; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0, 0; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0
+      ,0; }
+```

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

@@ -0,0 +1,107 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const stylelint = require('stylelint');
+const declarationValueIndex = require('stylelint/lib/utils/declarationValueIndex.cjs');
+const getDeclarationValue = require('stylelint/lib/utils/getDeclarationValue.cjs');
+const ruleMessages = require('stylelint/lib/utils/ruleMessages.cjs');
+const setDeclarationValue = require('stylelint/lib/utils/setDeclarationValue.cjs');
+const validateOptions = require('stylelint/lib/utils/validateOptions.cjs');
+
+const whitespaceChecker = require('../../utils/whitespaceChecker.cjs');
+const valueListCommaWhitespaceChecker = require('../valueListCommaWhitespaceChecker.cjs');
+
+const ruleName = 'plugin/value-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/value-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;
+		}
+
+		/** @type {Map<import('postcss').Declaration, number[]> | undefined} */
+		let fixData;
+
+		valueListCommaWhitespaceChecker({
+			root,
+			result,
+			locationChecker: checker.afterOneOnly,
+			checkedRuleName: ruleName,
+			fix: context.fix ?
+				(declNode, index) => {
+					const valueIndex = declarationValueIndex(declNode);
+
+					if (index <= valueIndex) {
+						return false;
+					}
+
+					fixData ||= new Map();
+					const commaIndices = fixData.get(declNode) || [];
+
+					commaIndices.push(index);
+					fixData.set(declNode, commaIndices);
+
+					return true;
+				  }
+				: null,
+			determineIndex: (declString, match) => {
+				const nextChars = declString.substring(match.endIndex, declString.length);
+
+				// If there's a // comment, that means there has to be a newline
+				// ending the comment so we're fine
+				if ((/^[\t ]*\/\//).test(nextChars)) {
+					return false;
+				}
+
+				// If there are spaces and then a comment begins, look for the newline
+				return (/^[\t ]*\/\*/).test(nextChars) ?
+					declString.indexOf('*/', match.endIndex) + 1
+					: match.startIndex;
+			}
+		});
+
+		if (fixData) {
+			for (const [decl, commaIndices] of fixData.entries()) {
+				for (const index of commaIndices.sort((a, b) => a - b).reverse()) {
+					const value = getDeclarationValue(decl);
+					const valueIndex = index - declarationValueIndex(decl);
+					const beforeValue = value.slice(0, valueIndex + 1);
+					let afterValue = value.slice(valueIndex + 1);
+
+					if (primary.startsWith('always')) {
+						afterValue = context.newline + afterValue;
+					}
+					else if (primary.startsWith('never-multi-line')) {
+						afterValue = afterValue.replace(/^\s*/, '');
+					}
+
+					setDeclarationValue(decl, beforeValue + afterValue);
+				}
+			}
+		}
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+module.exports = stylelint.createPlugin(ruleName, rule);

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

@@ -0,0 +1,100 @@
+# value-list-comma-newline-before
+
+Require a newline or disallow whitespace before the commas of value lists.
+
+<!-- prettier-ignore -->
+```css
+  a { background-size: 0
+    , 0; }
+/** ↑
+ * The newline before this comma */
+```
+
+## 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 { background-size: 0,0; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0,
+      0; }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0
+      , 0; }
+```
+
+### `"always-multi-line"`
+
+There _must always_ be a newline before the commas in multi-line value lists.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0,
+      0; }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0, 0; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0,0; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0
+      , 0; }
+```
+
+### `"never-multi-line"`
+
+There _must never_ be whitespace before the commas in multi-line value lists.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0
+      , 0; }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0,0; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0, 0; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0,
+      0; }
+```

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

@@ -0,0 +1,49 @@
+/* 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 valueListCommaWhitespaceChecker = require('../valueListCommaWhitespaceChecker.cjs');
+
+const ruleName = 'plugin/value-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/value-list-comma-newline-before/README.md'
+};
+
+/** @type {import('stylelint').Rule} */
+const rule = (primary) => {
+	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;
+		}
+
+		valueListCommaWhitespaceChecker({
+			root,
+			result,
+			locationChecker: checker.beforeAllowingIndentation,
+			checkedRuleName: 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/value-list-comma-space-after/README.md

@@ -0,0 +1,136 @@
+# value-list-comma-space-after
+
+Require a single space or disallow whitespace after the commas of value lists.
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0, 0; }
+/**                   ↑
+ * The space after this comma */
+```
+
+The [`fix` option](https://stylelint.io/user-guide/options/#fix) can automatically fix most 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 { background-size: 0,0; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0
+      , 0; }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0, 0; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0
+      , 0; }
+```
+
+### `"never"`
+
+There _must never_ be whitespace after the commas.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0, 0; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0 ,
+      0; }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0,0; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0
+      ,0; }
+```
+
+### `"always-single-line"`
+
+There _must always_ be a single space after the commas in single-line value lists.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0,0; }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0, 0; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0
+    , 0; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0
+      ,0; }
+```
+
+### `"never-single-line"`
+
+There _must never_ be whitespace after the commas in single-line value lists.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0, 0; }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0,0; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0
+      ,0; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0
+      , 0; }
+```