eslint-plugin-effector 0.18.0 → 0.19.0

package/dist/index.mjs

@@ -1,16 +1,16 @@
 import { ASTUtils, AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
 import { getContextualType, typeMatchesSpecifier } from "@typescript-eslint/type-utils";
-import { isExpression } from "typescript";
+import ts, { isExpression } from "typescript";
 import esquery from "esquery";
 //#region package.json
 var name = "eslint-plugin-effector";
-var version = "0.18.0";
+var version = "0.19.0";
 //#endregion
 //#region src/shared/create.ts
 const createRule = ESLintUtils.RuleCreator((name) => `https://eslint.effector.dev/rules/${name}`);
 //#endregion
 //#region src/shared/is.ts
-const check = (symbol, types, from) => {
+const check$1 = (symbol, types, from) => {
 	const name = symbol.getName();
 	const declarations = symbol.declarations ?? [];
 	return types.includes(name) && declarations.map((decl) => decl.getSourceFile().fileName).some((fname) => fname.includes("node_modules") && fname.includes(from));
@@ -31,6 +31,11 @@ const isType = {
 		package: "effector",
 		name: "Effect"
 	}, program),
+	domain: (type, program) => typeMatchesSpecifier(type, {
+		from: "package",
+		package: "effector",
+		name: "Domain"
+	}, program),
 	unit: (type, program) => {
 		return typeMatchesSpecifier(type, {
 			from: "package",
@@ -45,14 +50,9 @@ const isType = {
 			]
 		}, program);
 	},
-	domain: (type, program) => typeMatchesSpecifier(type, {
-		from: "package",
-		package: "effector",
-		name: "Domain"
-	}, program),
 	gate: (type) => {
 		const symbol = type.getSymbol() ?? type.aliasSymbol;
-		return symbol ? check(symbol, ["Gate"], "effector") : false;
+		return symbol ? check$1(symbol, ["Gate"], "effector") : false;
 	},
 	jsx: (type, program) => {
 		return typeMatchesSpecifier(type, {
@@ -87,7 +87,7 @@ var enforce_effect_naming_convention_default = createRule({
 		type: "problem",
 		docs: { description: "Enforce Fx as a suffix for any Effector Effect." },
 		messages: {
-			invalid: "Effect `{{ current }}` should be named with suffix, rename it to `{{ fixed }}`",
+			invalid: "Effect \"{{ current }}\" should be named with `Fx` suffix, rename it to \"{{ fixed }}\"",
 			rename: "Rename \"{{ current }}\" to \"{{ fixed }}\""
 		},
 		schema: [],
@@ -96,33 +96,188 @@ var enforce_effect_naming_convention_default = createRule({
 	defaultOptions: [],
 	create: (context) => {
 		const services = ESLintUtils.getParserServices(context);
-		return { [`VariableDeclarator[id.name!=${FxRegex}]`]: (node) => {
-			const type = services.getTypeAtLocation(node);
-			if (!isType.effect(type, services.program)) return;
-			const current = node.id.name;
-			const fixed = current + "Fx";
-			const data = {
-				current,
-				fixed
-			};
-			const suggestion = {
-				messageId: "rename",
-				data: {
-					current,
-					fixed
-				},
-				fix: (fixer) => fixer.replaceText(node.id, fixed)
-			};
-			context.report({
-				node: node.id,
-				messageId: "invalid",
-				data,
-				suggest: [suggestion]
-			});
-		} };
+		return {
+			[`${selector$14.variable}, ${selector$14.array.identifier}, ${selector$14.array.assignment}, ${selector$14.function.identifier}, ${selector$14.function.assignment}`]: (node) => {
+				const type = services.getTypeAtLocation(node);
+				if (!isType.effect(type, services.program)) return;
+				const data = {
+					current: node.name,
+					fixed: node.name + "Fx"
+				};
+				if (node.typeAnnotation) return context.report({
+					node,
+					messageId: "invalid",
+					data
+				});
+				const suggestion = {
+					messageId: "rename",
+					data: {
+						current: node.name,
+						fixed: data.fixed
+					},
+					fix: (fixer) => fixer.replaceText(node, data.fixed)
+				};
+				context.report({
+					node,
+					messageId: "invalid",
+					data,
+					suggest: [suggestion]
+				});
+			},
+			[`${selector$14.shape.identifier}, ${selector$14.shape.assignment}`]: (node) => {
+				const type = services.getTypeAtLocation(node.value);
+				const ident = node.value.type === AST_NODE_TYPES.Identifier ? node.value : node.value.left;
+				if (!isType.effect(type, services.program)) return;
+				const data = {
+					current: ident.name,
+					fixed: ident.name + "Fx"
+				};
+				const suggestion = {
+					messageId: "rename",
+					data: {
+						current: ident.name,
+						fixed: data.fixed
+					},
+					fix: (fixer) => node.shorthand ? fixer.insertTextAfter(node.key, `: ${data.fixed}`) : fixer.replaceText(ident, data.fixed)
+				};
+				context.report({
+					node: ident,
+					messageId: "invalid",
+					data,
+					suggest: [suggestion]
+				});
+			}
+		};
 	}
 });
 const FxRegex = /Fx$/;
+const selector$14 = {
+	variable: `VariableDeclarator > Identifier.id[name!=${FxRegex}]`,
+	array: {
+		identifier: `ArrayPattern > Identifier.elements[name!=${FxRegex}]`,
+		assignment: `ArrayPattern > AssignmentPattern > Identifier.left[name!=${FxRegex}]`
+	},
+	shape: {
+		identifier: `ObjectPattern > Property:has(> Identifier.value[name!=${FxRegex}])`,
+		assignment: `ObjectPattern > Property:has(> AssignmentPattern:has(> Identifier.left[name!=${FxRegex}]))`
+	},
+	function: {
+		identifier: `:function > Identifier.params[name!=${FxRegex}]`,
+		assignment: `:function > AssignmentPattern > Identifier.left[name!=${FxRegex}]`
+	}
+};
+//#endregion
+//#region src/shared/package.ts
+const PACKAGE_NAME$1 = {
+	core: /^effector(?:\u002Fcompat)?$/,
+	react: /^effector-react$/,
+	storage: /^@?effector-storage(\u002F[\w-]+)*$/
+};
+//#endregion
+//#region src/rules/enforce-exhaustive-useUnit-destructuring/enforce-exhaustive-useUnit-destructuring.ts
+var enforce_exhaustive_useUnit_destructuring_default = createRule({
+	name: "enforce-exhaustive-useUnit-destructuring",
+	meta: {
+		type: "problem",
+		docs: { description: "Ensure all units passed to useUnit are properly destructured." },
+		messages: {
+			unusedKey: "Property \"{{name}}\" is passed but not destructured.",
+			missingKey: "Property \"{{name}}\" is destructured but not passed in the unit object."
+		},
+		schema: [],
+		defaultOptions: []
+	},
+	create(context) {
+		const importedAs = /* @__PURE__ */ new Set();
+		return {
+			[selector$13.import]: (node) => void importedAs.add(node.local.name),
+			[`${selector$13.variable.shape}:has(> ${selector$13.call}:has(${selector$13.arg.shape}))`](node) {
+				if (!importedAs.has(node.init.callee.name)) return;
+				const provided = shapeToKeyMap(node.init.arguments[0]);
+				const consumed = shapeToKeyMap(node.id);
+				if (provided === null || consumed === null) return;
+				for (const { type, name } of check(provided, consumed)) if (type === "unused") context.report({
+					node: node.init.arguments[0],
+					messageId: "unusedKey",
+					data: { name }
+				});
+				else context.report({
+					node: node.id,
+					messageId: "missingKey",
+					data: { name }
+				});
+			},
+			[`${selector$13.variable.list}:has(> ${selector$13.call}:has(${selector$13.arg.list}))`](node) {
+				if (!importedAs.has(node.init.callee.name)) return;
+				const provided = listToKeyMap(node.init.arguments[0]);
+				const consumed = listToKeyMap(node.id);
+				if (provided === null || consumed === null) return;
+				for (const { type, name } of check(provided, consumed)) if (type === "unused") context.report({
+					node: node.init.arguments[0],
+					messageId: "unusedKey",
+					data: { name }
+				});
+				else context.report({
+					node: node.id,
+					messageId: "missingKey",
+					data: { name }
+				});
+			}
+		};
+	}
+});
+const selector$13 = {
+	import: `ImportDeclaration[source.value=${PACKAGE_NAME$1.react}] > ImportSpecifier[imported.name=useUnit]`,
+	variable: {
+		shape: "VariableDeclarator[id.type=ObjectPattern]",
+		list: "VariableDeclarator[id.type=ArrayPattern]"
+	},
+	call: "CallExpression.init[arguments.length=1][callee.type=Identifier]",
+	arg: {
+		shape: "ObjectExpression.arguments",
+		list: "ArrayExpression.arguments"
+	}
+};
+function toName$1(key, node) {
+	if (node.type === AST_NODE_TYPES.Identifier) return node.name;
+	if (node.type === AST_NODE_TYPES.Literal) return String(node.value);
+	if (node.type === AST_NODE_TYPES.MemberExpression && node.property.type === AST_NODE_TYPES.Identifier) return `${toName$1(key, node.object)}.${node.property.name}`;
+	return `<unknown at ${key}>`;
+}
+function toKey(prop) {
+	if (prop.computed) return null;
+	else if (prop.key.type === AST_NODE_TYPES.Identifier) return prop.key.name;
+	else return prop.key.value;
+}
+function* check(provided, consumed) {
+	for (const [key, node] of provided) if (!consumed.has(key)) yield {
+		type: "unused",
+		name: toName$1(key, node)
+	};
+	for (const [key, node] of consumed) if (!provided.has(key)) yield {
+		type: "missing",
+		name: toName$1(key, node)
+	};
+}
+function shapeToKeyMap(shape) {
+	const map = /* @__PURE__ */ new Map();
+	for (const prop of shape.properties) {
+		if (prop.type !== AST_NODE_TYPES.Property) return null;
+		const key = toKey(prop);
+		if (key === null) return null;
+		else map.set(key, prop.key);
+	}
+	return map;
+}
+function listToKeyMap(list) {
+	const map = /* @__PURE__ */ new Map();
+	for (const [index, element] of list.elements.entries()) {
+		if (element === null) continue;
+		if (element.type === AST_NODE_TYPES.RestElement || element.type === AST_NODE_TYPES.SpreadElement) return null;
+		map.set(index, element);
+	}
+	return map;
+}
 //#endregion
 //#region src/rules/enforce-gate-naming-convention/enforce-gate-naming-convention.ts
 var enforce_gate_naming_convention_default = createRule({
@@ -190,43 +345,81 @@ var enforce_store_naming_convention_default = createRule({
 	defaultOptions: [{ mode: "prefix" }],
 	create: (context, [options]) => {
 		const services = ESLintUtils.getParserServices(context);
-		return { [`VariableDeclarator[id.name=${options.mode === "prefix" ? PrefixRegex : PostfixRegex}]`]: (node) => {
-			const type = services.getTypeAtLocation(node);
-			if (!isType.store(type, services.program)) return;
-			const current = node.id.name;
-			const trimmed = current.replaceAll(options.mode === "prefix" ? /\$+$/g : /^\$+/g, "");
+		const selector = createSelector(options.mode === "prefix" ? PrefixRegex : PostfixRegex);
+		const rename = (node) => {
+			const trimmed = node.name.replace(options.mode === "prefix" ? /\$+$/g : /^\$+/g, "");
 			const fixed = options.mode === "prefix" ? `$${trimmed}` : `${trimmed}$`;
-			const data = {
-				current,
+			return {
+				current: node.name,
 				convention: options.mode,
 				fixed
 			};
-			const suggestion = {
-				messageId: "rename",
-				data: {
-					current,
-					fixed
-				},
-				fix: (fixer) => fixer.replaceText(node.id, fixed)
-			};
-			context.report({
-				node: node.id,
-				messageId: "invalid",
-				data,
-				suggest: [suggestion]
-			});
-		} };
+		};
+		return {
+			[`${selector.variable}, ${selector.array.identifier}, ${selector.array.assignment}, ${selector.function.identifier}, ${selector.function.assignment}`]: (node) => {
+				const type = services.getTypeAtLocation(node);
+				if (!isType.store(type, services.program)) return;
+				const data = rename(node);
+				if (node.typeAnnotation) return context.report({
+					node,
+					messageId: "invalid",
+					data
+				});
+				const suggestion = {
+					messageId: "rename",
+					data: {
+						current: node.name,
+						fixed: data.fixed
+					},
+					fix: (fixer) => fixer.replaceText(node, data.fixed)
+				};
+				context.report({
+					node,
+					messageId: "invalid",
+					data,
+					suggest: [suggestion]
+				});
+			},
+			[`${selector.shape.identifier}, ${selector.shape.assignment}`]: (node) => {
+				const type = services.getTypeAtLocation(node.value);
+				const ident = node.value.type === AST_NODE_TYPES.Identifier ? node.value : node.value.left;
+				if (!isType.store(type, services.program)) return;
+				const data = rename(ident);
+				const suggestion = {
+					messageId: "rename",
+					data: {
+						current: ident.name,
+						fixed: data.fixed
+					},
+					fix: (fixer) => node.shorthand ? fixer.insertTextAfter(node.key, `: ${data.fixed}`) : fixer.replaceText(ident, data.fixed)
+				};
+				context.report({
+					node: ident,
+					messageId: "invalid",
+					data,
+					suggest: [suggestion]
+				});
+			}
+		};
 	}
 });
 const PrefixRegex = /^[^$]/;
 const PostfixRegex = /[^$]$/;
-//#endregion
-//#region src/shared/package.ts
-const PACKAGE_NAME$1 = {
-	core: /^effector(?:\u002Fcompat)?$/,
-	react: /^effector-react$/,
-	storage: /^@?effector-storage(\u002F[\w-]+)*$/
-};
+const createSelector = (regex) => ({
+	variable: `VariableDeclarator > Identifier.id[name=${regex}]`,
+	array: {
+		identifier: `ArrayPattern > Identifier.elements[name=${regex}]`,
+		assignment: `ArrayPattern > AssignmentPattern > Identifier.left[name=${regex}]`
+	},
+	shape: {
+		identifier: `ObjectPattern > Property:has(> Identifier.value[name=${regex}])`,
+		assignment: `ObjectPattern > Property:has(> AssignmentPattern:has(> Identifier.left[name=${regex}]))`
+	},
+	function: {
+		identifier: `:function > Identifier.params[name=${regex}]`,
+		assignment: `:function > AssignmentPattern > Identifier.left[name=${regex}]`
+	}
+});
 //#endregion
 //#region src/rules/keep-options-order/keep-options-order.ts
 var keep_options_order_default = createRule({
@@ -246,8 +439,8 @@ var keep_options_order_default = createRule({
 		const source = context.sourceCode;
 		const imports = /* @__PURE__ */ new Set();
 		return {
-			[`${`ImportDeclaration[source.value=${PACKAGE_NAME$1.core}]`} > ${selector$11.method}`]: (node) => imports.add(node.local.name),
-			[`CallExpression${selector$11.call}:has(${selector$11.argument})`]: (node) => {
+			[`${`ImportDeclaration[source.value=${PACKAGE_NAME$1.core}]`} > ${selector$12.method}`]: (node) => imports.add(node.local.name),
+			[`CallExpression${selector$12.call}:has(${selector$12.argument})`]: (node) => {
 				if (!imports.has(node.callee.name)) return;
 				const [config] = node.arguments;
 				if (config.properties.some((prop) => prop.type === AST_NODE_TYPES.SpreadElement || prop.key.type !== AST_NODE_TYPES.Identifier)) return;
@@ -286,7 +479,7 @@ const TRUE_ORDER = [
 	"batch",
 	"name"
 ];
-const selector$11 = {
+const selector$12 = {
 	method: `ImportSpecifier[imported.name=/(sample|guard)/]`,
 	call: `[callee.type="Identifier"][arguments.length=1]`,
 	argument: `ObjectExpression.arguments`
@@ -311,70 +504,109 @@ function functionToName(node) {
 	if (node.parent.type === AST_NODE_TYPES.AssignmentPattern && node.parent.left.type === AST_NODE_TYPES.Identifier) return node.parent.left;
 	return null;
 }
-const nameOf = { function: functionToName };
+function calleeToName(callee) {
+	if (callee.type === AST_NODE_TYPES.Identifier) return callee;
+	else if (callee.type === AST_NODE_TYPES.MemberExpression && callee.property.type === AST_NODE_TYPES.Identifier) return callee.property;
+	else return null;
+}
+function simpleExpressionToName(node) {
+	if (node.type === AST_NODE_TYPES.Identifier) return node.name;
+	if (node.type === AST_NODE_TYPES.MemberExpression && !node.computed) return node.property.name;
+	return null;
+}
+const nameOf = {
+	function: functionToName,
+	callee: calleeToName,
+	expression: { simple: simpleExpressionToName }
+};
 //#endregion
 //#region src/rules/mandatory-scope-binding/mandatory-scope-binding.ts
 var mandatory_scope_binding_default = createRule({
 	name: "mandatory-scope-binding",
 	meta: {
 		type: "problem",
-		docs: { description: "Forbid `Event` and `Effect` usage without `useUnit` in React components." },
-		messages: { useUnitNeeded: "\"{{ name }}\" must be wrapped with `useUnit` from `effector-react` before usage inside React components." },
+		docs: { description: "Forbid `Event` and `Effect` usage without `useUnit` in React." },
+		messages: { useUnitNeeded: "\"{{ name }}\" must be wrapped with `useUnit` from `effector-react` before usage inside React." },
 		schema: []
 	},
 	defaultOptions: [],
 	create: (context) => {
 		const services = ESLintUtils.getParserServices(context);
 		const checker = services.program.getTypeChecker();
-		const stack = {
-			render: [],
-			hook: []
+		const inRender = [];
+		const inHook = [];
+		/** check if the expression is used in a context specifically expecting a unit */
+		const isExpectingUnit = (slot) => {
+			const tsnode = services.esTreeNodeToTSNodeMap.get(slot);
+			const type = checker.getContextualType(tsnode);
+			if (type) return isType.event(type, services.program) || isType.effect(type, services.program);
+			else return false;
+		};
+		const check = (mode, node) => {
+			if (!(inRender.at(-1) ?? false)) return;
+			const type = services.getTypeAtLocation(node);
+			if (!isType.event(type, services.program) && !isType.effect(type, services.program)) return;
+			if (mode === "call") return report(node);
+			const delegated = isExpectingUnit(node);
+			if ((mode === "jsx" || (inHook.at(-1) ?? false)) && delegated) return;
+			else return report(node);
+		};
+		const report = (node) => {
+			const name = nameOf.expression.simple(node) ?? "<expression>";
+			context.report({
+				node,
+				messageId: "useUnitNeeded",
+				data: { name }
+			});
 		};
 		return {
-			[`FunctionDeclaration, FunctionExpression, ArrowFunctionExpression`]: (node) => {
-				if (stack.render.at(-1) ?? false) return void stack.render.push(true);
+			[`:matches(${selector$11.function})`]: (node) => {
+				if (inRender.at(-1) ?? false) return void inRender.push(true);
 				const name = nameOf.function(node);
-				if (name && UseRegex$1.test(name.name)) return void stack.render.push(true);
+				if (name && UseRegex$1.test(name.name)) return void inRender.push(true);
 				const tsnode = services.esTreeNodeToTSNodeMap.get(node);
 				const signature = checker.getSignatureFromDeclaration(tsnode);
 				const returnType = signature ? checker.getReturnTypeOfSignature(signature) : checker.getVoidType();
-				if (returnType.isUnion() ? returnType.types.some((type) => isType.jsx(type, services.program)) : isType.jsx(returnType, services.program)) return void stack.render.push(true);
-				const inferred = isExpression(tsnode) && getContextualType(checker, tsnode) || checker.getUnknownType();
-				if (inferred.isUnion() ? inferred.types.some((type) => isType.component(type, services.program)) : isType.component(inferred, services.program)) return void stack.render.push(true);
-				stack.render.push(false);
+				if (returnType.isUnion() ? returnType.types.some((type) => isType.jsx(type, services.program)) : isType.jsx(returnType, services.program)) return void inRender.push(true);
+				const inferred = ts.isExpression(tsnode) && getContextualType(checker, tsnode) || checker.getUnknownType();
+				if (inferred.isUnion() ? inferred.types.some((type) => isType.component(type, services.program)) : isType.component(inferred, services.program)) return void inRender.push(true);
+				inRender.push(false);
 			},
-			[`:matches(FunctionDeclaration, FunctionExpression, ArrowFunctionExpression):exit`]: () => void stack.render.pop(),
-			"ClassDeclaration": () => void stack.render.push(false),
-			"ClassDeclaration:exit": () => void stack.render.pop(),
+			[`:matches(${selector$11.function}):exit`]: () => void inRender.pop(),
+			"ClassDeclaration": () => void inRender.push(false),
+			"ClassDeclaration:exit": () => void inRender.pop(),
 			"CallExpression": (node) => {
-				const isHook = typeMatchesSpecifier(services.getTypeAtLocation(node.callee), {
-					from: "package",
-					package: "effector-react",
-					name: [
-						"useStore",
-						"useStoreMap",
-						"useList",
-						"useEvent",
-						"useUnit"
-					]
-				}, services.program);
-				stack.hook.push(isHook);
+				const id = nameOf.callee(node.callee), isEnteringHook = id !== null && UseRegex$1.test(id.name);
+				inHook.push(isEnteringHook);
 			},
-			"Identifier": (node) => {
-				if (!(stack.render.at(-1) ?? false)) return;
-				if (stack.hook.at(-1) ?? false) return;
-				const type = services.getTypeAtLocation(node);
-				if (!isType.event(type, services.program) && !isType.effect(type, services.program)) return;
-				context.report({
-					node,
-					messageId: "useUnitNeeded",
-					data: { name: node.name }
-				});
-			}
+			"CallExpression:exit": () => void inHook.pop(),
+			[`${selector$11.callee.direct}, ${selector$11.callee.member}`]: (node) => check("call", node),
+			[`${selector$11.arg.direct}, ${selector$11.arg.member}`]: (node) => check("arg", node),
+			[`${selector$11.prop.direct}, ${selector$11.prop.member}`]: (node) => check("prop", node),
+			[`${selector$11.jsx.direct}, ${selector$11.jsx.member}`]: (node) => check("jsx", node)
 		};
 	}
 });
 const UseRegex$1 = /^use[A-Z0-9].*$/;
+const selector$11 = {
+	function: "FunctionDeclaration, FunctionExpression, ArrowFunctionExpression",
+	callee: {
+		direct: "CallExpression > Identifier.callee",
+		member: "CallExpression > MemberExpression[computed=false].callee"
+	},
+	arg: {
+		direct: "CallExpression > Identifier:not(.callee)",
+		member: "CallExpression > MemberExpression[computed=false]:not(.callee)"
+	},
+	prop: {
+		direct: "CallExpression > ObjectExpression > Property > Identifier.value",
+		member: "CallExpression > ObjectExpression > Property > MemberExpression[computed=false].value"
+	},
+	jsx: {
+		direct: "JSXExpressionContainer > Identifier",
+		member: "JSXExpressionContainer > MemberExpression[computed=false]"
+	}
+};
 //#endregion
 //#region src/shared/locate.ts
 const property = (key, node) => node.properties.find((prop) => prop.type == AST_NODE_TYPES.Property && prop.key.type === AST_NODE_TYPES.Identifier && prop.key.name === key);
@@ -713,7 +945,7 @@ var no_getState_default = createRule({
 		return { [`CallExpression[callee.type="MemberExpression"][callee.property.name="getState"]`]: (node) => {
 			const type = services.getTypeAtLocation(node.callee.object);
 			if (!isType.store(type, services.program)) return;
-			const name = toName$1(node.callee.object);
+			const name = nameOf.expression.simple(node.callee.object);
 			if (name) context.report({
 				node,
 				messageId: "named",
@@ -726,11 +958,6 @@ var no_getState_default = createRule({
 		} };
 	}
 });
-const toName$1 = (node) => {
-	if (node.type === AST_NODE_TYPES.Identifier) return node.name;
-	if (node.type === AST_NODE_TYPES.MemberExpression && !node.computed) return node.property.name;
-	return null;
-};
 //#endregion
 //#region src/rules/no-guard/no-guard.ts
 var no_guard_default = createRule({
@@ -1028,6 +1255,8 @@ function hasEffectorUnitInType(ctx, type, depth = 3) {
 }
 function isEffectorFactorioHook(callee, getTypeAtLocation) {
 	if (callee.type !== AST_NODE_TYPES.MemberExpression) return false;
+	if (callee.property.type !== AST_NODE_TYPES.Identifier) return false;
+	if (callee.property.name !== "useModel") return false;
 	const objectType = getTypeAtLocation(callee.object);
 	const propertyNames = new Set(objectType.getProperties().map((p) => p.getName()));
 	return EFFECTOR_FACTORIO_SHAPE.every((name) => propertyNames.has(name));
@@ -1218,10 +1447,8 @@ var no_useless_methods_default = createRule({
 					if (locate.property("target", config)?.value) return;
 				}
 				const grandparent = node.parent.parent;
-				if (grandparent) {
-					const ancestry = source.getAncestors(grandparent);
-					if (esquery.matches(grandparent, query.watch, ancestry, { visitorKeys })) return;
-				}
+				const ancestry = source.getAncestors(grandparent);
+				if (esquery.matches(grandparent, query.watch, ancestry, { visitorKeys })) return;
 				const method = node.callee.name;
 				context.report({
 					node,
@@ -1351,7 +1578,6 @@ var strict_effect_handlers_default = createRule({
 		};
 		const exit = (node) => {
 			const scope = stack.pop();
-			if (!scope) return;
 			if (scope.effect && scope.regular) context.report({
 				node,
 				messageId: "mixed"
@@ -1390,6 +1616,7 @@ const ruleset = {
 	},
 	react: {
 		"effector/enforce-gate-naming-convention": "error",
+		"effector/enforce-exhaustive-useUnit-destructuring": "warn",
 		"effector/mandatory-scope-binding": "error",
 		"effector/no-units-spawn-in-render": "error",
 		"effector/prefer-useUnit": "error"
@@ -1406,6 +1633,7 @@ const base = {
 	},
 	rules: {
 		"enforce-effect-naming-convention": enforce_effect_naming_convention_default,
+		"enforce-exhaustive-useUnit-destructuring": enforce_exhaustive_useUnit_destructuring_default,
 		"enforce-gate-naming-convention": enforce_gate_naming_convention_default,
 		"enforce-store-naming-convention": enforce_store_naming_convention_default,
 		"keep-options-order": keep_options_order_default,