linter-bundle 5.1.0 → 6.1.0

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

@@ -0,0 +1,94 @@
+/* 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-space-after';
+
+const messages = ruleMessages(ruleName, {
+	expectedAfter: () => 'Expected single space after ","',
+	rejectedAfter: () => 'Unexpected whitespace after ","',
+	expectedAfterSingleLine: () => 'Expected single space after "," in a single-line list',
+	rejectedAfterSingleLine: () => 'Unexpected whitespace after "," 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/value-list-comma-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', 'always-single-line', 'never-single-line']
+		});
+
+		if (!validOptions) {
+			return;
+		}
+
+		/** @type {Map<import('postcss').Declaration, number[]> | undefined} */
+		let fixData;
+
+		valueListCommaWhitespaceChecker({
+			root,
+			result,
+			locationChecker: checker.after,
+			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
+		});
+
+		if (fixData) {
+			for (const [decl, commaIndices] of fixData.entries()) {
+				for (const index of commaIndices.sort((a, b) => b - a)) {
+					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 = afterValue.replace(/^\s*/, ' ');
+					}
+					else if (primary.startsWith('never')) {
+						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-space-before/README.md

@@ -0,0 +1,136 @@
+# value-list-comma-space-before
+
+Require a single space or disallow whitespace before the commas of value lists.
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0 ,0; }
+/**                    ↑
+ * The space before 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 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; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0 ,
+      0; }
+```
+
+### `"never"`
+
+There _must never_ be whitespace 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; }
+```
+
+<!-- prettier-ignore -->
+```css
+a { background-size: 0,
+      0; }
+```
+
+### `"always-single-line"`
+
+There _must always_ be a single space before 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 before 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; }
+```

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

@@ -0,0 +1,94 @@
+/* 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-space-before';
+
+const messages = ruleMessages(ruleName, {
+	expectedBefore: () => 'Expected single space before ","',
+	rejectedBefore: () => 'Unexpected whitespace before ","',
+	expectedBeforeSingleLine: () => 'Unexpected whitespace 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/value-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').Declaration, number[]> | undefined} */
+		let fixData;
+
+		valueListCommaWhitespaceChecker({
+			root,
+			result,
+			locationChecker: checker.before,
+			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
+		});
+
+		if (fixData) {
+			for (const [decl, commaIndices] of fixData.entries()) {
+				for (const index of commaIndices.sort((a, b) => b - a)) {
+					const value = getDeclarationValue(decl);
+					const valueIndex = index - declarationValueIndex(decl);
+					let beforeValue = value.slice(0, valueIndex);
+					const afterValue = value.slice(valueIndex);
+
+					if (primary.startsWith('always')) {
+						beforeValue = beforeValue.replace(/\s*$/, ' ');
+					}
+					else if (primary.startsWith('never')) {
+						beforeValue = beforeValue.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-max-empty-lines/README.md

@@ -0,0 +1,121 @@
+# value-list-max-empty-lines
+
+Limit the number of adjacent empty lines within value lists.
+
+<!-- prettier-ignore -->
+```css
+a {
+  box-shadow:
+    inset 0 2px 0 #dcffa6,
+                    /* ← */
+    0 2px 5px #000; /* ↑ */
+}                   /* ↑ */
+/**                    ↑
+ *       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 {
+  padding: 10px
+
+    10px
+    10px
+    10px
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  padding:
+    10px
+    10px
+    10px
+
+    10px
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  box-shadow: inset 0 2px 0 #dcffa6,
+
+    0 2px 5px #000;
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  box-shadow:
+    inset 0 2px 0 #dcffa6,
+
+    0 2px 5px #000;
+}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a {
+  padding: 10px 10px 10px 10px
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  padding: 10px
+    10px
+    10px
+    10px
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  padding:
+    10px
+    10px
+    10px
+    10px
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  box-shadow: inset 0 2px 0 #dcffa6, 0 2px 5px #000;
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  box-shadow: inset 0 2px 0 #dcffa6,
+    0 2px 5px #000;
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  box-shadow:
+    inset 0 2px 0 #dcffa6,
+    0 2px 5px #000;
+}
+```

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

@@ -0,0 +1,68 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const stylelint = require('stylelint');
+const getDeclarationValue = require('stylelint/lib/utils/getDeclarationValue.cjs');
+const report = require('stylelint/lib/utils/report.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 { isNumber } = require('stylelint/lib/utils/validateTypes.cjs');
+
+const ruleName = 'plugin/value-list-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/value-list-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.walkDecls((decl) => {
+			const value = getDeclarationValue(decl);
+
+			if (context.fix) {
+				const newValueString = value
+					.replace(new RegExp(violatedLFNewLinesRegex, 'gm'), allowedLFNewLinesString)
+					.replace(new RegExp(violatedCRLFNewLinesRegex, 'gm'), allowedCRLFNewLinesString);
+
+				setDeclarationValue(decl, newValueString);
+			}
+			else if (violatedLFNewLinesRegex.test(value) || violatedCRLFNewLinesRegex.test(value)) {
+				report({
+					message: messages.expected(primary),
+					node: decl,
+					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/valueListCommaWhitespaceChecker.cjs

@@ -0,0 +1,74 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const isStandardSyntaxDeclaration = require('stylelint/lib/utils/isStandardSyntaxDeclaration.cjs');
+const isStandardSyntaxProperty = require('stylelint/lib/utils/isStandardSyntaxProperty.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?: ((node: import('postcss').Declaration, index: number) => boolean) | null,
+ *   determineIndex?: (declString: string, match: import('style-search').StyleSearchMatch) => number | false,
+ * }} opts
+ * @param options
+ */
+module.exports = function valueListCommaWhitespaceChecker (options) {
+	options.root.walkDecls((decl) => {
+		if (!isStandardSyntaxDeclaration(decl) || !isStandardSyntaxProperty(decl.prop)) {
+			return;
+		}
+
+		const declString = decl.toString();
+
+		styleSearch(
+			{
+				source: declString,
+				target: ',',
+				functionArguments: 'skip'
+			},
+			(match) => {
+				const indexToCheckAfter = options.determineIndex ?
+					options.determineIndex(declString, match)
+					: match.startIndex;
+
+				if (indexToCheckAfter === false) {
+					return;
+				}
+
+				checkComma(declString, indexToCheckAfter, decl);
+			}
+		);
+	});
+
+	/**
+	 * @param {string} source
+	 * @param {number} index
+	 * @param {import('postcss').Declaration} node
+	 * @returns {void}
+	 */
+	function checkComma (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
+				});
+			}
+		});
+	}
+};

package/stylelint/plugins/stylelint-15.11.0-stylistic/style-search/LICENSE

@@ -0,0 +1,13 @@
+Copyright (c) 2016, David Clark
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.