linter-bundle 5.0.1 → 6.0.0

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);

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/function-parentheses-newline-inside/README.md

@@ -0,0 +1,144 @@
+# function-parentheses-newline-inside
+
+Require a newline or disallow whitespace on the inside of the parentheses of functions.
+
+<!-- prettier-ignore -->
+```css
+  a {
+    transform: translate(
+      1,             /* ↑ */
+      1              /* ↑ */
+    );               /* ↑ */
+  }                  /* ↑ */
+/** ↑                   ↑
+ * The newline 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"|"always-multi-line"|"never-multi-line"`
+
+### `"always"`
+
+There _must always_ be a newline inside the parentheses.
+
+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-multi-line"`
+
+There _must always_ be a newline inside the parentheses of multi-line functions.
+
+The following patterns are considered problems:
+
+<!-- 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
+  );
+}
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  transform: translate(
+    1,
+    1
+  );
+}
+```
+
+### `"never-multi-line"`
+
+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-parentheses-newline-inside/index.cjs

@@ -0,0 +1,282 @@
+/* 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 declarationValueIndex = require('stylelint/lib/utils/declarationValueIndex.cjs');
+const getDeclarationValue = require('stylelint/lib/utils/getDeclarationValue.cjs');
+const isSingleLineString = require('stylelint/lib/utils/isSingleLineString.cjs');
+const isStandardSyntaxFunction = require('stylelint/lib/utils/isStandardSyntaxFunction.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 ruleName = 'plugin/function-parentheses-newline-inside';
+
+const messages = ruleMessages(ruleName, {
+	expectedOpening: 'Expected newline after "("',
+	expectedClosing: 'Expected newline before ")"',
+	expectedOpeningMultiLine: 'Expected newline after "(" in a multi-line function',
+	rejectedOpeningMultiLine: 'Unexpected whitespace after "(" in a multi-line function',
+	expectedClosingMultiLine: 'Expected newline before ")" in a multi-line function',
+	rejectedClosingMultiLine: 'Unexpected whitespace before ")" in a multi-line function'
+});
+
+const meta = {
+	url: 'https://github.com/jens-duttke/linter-bundle/blob/main/stylelint/plugins/stylelint-15.11.0-stylistic/rules/function-parentheses-newline-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', 'always-multi-line', 'never-multi-line']
+	});
+
+	if (!validOptions) {
+		return;
+	}
+
+	root.walkDecls((decl) => {
+		if (!decl.value.includes('(')) {
+			return;
+		}
+
+		let hasFixed = false;
+		const declValue = getDeclarationValue(decl);
+		const parsedValue = valueParser(declValue);
+
+		parsedValue.walk((valueNode) => {
+			if (valueNode.type !== 'function') {
+				return;
+			}
+
+			if (!isStandardSyntaxFunction(valueNode)) {
+				return;
+			}
+
+			const functionString = valueParser.stringify(valueNode);
+			const isMultiLine = !isSingleLineString(functionString);
+			const containsNewline = (/** @type {string} */ string_) => string_.includes('\n');
+
+			// Check opening ...
+
+			const openingIndex = valueNode.sourceIndex + valueNode.value.length + 1;
+			const checkBefore = getCheckBefore(valueNode);
+
+			if (primary === 'always' && !containsNewline(checkBefore)) {
+				if (context.fix) {
+					hasFixed = true;
+					fixBeforeForAlways(valueNode, context.newline || '');
+				}
+				else {
+					complain(messages.expectedOpening, openingIndex);
+				}
+			}
+
+			if (isMultiLine && primary === 'always-multi-line' && !containsNewline(checkBefore)) {
+				if (context.fix) {
+					hasFixed = true;
+					fixBeforeForAlways(valueNode, context.newline || '');
+				}
+				else {
+					complain(messages.expectedOpeningMultiLine, openingIndex);
+				}
+			}
+
+			if (isMultiLine && primary === 'never-multi-line' && checkBefore !== '') {
+				if (context.fix) {
+					hasFixed = true;
+					fixBeforeForNever(valueNode);
+				}
+				else {
+					complain(messages.rejectedOpeningMultiLine, openingIndex);
+				}
+			}
+
+			// Check closing ...
+
+			const closingIndex = valueNode.sourceIndex + functionString.length - 2;
+			const checkAfter = getCheckAfter(valueNode);
+
+			if (primary === 'always' && !containsNewline(checkAfter)) {
+				if (context.fix) {
+					hasFixed = true;
+					fixAfterForAlways(valueNode, context.newline || '');
+				}
+				else {
+					complain(messages.expectedClosing, closingIndex);
+				}
+			}
+
+			if (isMultiLine && primary === 'always-multi-line' && !containsNewline(checkAfter)) {
+				if (context.fix) {
+					hasFixed = true;
+					fixAfterForAlways(valueNode, context.newline || '');
+				}
+				else {
+					complain(messages.expectedClosingMultiLine, closingIndex);
+				}
+			}
+
+			if (isMultiLine && primary === 'never-multi-line' && checkAfter !== '') {
+				if (context.fix) {
+					hasFixed = true;
+					fixAfterForNever(valueNode);
+				}
+				else {
+					complain(messages.rejectedClosingMultiLine, closingIndex);
+				}
+			}
+		});
+
+		if (hasFixed) {
+			setDeclarationValue(decl, parsedValue.toString());
+		}
+
+		/**
+		 * @param {string} message
+		 * @param {number} offset
+		 */
+		function complain (message, offset) {
+			report({
+				ruleName,
+				result,
+				message,
+				node: decl,
+				index: declarationValueIndex(decl) + offset
+			});
+		}
+	});
+};
+
+/** @typedef {import('postcss-value-parser').FunctionNode} FunctionNode */
+
+/**
+ * @param {FunctionNode} valueNode
+ */
+function getCheckBefore (valueNode) {
+	let before = valueNode.before;
+
+	for (const node of valueNode.nodes) {
+		if (node.type === 'comment') {
+			continue;
+		}
+
+		if (node.type === 'space') {
+			before += node.value;
+			continue;
+		}
+
+		break;
+	}
+
+	return before;
+}
+
+/**
+ * @param {FunctionNode} valueNode
+ */
+function getCheckAfter (valueNode) {
+	let after = '';
+
+	for (const node of [...valueNode.nodes].reverse()) {
+		if (node.type === 'comment') {
+			continue;
+		}
+
+		if (node.type === 'space') {
+			after = node.value + after;
+			continue;
+		}
+
+		break;
+	}
+
+	after += valueNode.after;
+
+	return after;
+}
+
+/**
+ * @param {FunctionNode} valueNode
+ * @param {string} newline
+ */
+function fixBeforeForAlways (valueNode, newline) {
+	let target;
+
+	for (const node of valueNode.nodes) {
+		if (node.type === 'comment') {
+			continue;
+		}
+
+		if (node.type === 'space') {
+			target = node;
+			continue;
+		}
+
+		break;
+	}
+
+	if (target) {
+		target.value = newline + target.value;
+	}
+	else {
+		valueNode.before = newline + valueNode.before;
+	}
+}
+
+/**
+ * @param {FunctionNode} valueNode
+ */
+function fixBeforeForNever (valueNode) {
+	valueNode.before = '';
+
+	for (const node of valueNode.nodes) {
+		if (node.type === 'comment') {
+			continue;
+		}
+
+		if (node.type === 'space') {
+			node.value = '';
+			continue;
+		}
+
+		break;
+	}
+}
+
+/**
+ * @param {FunctionNode} valueNode
+ * @param {string} newline
+ */
+function fixAfterForAlways (valueNode, newline) {
+	valueNode.after = newline + valueNode.after;
+}
+
+/**
+ * @param {FunctionNode} valueNode
+ */
+function fixAfterForNever (valueNode) {
+	valueNode.after = '';
+
+	for (const node of [...valueNode.nodes].reverse()) {
+		if (node.type === 'comment') {
+			continue;
+		}
+
+		if (node.type === 'space') {
+			node.value = '';
+			continue;
+		}
+
+		break;
+	}
+}
+
+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-parentheses-space-inside/README.md

@@ -0,0 +1,140 @@
+# function-parentheses-space-inside
+
+Require a single space or disallow whitespace on the inside of the parentheses of functions.
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate( 1, 1 ); }
+/**                     ↑      ↑
+ * 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-single-line"|"never-single-line"`
+
+### `"always"`
+
+There _must always_ be a single space inside of the parentheses.
+
+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 ); }
+```
+
+### `"never"`
+
+There _must never_ be whitespace on the inside of the parentheses.
+
+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); }
+```
+
+### `"always-single-line"`
+
+There _must always_ be a single space inside the parentheses of 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 inside the parentheses of 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
+  )
+}
+```