Add ignorePseudoClasses: [] to max-nesting-depth

lib/rules/max-nesting-depth/README.md

@@ -353,3 +353,61 @@ a {
   }
 }
 ```
+
+### `ignorePseudoClasses: ["/regex/", /regex/, "string"]`
+
+Ignore the specified pseudo classes.
+
+For example, with `1` and given:
+
+```json
+["hover", "active"]
+```
+
+The following patterns are _not_ considered problems:
+
+<!-- prettier-ignore -->
+```css
+.a {
+  &:hover {   /* ignored */
+    .b {      /* 1 */
+      top: 0;
+    }
+  }
+}
+```
+
+<!-- prettier-ignore -->
+```css
+.a {
+  &:hover, &:active { /* ignored */
+    .b {              /* 1 */
+      top: 0;
+    }
+  }
+}
+```
+
+The following patterns are considered problems:
+
+<!-- prettier-ignore -->
+```css
+.a {
+  &:visited { /* 1 */
+    .b {      /* 2 */
+      top: 0;
+    }
+  }
+}
+```
+
+<!-- prettier-ignore -->
+```css
+.a {
+  &:hover, &:visited { /* 1 */
+    .b {               /* 2 */
+      top: 0;
+    }
+  }
+}
+```

lib/rules/max-nesting-depth/__tests__/index.js

@@ -166,6 +166,38 @@ testRule({
 	],
 });
 
+testRule({
+	ruleName,
+	config: [1, { ignorePseudoClasses: ['hover', '/^custom-.*$/'] }],
+
+	accept: [
+		{
+			code: '.a { &:hover { .b { top: 0; } } }',
+		},
+		{
+			code: '.a { &:hover, &:custom-pseudo { .b { top: 0; } } }',
+		},
+	],
+
+	reject: [
+		{
+			code: '.a { &:visited { .b { top: 0; } } }',
+			message: messages.expected(1),
+			description: 'pseudo-class not ignored',
+		},
+		{
+			code: '.a { &:custom-pseudo, &:visited { .b { top: 0; } } }',
+			message: messages.expected(1),
+			description: 'ignored pseudo-class alongside pseudo-class',
+		},
+		{
+			code: '.a { &:hover, .b { .c { top: 0; } } }',
+			message: messages.expected(1),
+			description: 'pseudo-class alongside class',
+		},
+	],
+});
+
 testRule({
 	ruleName,
 	config: [1, { ignoreAtRules: ['media', '/^my-/'] }],

lib/rules/max-nesting-depth/index.js

@@ -25,7 +25,7 @@ const rule = (primary, secondaryOptions) => {
 		isAtRule(node) && optionsMatches(secondaryOptions, 'ignoreAtRules', node.name);
 
 	return (root, result) => {
-		validateOptions(
+		const validOptions = validateOptions(
 			result,
 			ruleName,
 			{
@@ -38,10 +38,13 @@ const rule = (primary, secondaryOptions) => {
 				possible: {
 					ignore: ['blockless-at-rules', 'pseudo-classes'],
 					ignoreAtRules: [isString, isRegExp],
+					ignorePseudoClasses: [isString, isRegExp],
 				},
 			},
 		);
 
+		if (!validOptions) return;
+
 		root.walkRules(checkStatement);
 		root.walkAtRules(checkStatement);
 
@@ -108,13 +111,31 @@ const rule = (primary, secondaryOptions) => {
 			return selectors.every((sel) => sel.startsWith('&:') && sel[2] !== ':');
 		}
 
+		/**
+		 * @param {string[]} selectors
+		 * @returns {boolean}
+		 */
+		function containsIgnoredPseudoClassesOnly(selectors) {
+			return selectors.every((selector) => {
+				const pseudoRule = selector.startsWith('&:') && selector[2] !== ':' && selector.substr(2);
+
+				if (!pseudoRule) return false;
+
+				return optionsMatches(secondaryOptions, 'ignorePseudoClasses', pseudoRule);
+			});
+		}
+
 		if (
 			(optionsMatches(secondaryOptions, 'ignore', 'blockless-at-rules') &&
 				isAtRule(node) &&
 				node.every((child) => !isDeclaration(child))) ||
 			(optionsMatches(secondaryOptions, 'ignore', 'pseudo-classes') &&
 				isRule(node) &&
-				containsPseudoClassesOnly(node.selector))
+				containsPseudoClassesOnly(node.selector)) ||
+			(isRule(node) &&
+				secondaryOptions &&
+				secondaryOptions.ignorePseudoClasses &&
+				containsIgnoredPseudoClassesOnly(node.selectors))
 		) {
 			return nestingDepth(parent, level);
 		}