linter-bundle 5.1.0 → 6.1.0

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

@@ -0,0 +1,182 @@
+/* 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-space-inside';
+
+const messages = ruleMessages(ruleName, {
+	expectedOpening: 'Expected single space after "("',
+	rejectedOpening: 'Unexpected whitespace after "("',
+	expectedClosing: 'Expected single space before ")"',
+	rejectedClosing: 'Unexpected whitespace before ")"',
+	expectedOpeningSingleLine: 'Expected single space after "(" in a single-line function',
+	rejectedOpeningSingleLine: 'Unexpected whitespace after "(" in a single-line function',
+	expectedClosingSingleLine: 'Expected single space before ")" in a single-line function',
+	rejectedClosingSingleLine: '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-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', 'always-single-line', 'never-single-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;
+			}
+
+			// Ignore function without parameters
+			if (valueNode.nodes.length === 0) {
+				return;
+			}
+
+			const functionString = valueParser.stringify(valueNode);
+			const isSingleLine = isSingleLineString(functionString);
+
+			// Check opening ...
+
+			const openingIndex = valueNode.sourceIndex + valueNode.value.length + 1;
+
+			if (primary === 'always' && valueNode.before !== ' ') {
+				if (context.fix) {
+					hasFixed = true;
+					valueNode.before = ' ';
+				}
+				else {
+					complain(messages.expectedOpening, openingIndex);
+				}
+			}
+
+			if (primary === 'never' && valueNode.before !== '') {
+				if (context.fix) {
+					hasFixed = true;
+					valueNode.before = '';
+				}
+				else {
+					complain(messages.rejectedOpening, openingIndex);
+				}
+			}
+
+			if (isSingleLine && primary === 'always-single-line' && valueNode.before !== ' ') {
+				if (context.fix) {
+					hasFixed = true;
+					valueNode.before = ' ';
+				}
+				else {
+					complain(messages.expectedOpeningSingleLine, openingIndex);
+				}
+			}
+
+			if (isSingleLine && primary === 'never-single-line' && valueNode.before !== '') {
+				if (context.fix) {
+					hasFixed = true;
+					valueNode.before = '';
+				}
+				else {
+					complain(messages.rejectedOpeningSingleLine, openingIndex);
+				}
+			}
+
+			// Check closing ...
+
+			const closingIndex = valueNode.sourceIndex + functionString.length - 2;
+
+			if (primary === 'always' && valueNode.after !== ' ') {
+				if (context.fix) {
+					hasFixed = true;
+					valueNode.after = ' ';
+				}
+				else {
+					complain(messages.expectedClosing, closingIndex);
+				}
+			}
+
+			if (primary === 'never' && valueNode.after !== '') {
+				if (context.fix) {
+					hasFixed = true;
+					valueNode.after = '';
+				}
+				else {
+					complain(messages.rejectedClosing, closingIndex);
+				}
+			}
+
+			if (isSingleLine && primary === 'always-single-line' && valueNode.after !== ' ') {
+				if (context.fix) {
+					hasFixed = true;
+					valueNode.after = ' ';
+				}
+				else {
+					complain(messages.expectedClosingSingleLine, closingIndex);
+				}
+			}
+
+			if (isSingleLine && primary === 'never-single-line' && valueNode.after !== '') {
+				if (context.fix) {
+					hasFixed = true;
+					valueNode.after = '';
+				}
+				else {
+					complain(messages.rejectedClosingSingleLine, 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
+			});
+		}
+	});
+};
+
+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-whitespace-after/README.md

@@ -0,0 +1,80 @@
+# function-whitespace-after
+
+Require or disallow whitespace after functions.
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1, 1) scale(3); }
+/**                           ↑
+ *                   This space */
+```
+
+This rule does not check for space immediately after `)` if the very next character is `,`, `)`, `/` or `}`, allowing some of the patterns exemplified below.
+
+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 whitespace after the function.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1, 1)scale(3); }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1, 1) scale(3); }
+```
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1, 1)     scale(3); }
+```
+
+<!-- prettier-ignore -->
+```css
+a {
+  transform:
+    translate(1, 1)
+    scale(3);
+}
+```
+
+<!-- prettier-ignore -->
+```css
+/* notice the two closing parentheses without a space between */
+a { top: calc(1 * (1 + 3)); }
+```
+
+<!-- prettier-ignore -->
+```css
+/* notice the ), with no space after the closing parenthesis */
+a { padding: calc(1 * 2px), calc(2 * 5px); }
+```
+
+### `"never"`
+
+There _must never_ be whitespace after the function.
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1, 1) scale(3); }
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+a { transform: translate(1, 1)scale(3); }
+```

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

@@ -0,0 +1,198 @@
+/* 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 declarationValueIndex = require('stylelint/lib/utils/declarationValueIndex.cjs');
+const getDeclarationValue = require('stylelint/lib/utils/getDeclarationValue.cjs');
+const isWhitespace = require('stylelint/lib/utils/isWhitespace.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 styleSearch = require('../../style-search/index.cjs');
+
+const ruleName = 'plugin/function-whitespace-after';
+
+const messages = ruleMessages(ruleName, {
+	expected: 'Expected whitespace after ")"',
+	rejected: 'Unexpected whitespace after ")"'
+});
+
+const meta = {
+	url: 'https://github.com/jens-duttke/linter-bundle/blob/main/stylelint/plugins/stylelint-15.11.0-stylistic/rules/function-whitespace-after/README.md',
+	fixable: true
+};
+
+const ACCEPTABLE_AFTER_CLOSING_PAREN = new Set([')', ',', '}', ':', '/', undefined]);
+
+/** @type {import('stylelint').Rule} */
+const rule = (primary, _secondaryOptions, context) => (root, result) => {
+	const validOptions = validateOptions(result, ruleName, {
+		actual: primary,
+		possible: ['always', 'never']
+	});
+
+	if (!validOptions) {
+		return;
+	}
+
+	/**
+	 * @param {import('postcss').Node} node
+	 * @param {string} value
+	 * @param {number} nodeIndex
+	 * @param {((index: number) => void) | undefined} fix
+	 */
+	function check (node, value, nodeIndex, fix) {
+		styleSearch(
+			{
+				source: value,
+				target: ')',
+				functionArguments: 'only'
+			},
+			(match) => {
+				checkClosingParen(value, match.startIndex + 1, node, nodeIndex, fix);
+			}
+		);
+	}
+
+	/**
+	 * @param {string} source
+	 * @param {number} index
+	 * @param {import('postcss').Node} node
+	 * @param {number} nodeIndex
+	 * @param {((index: number) => void) | undefined} fix
+	 */
+	function checkClosingParen (source, index, node, nodeIndex, fix) {
+		const nextChar = source.charAt(index);
+
+		if (!nextChar) { return; }
+
+		if (primary === 'always') {
+			// Allow for the next character to be a single empty space,
+			// another closing parenthesis, a comma, or the end of the value
+			if (nextChar === ' ') {
+				return;
+			}
+
+			if (nextChar === '\n') {
+				return;
+			}
+
+			if (source.slice(index, index + 2) === '\r\n') {
+				return;
+			}
+
+			if (ACCEPTABLE_AFTER_CLOSING_PAREN.has(nextChar)) {
+				return;
+			}
+
+			if (fix) {
+				fix(index);
+
+				return;
+			}
+
+			report({
+				message: messages.expected,
+				node,
+				index: nodeIndex + index,
+				result,
+				ruleName
+			});
+		}
+		else if (primary === 'never' && isWhitespace(nextChar)) {
+			if (fix) {
+				fix(index);
+
+				return;
+			}
+
+			report({
+				message: messages.rejected,
+				node,
+				index: nodeIndex + index,
+				result,
+				ruleName
+			});
+		}
+	}
+
+	/**
+	 * @param {string} value
+	 */
+	function createFixer (value) {
+		let fixed = '';
+		let lastIndex = 0;
+		/** @type {(index: number) => void} */
+		let applyFix;
+
+		if (primary === 'always') {
+			applyFix = (index) => {
+				 
+				fixed += value.slice(lastIndex, index) + ' ';
+				lastIndex = index;
+			};
+		}
+		else if (primary === 'never') {
+			applyFix = (index) => {
+				let whitespaceEndIndex = index + 1;
+
+				while (
+					whitespaceEndIndex < value.length &&
+						isWhitespace(value.charAt(whitespaceEndIndex))
+				) {
+					whitespaceEndIndex++;
+				}
+
+				fixed += value.slice(lastIndex, index);
+				lastIndex = whitespaceEndIndex;
+			};
+		}
+		else {
+			throw new Error(`Unexpected option: "${primary}"`);
+		}
+
+		return {
+			applyFix,
+			get hasFixed () {
+				return Boolean(lastIndex);
+			},
+			get fixed () {
+				return fixed + value.slice(lastIndex);
+			}
+		};
+	}
+
+	root.walkAtRules(/^import$/i, (atRule) => {
+		const parameter = (atRule.raws.params?.raw) || atRule.params;
+		const fixer = context.fix && createFixer(parameter);
+
+		check(atRule, parameter, atRuleParamIndex(atRule), fixer ? fixer.applyFix : undefined);
+
+		if (fixer && fixer.hasFixed) {
+			if (atRule.raws.params) {
+				atRule.raws.params.raw = fixer.fixed;
+			}
+			else {
+				atRule.params = fixer.fixed;
+			}
+		}
+	});
+	root.walkDecls((decl) => {
+		const value = getDeclarationValue(decl);
+		const fixer = context.fix && createFixer(value);
+
+		check(decl, value, declarationValueIndex(decl), fixer ? fixer.applyFix : undefined);
+
+		if (fixer && fixer.hasFixed) {
+			setDeclarationValue(decl, fixer.fixed);
+		}
+	});
+};
+
+rule.ruleName = ruleName;
+rule.messages = messages;
+rule.meta = meta;
+module.exports = stylelint.createPlugin(ruleName, rule);

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/functionCommaSpaceChecker.cjs

@@ -0,0 +1,125 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+const valueParser = require('postcss-value-parser');
+const declarationValueIndex = require('stylelint/lib/utils/declarationValueIndex.cjs');
+const getDeclarationValue = require('stylelint/lib/utils/getDeclarationValue.cjs');
+const isStandardSyntaxFunction = require('stylelint/lib/utils/isStandardSyntaxFunction.cjs');
+const report = require('stylelint/lib/utils/report.cjs');
+const setDeclarationValue = require('stylelint/lib/utils/setDeclarationValue.cjs');
+
+/** @typedef {import('postcss-value-parser').Node} ValueParserNode */
+/** @typedef {import('postcss-value-parser').DivNode} ValueParserDivNode */
+/** @typedef {(args: { source: string, index: number, err: (message: string) => void }) => void} LocationChecker */
+
+/**
+ * @param {{
+ *   root: import('postcss').Root,
+ *   locationChecker: LocationChecker,
+ *   fix: ((node: ValueParserDivNode, index: number, nodes: ValueParserNode[]) => boolean) | null,
+ *   result: import('stylelint').PostcssResult,
+ *   checkedRuleName: string,
+ * }} opts
+ * @param options
+ */
+module.exports = function functionCommaSpaceChecker (options) {
+	options.root.walkDecls((decl) => {
+		const declValue = getDeclarationValue(decl);
+
+		let hasFixed;
+		const parsedValue = valueParser(declValue);
+
+		parsedValue.walk((valueNode) => {
+			if (valueNode.type !== 'function') {
+				return;
+			}
+
+			if (!isStandardSyntaxFunction(valueNode)) {
+				return;
+			}
+
+			// Ignore `url()` arguments, which may contain data URIs or other funky stuff
+			if (valueNode.value.toLowerCase() === 'url') {
+				return;
+			}
+
+			const argumentStrings = valueNode.nodes.map((node) => valueParser.stringify(node));
+
+			const functionArguments = (() => {
+				// Remove function name and parens
+				let result = valueNode.before + argumentStrings.join('') + valueNode.after;
+
+				// 1. Remove comments including preceding whitespace (when only succeeded by whitespace)
+				// 2. Remove all other comments, but leave adjacent whitespace intact
+				// eslint-disable-next-line regexp/no-dupe-disjunctions -- TODO: Possible to simplify the regex.
+				result = result.replace(/( *\/(\*.*\*\/(?!\S)|\/.*)|(\/(\*.*\*\/|\/.*)))/, '');
+
+				return result;
+			})();
+
+			/**
+			 * Gets the index of the comma for checking.
+			 * @param {ValueParserDivNode} commaNode - The comma node
+			 * @param {number} nodeIndex - The index of the comma node
+			 * @returns {number} The index of the comma for checking
+			 */
+			const getCommaCheckIndex = (commaNode, nodeIndex) => {
+				let commaBefore =
+					valueNode.before + argumentStrings.slice(0, nodeIndex).join('') + commaNode.before;
+
+				// 1. Remove comments including preceding whitespace (when only succeeded by whitespace)
+				// 2. Remove all other comments, but leave adjacent whitespace intact
+				// eslint-disable-next-line regexp/no-dupe-disjunctions -- TODO: Possible to simplify the regex.
+				commaBefore = commaBefore.replace(/( *\/(\*.*\*\/(?!\S)|\/.*)|(\/(\*.*\*\/|\/.*)))/, '');
+
+				return commaBefore.length;
+			};
+
+			/** @type {{ commaNode: ValueParserDivNode, checkIndex: number, nodeIndex: number }[]} */
+			const commaDataList = [];
+
+			for (const [nodeIndex, node] of valueNode.nodes.entries()) {
+				if (node.type !== 'div' || node.value !== ',') {
+					continue;
+				}
+
+				const checkIndex = getCommaCheckIndex(node, nodeIndex);
+
+				commaDataList.push({
+					commaNode: node,
+					checkIndex,
+					nodeIndex
+				});
+			}
+
+			for (const { commaNode, checkIndex, nodeIndex } of commaDataList) {
+				options.locationChecker({
+					source: functionArguments,
+					index: checkIndex,
+					err: (message) => {
+						const index =
+							declarationValueIndex(decl) + commaNode.sourceIndex + commaNode.before.length;
+
+						if (options.fix?.(commaNode, nodeIndex, valueNode.nodes)) {
+							hasFixed = true;
+
+							return;
+						}
+
+						report({
+							index,
+							message,
+							node: decl,
+							result: options.result,
+							ruleName: options.checkedRuleName
+						});
+					}
+				});
+			}
+		});
+
+		if (hasFixed) {
+			setDeclarationValue(decl, parsedValue.toString());
+		}
+	});
+};

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/functionCommaSpaceFix.cjs

@@ -0,0 +1,51 @@
+/* eslint-disable -- We want to keep as much of the original code as possible */
+// @ts-nocheck
+
+/**
+ * @param {{
+ *   div: import('postcss-value-parser').DivNode,
+ *   index: number,
+ *   nodes: import('postcss-value-parser').Node[],
+ *   expectation: string,
+ *   position: 'before' | 'after',
+ *   symb: string,
+ * }} params
+ * @param parameters
+ * @returns {boolean}
+ */
+module.exports = function functionCommaSpaceFix (parameters) {
+	const { div, index, nodes, expectation, position, symb } = parameters;
+
+	if (expectation.startsWith('always')) {
+		div[position] = symb;
+
+		return true;
+	}
+
+	if (expectation.startsWith('never')) {
+		div[position] = '';
+
+		for (let i = index + 1; i < nodes.length; i++) {
+			const node = nodes[i];
+
+			if (node === undefined) {
+				continue;
+			}
+
+			if (node.type === 'comment') {
+				continue;
+			}
+
+			if (node.type === 'space') {
+				node.value = '';
+				continue;
+			}
+
+			break;
+		}
+
+		return true;
+	}
+
+	return false;
+};