linter-bundle 5.1.0 → 6.1.0

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/function-comma-space-after/README.md

@@ -0,0 +1,144 @@
+# function-comma-space-after
+
+Require a single space or disallow whitespace after the commas of functions.
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1, 1) }
+/**                       ↑
+ * The space after this comma */
+```
+
+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-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 { transform: translate(1,1) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1 ,1) }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1, 1) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1 , 1) }
+```
+
+### `"never"`
+
+There _must never_ be whitespace after the commas.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1, 1) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1 , 1) }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1,1) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1 ,1) }
+```
+
+### `"always-single-line"`
+
+There _must always_ be a single space after the commas in single-line functions.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1,1) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1 ,1) }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1, 1) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1 , 1) }
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  transform: translate(1
+    ,1)
+}
+```
+
+### `"never-single-line"`
+
+There _must never_ be whitespace after the commas in single-line functions.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1, 1) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1 , 1) }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1,1) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1 ,1) }
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  transform: translate(1
+    , 1)
+}
+```

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

@@ -0,0 +1,62 @@
+/* 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 functionCommaSpaceChecker = require('../functionCommaSpaceChecker.cjs');
+const fixer = require('../functionCommaSpaceFix.cjs');
+
+const ruleName = 'plugin/function-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 function',
+	rejectedAfterSingleLine: () => 'Unexpected whitespace after "," in a single-line function'
+});
+
+const meta = {
+	url: 'https://github.com/jens-duttke/linter-bundle/blob/main/stylelint/plugins/stylelint-15.11.0-stylistic/rules/function-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;
+		}
+
+		functionCommaSpaceChecker({
+			root,
+			result,
+			locationChecker: checker.after,
+			checkedRuleName: ruleName,
+			fix: context.fix ?
+				(div, index, nodes) => fixer({
+					div,
+					index,
+					nodes,
+					expectation: primary,
+					position: 'after',
+					symb: ' '
+				})
+				: null
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+module.exports = stylelint.createPlugin(ruleName, rule);

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/function-comma-space-before/README.md

@@ -0,0 +1,144 @@
+# function-comma-space-before
+
+Require a single space or disallow whitespace before the commas of functions.
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1 ,1) }
+/**                        ↑
+ * The space before this comma */
+```
+
+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-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 { transform: translate(1,1) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1, 1) }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1 ,1) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1 , 1) }
+```
+
+### `"never"`
+
+There _must never_ be whitespace before the commas.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1 ,1) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1 , 1) }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1,1) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1, 1) }
+```
+
+### `"always-single-line"`
+
+There _must always_ be a single space before the commas in single-line functions.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1,1) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1, 1) }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1 ,1) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1 , 1) }
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  transform: translate(1,
+    1)
+}
+```
+
+### `"never-single-line"`
+
+There _must never_ be whitespace before the commas in single-line functions.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1 ,1) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1 , 1) }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1,1) }
+```
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1, 1) }
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  transform: translate(1 ,
+    1)
+}
+```

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

@@ -0,0 +1,62 @@
+/* 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 functionCommaSpaceChecker = require('../functionCommaSpaceChecker.cjs');
+const fixer = require('../functionCommaSpaceFix.cjs');
+
+const ruleName = 'plugin/function-comma-space-before';
+
+const messages = ruleMessages(ruleName, {
+	expectedBefore: () => 'Expected single space before ","',
+	rejectedBefore: () => 'Unexpected whitespace before ","',
+	expectedBeforeSingleLine: () => 'Expected single space before "," in a single-line function',
+	rejectedBeforeSingleLine: () => 'Unexpected whitespace before "," in a single-line function'
+});
+
+const meta = {
+	url: 'https://github.com/jens-duttke/linter-bundle/blob/main/stylelint/plugins/stylelint-15.11.0-stylistic/rules/function-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;
+		}
+
+		functionCommaSpaceChecker({
+			root,
+			result,
+			locationChecker: checker.before,
+			checkedRuleName: ruleName,
+			fix: context.fix ?
+				(div, index, nodes) => fixer({
+					div,
+					index,
+					nodes,
+					expectation: primary,
+					position: 'before',
+					symb: ' '
+				})
+				: null
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+module.exports = stylelint.createPlugin(ruleName, rule);

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/function-max-empty-lines/README.md

@@ -0,0 +1,78 @@
+# function-max-empty-lines
+
+Limit the number of adjacent empty lines within functions.
+
+<!-- prettier-ignore -->
+```css
+a {
+  transform:
+    translate(
+                /* ← */
+      1,        /* ↑ */
+                /* ← */
+      1         /* ↑ */
+                /* ← */
+    );          /* ↑ */
+}               /* ↑ */
+/**                ↑
+ *            These lines */
+```
+
+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 {
+  transform:
+    translate(
+
+      1,
+      1
+    );
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  transform:
+    translate(
+      1,
+
+      1
+    );
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  transform:
+    translate(
+      1,
+      1
+
+    );
+}
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a {
+  transform:
+    translate(
+      1,
+      1
+    );
+}
+```

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

@@ -0,0 +1,115 @@
+/* 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 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/function-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/function-max-empty-lines/README.md',
+	fixable: true
+};
+
+/**
+ * @param {import('postcss').Declaration} decl
+ */
+function placeIndexOnValueStart (decl) {
+	if (decl.raws.between == null) { throw new Error('`between` must be present'); }
+
+	return decl.prop.length + decl.raws.between.length - 1;
+}
+
+/** @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) => {
+			if (!decl.value.includes('(')) {
+				return;
+			}
+
+			const stringValue = getDeclarationValue(decl);
+			/** @type {Array<[string, string]>} */
+			const splittedValue = [];
+			let sourceIndexStart = 0;
+
+			valueParser(stringValue).walk((node) => {
+				if (
+					node.type !== 'function' /* ignore non functions */ ||
+					node.value.length === 0 /* ignore sass lists */
+				) {
+					return;
+				}
+
+				const stringifiedNode = valueParser.stringify(node);
+
+				if (
+					!violatedLFNewLinesRegex.test(stringifiedNode) &&
+					!violatedCRLFNewLinesRegex.test(stringifiedNode)
+				) {
+					return;
+				}
+
+				if (context.fix) {
+					const newNodeString = stringifiedNode
+						.replace(new RegExp(violatedLFNewLinesRegex, 'gm'), allowedLFNewLinesString)
+						.replace(new RegExp(violatedCRLFNewLinesRegex, 'gm'), allowedCRLFNewLinesString);
+
+					splittedValue.push([
+						stringValue.slice(sourceIndexStart, node.sourceIndex),
+						newNodeString
+					]);
+					sourceIndexStart = node.sourceIndex + stringifiedNode.length;
+				}
+				else {
+					report({
+						message: messages.expected(primary),
+						node: decl,
+						index: placeIndexOnValueStart(decl) + node.sourceIndex,
+						result,
+						ruleName
+					});
+				}
+			});
+
+			if (context.fix && splittedValue.length > 0) {
+				const updatedValue =
+					splittedValue.reduce((accumulator, current) => accumulator + current[0] + current[1], '') +
+					stringValue.slice(sourceIndexStart);
+
+				setDeclarationValue(decl, updatedValue);
+			}
+		});
+	};
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+module.exports = stylelint.createPlugin(ruleName, rule);