linter-bundle 7.2.0 → 7.3.0

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/declarationColonSpaceChecker.mjs

@@ -39,17 +39,14 @@ export default function declarationColonSpaceChecker(opts) {
 				index: i,
 				lineCheckStr: decl.value,
 				err: (message) => {
-					if (opts.fix && opts.fix(decl, i)) {
-						return;
-					}
-
 					report({
 						message,
 						node: decl,
 						index: decl.prop.toString().length + 1,
-						endIndex: index,
+						endIndex: decl.prop.toString().length + 1,
 						result: opts.result,
 						ruleName: opts.checkedRuleName,
+						fix: (opts.fix ? () => opts.fix(decl, i) : undefined)
 					});
 				},
 			});

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/function-comma-newline-after/index.mjs

@@ -41,16 +41,14 @@ const rule = (primary, _secondaryOptions, context) => {
 			result,
 			locationChecker: checker.afterOneOnly,
 			checkedRuleName: ruleName,
-			fix: context.fix ?
-				(div, index, nodes) => fixer({
-					div,
-					index,
-					nodes,
-					expectation: primary,
-					position: 'after',
-					symb: context.newline || ''
-				})
-				: null
+			fix: (div, index, nodes) => fixer({
+				div,
+				index,
+				nodes,
+				expectation: primary,
+				position: 'after',
+				symb: context.newline || ''
+			})
 		});
 	};
 };

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/function-comma-newline-before/index.mjs

@@ -41,16 +41,14 @@ const rule = (primary, _secondaryOptions, context) => {
 			result,
 			locationChecker: checker.beforeAllowingIndentation,
 			checkedRuleName: ruleName,
-			fix: context.fix ?
-				(div, index, nodes) => fixer({
-					div,
-					index,
-					nodes,
-					expectation: primary,
-					position: 'before',
-					symb: context.newline || ''
-				})
-				: null
+			fix: (div, index, nodes) => fixer({
+				div,
+				index,
+				nodes,
+				expectation: primary,
+				position: 'before',
+				symb: context.newline || ''
+			})
 		});
 	};
 };

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

@@ -24,7 +24,7 @@ const meta = {
 };
 
 /** @type {import('stylelint').Rule} */
-const rule = (primary, _secondaryOptions, context) => {
+const rule = (primary, _secondaryOptions) => {
 	const checker = whitespaceChecker('space', primary, messages);
 
 	return (root, result) => {
@@ -42,16 +42,14 @@ const rule = (primary, _secondaryOptions, context) => {
 			result,
 			locationChecker: checker.after,
 			checkedRuleName: ruleName,
-			fix: context.fix ?
-				(div, index, nodes) => fixer({
-					div,
-					index,
-					nodes,
-					expectation: primary,
-					position: 'after',
-					symb: ' '
-				})
-				: null
+			fix: (div, index, nodes) => fixer({
+				div,
+				index,
+				nodes,
+				expectation: primary,
+				position: 'after',
+				symb: ' '
+			})
 		});
 	};
 };

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

@@ -24,7 +24,7 @@ const meta = {
 };
 
 /** @type {import('stylelint').Rule} */
-const rule = (primary, _secondaryOptions, context) => {
+const rule = (primary, _secondaryOptions) => {
 	const checker = whitespaceChecker('space', primary, messages);
 
 	return (root, result) => {
@@ -42,16 +42,14 @@ const rule = (primary, _secondaryOptions, context) => {
 			result,
 			locationChecker: checker.before,
 			checkedRuleName: ruleName,
-			fix: context.fix ?
-				(div, index, nodes) => fixer({
-					div,
-					index,
-					nodes,
-					expectation: primary,
-					position: 'before',
-					symb: ' '
-				})
-				: null
+			fix: (div, index, nodes) => fixer({
+				div,
+				index,
+				nodes,
+				expectation: primary,
+				position: 'before',
+				symb: ' '
+			})
 		});
 	};
 };

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

@@ -31,7 +31,7 @@ function placeIndexOnValueStart (decl) {
 }
 
 /** @type {import('stylelint').Rule} */
-const rule = (primary, _secondaryOptions, context) => {
+const rule = (primary, _secondaryOptions) => {
 	const maxAdjacentNewlines = primary + 1;
 
 	return (root, result) => {
@@ -46,8 +46,8 @@ const rule = (primary, _secondaryOptions, context) => {
 
 		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) : '';
+		const allowedLFNewLinesString = '\n'.repeat(maxAdjacentNewlines);
+		const allowedCRLFNewLinesString = '\r\n'.repeat(maxAdjacentNewlines);
 
 		root.walkDecls((decl) => {
 			if (!decl.value.includes('(')) {
@@ -76,30 +76,28 @@ const rule = (primary, _secondaryOptions, context) => {
 					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,
-						endIndex: placeIndexOnValueStart(decl) + node.sourceIndex,
-						result,
-						ruleName
-					});
-				}
+				report({
+					message: messages.expected(primary),
+					node: decl,
+					index: placeIndexOnValueStart(decl) + node.sourceIndex,
+					endIndex: placeIndexOnValueStart(decl) + node.sourceIndex,
+					result,
+					ruleName,
+					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;
+					}
+				});
 			});
 
-			if (context.fix && splittedValue.length > 0) {
+			if (splittedValue.length > 0) {
 				const updatedValue =
 					splittedValue.reduce((accumulator, current) => accumulator + current[0] + current[1], '') +
 					stringValue.slice(sourceIndexStart);

package/stylelint/plugins/stylelint-15.11.0-stylistic/rules/function-parentheses-newline-inside/index.mjs

@@ -67,33 +67,48 @@ const rule = (primary, _secondaryOptions, context) => (root, result) => {
 			const checkBefore = getCheckBefore(valueNode);
 
 			if (primary === 'always' && !containsNewline(checkBefore)) {
-				if (context.fix) {
-					hasFixed = true;
-					fixBeforeForAlways(valueNode, context.newline || '');
-				}
-				else {
-					complain(messages.expectedOpening, openingIndex);
-				}
+				report({
+					ruleName,
+					result,
+					message: messages.expectedOpening,
+					node: decl,
+					index: declarationValueIndex(decl) + openingIndex,
+					endIndex: declarationValueIndex(decl) + openingIndex,
+					fix: () => {
+						hasFixed = true;
+						fixBeforeForAlways(valueNode, context.newline || '');
+					}
+				});
 			}
 
 			if (isMultiLine && primary === 'always-multi-line' && !containsNewline(checkBefore)) {
-				if (context.fix) {
-					hasFixed = true;
-					fixBeforeForAlways(valueNode, context.newline || '');
-				}
-				else {
-					complain(messages.expectedOpeningMultiLine, openingIndex);
-				}
+				report({
+					ruleName,
+					result,
+					message: messages.expectedOpeningMultiLine,
+					node: decl,
+					index: declarationValueIndex(decl) + openingIndex,
+					endIndex: declarationValueIndex(decl) + openingIndex,
+					fix: () => {
+						hasFixed = true;
+						fixBeforeForAlways(valueNode, context.newline || '');
+					}
+				});
 			}
 
 			if (isMultiLine && primary === 'never-multi-line' && checkBefore !== '') {
-				if (context.fix) {
-					hasFixed = true;
-					fixBeforeForNever(valueNode);
-				}
-				else {
-					complain(messages.rejectedOpeningMultiLine, openingIndex);
-				}
+				report({
+					ruleName,
+					result,
+					message: messages.rejectedOpeningMultiLine,
+					node: decl,
+					index: declarationValueIndex(decl) + openingIndex,
+					endIndex: declarationValueIndex(decl) + openingIndex,
+					fix: () => {
+						hasFixed = true;
+						fixBeforeForNever(valueNode);
+					}
+				});
 			}
 
 			// Check closing ...
@@ -102,54 +117,54 @@ const rule = (primary, _secondaryOptions, context) => (root, result) => {
 			const checkAfter = getCheckAfter(valueNode);
 
 			if (primary === 'always' && !containsNewline(checkAfter)) {
-				if (context.fix) {
-					hasFixed = true;
-					fixAfterForAlways(valueNode, context.newline || '');
-				}
-				else {
-					complain(messages.expectedClosing, closingIndex);
-				}
+				report({
+					ruleName,
+					result,
+					message: messages.expectedClosing,
+					node: decl,
+					index: declarationValueIndex(decl) + closingIndex,
+					endIndex: declarationValueIndex(decl) + closingIndex,
+					fix: () => {
+						hasFixed = true;
+						fixAfterForAlways(valueNode, context.newline || '');
+					}
+				});
 			}
 
 			if (isMultiLine && primary === 'always-multi-line' && !containsNewline(checkAfter)) {
-				if (context.fix) {
-					hasFixed = true;
-					fixAfterForAlways(valueNode, context.newline || '');
-				}
-				else {
-					complain(messages.expectedClosingMultiLine, closingIndex);
-				}
+				report({
+					ruleName,
+					result,
+					message,
+					node: decl,
+					index: declarationValueIndex(decl) + messages.expectedClosingMultiLine,
+					endIndex: declarationValueIndex(decl) + closingIndex,
+					fix: () => {
+						hasFixed = true;
+						fixAfterForAlways(valueNode, context.newline || '');
+					}
+				});
 			}
 
 			if (isMultiLine && primary === 'never-multi-line' && checkAfter !== '') {
-				if (context.fix) {
-					hasFixed = true;
-					fixAfterForNever(valueNode);
-				}
-				else {
-					complain(messages.rejectedClosingMultiLine, closingIndex);
-				}
+				report({
+					ruleName,
+					result,
+					message: messages.rejectedClosingMultiLine,
+					node: decl,
+					index: declarationValueIndex(decl) + closingIndex,
+					endIndex: declarationValueIndex(decl) + closingIndex,
+					fix: () => {
+						hasFixed = true;
+						fixAfterForNever(valueNode);
+					}
+				});
 			}
 		});
 
 		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,
-				endIndex: declarationValueIndex(decl) + offset
-			});
-		}
 	});
 };
 

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

@@ -31,7 +31,7 @@ const meta = {
 };
 
 /** @type {import('stylelint').Rule} */
-const rule = (primary, _secondaryOptions, context) => (root, result) => {
+const rule = (primary, _secondaryOptions) => (root, result) => {
 	const validOptions = validateOptions(result, ruleName, {
 		actual: primary,
 		possible: ['always', 'never', 'always-single-line', 'never-single-line']
@@ -72,43 +72,63 @@ const rule = (primary, _secondaryOptions, context) => (root, result) => {
 			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);
-				}
+				report({
+					ruleName,
+					result,
+					message: messages.expectedOpening,
+					node: decl,
+					index: declarationValueIndex(decl) + openingIndex,
+					endIndex: declarationValueIndex(decl) + openingIndex,
+					fix: () => {
+						hasFixed = true;
+						valueNode.before = ' ';
+					}
+				});
 			}
 
 			if (primary === 'never' && valueNode.before !== '') {
-				if (context.fix) {
-					hasFixed = true;
-					valueNode.before = '';
-				}
-				else {
-					complain(messages.rejectedOpening, openingIndex);
-				}
+				report({
+					ruleName,
+					result,
+					message: messages.rejectedOpening,
+					node: decl,
+					index: declarationValueIndex(decl) + openingIndex,
+					endIndex: declarationValueIndex(decl) + openingIndex,
+					fix: () => {
+						hasFixed = true;
+						valueNode.before = '';
+					}
+				});
 			}
 
 			if (isSingleLine && primary === 'always-single-line' && valueNode.before !== ' ') {
-				if (context.fix) {
-					hasFixed = true;
-					valueNode.before = ' ';
-				}
-				else {
-					complain(messages.expectedOpeningSingleLine, openingIndex);
-				}
+				report({
+					ruleName,
+					result,
+					message: messages.expectedOpeningSingleLine,
+					node: decl,
+					index: declarationValueIndex(decl) + openingIndex,
+					endIndex: declarationValueIndex(decl) + openingIndex,
+					fix: () => {
+						hasFixed = true;
+						valueNode.before = ' ';
+					}
+				});
 			}
 
 			if (isSingleLine && primary === 'never-single-line' && valueNode.before !== '') {
-				if (context.fix) {
-					hasFixed = true;
-					valueNode.before = '';
-				}
-				else {
-					complain(messages.rejectedOpeningSingleLine, openingIndex);
-				}
+				report({
+					ruleName,
+					result,
+					message: messages.rejectedOpeningSingleLine,
+					node: decl,
+					index: declarationValueIndex(decl) + openingIndex,
+					endIndex: declarationValueIndex(decl) + openingIndex,
+					fix: () => {
+						hasFixed = true;
+						valueNode.before = '';
+					}
+				});
 			}
 
 			// Check closing ...
@@ -116,64 +136,69 @@ const rule = (primary, _secondaryOptions, context) => (root, result) => {
 			const closingIndex = valueNode.sourceIndex + functionString.length - 2;
 
 			if (primary === 'always' && valueNode.after !== ' ') {
-				if (context.fix) {
-					hasFixed = true;
-					valueNode.after = ' ';
-				}
-				else {
-					complain(messages.expectedClosing, closingIndex);
-				}
+				report({
+					ruleName,
+					result,
+					message: messages.expectedClosing,
+					node: decl,
+					index: declarationValueIndex(decl) + closingIndex,
+					endIndex: declarationValueIndex(decl) + closingIndex,
+					fix: () => {
+						hasFixed = true;
+						valueNode.after = ' ';
+					}
+				});
 			}
 
 			if (primary === 'never' && valueNode.after !== '') {
-				if (context.fix) {
-					hasFixed = true;
-					valueNode.after = '';
-				}
-				else {
-					complain(messages.rejectedClosing, closingIndex);
-				}
+				report({
+					ruleName,
+					result,
+					message: messages.rejectedClosing,
+					node: decl,
+					index: declarationValueIndex(decl) + closingIndex,
+					endIndex: declarationValueIndex(decl) + closingIndex,
+					fix: () => {
+						hasFixed = true;
+						valueNode.after = '';
+					}
+				});
 			}
 
 			if (isSingleLine && primary === 'always-single-line' && valueNode.after !== ' ') {
-				if (context.fix) {
-					hasFixed = true;
-					valueNode.after = ' ';
-				}
-				else {
-					complain(messages.expectedClosingSingleLine, closingIndex);
-				}
+				report({
+					ruleName,
+					result,
+					message: messages.expectedClosingSingleLine,
+					node: decl,
+					index: declarationValueIndex(decl) + closingIndex,
+					endIndex: declarationValueIndex(decl) + closingIndex,
+					fix: () => {
+						hasFixed = true;
+						valueNode.after = ' ';
+					}
+				});
 			}
 
 			if (isSingleLine && primary === 'never-single-line' && valueNode.after !== '') {
-				if (context.fix) {
-					hasFixed = true;
-					valueNode.after = '';
-				}
-				else {
-					complain(messages.rejectedClosingSingleLine, closingIndex);
-				}
+				report({
+					ruleName,
+					result,
+					message: messages.rejectedClosingSingleLine,
+					node: decl,
+					index: declarationValueIndex(decl) + closingIndex,
+					endIndex: declarationValueIndex(decl) + closingIndex,
+					fix: () => {
+						hasFixed = true;
+						valueNode.after = '';
+					}
+				});
 			}
 		});
 
 		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,
-				endIndex: declarationValueIndex(decl) + offset
-			});
-		}
 	});
 };
 

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

@@ -87,35 +87,29 @@ const rule = (primary, _secondaryOptions, context) => (root, result) => {
 				return;
 			}
 
-			if (fix) {
-				fix(index);
-
-				return;
-			}
-
 			report({
 				message: messages.expected,
 				node,
 				index: nodeIndex + index,
 				endIndex: nodeIndex + index,
 				result,
-				ruleName
+				ruleName,
+				fix: () => {
+					fix(index);
+				}
 			});
 		}
 		else if (primary === 'never' && isWhitespace(nextChar)) {
-			if (fix) {
-				fix(index);
-
-				return;
-			}
-
 			report({
 				message: messages.rejected,
 				node,
 				index: nodeIndex + index,
 				endIndex: nodeIndex + index,
 				result,
-				ruleName
+				ruleName,
+				fix: () => {
+					fix(index);
+				}
 			});
 		}
 	}
@@ -167,7 +161,7 @@ const rule = (primary, _secondaryOptions, context) => (root, result) => {
 
 	root.walkAtRules(/^import$/i, (atRule) => {
 		const parameter = (atRule.raws.params?.raw) || atRule.params;
-		const fixer = context.fix && createFixer(parameter);
+		const fixer = createFixer(parameter);
 
 		check(atRule, parameter, atRuleParamIndex(atRule), fixer ? fixer.applyFix : undefined);
 
@@ -182,7 +176,7 @@ const rule = (primary, _secondaryOptions, context) => (root, result) => {
 	});
 	root.walkDecls((decl) => {
 		const value = getDeclarationValue(decl);
-		const fixer = context.fix && createFixer(value);
+		const fixer = createFixer(value);
 
 		check(decl, value, declarationValueIndex(decl), fixer ? fixer.applyFix : undefined);
 

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

@@ -97,14 +97,7 @@ export default function functionCommaSpaceChecker (options) {
 					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;
-						}
+						const index = declarationValueIndex(decl) + commaNode.sourceIndex + commaNode.before.length;
 
 						report({
 							index,
@@ -112,7 +105,12 @@ export default function functionCommaSpaceChecker (options) {
 							message,
 							node: decl,
 							result: options.result,
-							ruleName: options.checkedRuleName
+							ruleName: options.checkedRuleName,
+							fix: (options.fix ? () => {
+								if (options.fix(commaNode, nodeIndex, valueNode.nodes)) {
+									hasFixed = true;
+								}
+							} : undefined)
 						});
 					}
 				});