eslint-plugin-rxjs-x 1.0.2 → 1.0.3

package/README.md

@@ -3,6 +3,7 @@
 [![GitHub License](https://img.shields.io/badge/license-MIT-blue.svg)](https://github.com/JasonWeinzierl/eslint-plugin-rxjs-x/blob/master/LICENSE)
 [![NPM version](https://img.shields.io/npm/v/eslint-plugin-rxjs-x.svg)](https://www.npmjs.com/package/eslint-plugin-rxjs-x)
 [![OpenSSF Scorecard](https://api.scorecard.dev/projects/github.com/JasonWeinzierl/eslint-plugin-rxjs-x/badge)](https://scorecard.dev/viewer/?uri=github.com/JasonWeinzierl/eslint-plugin-rxjs-x)
+[![OpenSSF Best Practices](https://www.bestpractices.dev/projects/12936/badge)](https://www.bestpractices.dev/projects/12936)
 
 > [!NOTE]
 > Forked from [`eslint-plugin-rxjs`](https://github.com/cartant/eslint-plugin-rxjs)
@@ -49,7 +50,7 @@ Additionally, consider if the `rxjsX.configs.strict` shared config is right for
 2. The namespace of this plugin is `rxjs-x` instead of `rxjs`.
     - e.g. if your ESLint config had `"rxjs/no-subject-value": "error"`, replace it with `"rxjs-x/no-subject-value": "error"`.
     - e.g. if your project had inline comments like `// eslint-disable-next-line rxjs/no-async-subscribe`, replace them with `// eslint-disable-next-line rxjs-x/no-async-subscribe`.
-3. `rxjs/no-ignored-observable` is replaced with `rxjs-x/no-floating-observable`.
+3. `rxjs/no-ignored-observable` is replaced with `rxjs-x/no-floating-observables`.
 
 > [!TIP]
 > A complete description of all changes from `eslint-plugin-rxjs` are documented in the [CHANGELOG](CHANGELOG.md) file.

package/dist/index.d.ts

@@ -1,6 +1,5 @@
 import { TSESLint } from "@typescript-eslint/utils";
 import { ESLint, Rule } from "eslint";
-
 //#region src/index.d.ts
 declare const allRules: {
   'ban-observables': TSESLint.RuleModule<"forbidden", readonly [Record<string, string | boolean>], {
@@ -347,8 +346,9 @@ declare const rxjsX: {
     name: string;
     version: string;
     namespace: string;
-  }; /** Compatibility with `defineConfig` until https://github.com/typescript-eslint/typescript-eslint/issues/11543 is addressed. */
-  rules: { [K in keyof typeof allRules]: (typeof allRules)[K] & Rule.RuleModule };
+  };
+  /** Compatibility with `defineConfig` until https://github.com/typescript-eslint/typescript-eslint/issues/11543 is addressed. */
+  rules: { [K in keyof typeof allRules]: (typeof allRules)[K] & Rule.RuleModule; };
 };
 //#endregion
 export { rxjsX as default };

package/dist/index.js

@@ -5,7 +5,7 @@ import { getFunctionHeadLocation, isFunction } from "@typescript-eslint/utils/as
 import decamelize from "decamelize";
 //#region package.json
 var name = "eslint-plugin-rxjs-x";
-var version = "1.0.2";
+var version = "1.0.3";
 //#endregion
 //#region src/configs/recommended.ts
 const createRecommendedConfig = (plugin) => ({
@@ -564,15 +564,13 @@ const finnishRule = ruleCreator({
 				checkNode(node);
 			},
 			"ArrowFunctionExpression > Identifier": (node) => {
-				if (config.parameters) {
-					if (node !== node.parent.body) checkNode(node);
-				}
+				if (!config.parameters) return;
+				if (node !== node.parent.body) checkNode(node);
 			},
 			"PropertyDefinition[computed=false]": (node) => {
-				if (config.properties) {
-					if (node.override) return;
-					checkNode(node.key);
-				}
+				if (!config.properties) return;
+				if (node.override) return;
+				checkNode(node.key);
 			},
 			"FunctionDeclaration > Identifier": (node) => {
 				const parent = node.parent;
@@ -587,22 +585,19 @@ const finnishRule = ruleCreator({
 				} else if (config.parameters) checkNode(node);
 			},
 			"MethodDefinition[kind='get'][computed=false]": (node) => {
-				if (config.properties) {
-					if (node.override) return;
-					checkNode(node.key, node);
-				}
+				if (!config.properties) return;
+				if (node.override) return;
+				checkNode(node.key, node);
 			},
 			"MethodDefinition[kind='method'][computed=false]": (node) => {
-				if (config.methods) {
-					if (node.override) return;
-					checkNode(node.key, node);
-				}
+				if (!config.methods) return;
+				if (node.override) return;
+				checkNode(node.key, node);
 			},
 			"MethodDefinition[kind='set'][computed=false]": (node) => {
-				if (config.properties) {
-					if (node.override) return;
-					checkNode(node.key, node);
-				}
+				if (!config.properties) return;
+				if (node.override) return;
+				checkNode(node.key, node);
 			},
 			"TSAbstractMethodDefinition[computed=false]": (node) => {
 				if (node.override) return;
@@ -747,7 +742,7 @@ const noConnectableRule = ruleCreator({
 				});
 			},
 			"CallExpression[callee.name=/^(publish|publishBehavior|publishLast|publishReplay)$/]": (node) => {
-				if (!node.arguments.some((arg) => couldBeFunction(arg))) context.report({
+				if (node.arguments.every((arg) => !couldBeFunction(arg))) context.report({
 					messageId: "forbidden",
 					node: node.callee
 				});
@@ -1001,40 +996,37 @@ const noExposedSubjectsRule = ruleCreator({
 		}
 		return {
 			[`PropertyDefinition[accessibility!=${accessibilityRexExp}]`]: (node) => {
-				if (isSubject(node)) {
-					const { key } = node;
-					if (isIdentifier(key)) context.report({
-						messageId,
-						node: key,
-						data: { subject: key.name }
-					});
-				}
+				if (!isSubject(node)) return;
+				const { key } = node;
+				if (isIdentifier(key)) context.report({
+					messageId,
+					node: key,
+					data: { subject: key.name }
+				});
 			},
 			[`MethodDefinition[kind='constructor'] > FunctionExpression > TSParameterProperty[accessibility!=${accessibilityRexExp}] > Identifier`]: (node) => {
-				if (isSubject(node)) {
-					const { loc } = node;
-					context.report({
-						messageId,
-						loc: {
-							...loc,
-							end: {
-								...loc.start,
-								column: loc.start.column + node.name.length
-							}
-						},
-						data: { subject: node.name }
-					});
-				}
+				if (!isSubject(node)) return;
+				const { loc } = node;
+				context.report({
+					messageId,
+					loc: {
+						...loc,
+						end: {
+							...loc.start,
+							column: loc.start.column + node.name.length
+						}
+					},
+					data: { subject: node.name }
+				});
 			},
 			[`MethodDefinition[accessibility!=${accessibilityRexExp}][kind=/^(get|set)$/]`]: (node) => {
-				if (isSubject(node)) {
-					const key = node.key;
-					context.report({
-						messageId,
-						node: key,
-						data: { subject: key.name }
-					});
-				}
+				if (!isSubject(node)) return;
+				const key = node.key;
+				context.report({
+					messageId,
+					node: key,
+					data: { subject: key.name }
+				});
 			},
 			[`MethodDefinition[accessibility!=${accessibilityRexExp}][kind='method']`]: (node) => {
 				const functionExpression = node.value;
@@ -1068,13 +1060,12 @@ const noFinnishRule = ruleCreator({
 		const { esTreeNodeToTSNodeMap } = ESLintUtils.getParserServices(context);
 		const { couldBeObservable, couldReturnObservable } = getTypeServices(context);
 		function checkNode(nameNode, typeNode) {
-			if (couldBeObservable(typeNode ?? nameNode) || couldReturnObservable(typeNode ?? nameNode)) {
-				const tsNode = esTreeNodeToTSNodeMap.get(nameNode);
-				if (/\$+$/.test(tsNode.getText())) context.report({
-					loc: getLoc(tsNode),
-					messageId: "forbidden"
-				});
-			}
+			if (!couldBeObservable(typeNode ?? nameNode) && !couldReturnObservable(typeNode ?? nameNode)) return;
+			const tsNode = esTreeNodeToTSNodeMap.get(nameNode);
+			if (/\$+$/.test(tsNode.getText())) context.report({
+				loc: getLoc(tsNode),
+				messageId: "forbidden"
+			});
 		}
 		return {
 			"ArrayPattern > Identifier[name=/[$]+$/]": (node) => {
@@ -1208,8 +1199,11 @@ const noIgnoredDefaultValueRule = ruleCreator({
 	create: (context) => {
 		const { getTypeAtLocation } = ESLintUtils.getParserServices(context);
 		const { couldBeObservable, couldBeType } = getTypeServices(context);
+		function isDefaultValueProperty(property) {
+			return isProperty(property) && isIdentifier(property.key) && property.key.name === "defaultValue";
+		}
 		function checkConfigObj(configArg) {
-			if (!configArg.properties.some((p) => isProperty(p) && isIdentifier(p.key) && p.key.name === "defaultValue")) context.report({
+			if (configArg.properties.every((property) => !isDefaultValueProperty(property))) context.report({
 				messageId: "forbidden",
 				node: configArg
 			});
@@ -1296,8 +1290,11 @@ const noIgnoredErrorRule = ruleCreator({
 			if (callExpression.arguments.length >= 2) return false;
 			return couldBeFunction(callExpression.arguments[0]);
 		}
+		function isErrorProperty(property) {
+			return isProperty(property) && isIdentifier(property.key) && property.key.name === "error";
+		}
 		function isObjMissingError(arg) {
-			return !arg.properties.some((property) => isProperty(property) && isIdentifier(property.key) && property.key.name === "error");
+			return arg.properties.every((property) => !isErrorProperty(property));
 		}
 		function isTypeMissingError(arg) {
 			return !getTypeAtLocation(arg)?.getProperties().some((p) => p.name === "error");
@@ -1343,20 +1340,19 @@ const noIgnoredNotifierRule = ruleCreator({
 		}
 		return {
 			"CallExpression[callee.name=/^(repeatWhen|retryWhen)$/]": (node) => {
-				if (couldBeMonoTypeOperatorFunction(node)) {
-					const [arg] = node.arguments;
-					if (isArrowFunctionExpression(arg) || isFunctionExpression(arg)) {
-						const [param] = arg.params;
-						if (param) entries.push({
-							node,
-							param,
-							sightings: 0
-						});
-						else context.report({
-							messageId: "forbidden",
-							node: node.callee
-						});
-					}
+				if (!couldBeMonoTypeOperatorFunction(node)) return;
+				const [arg] = node.arguments;
+				if (isArrowFunctionExpression(arg) || isFunctionExpression(arg)) {
+					const [param] = arg.params;
+					if (param) entries.push({
+						node,
+						param,
+						sightings: 0
+					});
+					else context.report({
+						messageId: "forbidden",
+						node: node.callee
+					});
 				}
 			},
 			"CallExpression[callee.name=/^(repeatWhen|retryWhen)$/]:exit": (node) => {
@@ -1392,8 +1388,11 @@ const noIgnoredReplayBufferRule = ruleCreator({
 	},
 	name: "no-ignored-replay-buffer",
 	create: (context) => {
+		function isBufferSizeProperty(property) {
+			return isProperty(property) && isIdentifier(property.key) && property.key.name === "bufferSize";
+		}
 		function checkShareReplayConfig(node, shareReplayConfigArg) {
-			if (!shareReplayConfigArg.properties.some((p) => isProperty(p) && isIdentifier(p.key) && p.key.name === "bufferSize")) context.report({
+			if (shareReplayConfigArg.properties.every((p) => !isBufferSizeProperty(p))) context.report({
 				messageId: "forbidden",
 				node
 			});
@@ -1505,15 +1504,14 @@ The \`postCompleters\` property is an array containing the names of the operator
 			return false;
 		}
 		return { "ExpressionStatement > CallExpression > MemberExpression[property.name='subscribe']": (node) => {
-			if (couldBeObservable(node.object)) {
-				const callExpression = node.parent;
-				if (callExpression.arguments.length === 1 && couldBeType(callExpression.arguments[0], "Subscriber")) return;
-				if (hasAllowedOperator(node.object)) return;
-				context.report({
-					messageId: "forbidden",
-					node: node.property
-				});
-			}
+			if (!couldBeObservable(node.object)) return;
+			const callExpression = node.parent;
+			if (callExpression.arguments.length === 1 && couldBeType(callExpression.arguments[0], "Subscriber")) return;
+			if (hasAllowedOperator(node.object)) return;
+			context.report({
+				messageId: "forbidden",
+				node: node.property
+			});
 		} };
 	}
 });
@@ -1622,62 +1620,61 @@ const noImplicitAnyCatchRule = ruleCreator({
 			};
 		}
 		function checkCallback(callback) {
-			if (isArrowFunctionExpression(callback) || isFunctionExpression(callback)) {
-				const [param, ...restParams] = callback.params;
-				if (!param) return;
-				if (hasTypeAnnotation(param)) {
-					const { typeAnnotation } = param;
-					const { typeAnnotation: { type } } = typeAnnotation;
-					if (type === AST_NODE_TYPES.TSAnyKeyword) {
-						if (allowExplicitAny) return;
-						context.report({
-							messageId: "explicitAny",
-							node: param,
-							suggest: [{
-								messageId: "suggestExplicitUnknown",
-								fix: createReplacerFix(typeAnnotation, "unknown")
-							}]
-						});
-					} else if (type !== AST_NODE_TYPES.TSUnknownKeyword) {
-						let isAllowedError = false;
-						if (allowExplicitError && type === AST_NODE_TYPES.TSTypeReference) {
-							const typeRef = typeAnnotation.typeAnnotation;
-							if (isIdentifier(typeRef.typeName)) isAllowedError = typeRef.typeName.name === "Error";
-						}
-						if (!isAllowedError) context.report({
-							messageId: allowExplicitError ? "narrowedAllowError" : "narrowed",
-							node: param,
-							suggest: [
-								{
-									messageId: "suggestExplicitUnknown",
-									fix: createReplacerFix(typeAnnotation, "unknown")
-								},
-								allowExplicitAny ? {
-									messageId: "suggestExplicitAny",
-									fix: createReplacerFix(typeAnnotation, "any")
-								} : null,
-								allowExplicitError && !isAllowedError ? {
-									messageId: "suggestExplicitError",
-									fix: createReplacerFix(typeAnnotation, "Error")
-								} : null
-							].filter((x) => !!x)
-						});
-					}
-				} else {
-					const hasRestParams = restParams.length > 0;
+			if (!isArrowFunctionExpression(callback) && !isFunctionExpression(callback)) return;
+			const [param, ...restParams] = callback.params;
+			if (!param) return;
+			if (hasTypeAnnotation(param)) {
+				const { typeAnnotation } = param;
+				const { typeAnnotation: { type } } = typeAnnotation;
+				if (type === AST_NODE_TYPES.TSAnyKeyword) {
+					if (allowExplicitAny) return;
 					context.report({
-						fix: allowExplicitAny ? createInserterFix(param, "any", { hasRestParams }) : void 0,
-						messageId: "implicitAny",
+						messageId: "explicitAny",
 						node: param,
 						suggest: [{
 							messageId: "suggestExplicitUnknown",
-							fix: createInserterFix(param, "unknown", { hasRestParams })
-						}, allowExplicitAny ? {
-							messageId: "suggestExplicitAny",
-							fix: createInserterFix(param, "any", { hasRestParams })
-						} : null].filter((x) => !!x)
+							fix: createReplacerFix(typeAnnotation, "unknown")
+						}]
+					});
+				} else if (type !== AST_NODE_TYPES.TSUnknownKeyword) {
+					let isAllowedError = false;
+					if (allowExplicitError && type === AST_NODE_TYPES.TSTypeReference) {
+						const typeRef = typeAnnotation.typeAnnotation;
+						if (isIdentifier(typeRef.typeName)) isAllowedError = typeRef.typeName.name === "Error";
+					}
+					if (!isAllowedError) context.report({
+						messageId: allowExplicitError ? "narrowedAllowError" : "narrowed",
+						node: param,
+						suggest: [
+							{
+								messageId: "suggestExplicitUnknown",
+								fix: createReplacerFix(typeAnnotation, "unknown")
+							},
+							allowExplicitAny ? {
+								messageId: "suggestExplicitAny",
+								fix: createReplacerFix(typeAnnotation, "any")
+							} : null,
+							allowExplicitError && !isAllowedError ? {
+								messageId: "suggestExplicitError",
+								fix: createReplacerFix(typeAnnotation, "Error")
+							} : null
+						].filter((x) => !!x)
 					});
 				}
+			} else {
+				const hasRestParams = restParams.length > 0;
+				context.report({
+					fix: allowExplicitAny ? createInserterFix(param, "any", { hasRestParams }) : void 0,
+					messageId: "implicitAny",
+					node: param,
+					suggest: [{
+						messageId: "suggestExplicitUnknown",
+						fix: createInserterFix(param, "unknown", { hasRestParams })
+					}, allowExplicitAny ? {
+						messageId: "suggestExplicitAny",
+						fix: createInserterFix(param, "any", { hasRestParams })
+					} : null].filter((x) => !!x)
+				});
 			}
 		}
 		return {
@@ -1899,7 +1896,8 @@ const noMisusedObservablesRule = ruleCreator({
 			});
 		} };
 		function checkArguments(node) {
-			const voidArgs = voidFunctionArguments(checker, esTreeNodeToTSNodeMap.get(node));
+			const tsNode = esTreeNodeToTSNodeMap.get(node);
+			const voidArgs = voidFunctionArguments(checker, tsNode);
 			if (!voidArgs.size) return;
 			for (const [index, argument] of node.arguments.entries()) {
 				if (!voidArgs.has(index)) continue;
@@ -1919,7 +1917,8 @@ const noMisusedObservablesRule = ruleCreator({
 			});
 		}
 		function checkClassLikeOrInterfaceNode(node) {
-			const heritageTypes = getHeritageTypes(checker, esTreeNodeToTSNodeMap.get(node));
+			const tsNode = esTreeNodeToTSNodeMap.get(node);
+			const heritageTypes = getHeritageTypes(checker, tsNode);
 			if (!heritageTypes?.length) return;
 			for (const element of node.body.body) {
 				const tsElement = esTreeNodeToTSNodeMap.get(element);
@@ -1940,7 +1939,8 @@ const noMisusedObservablesRule = ruleCreator({
 			}
 		}
 		function checkProperty(node) {
-			const contextualType = getPropertyContextualType(checker, esTreeNodeToTSNodeMap.get(node));
+			const tsNode = esTreeNodeToTSNodeMap.get(node);
+			const contextualType = getPropertyContextualType(checker, tsNode);
 			if (contextualType == null) return;
 			if (!isVoidReturningFunctionType(contextualType)) return;
 			if (!couldReturnObservable(node.value)) return;
@@ -2593,7 +2593,7 @@ const noUnnecessaryCollectionRule = ruleCreator({
 			const firstArg = args[0];
 			if (isArrayExpression(firstArg)) {
 				const nonNullElements = firstArg.elements.filter((element) => element !== null);
-				if (nonNullElements.length === 1 && couldBeObservable(nonNullElements[0])) context.report({
+				if (nonNullElements.length === 1 && !isSpreadElement(nonNullElements[0]) && couldBeObservable(nonNullElements[0])) context.report({
 					messageId: "forbidden",
 					node: node.callee,
 					data: {
@@ -2750,19 +2750,18 @@ const noUnsafeSubjectNext = ruleCreator({
 		const { getTypeAtLocation, program } = ESLintUtils.getParserServices(context);
 		const typeChecker = program.getTypeChecker();
 		return { [`CallExpression[callee.property.name='next']`]: (node) => {
-			if (node.arguments.length === 0 && isMemberExpression(node.callee)) {
-				const type = getTypeAtLocation(node.callee.object);
-				if (tsutils.isTypeReference(type) && couldBeType(type, "Subject")) {
-					const [typeArg] = typeChecker.getTypeArguments(type);
-					if (tsutils.isTypeFlagSet(typeArg, ts.TypeFlags.Any)) return;
-					if (tsutils.isTypeFlagSet(typeArg, ts.TypeFlags.Unknown)) return;
-					if (tsutils.isTypeFlagSet(typeArg, ts.TypeFlags.Void)) return;
-					if (tsutils.isUnionType(typeArg) && typeArg.types.some((t) => tsutils.isTypeFlagSet(t, ts.TypeFlags.Void))) return;
-					context.report({
-						messageId: "forbidden",
-						node: node.callee.property
-					});
-				}
+			if (node.arguments.length !== 0 || !isMemberExpression(node.callee)) return;
+			const type = getTypeAtLocation(node.callee.object);
+			if (tsutils.isTypeReference(type) && couldBeType(type, "Subject")) {
+				const [typeArg] = typeChecker.getTypeArguments(type);
+				if (tsutils.isTypeFlagSet(typeArg, ts.TypeFlags.Any)) return;
+				if (tsutils.isTypeFlagSet(typeArg, ts.TypeFlags.Unknown)) return;
+				if (tsutils.isTypeFlagSet(typeArg, ts.TypeFlags.Void)) return;
+				if (tsutils.isUnionType(typeArg) && typeArg.types.some((t) => tsutils.isTypeFlagSet(t, ts.TypeFlags.Void))) return;
+				context.report({
+					messageId: "forbidden",
+					node: node.callee.property
+				});
 			}
 		} };
 	}
@@ -2841,7 +2840,7 @@ The \`observable\` property is used to identify the action observables from whic
 				if (isMemberExpression(arg) && isIdentifier(arg.property)) return arg.property.name;
 				return "";
 			}).map((name) => decamelize(name));
-			if (allowRegExp) return !names.every((name) => allowRegExp?.test(name));
+			if (allowRegExp) return names.some((name) => !allowRegExp?.test(name));
 			if (disallowRegExp) return names.some((name) => disallowRegExp?.test(name));
 			return false;
 		}
@@ -3007,7 +3006,7 @@ const RENAMED_OPERATORS = {
 	race: "raceWith",
 	zip: "zipWith"
 };
-const DEPRECATED_OPERATORS = new Set(["partition"]);
+const DEPRECATED_OPERATORS = /* @__PURE__ */ new Set(["partition"]);
 const preferRootOperatorsRule = ruleCreator({
 	meta: {
 		docs: {
@@ -3123,310 +3122,301 @@ const preferRootOperatorsRule = ruleCreator({
 //#endregion
 //#region src/rules/suffix-subjects.ts
 const baseShouldHaveSuffix = "Subject identifiers must end with \"{{suffix}}\".";
-const suffixSubjectsRule = ruleCreator({
-	meta: {
-		docs: {
-			description: "Enforce the use of a suffix in subject identifiers.",
-			requiresTypeChecking: true
-		},
-		messages: {
-			forbidden: baseShouldHaveSuffix,
-			forbiddenProperty: `${baseShouldHaveSuffix} Add a type annotation, assertion, or 'satisfies' to silence this rule.`
-		},
-		schema: [{
-			properties: {
-				parameters: {
-					type: "boolean",
-					description: "Require for parameters."
-				},
+//#endregion
+//#region src/index.ts
+const allRules = {
+	"ban-observables": banObservablesRule,
+	"ban-operators": banOperatorsRule,
+	"finnish": finnishRule,
+	"just": justRule,
+	"no-async-subscribe": noAsyncSubscribeRule,
+	"no-connectable": noConnectableRule,
+	"no-create": noCreateRule,
+	"no-cyclic-action": noCyclicActionRule,
+	"no-explicit-generics": noExplicitGenericsRule,
+	"no-exposed-subjects": noExposedSubjectsRule,
+	"no-finnish": noFinnishRule,
+	"no-floating-observables": noFloatingObservablesRule,
+	"no-ignored-default-value": noIgnoredDefaultValueRule,
+	"no-ignored-error": noIgnoredErrorRule,
+	"no-ignored-notifier": noIgnoredNotifierRule,
+	"no-ignored-replay-buffer": noIgnoredReplayBufferRule,
+	"no-ignored-subscribe": noIgnoredSubscribeRule,
+	"no-ignored-subscription": noIgnoredSubscriptionRule,
+	"no-ignored-takewhile-value": noIgnoredTakewhileValueRule,
+	"no-implicit-any-catch": noImplicitAnyCatchRule,
+	"no-index": noIndexRule,
+	"no-internal": noInternalRule,
+	"no-misused-observables": noMisusedObservablesRule,
+	"no-nested-subscribe": noNestedSubscribeRule,
+	"no-redundant-notify": noRedundantNotifyRule,
+	"no-sharereplay": noSharereplayRule,
+	"no-sharereplay-before-takeuntil": noSharereplayBeforeTakeuntilRule,
+	"no-subclass": noSubclassRule,
+	"no-subject-unsubscribe": noSubjectUnsubscribeRule,
+	"no-subject-value": noSubjectValueRule,
+	"no-subscribe-handlers": noSubscribeHandlersRule,
+	"no-subscribe-in-pipe": noSubscribeInPipeRule,
+	"no-topromise": noTopromiseRule,
+	"no-unbound-methods": noUnboundMethodsRule,
+	"no-unnecessary-collection": noUnnecessaryCollectionRule,
+	"no-unsafe-catch": noUnsafeCatchRule,
+	"no-unsafe-first": noUnsafeFirstRule,
+	"no-unsafe-subject-next": noUnsafeSubjectNext,
+	"no-unsafe-switchmap": noUnsafeSwitchmapRule,
+	"no-unsafe-takeuntil": noUnsafeTakeuntilRule,
+	"prefer-observer": preferObserverRule,
+	"prefer-root-operators": preferRootOperatorsRule,
+	"suffix-subjects": ruleCreator({
+		meta: {
+			docs: {
+				description: "Enforce the use of a suffix in subject identifiers.",
+				requiresTypeChecking: true
+			},
+			messages: {
+				forbidden: baseShouldHaveSuffix,
+				forbiddenProperty: `${baseShouldHaveSuffix} Add a type annotation, assertion, or 'satisfies' to silence this rule.`
+			},
+			schema: [{
 				properties: {
-					type: "boolean",
-					description: "Require for properties, except object literal keys (see \"objects\" option)."
-				},
-				objects: {
-					type: "boolean",
-					description: "Require for object literal keys."
-				},
-				suffix: {
-					type: "string",
-					description: "The suffix to enforce."
-				},
-				types: {
-					type: "object",
-					description: "Enforce for specific types. Keys are a RegExp, values are a boolean."
+					parameters: {
+						type: "boolean",
+						description: "Require for parameters."
+					},
+					properties: {
+						type: "boolean",
+						description: "Require for properties, except object literal keys (see \"objects\" option)."
+					},
+					objects: {
+						type: "boolean",
+						description: "Require for object literal keys."
+					},
+					suffix: {
+						type: "string",
+						description: "The suffix to enforce."
+					},
+					types: {
+						type: "object",
+						description: "Enforce for specific types. Keys are a RegExp, values are a boolean."
+					},
+					variables: {
+						type: "boolean",
+						description: "Require for variables."
+					}
 				},
-				variables: {
-					type: "boolean",
-					description: "Require for variables."
-				}
-			},
-			type: "object"
-		}],
-		type: "problem",
-		defaultOptions: [{
-			parameters: true,
-			properties: true,
-			objects: true,
-			suffix: "Subject",
-			types: { "^EventEmitter$": false },
-			variables: true
-		}]
-	},
-	name: "suffix-subjects",
-	create: (context) => {
-		const { esTreeNodeToTSNodeMap } = ESLintUtils.getParserServices(context);
-		const { couldBeType } = getTypeServices(context);
-		const [config] = context.options;
-		const types = [];
-		if (config.types) for (const [key, validate] of Object.entries(config.types)) types.push({
-			regExp: new RegExp(key),
-			validate
-		});
-		const { suffix = "Subject" } = config;
-		const suffixRegex = new RegExp(String.raw`${escapeRegExp(suffix)}\$?$`, "i");
-		function checkNode(nameNode, typeNode, shouldMessage = "forbidden") {
-			const tsNode = esTreeNodeToTSNodeMap.get(nameNode);
-			const text = tsNode.getText();
-			if (!suffixRegex.test(text) && couldBeType(typeNode ?? nameNode, "Subject")) {
-				for (const type of types) {
-					const { regExp, validate } = type;
-					if (couldBeType(typeNode ?? nameNode, regExp) && !validate) return;
+				type: "object"
+			}],
+			type: "problem",
+			defaultOptions: [{
+				parameters: true,
+				properties: true,
+				objects: true,
+				suffix: "Subject",
+				types: { "^EventEmitter$": false },
+				variables: true
+			}]
+		},
+		name: "suffix-subjects",
+		create: (context) => {
+			const { esTreeNodeToTSNodeMap } = ESLintUtils.getParserServices(context);
+			const { couldBeType } = getTypeServices(context);
+			const [config] = context.options;
+			const types = [];
+			if (config.types) for (const [key, validate] of Object.entries(config.types)) types.push({
+				regExp: new RegExp(key),
+				validate
+			});
+			const { suffix = "Subject" } = config;
+			const suffixRegex = new RegExp(String.raw`${escapeRegExp(suffix)}\$?$`, "i");
+			function checkNode(nameNode, typeNode, shouldMessage = "forbidden") {
+				const tsNode = esTreeNodeToTSNodeMap.get(nameNode);
+				const text = tsNode.getText();
+				if (!suffixRegex.test(text) && couldBeType(typeNode ?? nameNode, "Subject")) {
+					for (const type of types) {
+						const { regExp, validate } = type;
+						if (couldBeType(typeNode ?? nameNode, regExp) && !validate) return;
+					}
+					context.report({
+						data: { suffix },
+						loc: getLoc(tsNode),
+						messageId: shouldMessage
+					});
 				}
-				context.report({
-					data: { suffix },
-					loc: getLoc(tsNode),
-					messageId: shouldMessage
-				});
 			}
-		}
-		return {
-			"ArrayPattern > Identifier": (node) => {
-				const found = findParent(node, "ArrowFunctionExpression", "FunctionDeclaration", "FunctionExpression", "VariableDeclarator");
-				if (!found) return;
-				if (!config.variables && isVariableDeclarator(found)) return;
-				if (!config.parameters) return;
-				checkNode(node);
-			},
-			"ArrowFunctionExpression > Identifier": (node) => {
-				if (config.parameters) {
+			return {
+				"ArrayPattern > Identifier": (node) => {
+					const found = findParent(node, "ArrowFunctionExpression", "FunctionDeclaration", "FunctionExpression", "VariableDeclarator");
+					if (!found) return;
+					if (!config.variables && isVariableDeclarator(found)) return;
+					if (!config.parameters) return;
+					checkNode(node);
+				},
+				"ArrowFunctionExpression > Identifier": (node) => {
+					if (!config.parameters) return;
 					if (node !== node.parent.body) checkNode(node);
-				}
-			},
-			"PropertyDefinition[computed=false]": (node) => {
-				const anyNode = node;
-				if (config.properties) {
+				},
+				"PropertyDefinition[computed=false]": (node) => {
+					if (!config.properties) return;
 					if (node.override) return;
-					checkNode(anyNode.key);
-				}
-			},
-			"FunctionDeclaration > Identifier": (node) => {
-				if (config.parameters) {
+					checkNode(node.key);
+				},
+				"FunctionDeclaration > Identifier": (node) => {
+					if (!config.parameters) return;
 					if (node !== node.parent.id) checkNode(node);
-				}
-			},
-			"FunctionExpression > Identifier": (node) => {
-				if (config.parameters) {
+				},
+				"FunctionExpression > Identifier": (node) => {
+					if (!config.parameters) return;
 					if (node !== node.parent.id) checkNode(node);
-				}
-			},
-			"MethodDefinition[kind='get'][computed=false]": (node) => {
-				if (config.properties) {
+				},
+				"MethodDefinition[kind='get'][computed=false]": (node) => {
+					if (!config.properties) return;
 					if (node.override) return;
 					checkNode(node.key, node);
-				}
-			},
-			"MethodDefinition[kind='set'][computed=false]": (node) => {
-				if (config.properties) {
+				},
+				"MethodDefinition[kind='set'][computed=false]": (node) => {
+					if (!config.properties) return;
 					if (node.override) return;
 					checkNode(node.key, node);
+				},
+				"TSAbstractMethodDefinition[computed=false]": (node) => {
+					if (node.override) return;
+					if (config.properties && (node.kind === "get" || node.kind === "set")) checkNode(node.key, node);
+					if (config.parameters) for (const param of node.value.params) checkNode(param);
+				},
+				"ObjectExpression > Property[computed=false] > Identifier": (node) => {
+					if (!config.objects) return;
+					if (node !== node.parent.key) return;
+					const found = findParent(node, "CallExpression", "VariableDeclarator", "TSSatisfiesExpression", "TSAsExpression");
+					if (found) {
+						if (isCallExpression(found)) return;
+						else if (isVariableDeclarator(found) && !!found.id.typeAnnotation) return;
+						else if (isTSAsExpression(found) || isTSSatisfiesExpression(found)) return;
+					}
+					checkNode(node, void 0, "forbiddenProperty");
+				},
+				"ObjectPattern > Property > Identifier": (node) => {
+					const found = findParent(node, "ArrowFunctionExpression", "FunctionDeclaration", "FunctionExpression", "VariableDeclarator");
+					if (!found) return;
+					if (!config.variables && isVariableDeclarator(found)) return;
+					if (!config.parameters) return;
+					if (node === node.parent.value) checkNode(node);
+				},
+				"TSCallSignatureDeclaration > Identifier": (node) => {
+					if (config.parameters) checkNode(node);
+				},
+				"TSConstructSignatureDeclaration > Identifier": (node) => {
+					if (config.parameters) checkNode(node);
+				},
+				"TSMethodSignature > Identifier": (node) => {
+					if (config.parameters) checkNode(node);
+				},
+				"TSParameterProperty > Identifier": (node) => {
+					if (config.parameters || config.properties) checkNode(node);
+				},
+				"TSPropertySignature[computed=false]": (node) => {
+					if (config.properties) checkNode(node.key);
+				},
+				"VariableDeclarator > Identifier": (node) => {
+					const parent = node.parent;
+					if (config.variables && node === parent.id) checkNode(node);
 				}
+			};
+		}
+	}),
+	"throw-error": ruleCreator({
+		meta: {
+			docs: {
+				description: "Enforce passing only `Error` values to `throwError` or `Subject.error`.",
+				recommended: {
+					recommended: true,
+					strict: [{
+						allowThrowingAny: false,
+						allowThrowingUnknown: false
+					}]
+				},
+				requiresTypeChecking: true
 			},
-			"TSAbstractMethodDefinition[computed=false]": (node) => {
-				if (node.override) return;
-				if (config.properties && (node.kind === "get" || node.kind === "set")) checkNode(node.key, node);
-				if (config.parameters) for (const param of node.value.params) checkNode(param);
-			},
-			"ObjectExpression > Property[computed=false] > Identifier": (node) => {
-				if (!config.objects) return;
-				if (node !== node.parent.key) return;
-				const found = findParent(node, "CallExpression", "VariableDeclarator", "TSSatisfiesExpression", "TSAsExpression");
-				if (found) {
-					if (isCallExpression(found)) return;
-					else if (isVariableDeclarator(found) && !!found.id.typeAnnotation) return;
-					else if (isTSAsExpression(found) || isTSSatisfiesExpression(found)) return;
-				}
-				checkNode(node, void 0, "forbiddenProperty");
-			},
-			"ObjectPattern > Property > Identifier": (node) => {
-				const found = findParent(node, "ArrowFunctionExpression", "FunctionDeclaration", "FunctionExpression", "VariableDeclarator");
-				if (!found) return;
-				if (!config.variables && isVariableDeclarator(found)) return;
-				if (!config.parameters) return;
-				if (node === node.parent.value) checkNode(node);
-			},
-			"TSCallSignatureDeclaration > Identifier": (node) => {
-				if (config.parameters) checkNode(node);
-			},
-			"TSConstructSignatureDeclaration > Identifier": (node) => {
-				if (config.parameters) checkNode(node);
-			},
-			"TSMethodSignature > Identifier": (node) => {
-				if (config.parameters) checkNode(node);
-			},
-			"TSParameterProperty > Identifier": (node) => {
-				if (config.parameters || config.properties) checkNode(node);
-			},
-			"TSPropertySignature[computed=false]": (node) => {
-				if (config.properties) checkNode(node.key);
-			},
-			"VariableDeclarator > Identifier": (node) => {
-				const parent = node.parent;
-				if (config.variables && node === parent.id) checkNode(node);
-			}
-		};
-	}
-});
-//#endregion
-//#region src/rules/throw-error.ts
-const throwErrorRule = ruleCreator({
-	meta: {
-		docs: {
-			description: "Enforce passing only `Error` values to `throwError` or `Subject.error`.",
-			recommended: {
-				recommended: true,
-				strict: [{
-					allowThrowingAny: false,
-					allowThrowingUnknown: false
-				}]
+			hasSuggestions: true,
+			messages: {
+				forbidden: "Passing non-Error values is forbidden.",
+				suggestErrorConstructor: "Wrap string in Error constructor."
 			},
-			requiresTypeChecking: true
-		},
-		hasSuggestions: true,
-		messages: {
-			forbidden: "Passing non-Error values is forbidden.",
-			suggestErrorConstructor: "Wrap string in Error constructor."
-		},
-		schema: [{
-			properties: {
-				allowThrowingAny: {
-					type: "boolean",
-					description: "Whether to always allow throwing values typed as `any`."
+			schema: [{
+				properties: {
+					allowThrowingAny: {
+						type: "boolean",
+						description: "Whether to always allow throwing values typed as `any`."
+					},
+					allowThrowingUnknown: {
+						type: "boolean",
+						description: "Whether to always allow throwing values typed as `unknown`."
+					}
 				},
-				allowThrowingUnknown: {
-					type: "boolean",
-					description: "Whether to always allow throwing values typed as `unknown`."
+				type: "object"
+			}],
+			type: "problem",
+			defaultOptions: [{
+				allowThrowingAny: true,
+				allowThrowingUnknown: true
+			}]
+		},
+		name: "throw-error",
+		create: (context) => {
+			const { esTreeNodeToTSNodeMap, program, getTypeAtLocation } = ESLintUtils.getParserServices(context);
+			const { couldBeObservable, couldBeSubject } = getTypeServices(context);
+			const [{ allowThrowingAny, allowThrowingUnknown }] = context.options;
+			function checkThrowArgument(node, noFunction = false) {
+				let type = getTypeAtLocation(node);
+				let reportNode = node;
+				if (!noFunction && couldBeFunction(type)) {
+					reportNode = node.body ?? node;
+					const tsNode = esTreeNodeToTSNodeMap.get(node);
+					const annotation = tsNode.type;
+					const body = tsNode.body;
+					type = program.getTypeChecker().getTypeAtLocation(annotation ?? body);
 				}
-			},
-			type: "object"
-		}],
-		type: "problem",
-		defaultOptions: [{
-			allowThrowingAny: true,
-			allowThrowingUnknown: true
-		}]
-	},
-	name: "throw-error",
-	create: (context) => {
-		const { esTreeNodeToTSNodeMap, program, getTypeAtLocation } = ESLintUtils.getParserServices(context);
-		const { couldBeObservable, couldBeSubject } = getTypeServices(context);
-		const [{ allowThrowingAny, allowThrowingUnknown }] = context.options;
-		function checkThrowArgument(node, noFunction = false) {
-			let type = getTypeAtLocation(node);
-			let reportNode = node;
-			if (!noFunction && couldBeFunction(type)) {
-				reportNode = node.body ?? node;
-				const tsNode = esTreeNodeToTSNodeMap.get(node);
-				const annotation = tsNode.type;
-				const body = tsNode.body;
-				type = program.getTypeChecker().getTypeAtLocation(annotation ?? body);
+				if (allowThrowingAny && tsutils.isIntrinsicAnyType(type)) return;
+				if (allowThrowingUnknown && tsutils.isIntrinsicUnknownType(type)) return;
+				if (couldBeType(type, /^Error$/)) return;
+				const isString = isTemplateLiteral(reportNode) || isLiteral(reportNode) && typeof reportNode.value === "string";
+				context.report({
+					messageId: "forbidden",
+					node: reportNode,
+					...isString && { suggest: [{
+						messageId: "suggestErrorConstructor",
+						fix: (fixer) => {
+							const nodeText = context.sourceCode.getText(reportNode);
+							return fixer.replaceText(reportNode, `new Error(${nodeText})`);
+						}
+					}] }
+				});
 			}
-			if (allowThrowingAny && tsutils.isIntrinsicAnyType(type)) return;
-			if (allowThrowingUnknown && tsutils.isIntrinsicUnknownType(type)) return;
-			if (couldBeType(type, /^Error$/)) return;
-			const isString = isTemplateLiteral(reportNode) || isLiteral(reportNode) && typeof reportNode.value === "string";
-			context.report({
-				messageId: "forbidden",
-				node: reportNode,
-				...isString && { suggest: [{
-					messageId: "suggestErrorConstructor",
-					fix: (fixer) => {
-						const nodeText = context.sourceCode.getText(reportNode);
-						return fixer.replaceText(reportNode, `new Error(${nodeText})`);
-					}
-				}] }
-			});
-		}
-		function checkThrowError(node) {
-			if (couldBeObservable(node)) {
+			function checkThrowError(node) {
+				if (!couldBeObservable(node)) return;
 				const [arg] = node.arguments;
 				if (arg) checkThrowArgument(arg);
 			}
-		}
-		function checkSubjectError(node) {
-			if (isMemberExpression(node.callee) && couldBeSubject(node.callee.object)) {
+			function checkSubjectError(node) {
+				if (!isMemberExpression(node.callee) || !couldBeSubject(node.callee.object)) return;
 				const [arg] = node.arguments;
 				if (arg) checkThrowArgument(arg, true);
 			}
+			return {
+				"CallExpression[callee.name='throwError']": checkThrowError,
+				"CallExpression[callee.property.name='throwError']": checkThrowError,
+				"CallExpression[callee.property.name='error']": checkSubjectError
+			};
 		}
-		return {
-			"CallExpression[callee.name='throwError']": checkThrowError,
-			"CallExpression[callee.property.name='throwError']": checkThrowError,
-			"CallExpression[callee.property.name='error']": checkSubjectError
-		};
-	}
-});
+	})
+};
 const plugin = {
 	meta: {
 		name,
 		version,
 		namespace: "rxjs-x"
 	},
-	rules: {
-		"ban-observables": banObservablesRule,
-		"ban-operators": banOperatorsRule,
-		"finnish": finnishRule,
-		"just": justRule,
-		"no-async-subscribe": noAsyncSubscribeRule,
-		"no-connectable": noConnectableRule,
-		"no-create": noCreateRule,
-		"no-cyclic-action": noCyclicActionRule,
-		"no-explicit-generics": noExplicitGenericsRule,
-		"no-exposed-subjects": noExposedSubjectsRule,
-		"no-finnish": noFinnishRule,
-		"no-floating-observables": noFloatingObservablesRule,
-		"no-ignored-default-value": noIgnoredDefaultValueRule,
-		"no-ignored-error": noIgnoredErrorRule,
-		"no-ignored-notifier": noIgnoredNotifierRule,
-		"no-ignored-replay-buffer": noIgnoredReplayBufferRule,
-		"no-ignored-subscribe": noIgnoredSubscribeRule,
-		"no-ignored-subscription": noIgnoredSubscriptionRule,
-		"no-ignored-takewhile-value": noIgnoredTakewhileValueRule,
-		"no-implicit-any-catch": noImplicitAnyCatchRule,
-		"no-index": noIndexRule,
-		"no-internal": noInternalRule,
-		"no-misused-observables": noMisusedObservablesRule,
-		"no-nested-subscribe": noNestedSubscribeRule,
-		"no-redundant-notify": noRedundantNotifyRule,
-		"no-sharereplay": noSharereplayRule,
-		"no-sharereplay-before-takeuntil": noSharereplayBeforeTakeuntilRule,
-		"no-subclass": noSubclassRule,
-		"no-subject-unsubscribe": noSubjectUnsubscribeRule,
-		"no-subject-value": noSubjectValueRule,
-		"no-subscribe-handlers": noSubscribeHandlersRule,
-		"no-subscribe-in-pipe": noSubscribeInPipeRule,
-		"no-topromise": noTopromiseRule,
-		"no-unbound-methods": noUnboundMethodsRule,
-		"no-unnecessary-collection": noUnnecessaryCollectionRule,
-		"no-unsafe-catch": noUnsafeCatchRule,
-		"no-unsafe-first": noUnsafeFirstRule,
-		"no-unsafe-subject-next": noUnsafeSubjectNext,
-		"no-unsafe-switchmap": noUnsafeSwitchmapRule,
-		"no-unsafe-takeuntil": noUnsafeTakeuntilRule,
-		"prefer-observer": preferObserverRule,
-		"prefer-root-operators": preferRootOperatorsRule,
-		"suffix-subjects": suffixSubjectsRule,
-		"throw-error": throwErrorRule
-	}
+	/** Compatibility with `defineConfig` until https://github.com/typescript-eslint/typescript-eslint/issues/11543 is addressed. */
+	rules: allRules
 };
 const rxjsX = {
 	...plugin,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-rxjs-x",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Modern ESLint plugin for RxJS",
   "keywords": [
     "lint",
@@ -46,9 +46,6 @@
     "test": "vitest",
     "typecheck": "tsc --noEmit"
   },
-  "resolutions": {
-    "rolldown": "^1.0.0-rc.12"
-  },
   "dependencies": {
     "@typescript-eslint/utils": "^8.58.0",
     "decamelize": "^6.0.1",
@@ -56,34 +53,41 @@
   },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
+    "@fast-check/vitest": "^0.4.1",
     "@stylistic/eslint-plugin": "^5.10.0",
     "@types/common-tags": "^1.8.4",
-    "@types/node": "~20.19.37",
-    "@typescript-eslint/rule-tester": "^8.58.0",
+    "@types/node": "~20.19.43",
+    "@typescript-eslint/rule-tester": "^8.63.0",
     "@typescript/vfs": "^1.6.4",
-    "@vitest/coverage-v8": "^4.1.2",
-    "@vitest/eslint-plugin": "^1.6.13",
-    "bumpp": "^11.0.1",
+    "@vitest/coverage-v8": "^4.1.10",
+    "@vitest/eslint-plugin": "^1.6.23",
+    "bumpp": "^11.1.0",
     "common-tags": "^1.8.2",
-    "eslint": "^10.1.0",
+    "eslint": "^10.7.0",
     "eslint-config-flat-gitignore": "^2.3.0",
-    "eslint-doc-generator": "^3.3.2",
-    "eslint-import-resolver-typescript": "^4.4.4",
+    "eslint-doc-generator": "^3.6.0",
+    "eslint-import-resolver-typescript": "^4.4.5",
     "eslint-plugin-eslint-plugin": "patch:eslint-plugin-eslint-plugin@npm%3A7.3.1#~/.yarn/patches/eslint-plugin-eslint-plugin-npm-7.3.1-6b766f9a07.patch",
-    "eslint-plugin-import-x": "^4.16.2",
-    "eslint-plugin-n": "^17.24.0",
-    "eslint-plugin-package-json": "^0.91.1",
-    "eslint-plugin-perfectionist": "^5.7.0",
-    "eslint-plugin-regexp": "^3.1.0",
+    "eslint-plugin-import-x": "^4.17.1",
+    "eslint-plugin-n": "^18.2.2",
+    "eslint-plugin-package-json": "~1.3.0",
+    "eslint-plugin-perfectionist": "^5.10.0",
+    "eslint-plugin-regexp": "^3.1.1",
     "eslint-plugin-unicorn": "^64.0.0",
+    "fast-check": "^4.9.0",
     "jsonc-eslint-parser": "^3.1.0",
-    "markdownlint-cli2": "~0.22.0",
+    "markdownlint-cli2": "~0.23.0",
     "rxjs": "^7.8.2",
-    "tsdown": "^0.21.7",
-    "typescript": "~6.0.2",
-    "typescript-eslint": "^8.58.0",
-    "vite": "^8.0.3",
-    "vitest": "^4.1.2"
+    "tsdown": "^0.22.4",
+    "typescript": "~6.0.3",
+    "typescript-eslint": "^8.63.0",
+    "unrun": "~0.3.1",
+    "vitest": "^4.1.10"
+  },
+  "dependenciesMeta": {
+    "unrs-resolver": {
+      "built": false
+    }
   },
   "peerDependencies": {
     "eslint": "^10.0.1",
@@ -95,7 +99,7 @@
       "optional": true
     }
   },
-  "packageManager": "yarn@4.13.0+sha512.5c20ba010c99815433e5c8453112165e673f1c7948d8d2b267f4b5e52097538658388ebc9f9580656d9b75c5cc996f990f611f99304a2197d4c56d21eea370e7",
+  "packageManager": "yarn@4.17.1+sha512.ccbfabf7d7b6b32075088be9386fb9a2e00bb6887ef07fa56effabc890a56d53da1ccc4128d62db245fcbd3961b236d75335bdf7d5320ed6eafb7588b7ad4697",
   "engines": {
     "node": "^20.19.0 || ^22.13.0 || >=24"
   },