eslint-plugin-effector 0.16.0 → 0.17.0

package/dist/index.mjs

@@ -0,0 +1,1233 @@
+import { ASTUtils, AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import { getContextualType, typeMatchesSpecifier } from "@typescript-eslint/type-utils";
+import { isExpression } from "typescript";
+import esquery from "esquery";
+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();
+	const declarations = symbol.declarations ?? [];
+	return types.includes(name$1) && declarations.map((decl) => decl.getSourceFile().fileName).some((fname) => fname.includes("node_modules") && fname.includes(from));
+};
+const isType = {
+	store: (type, program) => typeMatchesSpecifier(type, {
+		from: "package",
+		package: "effector",
+		name: ["Store", "StoreWritable"]
+	}, program),
+	event: (type, program) => typeMatchesSpecifier(type, {
+		from: "package",
+		package: "effector",
+		name: ["Event", "EventCallable"]
+	}, program),
+	effect: (type, program) => typeMatchesSpecifier(type, {
+		from: "package",
+		package: "effector",
+		name: "Effect"
+	}, program),
+	unit: (type, program) => {
+		return typeMatchesSpecifier(type, {
+			from: "package",
+			package: "effector",
+			name: [
+				"Store",
+				"StoreWritable",
+				"Event",
+				"EventCallable",
+				"Effect"
+			]
+		}, 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;
+	},
+	jsx: (type, program) => {
+		return typeMatchesSpecifier(type, {
+			from: "package",
+			package: "react",
+			name: [
+				"Element",
+				"ReactNode",
+				"ReactElement"
+			]
+		}, program);
+	},
+	component: (type, program) => {
+		return typeMatchesSpecifier(type, {
+			from: "package",
+			package: "react",
+			name: [
+				"FC",
+				"FunctionComponent",
+				"ComponentType",
+				"ComponentClass",
+				"ForwardRefRenderFunction"
+			]
+		}, program);
+	}
+};
+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 }}`",
+			rename: "Rename \"{{ current }}\" to \"{{ fixed }}\""
+		},
+		schema: [],
+		hasSuggestions: true
+	},
+	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]
+			});
+		} };
+	}
+});
+const FxRegex = /Fx$/;
+var enforce_gate_naming_convention_default = createRule({
+	name: "enforce-gate-naming-convention",
+	meta: {
+		type: "problem",
+		docs: { description: "Enforce a Gate is named capitalized like a React Component" },
+		messages: {
+			invalid: "Gate \"{{ current }}\" should be named with first capital letter, rename it to \"{{ fixed }}\"",
+			rename: "Rename \"{{ current }}\" to \"{{ fixed }}\""
+		},
+		schema: [],
+		hasSuggestions: true
+	},
+	defaultOptions: [],
+	create: (context) => {
+		const services = ESLintUtils.getParserServices(context);
+		return { [`VariableDeclarator[id.name=${GateRegex}]`]: (node) => {
+			const type = services.getTypeAtLocation(node);
+			if (!isType.gate(type)) return;
+			const current = node.id.name;
+			const fixed = current[0].toUpperCase() + current.slice(1);
+			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]
+			});
+		} };
+	}
+});
+const GateRegex = /^[^A-Z]/;
+var enforce_store_naming_convention_default = createRule({
+	name: "enforce-store-naming-convention",
+	meta: {
+		type: "problem",
+		docs: { description: "Enforce $ as a prefix/postfix for any Effector `Store`" },
+		messages: {
+			invalid: "Store \"{{ current }}\" should be named with a `$` {{ convention }}, rename it to \"{{ fixed }}\"",
+			rename: "Rename \"{{ current }}\" to \"{{ fixed }}\""
+		},
+		schema: [{
+			type: "object",
+			properties: { mode: {
+				type: "string",
+				enum: ["prefix", "postfix"]
+			} }
+		}],
+		hasSuggestions: true
+	},
+	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 fixed = options.mode === "prefix" ? `$${trimmed}` : `${trimmed}$`;
+			const data = {
+				current,
+				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]
+			});
+		} };
+	}
+});
+const PrefixRegex = /^[^$]/;
+const PostfixRegex = /[^$]$/;
+const PACKAGE_NAME$1 = {
+	core: /^effector(?:\u002Fcompat)?$/,
+	react: /^effector-react$/,
+	storage: /^@?effector-storage(\u002F[\w-]+)*$/
+};
+var keep_options_order_default = createRule({
+	name: "keep-options-order",
+	meta: {
+		type: "problem",
+		docs: { description: "Enforce options order for Effector methods" },
+		messages: {
+			invalidOrder: `Order of options should be \`{{ correctOrder }}\`, but found \`{{ currentOrder }}\`.`,
+			changeOrder: "Sort options to follow the recommended order."
+		},
+		schema: [],
+		hasSuggestions: true
+	},
+	defaultOptions: [],
+	create: (context) => {
+		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) => {
+				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;
+				const properties = config.properties;
+				const current = properties.map((prop) => prop.key.name);
+				if (isCorrectOrder(current)) return;
+				const correctOrder = TRUE_ORDER.filter((item) => current.includes(item));
+				const othersOrder = current.filter((item) => !TRUE_ORDER.includes(item));
+				const order = [...correctOrder, ...othersOrder];
+				const snippets = properties.toSorted((a, b) => order.indexOf(a.key.name) - order.indexOf(b.key.name)).map((prop) => source.getText(prop));
+				const suggestion = {
+					messageId: "changeOrder",
+					fix: (fixer) => [fixer.replaceText(config, `{ ${snippets.join(", ")} }`)]
+				};
+				const data = {
+					correctOrder: correctOrder.join(" -> "),
+					currentOrder: current.join(" -> ")
+				};
+				context.report({
+					node: config,
+					messageId: "invalidOrder",
+					data,
+					suggest: [suggestion]
+				});
+			}
+		};
+	}
+});
+const TRUE_ORDER = [
+	"clock",
+	"source",
+	"filter",
+	"fn",
+	"target",
+	"greedy",
+	"batch",
+	"name"
+];
+const selector$11 = {
+	method: `ImportSpecifier[imported.name=/(sample|guard)/]`,
+	call: `[callee.type="Identifier"][arguments.length=1]`,
+	argument: `ObjectExpression.arguments`
+};
+const isCorrectOrder = (current) => {
+	let seen = -1;
+	for (const item of current) {
+		const index = TRUE_ORDER.indexOf(item);
+		const placement = index === -1 ? Infinity : index;
+		if (placement <= seen) return false;
+		seen = placement;
+	}
+	return true;
+};
+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;
+	if (node.parent.type === AST_NODE_TYPES.AssignmentExpression && node.parent.left.type === AST_NODE_TYPES.Identifier) return node.parent.left;
+	if (node.parent.type === AST_NODE_TYPES.Property && node.parent.key.type === AST_NODE_TYPES.Identifier) return node.parent.key;
+	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 };
+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." },
+		schema: []
+	},
+	defaultOptions: [],
+	create: (context) => {
+		const services = ESLintUtils.getParserServices(context);
+		const checker = services.program.getTypeChecker();
+		const stack = {
+			render: [],
+			hook: []
+		};
+		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);
+				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);
+			},
+			[`:matches(FunctionDeclaration, FunctionExpression, ArrowFunctionExpression):exit`]: () => void stack.render.pop(),
+			"ClassDeclaration": () => void stack.render.push(false),
+			"ClassDeclaration:exit": () => void stack.render.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);
+			},
+			"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 }
+				});
+			}
+		};
+	}
+});
+const UseRegex = /^use[A-Z0-9].*$/;
+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 };
+var no_ambiguity_target_default = createRule({
+	name: "no-ambiguity-target",
+	meta: {
+		type: "problem",
+		docs: { description: "Forbid ambiguous target in `sample` and `guard`." },
+		messages: { ambiguous: "Method `{{ method }}` both specifies `target` option and assigns the result to a variable. Consider removing one of them." },
+		schema: []
+	},
+	defaultOptions: [],
+	create: (context) => {
+		const imports = /* @__PURE__ */ new Set();
+		const importSelector = `ImportDeclaration[source.value=${PACKAGE_NAME$1.core}]`;
+		const usageStack = [];
+		return {
+			"ReturnStatement": () => usageStack.push(true),
+			"ReturnStatement:exit": () => usageStack.pop(),
+			"VariableDeclarator": () => usageStack.push(true),
+			"VariableDeclarator:exit": () => usageStack.pop(),
+			"ObjectExpression": () => usageStack.push(true),
+			"ObjectExpression:exit": () => usageStack.pop(),
+			"BlockStatement": () => usageStack.push(false),
+			"BlockStatement:exit": () => usageStack.pop(),
+			[`${importSelector} > ${selector$10.method}`]: (node) => imports.add(node.local.name),
+			[`CallExpression[callee.type="Identifier"]`]: (node) => {
+				if (!imports.has(node.callee.name)) return;
+				if (!(usageStack.at(-1) ?? false)) return;
+				const [config] = node.arguments;
+				if (config?.type !== AST_NODE_TYPES.ObjectExpression) return;
+				if (!locate.property("target", config)) return;
+				context.report({
+					node,
+					messageId: "ambiguous",
+					data: { method: node.callee.name }
+				});
+			}
+		};
+	}
+});
+const selector$10 = { method: `ImportSpecifier[imported.name=/(sample|guard)/]` };
+var no_domain_unit_creators_default = createRule({
+	name: "no-domain-unit-creators",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow using Domain methods to create units." },
+		messages: { avoid: "Avoid using `.{{ method }}` on a Domain instance. Use a standard factory unit creator `{{ factory }}` with a `domain` option instead." },
+		schema: []
+	},
+	defaultOptions: [],
+	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 type = services.getTypeAtLocation(node.callee.object);
+			if (!isType.domain(type, services.program)) return;
+			const factory = ALIAS_MAP.get(name$1) ?? name$1;
+			context.report({
+				node,
+				messageId: "avoid",
+				data: {
+					method: name$1,
+					factory
+				}
+			});
+		} };
+	}
+});
+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"]` };
+var no_duplicate_clock_or_source_array_values_default = createRule({
+	name: "no-duplicate-clock-or-source-array-values",
+	meta: {
+		type: "problem",
+		docs: { description: "Forbid providing duplicate units in `clock` and `source` arrays in `sample` and `guard`." },
+		messages: {
+			duplicate: "`{{ field }}` contains a duplicate unit `{{ unit }}`.",
+			remove: "Remove duplicate unit `{{ unit }}`."
+		},
+		schema: [],
+		hasSuggestions: true
+	},
+	defaultOptions: [],
+	create: (context) => {
+		const imports = /* @__PURE__ */ new Set();
+		const importSelector = `ImportDeclaration[source.value=${PACKAGE_NAME$1.core}]`;
+		const analyze = (node, field) => {
+			const seen = /* @__PURE__ */ new Map();
+			const entries = node.elements.filter((item) => item !== null).filter((item) => item.type !== AST_NODE_TYPES.SpreadElement);
+			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 report = (node, name$1, field) => {
+			const data = {
+				field,
+				unit: name$1
+			};
+			const suggestion = {
+				messageId: "remove",
+				data: { unit: name$1 },
+				fix: function* (fixer) {
+					yield fixer.remove(node);
+					const before = context.sourceCode.getTokenBefore(node);
+					if (before?.value === ",") yield fixer.remove(before);
+				}
+			};
+			context.report({
+				node,
+				messageId: "duplicate",
+				data,
+				suggest: [suggestion]
+			});
+		};
+		return {
+			[`${importSelector} > ${selector$8.method}`]: (node) => imports.add(node.local.name),
+			[`CallExpression${selector$8.call}:has(${selector$8.argument})`]: (node) => {
+				if (!imports.has(node.callee.name)) return;
+				const [config] = node.arguments;
+				const clock = locate.property("clock", config);
+				const source = locate.property("source", config);
+				if (clock?.value?.type === AST_NODE_TYPES.ArrayExpression) analyze(clock.value, "clock");
+				if (source?.value?.type === AST_NODE_TYPES.ArrayExpression) analyze(source.value, "source");
+			}
+		};
+	}
+});
+const selector$8 = {
+	method: `ImportSpecifier[imported.name=/(sample|guard)/]`,
+	call: `[callee.type="Identifier"][arguments.length=1]`,
+	argument: `ObjectExpression.arguments`
+};
+function traverseToRoot$1(node, path = []) {
+	if (node.type === AST_NODE_TYPES.Identifier) return {
+		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;
+}
+var no_duplicate_on_default = createRule({
+	name: "no-duplicate-on",
+	meta: {
+		type: "problem",
+		docs: { description: "Forbid duplicate `.on` calls on Stores." },
+		messages: { duplicate: "Method `.on` is called on store `{{ store }}` more than once for `{{ unit }}`." },
+		schema: []
+	},
+	defaultOptions: [],
+	create: (context) => {
+		const services = ESLintUtils.getParserServices(context);
+		const map = /* @__PURE__ */ new Map();
+		return { [`CallExpression[callee.property.name="on"]`]: (node) => {
+			const type = services.getTypeAtLocation(node.callee.object);
+			if (!isType.store(type, services.program)) return;
+			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);
+			if (!store) return;
+			const set = map.get(store.id) ?? /* @__PURE__ */ new Set();
+			for (const unit of units) {
+				const instance = identify("unit", unit, scope$1);
+				if (!instance) continue;
+				if (set.has(instance.id)) {
+					const data = {
+						store: store.name,
+						unit: instance.name
+					};
+					context.report({
+						messageId: "duplicate",
+						node: unit,
+						data
+					});
+				} else set.add(instance.id);
+			}
+			map.set(store.id, set);
+		} };
+	}
+});
+function traverseToRoot(node, path = []) {
+	if (node.type === AST_NODE_TYPES.Identifier) return {
+		node,
+		path
+	};
+	if (node.type === AST_NODE_TYPES.MemberExpression && node.property.type === AST_NODE_TYPES.Identifier) return traverseToRoot(node.object, [node.property.name, ...path]);
+	return null;
+}
+const STORE_METHODS = ["on", "reset"];
+function traverseStoreToRoot(node, path = []) {
+	if (node.type === AST_NODE_TYPES.Identifier) return {
+		node,
+		path
+	};
+	if (node.type === AST_NODE_TYPES.MemberExpression && node.property.type === AST_NODE_TYPES.Identifier) return traverseStoreToRoot(node.object, [node.property.name, ...path]);
+	if (node.type === AST_NODE_TYPES.CallExpression && node.callee.type === AST_NODE_TYPES.MemberExpression) {
+		if (node.callee.property.type === AST_NODE_TYPES.Identifier && STORE_METHODS.includes(node.callee.property.name)) return traverseStoreToRoot(node.callee.object, path);
+	}
+	return null;
+}
+function raiseStoreToVariable(node) {
+	let current = node;
+	while (current.parent) {
+		if (current.parent.type === AST_NODE_TYPES.VariableDeclarator) return current.parent;
+		if (current.parent.type !== AST_NODE_TYPES.MemberExpression || current.parent.object !== current) return null;
+		if (current.parent.property.type !== AST_NODE_TYPES.Identifier || !STORE_METHODS.includes(current.parent.property.name)) return null;
+		const grandparent = current.parent.parent;
+		if (grandparent?.type !== AST_NODE_TYPES.CallExpression || grandparent.callee !== current.parent) return null;
+		current = current.parent.parent;
+	}
+	return null;
+}
+function findSuitableRoot(type, node) {
+	if (type === "unit") return traverseToRoot(node);
+	const root = traverseStoreToRoot(node);
+	if (root) return root;
+	const declarator = raiseStoreToVariable(node);
+	if (declarator && declarator.id.type === AST_NODE_TYPES.Identifier) return {
+		node: declarator.id,
+		path: []
+	};
+	return null;
+}
+function identify(type, node, scope$1) {
+	const root = findSuitableRoot(type, node);
+	if (!root) return null;
+	const variable = ASTUtils.findVariable(scope$1, root.node);
+	if (!variable) return null;
+	return {
+		id: `${variable.$id}+${root.path.join(".")}`,
+		name: [variable.name, ...root.path].join(".")
+	};
+}
+var no_forward_default = createRule({
+	name: "no-forward",
+	meta: {
+		type: "problem",
+		docs: { description: "Prefer `sample` over `forward`." },
+		messages: {
+			noForward: "Use `sample` operator instead of `forward` as a more universal approach.",
+			replaceWithSample: "Replace `forward` with `sample`."
+		},
+		hasSuggestions: true,
+		schema: []
+	},
+	defaultOptions: [],
+	create: (context) => {
+		let sample;
+		const forwards = /* @__PURE__ */ new Map();
+		const source = context.sourceCode;
+		const visitorKeys = source.visitorKeys;
+		const importSelector = `ImportDeclaration[source.value=${PACKAGE_NAME$1.core}]`;
+		return {
+			[`${importSelector} > ${selector$7.forward}`]: (node) => forwards.set(node.local.name, node),
+			[`${importSelector} > ${selector$7.sample}`]: (node) => sample = node.local.name,
+			[`CallExpression${selector$7.call}:has(${selector$7.argument})`]: (node) => {
+				if (!forwards.has(node.callee.name)) return;
+				const config = {};
+				const arg = node.arguments[0];
+				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);
+					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);
+					if (call) [config.clock, config.fn] = [call.callee.object, call.arguments[0]];
+				}
+				const code = [
+					"clock",
+					"fn",
+					"target"
+				].filter((key) => config[key] !== void 0).map((key) => `${key}: ${source.getText(config[key])}`).join(", ");
+				context.report({
+					messageId: "noForward",
+					node: node.callee,
+					suggest: [{
+						messageId: "replaceWithSample",
+						fix: function* (fixer) {
+							const fn = sample ?? "sample";
+							yield fixer.replaceText(node, `${fn}({ ${code} })`);
+							if (!sample) yield fixer.insertTextAfter(forwards.get(node.callee.name), `, sample`);
+						}
+					}]
+				});
+			}
+		};
+	}
+});
+const selector$7 = {
+	forward: `ImportSpecifier[imported.name="forward"]`,
+	sample: `ImportSpecifier[imported.name="sample"]`,
+	call: `[callee.type="Identifier"][arguments.length=1]`,
+	argument: `ObjectExpression.arguments`
+};
+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']))")
+};
+var no_getState_default = createRule({
+	name: "no-getState",
+	meta: {
+		type: "problem",
+		docs: { description: "Forbid `.getState` calls on Effector stores." },
+		messages: {
+			named: "Method `.getState` used on store `{{ name }}` can lead to race conditions. Replace with with `sample` or `attach`.",
+			anonymous: "Method `.getState` used on store can lead to race conditions. Replace with with `sample` or `attach`."
+		},
+		schema: []
+	},
+	defaultOptions: [],
+	create: (context) => {
+		const services = ESLintUtils.getParserServices(context);
+		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({
+				node,
+				messageId: "named",
+				data: { name: name$1 }
+			});
+			else context.report({
+				node,
+				messageId: "anonymous"
+			});
+		} };
+	}
+});
+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;
+};
+var no_guard_default = createRule({
+	name: "no-guard",
+	meta: {
+		type: "problem",
+		docs: { description: "Prefer `sample` over `guard`." },
+		messages: {
+			noGuard: "Use `sample` operator instead of `guard` as a more universal approach.",
+			replaceWithSample: "Replace `guard` with `sample`."
+		},
+		hasSuggestions: true,
+		schema: []
+	},
+	defaultOptions: [],
+	create: (context) => {
+		let sample;
+		const guards = /* @__PURE__ */ new Map();
+		const source = context.sourceCode;
+		const visitorKeys = source.visitorKeys;
+		const importSelector = `ImportDeclaration[source.value=${PACKAGE_NAME$1.core}]`;
+		return {
+			[`${importSelector} > ${selector$6.guard}`]: (node) => guards.set(node.local.name, node),
+			[`${importSelector} > ${selector$6.sample}`]: (node) => sample = node.local.name,
+			[`CallExpression${selector$6.call}`]: (node) => {
+				if (!guards.has(node.callee.name)) return;
+				const config = {};
+				if (node.arguments.length === 1 && node.arguments[0].type === AST_NODE_TYPES.ObjectExpression) {
+					const [arg] = node.arguments;
+					for (const key of [
+						"clock",
+						"source",
+						"filter",
+						"target"
+					]) config[key] = locate.property(key, arg)?.value;
+				} else if (node.arguments.length === 2 && node.arguments[1].type === AST_NODE_TYPES.ObjectExpression) {
+					const [clock, arg] = node.arguments;
+					config.clock = clock;
+					for (const key of [
+						"source",
+						"filter",
+						"target"
+					]) 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);
+					if (call) [config.target, config.fn] = [call.callee.object, call.arguments[0]];
+				}
+				const code = [
+					"clock",
+					"source",
+					"filter",
+					"fn",
+					"target"
+				].filter((key) => config[key] !== void 0).map((key) => `${key}: ${source.getText(config[key])}`).join(", ");
+				context.report({
+					messageId: "noGuard",
+					node: node.callee,
+					suggest: [{
+						messageId: "replaceWithSample",
+						fix: function* (fixer) {
+							const fn = sample ?? "sample";
+							yield fixer.replaceText(node, `${fn}({ ${code} })`);
+							if (!sample) yield fixer.insertTextAfter(guards.get(node.callee.name), `, sample`);
+						}
+					}]
+				});
+			}
+		};
+	}
+});
+const selector$6 = {
+	guard: `ImportSpecifier[imported.name="guard"]`,
+	sample: `ImportSpecifier[imported.name="sample"]`,
+	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']))") };
+var no_patronum_debug_default = createRule({
+	name: "no-patronum-debug",
+	meta: {
+		type: "problem",
+		docs: { description: "Disallow the use of `patronum` `debug`." },
+		messages: {
+			unexpected: "Unexpected `debug` call.",
+			remove: "Remove this `debug` call."
+		},
+		schema: [],
+		hasSuggestions: true
+	},
+	defaultOptions: [],
+	create: (context) => {
+		const debugs = /* @__PURE__ */ new Set();
+		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;
+				context.report({
+					messageId: "unexpected",
+					node: node.callee,
+					suggest: [{
+						messageId: "remove",
+						fix: (fixer) => {
+							if (node.parent.type === AST_NODE_TYPES.ExpressionStatement) return fixer.remove(node.parent);
+							else return fixer.replaceText(node, "undefined");
+						}
+					}]
+				});
+			}
+		};
+	}
+});
+const PACKAGE_NAME = /^patronum(?:\u002Fdebug)?$/;
+const selector$5 = {
+	debug: `ImportSpecifier[imported.name="debug"]`,
+	call: `[callee.type=Identifier], [callee.object.type=Identifier]`
+};
+const toName = (node) => {
+	switch (node.callee.type) {
+		case AST_NODE_TYPES.Identifier: return node.callee.name;
+		case AST_NODE_TYPES.MemberExpression: return node.callee.object.name;
+	}
+};
+var no_unnecessary_combination_default = createRule({
+	name: "no-unnecessary-combination",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Forbid unnecessary combinations in `clock` and `source`." },
+		messages: { unnecessary: "{{ method }} is used under the hood of {{ property }} in {{ operator }}, you can omit it." },
+		schema: []
+	},
+	defaultOptions: [],
+	create: (context) => {
+		const services = ESLintUtils.getParserServices(context);
+		const operators = /* @__PURE__ */ new Set();
+		const combinators = /* @__PURE__ */ new Map();
+		const importSelector = `ImportDeclaration[source.value=${PACKAGE_NAME$1.core}]`;
+		return {
+			[`${importSelector} > ${selector$4.operator}`]: (node) => operators.add(node.local.name),
+			[`${importSelector} > ${selector$4.combinator}`]: (node) => combinators.set(node.local.name, node.imported.name),
+			[`CallExpression${selector$4.call}:has(${selector$4.argument})`]: (node) => {
+				if (!operators.has(node.callee.name)) return;
+				const [config] = node.arguments;
+				const clock = locate.property("clock", config)?.value;
+				const source = locate.property("source", config)?.value;
+				if (clock?.type === AST_NODE_TYPES.CallExpression && clock.callee.type === AST_NODE_TYPES.Identifier) {
+					if (combinators.get(clock.callee.name) === "merge") {
+						const data = {
+							method: clock.callee.name,
+							property: "clock",
+							operator: node.callee.name
+						};
+						context.report({
+							node: clock,
+							messageId: "unnecessary",
+							data
+						});
+					}
+				}
+				if (source?.type === AST_NODE_TYPES.CallExpression && source.callee.type === AST_NODE_TYPES.Identifier) {
+					const method = combinators.get(source.callee.name);
+					if (!method) return;
+					if (method === "combine" && source.arguments.length > 1 && isFunction(source.arguments.at(-1), services)) return;
+					const data = {
+						method: source.callee.name,
+						property: "source",
+						operator: node.callee.name
+					};
+					context.report({
+						node: source,
+						messageId: "unnecessary",
+						data
+					});
+				}
+			}
+		};
+	}
+});
+const selector$4 = {
+	operator: `ImportSpecifier[imported.name=/(sample|guard)/]`,
+	combinator: `ImportSpecifier[imported.name=/(combine|merge)/]`,
+	call: `[callee.type="Identifier"][arguments.length=1]`,
+	argument: `ObjectExpression.arguments`
+};
+function isFunction(node, services) {
+	if (node.type === AST_NODE_TYPES.ArrowFunctionExpression) return true;
+	else if (node.type === AST_NODE_TYPES.FunctionExpression) return true;
+	else if (node.type === AST_NODE_TYPES.Identifier) {
+		const checker = services.program.getTypeChecker();
+		const tsnode = services.esTreeNodeToTSNodeMap.get(node);
+		return checker.getTypeAtLocation(tsnode).getCallSignatures().length > 0;
+	} else return false;
+}
+var no_unnecessary_duplication_default = createRule({
+	name: "no-unnecessary-duplication",
+	meta: {
+		type: "problem",
+		docs: { description: "Forbid duplicate `source` and `clock` in `sample` and `guard`." },
+		messages: {
+			duplicate: "Method `{{ method }}` has the same value for `source` and `clock`. Consider using only one of them.",
+			removeClock: "Remove the `clock`",
+			removeSource: "Remove the `source`"
+		},
+		schema: [],
+		hasSuggestions: true
+	},
+	defaultOptions: [],
+	create: (context) => {
+		const imports = /* @__PURE__ */ new Set();
+		return {
+			[`${`ImportDeclaration[source.value=${PACKAGE_NAME$1.core}]`} > ${selector$3.method}`]: (node) => imports.add(node.local.name),
+			[`CallExpression${selector$3.call}:has(${selector$3.argument})`]: (node) => {
+				if (!imports.has(node.callee.name)) return;
+				const [config] = node.arguments;
+				const source = locate.property("source", config)?.value;
+				if (!source) return;
+				const clock = locate.property("clock", config)?.value;
+				if (!clock) return;
+				if (!compare(clock, source)) return;
+				const suggestions = [{
+					messageId: "removeClock",
+					fix: function* (fixer) {
+						yield fixer.remove(clock.parent);
+						const after = context.sourceCode.getTokenAfter(clock.parent);
+						if (after?.value === ",") yield fixer.remove(after);
+					}
+				}, {
+					messageId: "removeSource",
+					fix: function* (fixer) {
+						yield fixer.remove(source.parent);
+						const after = context.sourceCode.getTokenAfter(source.parent);
+						if (after?.value === ",") yield fixer.remove(after);
+					}
+				}];
+				const data = { method: node.callee.name };
+				context.report({
+					node: config,
+					messageId: "duplicate",
+					data,
+					suggest: suggestions
+				});
+			}
+		};
+	}
+});
+const selector$3 = {
+	method: `ImportSpecifier[imported.name=/(sample|guard)/]`,
+	call: `[callee.type="Identifier"][arguments.length=1]`,
+	argument: `ObjectExpression.arguments`
+};
+function compare(clock, source, limit = 5) {
+	if (limit <= 0) return false;
+	if (clock.type === AST_NODE_TYPES.Identifier) return source.type === AST_NODE_TYPES.Identifier && clock.name === source.name;
+	if (clock.type === AST_NODE_TYPES.ArrayExpression) {
+		if (clock.elements.length !== 1) return false;
+		let a, b;
+		if (source.type === AST_NODE_TYPES.ArrayExpression) if (source.elements.length !== 1) return false;
+		else [a, b] = [clock.elements[0], source.elements[0]];
+		else [a, b] = [clock.elements[0], source];
+		return a.type === AST_NODE_TYPES.Identifier && b.type === AST_NODE_TYPES.Identifier && a.name === b.name;
+	}
+	if (clock.type === AST_NODE_TYPES.MemberExpression) {
+		if (source.type !== AST_NODE_TYPES.MemberExpression) return false;
+		if (clock.computed || source.computed) return false;
+		if (clock.property.name !== source.property.name) return false;
+		return compare(clock.object, source.object, limit - 1);
+	}
+	return false;
+}
+var no_useless_methods_default = createRule({
+	name: "no-useless-methods",
+	meta: {
+		type: "problem",
+		docs: { description: "Forbid useless calls of `sample` and `guard`." },
+		messages: { uselessMethod: "Method `{{ method }}` does nothing in this case. You should assign the result to variable or pass `target` to it." },
+		schema: []
+	},
+	defaultOptions: [],
+	create: (context) => {
+		const imports = /* @__PURE__ */ new Set();
+		const source = context.sourceCode;
+		const visitorKeys = source.visitorKeys;
+		const importSelector = `ImportDeclaration[source.value=${PACKAGE_NAME$1.core}]`;
+		const usageStack = [];
+		return {
+			"ReturnStatement": () => usageStack.push(true),
+			"ReturnStatement:exit": () => usageStack.pop(),
+			"VariableDeclarator": () => usageStack.push(true),
+			"VariableDeclarator:exit": () => usageStack.pop(),
+			"ObjectExpression": () => usageStack.push(true),
+			"ObjectExpression:exit": () => usageStack.pop(),
+			"BlockStatement": () => usageStack.push(false),
+			"BlockStatement:exit": () => usageStack.pop(),
+			[`${importSelector} > ${selector$2.method}`]: (node) => imports.add(node.local.name),
+			[`CallExpression[callee.type="Identifier"]`]: (node) => {
+				if (!imports.has(node.callee.name)) return;
+				if (usageStack.at(-1) ?? false) return;
+				if (node.parent.type === AST_NODE_TYPES.CallExpression) return;
+				const [config] = node.arguments;
+				if (config?.type === AST_NODE_TYPES.ObjectExpression) {
+					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 method = node.callee.name;
+				context.report({
+					node,
+					messageId: "uselessMethod",
+					data: { method }
+				});
+			}
+		};
+	}
+});
+const selector$2 = { method: `ImportSpecifier[imported.name=/(sample|guard)/]` };
+const query = { watch: esquery.parse("CallExpression:has(> MemberExpression.callee[property.name=watch]:has(> CallExpression.object))") };
+var no_watch_default = createRule({
+	name: "no-watch",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Restrict usage of `.watch` on any Effector Unit." },
+		messages: { restricted: "Using `.watch` method leads to imperative code. Replace it with an operator `sample` or use the `target` parameter of `sample` operator." },
+		schema: []
+	},
+	defaultOptions: [],
+	create: (context) => {
+		const services = ESLintUtils.getParserServices(context);
+		return { [`CallExpression[callee.type="MemberExpression"][callee.property.name="watch"]`]: (node) => {
+			const type = services.getTypeAtLocation(node.callee.object);
+			if (!isType.unit(type, services.program)) return;
+			context.report({
+				node,
+				messageId: "restricted"
+			});
+		} };
+	}
+});
+var prefer_useUnit_default = createRule({
+	name: "prefer-useUnit",
+	meta: {
+		type: "suggestion",
+		docs: { description: "Prefer `useUnit` over deprecated `useStore` and `useEvent` hooks." },
+		messages: { useUseUnit: "`{{ name }}` should be replaced with `useUnit`." },
+		schema: []
+	},
+	defaultOptions: [],
+	create: (context) => {
+		const imports = /* @__PURE__ */ new Map();
+		const importSelector = `ImportDeclaration[source.value=${PACKAGE_NAME$1.react}]`;
+		return {
+			[`${importSelector} > ${selector$1.useStore}`]: (node) => void imports.set(node.local.name, "useStore"),
+			[`${importSelector} > ${selector$1.useEvent}`]: (node) => void imports.set(node.local.name, "useEvent"),
+			[`CallExpression[callee.type="Identifier"]`]: (node) => {
+				const hook = imports.get(node.callee.name);
+				if (!hook) return;
+				context.report({
+					node,
+					messageId: "useUseUnit",
+					data: { name: hook }
+				});
+			}
+		};
+	}
+});
+const selector$1 = {
+	useStore: `ImportSpecifier[imported.name=useStore]`,
+	useEvent: `ImportSpecifier[imported.name=useEvent]`
+};
+var require_pickup_in_persist_default = createRule({
+	name: "require-pickup-in-persist",
+	meta: {
+		type: "problem",
+		docs: { description: "Require every `persist` call of `effector-storage` to use `pickup`." },
+		messages: { missing: "This `persist` call does not specify a `pickup` event that is required for scoped usage of `effector-storage`." },
+		schema: []
+	},
+	defaultOptions: [],
+	create: (context) => {
+		const imports = /* @__PURE__ */ new Set();
+		return {
+			[`${`ImportDeclaration[source.value=${PACKAGE_NAME$1.storage}]`} > ${selector.persist}`]: (node) => imports.add(node.local.name),
+			[`CallExpression${selector.call}${selector.config}`]: (node) => {
+				if (!imports.has(node.callee.name)) return;
+				if (node.arguments[0].properties.filter((prop) => prop.type === AST_NODE_TYPES.Property).map((prop) => prop.key).filter((key) => key.type === AST_NODE_TYPES.Identifier).some((key) => key.name === "pickup")) return;
+				context.report({
+					node,
+					messageId: "missing"
+				});
+			}
+		};
+	}
+});
+const selector = {
+	persist: `ImportSpecifier[imported.name="persist"]`,
+	call: `[callee.type="Identifier"]`,
+	config: `[arguments.length=1][arguments.0.type="ObjectExpression"]`
+};
+var strict_effect_handlers_default = createRule({
+	name: "strict-effect-handlers",
+	meta: {
+		type: "problem",
+		docs: { description: "Forbid mixing calls to both regular async functions and Effects in the same function." },
+		messages: { mixed: "This function can lead to losing Scope in Effector Fork API." },
+		schema: []
+	},
+	defaultOptions: [],
+	create: (context) => {
+		const services = ESLintUtils.getParserServices(context);
+		const stack = [];
+		const track = (node) => {
+			const current = stack.at(-1);
+			if (!current) return;
+			const callee = node.argument.callee;
+			const type = services.getTypeAtLocation(callee);
+			if (isType.effect(type, services.program)) return current.effect = true;
+			else return current.regular = true;
+		};
+		const enter = () => {
+			stack.push({
+				effect: false,
+				regular: false
+			});
+		};
+		const exit = (node) => {
+			const scope$1 = stack.pop();
+			if (!scope$1) return;
+			if (scope$1.effect && scope$1.regular) context.report({
+				node,
+				messageId: "mixed"
+			});
+		};
+		return {
+			"ArrowFunctionExpression": enter,
+			"ArrowFunctionExpression:exit": exit,
+			"FunctionExpression": enter,
+			"FunctionExpression:exit": exit,
+			"FunctionDeclaration": enter,
+			"FunctionDeclaration:exit": exit,
+			"AwaitExpression:matches([argument.type='CallExpression'], [argument.type='NewExpression'])": track
+		};
+	}
+});
+const ruleset = {
+	recommended: {
+		"effector/enforce-effect-naming-convention": "error",
+		"effector/enforce-store-naming-convention": "error",
+		"effector/keep-options-order": "warn",
+		"effector/no-ambiguity-target": "warn",
+		"effector/no-duplicate-on": "error",
+		"effector/no-forward": "error",
+		"effector/no-getState": "error",
+		"effector/no-guard": "error",
+		"effector/no-unnecessary-combination": "warn",
+		"effector/no-unnecessary-duplication": "warn",
+		"effector/no-useless-methods": "error",
+		"effector/no-watch": "warn"
+	},
+	patronum: { "effector/no-patronum-debug": "warn" },
+	scope: {
+		"effector/require-pickup-in-persist": "error",
+		"effector/strict-effect-handlers": "error"
+	},
+	react: {
+		"effector/enforce-gate-naming-convention": "error",
+		"effector/mandatory-scope-binding": "error",
+		"effector/prefer-useUnit": "error"
+	},
+	future: { "effector/no-domain-unit-creators": "warn" }
+};
+const base = {
+	meta: {
+		name,
+		version,
+		namespace: "effector"
+	},
+	rules: {
+		"enforce-effect-naming-convention": enforce_effect_naming_convention_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,
+		"mandatory-scope-binding": mandatory_scope_binding_default,
+		"no-ambiguity-target": no_ambiguity_target_default,
+		"no-domain-unit-creators": no_domain_unit_creators_default,
+		"no-duplicate-clock-or-source-array-values": no_duplicate_clock_or_source_array_values_default,
+		"no-duplicate-on": no_duplicate_on_default,
+		"no-forward": no_forward_default,
+		"no-getState": no_getState_default,
+		"no-guard": no_guard_default,
+		"no-patronum-debug": no_patronum_debug_default,
+		"no-unnecessary-combination": no_unnecessary_combination_default,
+		"no-unnecessary-duplication": no_unnecessary_duplication_default,
+		"no-useless-methods": no_useless_methods_default,
+		"no-watch": no_watch_default,
+		"prefer-useUnit": prefer_useUnit_default,
+		"require-pickup-in-persist": require_pickup_in_persist_default,
+		"strict-effect-handlers": strict_effect_handlers_default
+	}
+};
+const legacyConfigs = {
+	recommended: { rules: ruleset.recommended },
+	scope: { rules: ruleset.scope },
+	react: { rules: ruleset.react },
+	future: { rules: ruleset.future },
+	patronum: { rules: ruleset.patronum }
+};
+const self = base;
+const flatConfigs = {
+	recommended: {
+		plugins: { effector: self },
+		rules: ruleset.recommended
+	},
+	scope: {
+		plugins: { effector: self },
+		rules: ruleset.scope
+	},
+	react: {
+		plugins: { effector: self },
+		rules: ruleset.react
+	},
+	future: {
+		plugins: { effector: self },
+		rules: ruleset.future
+	},
+	patronum: {
+		plugins: { effector: self },
+		rules: ruleset.patronum
+	}
+};
+const plugin = base;
+plugin.configs = legacyConfigs;
+plugin.flatConfigs = flatConfigs;
+var src_default = plugin;
+export { src_default as default };