eslint-plugin-effector 0.17.0 → 0.19.0

package/dist/index.mjs

@@ -1,14 +1,19 @@
 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.17.0";
-const createRule = ESLintUtils.RuleCreator((name$1) => `https://eslint.effector.dev/rules/${name$1}`);
-const check = (symbol, types, from) => {
-	const name$1 = symbol.getName();
+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$1 = (symbol, types, from) => {
+	const name = symbol.getName();
 	const declarations = symbol.declarations ?? [];
-	return types.includes(name$1) && declarations.map((decl) => decl.getSourceFile().fileName).some((fname) => fname.includes("node_modules") && fname.includes(from));
+	return types.includes(name) && declarations.map((decl) => decl.getSourceFile().fileName).some((fname) => fname.includes("node_modules") && fname.includes(from));
 };
 const isType = {
 	store: (type, program) => typeMatchesSpecifier(type, {
@@ -26,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",
@@ -35,18 +45,14 @@ const isType = {
 				"StoreWritable",
 				"Event",
 				"EventCallable",
-				"Effect"
+				"Effect",
+				"Domain"
 			]
 		}, 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, {
@@ -73,13 +79,15 @@ const isType = {
 		}, program);
 	}
 };
+//#endregion
+//#region src/rules/enforce-effect-naming-convention/enforce-effect-naming-convention.ts
 var enforce_effect_naming_convention_default = createRule({
 	name: "enforce-effect-naming-convention",
 	meta: {
 		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: [],
@@ -88,33 +96,190 @@ 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({
 	name: "enforce-gate-naming-convention",
 	meta: {
@@ -157,6 +322,8 @@ var enforce_gate_naming_convention_default = createRule({
 	}
 });
 const GateRegex = /^[^A-Z]/;
+//#endregion
+//#region src/rules/enforce-store-naming-convention/enforce-store-naming-convention.ts
 var enforce_store_naming_convention_default = createRule({
 	name: "enforce-store-naming-convention",
 	meta: {
@@ -178,41 +345,83 @@ 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 = /[^$]$/;
-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({
 	name: "keep-options-order",
 	meta: {
@@ -230,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;
@@ -270,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`
@@ -285,6 +494,8 @@ const isCorrectOrder = (current) => {
 	}
 	return true;
 };
+//#endregion
+//#region src/shared/name.ts
 function functionToName(node) {
 	if (node.id) return node.id;
 	if (node.parent.type === AST_NODE_TYPES.VariableDeclarator && node.parent.id.type === AST_NODE_TYPES.Identifier) return node.parent.id;
@@ -293,70 +504,115 @@ 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);
-				const name$1 = nameOf.function(node);
-				if (name$1 && UseRegex.test(name$1.name)) 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 inRender.push(true);
 				const tsnode = services.esTreeNodeToTSNodeMap.get(node);
 				const signature = checker.getSignatureFromDeclaration(tsnode);
 				const returnType = signature ? checker.getReturnTypeOfSignature(signature) : checker.getVoidType();
-				if (isType.jsx(returnType, services.program)) return void stack.render.push(true);
-				const inferred = isExpression(tsnode) ? getContextualType(checker, tsnode) : void 0;
-				if (inferred ? isType.component(inferred, services.program) : false) 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 = /^use[A-Z0-9].*$/;
+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);
 const locate = { property };
+//#endregion
+//#region src/rules/no-ambiguity-target/no-ambiguity-target.ts
 var no_ambiguity_target_default = createRule({
 	name: "no-ambiguity-target",
 	meta: {
@@ -396,6 +652,8 @@ var no_ambiguity_target_default = createRule({
 	}
 });
 const selector$10 = { method: `ImportSpecifier[imported.name=/(sample|guard)/]` };
+//#endregion
+//#region src/rules/no-domain-unit-creators/no-domain-unit-creators.ts
 var no_domain_unit_creators_default = createRule({
 	name: "no-domain-unit-creators",
 	meta: {
@@ -408,16 +666,16 @@ var no_domain_unit_creators_default = createRule({
 	create: (context) => {
 		const services = ESLintUtils.getParserServices(context);
 		return { [`CallExpression:has(> ${selector$9.member})`]: (node) => {
-			const name$1 = node.callee.property.name;
-			if (!METHODS.has(name$1)) return;
+			const name = node.callee.property.name;
+			if (!METHODS.has(name)) return;
 			const type = services.getTypeAtLocation(node.callee.object);
 			if (!isType.domain(type, services.program)) return;
-			const factory = ALIAS_MAP.get(name$1) ?? name$1;
+			const factory = ALIAS_MAP.get(name) ?? name;
 			context.report({
 				node,
 				messageId: "avoid",
 				data: {
-					method: name$1,
+					method: name,
 					factory
 				}
 			});
@@ -427,6 +685,8 @@ var no_domain_unit_creators_default = createRule({
 const ALIAS_MAP = (/* @__PURE__ */ new Map()).set("event", "createEvent").set("store", "createStore").set("effect", "createEffect").set("domain", "createDomain");
 const METHODS = new Set([...ALIAS_MAP.values(), ...ALIAS_MAP.keys()]);
 const selector$9 = { member: `MemberExpression.callee[property.type="Identifier"]` };
+//#endregion
+//#region src/rules/no-duplicate-clock-or-source-array-values/no-duplicate-clock-or-source-array-values.ts
 var no_duplicate_clock_or_source_array_values_default = createRule({
 	name: "no-duplicate-clock-or-source-array-values",
 	meta: {
@@ -449,19 +709,19 @@ var no_duplicate_clock_or_source_array_values_default = createRule({
 			for (const entry of entries) {
 				const root = traverseToRoot$1(entry);
 				if (!root) continue;
-				const name$1 = [root.node.name, ...root.path].join(".");
-				if (seen.has(name$1)) report(entry, name$1, field);
-				else seen.set(name$1, entry);
+				const name = [root.node.name, ...root.path].join(".");
+				if (seen.has(name)) report(entry, name, field);
+				else seen.set(name, entry);
 			}
 		};
-		const report = (node, name$1, field) => {
+		const report = (node, name, field) => {
 			const data = {
 				field,
-				unit: name$1
+				unit: name
 			};
 			const suggestion = {
 				messageId: "remove",
-				data: { unit: name$1 },
+				data: { unit: name },
 				fix: function* (fixer) {
 					yield fixer.remove(node);
 					const before = context.sourceCode.getTokenBefore(node);
@@ -501,6 +761,8 @@ function traverseToRoot$1(node, path = []) {
 	if (node.type === AST_NODE_TYPES.MemberExpression && node.property.type === AST_NODE_TYPES.Identifier) return traverseToRoot$1(node.object, [node.property.name, ...path]);
 	return null;
 }
+//#endregion
+//#region src/rules/no-duplicate-on/no-duplicate-on.ts
 var no_duplicate_on_default = createRule({
 	name: "no-duplicate-on",
 	meta: {
@@ -519,12 +781,12 @@ var no_duplicate_on_default = createRule({
 			const arg = node.arguments[0];
 			if (!arg || arg.type === AST_NODE_TYPES.SpreadElement) return;
 			const units = arg.type === AST_NODE_TYPES.ArrayExpression ? arg.elements.filter((item) => item !== null && item.type !== AST_NODE_TYPES.SpreadElement) : [arg];
-			const scope$1 = context.sourceCode.getScope(node);
-			const store = identify("store", node.callee.object, scope$1);
+			const scope = context.sourceCode.getScope(node);
+			const store = identify("store", node.callee.object, scope);
 			if (!store) return;
 			const set = map.get(store.id) ?? /* @__PURE__ */ new Set();
 			for (const unit of units) {
-				const instance = identify("unit", unit, scope$1);
+				const instance = identify("unit", unit, scope);
 				if (!instance) continue;
 				if (set.has(instance.id)) {
 					const data = {
@@ -585,16 +847,18 @@ function findSuitableRoot(type, node) {
 	};
 	return null;
 }
-function identify(type, node, scope$1) {
+function identify(type, node, scope) {
 	const root = findSuitableRoot(type, node);
 	if (!root) return null;
-	const variable = ASTUtils.findVariable(scope$1, root.node);
+	const variable = ASTUtils.findVariable(scope, root.node);
 	if (!variable) return null;
 	return {
 		id: `${variable.$id}+${root.path.join(".")}`,
 		name: [variable.name, ...root.path].join(".")
 	};
 }
+//#endregion
+//#region src/rules/no-forward/no-forward.ts
 var no_forward_default = createRule({
 	name: "no-forward",
 	meta: {
@@ -624,11 +888,11 @@ var no_forward_default = createRule({
 				config.clock = locate.property("from", arg)?.value;
 				config.target = locate.property("to", arg)?.value;
 				if (config.target) {
-					const [call] = esquery.match(config.target, query$2.prepend, { visitorKeys }).map((node$1) => node$1).filter((node$1) => node$1 === config.target);
+					const [call] = esquery.match(config.target, query$2.prepend, { visitorKeys }).map((node) => node).filter((node) => node === config.target);
 					if (call) [config.target, config.fn] = [call.callee.object, call.arguments[0]];
 				}
 				if (config.clock && !config.fn) {
-					const [call] = esquery.match(config.clock, query$2.map, { visitorKeys }).map((node$1) => node$1).filter((node$1) => node$1 === config.clock);
+					const [call] = esquery.match(config.clock, query$2.map, { visitorKeys }).map((node) => node).filter((node) => node === config.clock);
 					if (call) [config.clock, config.fn] = [call.callee.object, call.arguments[0]];
 				}
 				const code = [
@@ -662,6 +926,8 @@ const query$2 = {
 	map: esquery.parse("CallExpression[arguments.length=1]:has(> :first-child:expression.arguments):has(> MemberExpression.callee:has(Identifier.property[name='map']))"),
 	prepend: esquery.parse("CallExpression[arguments.length=1]:has(> :first-child:expression.arguments):has(> MemberExpression.callee:has(Identifier.property[name='prepend']))")
 };
+//#endregion
+//#region src/rules/no-getState/no-getState.ts
 var no_getState_default = createRule({
 	name: "no-getState",
 	meta: {
@@ -679,11 +945,11 @@ 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$1 = toName$1(node.callee.object);
-			if (name$1) context.report({
+			const name = nameOf.expression.simple(node.callee.object);
+			if (name) context.report({
 				node,
 				messageId: "named",
-				data: { name: name$1 }
+				data: { name }
 			});
 			else context.report({
 				node,
@@ -692,11 +958,8 @@ 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({
 	name: "no-guard",
 	meta: {
@@ -740,7 +1003,7 @@ var no_guard_default = createRule({
 					]) config[key] = locate.property(key, arg)?.value;
 				} else return;
 				if (config.target) {
-					const [call] = esquery.match(config.target, query$1.prepend, { visitorKeys }).map((node$1) => node$1).filter((node$1) => node$1 === config.target);
+					const [call] = esquery.match(config.target, query$1.prepend, { visitorKeys }).map((node) => node).filter((node) => node === config.target);
 					if (call) [config.target, config.fn] = [call.callee.object, call.arguments[0]];
 				}
 				const code = [
@@ -772,6 +1035,8 @@ const selector$6 = {
 	call: `[callee.type="Identifier"]`
 };
 const query$1 = { prepend: esquery.parse("CallExpression[arguments.length=1]:has(:first-child:expression.arguments):has(> MemberExpression.callee:has(Identifier.property[name='prepend']))") };
+//#endregion
+//#region src/rules/no-patronum-debug/no-patronum-debug.ts
 var no_patronum_debug_default = createRule({
 	name: "no-patronum-debug",
 	meta: {
@@ -790,8 +1055,8 @@ var no_patronum_debug_default = createRule({
 		return {
 			[`${`ImportDeclaration[source.value=${PACKAGE_NAME}]`} > ${selector$5.debug}`]: (node) => debugs.add(node.local.name),
 			[`CallExpression:matches(${selector$5.call})`]: (node) => {
-				const name$1 = toName(node);
-				if (!debugs.has(name$1)) return;
+				const name = toName(node);
+				if (!debugs.has(name)) return;
 				context.report({
 					messageId: "unexpected",
 					node: node.callee,
@@ -818,6 +1083,186 @@ const toName = (node) => {
 		case AST_NODE_TYPES.MemberExpression: return node.callee.object.name;
 	}
 };
+//#endregion
+//#region src/rules/no-units-spawn-in-render/no-units-spawn-in-render.ts
+const EFFECTOR_FACTORIES = new Set([
+	"createStore",
+	"createEvent",
+	"createEffect",
+	"createDomain",
+	"createApi",
+	"restore"
+]);
+const EFFECTOR_OPERATORS = new Set([
+	"sample",
+	"guard",
+	"forward",
+	"merge",
+	"split",
+	"combine",
+	"attach"
+]);
+const REACT_HOOKS_SPEC = {
+	from: "package",
+	package: "react",
+	name: [
+		"useState",
+		"useEffect",
+		"useLayoutEffect",
+		"useCallback",
+		"useMemo",
+		"useRef",
+		"useReducer",
+		"useImperativeHandle",
+		"useDebugValue",
+		"useDeferredValue",
+		"useTransition",
+		"useId",
+		"useSyncExternalStore",
+		"useInsertionEffect",
+		"useContext"
+	]
+};
+const EFFECTOR_FACTORY_SPEC = {
+	from: "package",
+	package: "effector",
+	name: [...EFFECTOR_FACTORIES]
+};
+const EFFECTOR_OPERATOR_SPEC = {
+	from: "package",
+	package: "effector",
+	name: [...EFFECTOR_OPERATORS]
+};
+const EFFECTOR_FACTORIO_SHAPE = [
+	"useModel",
+	"createModel",
+	"Provider",
+	"@@unitShape"
+];
+var no_units_spawn_in_render_default = createRule({
+	name: "no-units-spawn-in-render",
+	meta: {
+		type: "problem",
+		docs: { description: "Forbid creating Effector units or calling operators inside React components or hooks." },
+		messages: {
+			noFactoryInRender: "Creating Effector units with \"{{ name }}\" inside React component or hook is forbidden, since it may cause memory leaks and other bugs.",
+			noOperatorInRender: "Using Effector operator \"{{ name }}\" inside React component or hook is forbidden, since it may cause memory leaks and other bugs.",
+			noCustomFactoryInRender: "Creating Effector units with \"{{ name }}\" inside React component or hook is forbidden, since it may cause memory leaks and other bugs. If this is a false positive, add \"{{ name }}\" to the allowlist in the detectCustomFactories option."
+		},
+		schema: [{
+			type: "object",
+			properties: { detectCustomFactories: { oneOf: [{ type: "boolean" }, {
+				type: "object",
+				properties: { allowlist: {
+					type: "array",
+					items: { type: "string" },
+					uniqueItems: true
+				} },
+				required: ["allowlist"],
+				additionalProperties: false
+			}] } },
+			additionalProperties: false
+		}]
+	},
+	defaultOptions: [{ detectCustomFactories: true }],
+	create: (context, [options]) => {
+		const services = ESLintUtils.getParserServices(context);
+		const checker = services.program.getTypeChecker();
+		const { detectCustomFactories } = options;
+		const allowlist = typeof detectCustomFactories === "object" ? new Set(detectCustomFactories.allowlist) : void 0;
+		const stack = { render: [] };
+		const effectorImports = /* @__PURE__ */ new Map();
+		return {
+			[`${`ImportDeclaration[source.value=${PACKAGE_NAME$1.core}]`} > ImportSpecifier[imported.type="Identifier"]`]: (node) => {
+				const imported = node.imported.name;
+				const local = node.local.name;
+				if (EFFECTOR_FACTORIES.has(imported)) effectorImports.set(local, "factory");
+				else if (EFFECTOR_OPERATORS.has(imported)) effectorImports.set(local, "operator");
+			},
+			[`FunctionDeclaration, FunctionExpression, ArrowFunctionExpression`]: (node) => {
+				if (stack.render.at(-1) ?? false) return void stack.render.push(true);
+				const name = nameOf.function(node);
+				if (name && UseRegex.test(name.name)) return void stack.render.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);
+			},
+			[`:matches(FunctionDeclaration, FunctionExpression, ArrowFunctionExpression):exit`]: () => void stack.render.pop(),
+			"ClassDeclaration": () => void stack.render.push(false),
+			"ClassDeclaration:exit": () => void stack.render.pop(),
+			"CallExpression": (node) => {
+				if (!(stack.render.at(-1) ?? false)) return;
+				const calleeName = getCalleeName(node.callee);
+				switch (calleeName ? effectorImports.get(calleeName) : void 0) {
+					case "factory": return context.report({
+						node,
+						messageId: "noFactoryInRender",
+						data: { name: calleeName }
+					});
+					case "operator": return context.report({
+						node,
+						messageId: "noOperatorInRender",
+						data: { name: calleeName }
+					});
+				}
+				if (detectCustomFactories === false) return;
+				const returnType = services.getTypeAtLocation(node);
+				if (!hasEffectorUnitInType({
+					node: services.esTreeNodeToTSNodeMap.get(node),
+					checker,
+					program: services.program
+				}, returnType)) return;
+				const calleeType = services.getTypeAtLocation(node.callee);
+				const displayName = calleeName ?? "<expression>";
+				if (typeMatchesSpecifier(calleeType, REACT_HOOKS_SPEC, services.program)) return;
+				if (isEffectorFactorioHook(node.callee, services.getTypeAtLocation)) return;
+				if (typeMatchesSpecifier(calleeType, EFFECTOR_FACTORY_SPEC, services.program)) return context.report({
+					node,
+					messageId: "noFactoryInRender",
+					data: { name: displayName }
+				});
+				if (typeMatchesSpecifier(calleeType, EFFECTOR_OPERATOR_SPEC, services.program)) return context.report({
+					node,
+					messageId: "noOperatorInRender",
+					data: { name: displayName }
+				});
+				if (allowlist && calleeName && allowlist.has(calleeName)) return;
+				context.report({
+					node,
+					messageId: "noCustomFactoryInRender",
+					data: { name: displayName }
+				});
+			}
+		};
+	}
+});
+const UseRegex = /^use[A-Z0-9].*$/;
+function getCalleeName(callee) {
+	if (callee.type === AST_NODE_TYPES.Identifier) return callee.name;
+	if (callee.type === AST_NODE_TYPES.MemberExpression && callee.property.type === AST_NODE_TYPES.Identifier) return callee.property.name;
+	else return null;
+}
+function hasEffectorUnitInType(ctx, type, depth = 3) {
+	if (isType.unit(type, ctx.program)) return true;
+	if (depth <= 0) return false;
+	if (type.isUnion()) return type.types.some((type) => hasEffectorUnitInType(ctx, type, depth));
+	for (const property of type.getProperties()) if (hasEffectorUnitInType(ctx, ctx.checker.getTypeOfSymbolAtLocation(property, ctx.node), depth - 1)) return true;
+	return false;
+}
+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));
+}
+//#endregion
+//#region src/rules/no-unnecessary-combination/no-unnecessary-combination.ts
 var no_unnecessary_combination_default = createRule({
 	name: "no-unnecessary-combination",
 	meta: {
@@ -888,6 +1333,8 @@ function isFunction(node, services) {
 		return checker.getTypeAtLocation(tsnode).getCallSignatures().length > 0;
 	} else return false;
 }
+//#endregion
+//#region src/rules/no-unnecessary-duplication/no-unnecessary-duplication.ts
 var no_unnecessary_duplication_default = createRule({
 	name: "no-unnecessary-duplication",
 	meta: {
@@ -964,6 +1411,8 @@ function compare(clock, source, limit = 5) {
 	}
 	return false;
 }
+//#endregion
+//#region src/rules/no-useless-methods/no-useless-methods.ts
 var no_useless_methods_default = createRule({
 	name: "no-useless-methods",
 	meta: {
@@ -998,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,
@@ -1014,6 +1461,8 @@ var no_useless_methods_default = createRule({
 });
 const selector$2 = { method: `ImportSpecifier[imported.name=/(sample|guard)/]` };
 const query = { watch: esquery.parse("CallExpression:has(> MemberExpression.callee[property.name=watch]:has(> CallExpression.object))") };
+//#endregion
+//#region src/rules/no-watch/no-watch.ts
 var no_watch_default = createRule({
 	name: "no-watch",
 	meta: {
@@ -1035,6 +1484,8 @@ var no_watch_default = createRule({
 		} };
 	}
 });
+//#endregion
+//#region src/rules/prefer-useUnit/prefer-useUnit.ts
 var prefer_useUnit_default = createRule({
 	name: "prefer-useUnit",
 	meta: {
@@ -1066,6 +1517,8 @@ const selector$1 = {
 	useStore: `ImportSpecifier[imported.name=useStore]`,
 	useEvent: `ImportSpecifier[imported.name=useEvent]`
 };
+//#endregion
+//#region src/rules/require-pickup-in-persist/require-pickup-in-persist.ts
 var require_pickup_in_persist_default = createRule({
 	name: "require-pickup-in-persist",
 	meta: {
@@ -1095,6 +1548,8 @@ const selector = {
 	call: `[callee.type="Identifier"]`,
 	config: `[arguments.length=1][arguments.0.type="ObjectExpression"]`
 };
+//#endregion
+//#region src/rules/strict-effect-handlers/strict-effect-handlers.ts
 var strict_effect_handlers_default = createRule({
 	name: "strict-effect-handlers",
 	meta: {
@@ -1122,9 +1577,8 @@ var strict_effect_handlers_default = createRule({
 			});
 		};
 		const exit = (node) => {
-			const scope$1 = stack.pop();
-			if (!scope$1) return;
-			if (scope$1.effect && scope$1.regular) context.report({
+			const scope = stack.pop();
+			if (scope.effect && scope.regular) context.report({
 				node,
 				messageId: "mixed"
 			});
@@ -1162,11 +1616,15 @@ 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"
 	},
 	future: { "effector/no-domain-unit-creators": "warn" }
 };
+//#endregion
+//#region src/index.ts
 const base = {
 	meta: {
 		name,
@@ -1175,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,
@@ -1187,6 +1646,7 @@ const base = {
 		"no-getState": no_getState_default,
 		"no-guard": no_guard_default,
 		"no-patronum-debug": no_patronum_debug_default,
+		"no-units-spawn-in-render": no_units_spawn_in_render_default,
 		"no-unnecessary-combination": no_unnecessary_combination_default,
 		"no-unnecessary-duplication": no_unnecessary_duplication_default,
 		"no-useless-methods": no_useless_methods_default,
@@ -1229,5 +1689,5 @@ const flatConfigs = {
 const plugin = base;
 plugin.configs = legacyConfigs;
 plugin.flatConfigs = flatConfigs;
-var src_default = plugin;
-export { src_default as default };
+//#endregion
+export { plugin as default };