@zayne-labs/eslint-config 0.11.5 → 0.11.6

package/dist/src-BncWNtPe.js

@@ -0,0 +1,671 @@
+import globals from "globals";
+
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.8.1_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/util/ast.js
+/**
+* @import {Scope,Rule} from 'eslint'
+*/
+/**
+* Get all references that ultimately flow into `ref`.
+*
+* @param {Rule.RuleContext} context
+* @param {Scope.Reference} ref
+* @param {"leaf" | "all"} [mode="all"]
+* @param {Set<Scope.Reference>} visited
+*
+* @returns {Scope.Reference[]}
+*/
+const getUpstreamRefs = (context, ref, mode = "all", visited = /* @__PURE__ */ new Set()) => {
+	visited.add(ref);
+	const upstreamRefs = ref.resolved?.defs.filter((def) => def.type !== "ImportBinding").filter((def) => def.type !== "Parameter").map((def) => def.node.init ?? def.node.body).filter(Boolean).flatMap((node) => getDownstreamRefs(context, node)).filter((ref$1) => !visited.has(ref$1)).flatMap((ref$1) => getUpstreamRefs(context, ref$1, mode, visited));
+	const isLeafRef = upstreamRefs === void 0 || upstreamRefs.length === 0;
+	return mode === "leaf" ? isLeafRef ? [ref] : upstreamRefs : [ref].concat(upstreamRefs ?? []);
+};
+/**
+* Descend the AST from `node`, calling `visit` on each node.
+*
+* @param {Rule.RuleContext} context
+* @param {Rule.Node} node
+* @param {(node: Rule.Node) => void} visit
+* @param {Set<Rule.Node>} visited
+*/
+const descend = (context, node, visit, visited = /* @__PURE__ */ new Set()) => {
+	if (visited.has(node)) return;
+	visit(node);
+	visited.add(node);
+	(context.sourceCode.visitorKeys[node.type] || []).map((key) => node[key]).filter(Boolean).flatMap((child) => Array.isArray(child) ? child : [child]).filter(Boolean).filter((child) => typeof child.type === "string").forEach((child) => descend(context, child, visit, visited));
+};
+/**
+* @param {Rule.RuleContext} context
+* @param {Rule.Node} topNode
+* @param {string} type
+*/
+const findDownstreamNodes = (context, topNode, type) => {
+	const nodes = [];
+	descend(context, topNode, (node) => {
+		if (node.type === type) nodes.push(node);
+	});
+	return nodes;
+};
+/**
+* @param {Rule.RuleContext} context
+* @param {Rule.Node} node
+*/
+const getDownstreamRefs = (context, node) => findDownstreamNodes(context, node, "Identifier").map((identifier) => getRef(context, identifier)).filter(Boolean);
+/**
+* @param {Scope.Reference} ref
+* @param {Rule.Node} current
+* @returns {Rule.Node | undefined}
+*/
+const getCallExpr = (ref, current = ref.identifier.parent) => {
+	if (current.type === "CallExpression") {
+		let node = ref.identifier;
+		while (node.parent.type === "MemberExpression") node = node.parent;
+		if (current.callee === node) return current;
+	}
+	if (current.type === "MemberExpression") return getCallExpr(ref, current.parent);
+};
+/**
+* When using this, we assume that args passed to the derived function are always eventually passed to underlying functions.
+* Which they may not be. Would be better to trace the actual flow of values, but that's complex. We'll start with this for now.
+*
+* @param {Rule.RuleContext} context
+* @param {Scope.Reference} ref
+* @param {"leaf" | "all"} [mode="all"] Whether to return all refs, or only leaf refs. Note that "all" includes `ref` itself.
+* @returns {Rule.Node[]}
+*/
+const getArgsUpstreamRefs = (context, ref, mode) => getUpstreamRefs(context, ref, mode).map((ref$1) => getCallExpr(ref$1)).filter(Boolean).flatMap((callExpr) => callExpr.arguments).flatMap((arg) => getDownstreamRefs(context, arg)).flatMap((ref$1) => getUpstreamRefs(context, ref$1));
+/**
+* Walks up the AST until `within` (returns `true`) or finding any of (returns `false`):
+* - An `async` function
+* - A function declaration, which may be called at an arbitrary later time.
+*   - While we return false for *this* call, we may still return true for a call to a function containing this call. Combined with `getUpstreamRefs()`, it will still flag calls to the containing function.
+* - A function passed as a callback to another function or `new` - event handler, `setTimeout`, `Promise.then()` `new ResizeObserver()`, etc.
+*
+* Inspired by https://eslint-react.xyz/docs/rules/hooks-extra-no-direct-set-state-in-use-effect
+*
+* @param {Rule.Node} node
+* @param {Rule.Node} within
+* @returns {boolean}
+*/
+const isSynchronous = (node, within) => {
+	if (node == within) return true;
+	else if (node.async || node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression") return false;
+	else return isSynchronous(node.parent, within);
+};
+/**
+* @param {Rule.RuleContext} context
+* @param {Rule.Node} identifier
+*
+* @returns {Scope.Reference | undefined}
+*/
+const getRef = (context, identifier) => context.sourceCode.getScope(identifier)?.references.find((ref) => ref.identifier == identifier);
+/**
+* @param {Rule.RuleContext} context
+* @param {Scope.Reference} ref
+* @param {(ref: Scope.Reference) => boolean} predicate
+* @returns {boolean} Whether this reference eventually calls a function matching the given predicate.
+*/
+const isEventualCallTo = (context, ref, predicate) => getCallExpr(ref) !== void 0 && getUpstreamRefs(context, ref).some(predicate);
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.8.1_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/util/react.js
+/**
+* @import {Scope,Rule} from 'eslint'
+*/
+/**
+* @param {Rule.Node} node
+* @returns {boolean}
+*/
+const isReactFunctionalComponent = (node) => (node.type === "FunctionDeclaration" || node.type === "VariableDeclarator" && (node.init.type === "ArrowFunctionExpression" || node.init.type === "CallExpression")) && node.id.type === "Identifier" && node.id.name[0].toUpperCase() === node.id.name[0];
+/**
+* Excludes known pure HOCs like `memo` and `forwardRef`.
+* Basically this is meant to detect custom HOCs that may have side effects, particularly when using their props.
+*
+* TODO: Will not detect when the component is defined normally and then exported wrapped in an HOC.
+* e.g. `const MyComponent = (props) => {...}; export default memo(MyComponent);`
+*
+* @param {Rule.Node} node
+* @returns {boolean}
+*/
+const isReactFunctionalHOC = (node) => node.type === "VariableDeclarator" && node.init && node.init.type === "CallExpression" && node.init.callee.type === "Identifier" && !["memo", "forwardRef"].includes(node.init.callee.name) && node.init.arguments.length > 0 && (node.init.arguments[0].type === "ArrowFunctionExpression" || node.init.arguments[0].type === "FunctionExpression") && node.id.type === "Identifier" && node.id.name[0].toUpperCase() === node.id.name[0];
+/**
+* @param {Rule.Node} node
+* @returns {boolean}
+*/
+const isCustomHook = (node) => (node.type === "FunctionDeclaration" || node.type === "VariableDeclarator" && node.init && (node.init.type === "ArrowFunctionExpression" || node.init.type === "FunctionExpression")) && node.id.type === "Identifier" && node.id.name.startsWith("use") && node.id.name[3] === node.id.name[3].toUpperCase();
+/**
+* @param {Scope.Reference} ref
+* @returns {boolean}
+*/
+const isUseState = (ref) => ref.identifier.type === "Identifier" && ref.identifier.name === "useState" || ref.identifier.parent.type === "MemberExpression" && ref.identifier.parent.object.name === "React" && ref.identifier.parent.property.name === "useState";
+/**
+* @param {Scope.Reference} ref
+* @returns {boolean}
+*/
+const isState = (ref) => ref.resolved?.defs.some((def) => def.node.type === "VariableDeclarator" && def.node.id.type === "ArrayPattern" && (def.node.id.elements.length === 1 || def.node.id.elements.length === 2) && def.node.id.elements[0]?.type === "Identifier" && def.node.id.elements[0].name === ref.identifier.name);
+/**
+* @param {Scope.Reference} ref
+* @returns {boolean}
+*/
+const isStateSetter = (ref) => ref.resolved?.defs.some((def) => def.node.type === "VariableDeclarator" && def.node.id.type === "ArrayPattern" && def.node.id.elements.length === 2 && def.node.id.elements[1]?.type === "Identifier" && def.node.id.elements[1].name === ref.identifier.name);
+/**
+* Returns false for props of HOCs (e.g. `withRouter`) because they usually have side effects.
+*
+* @param {Scope.Reference} ref
+* @returns {boolean}
+*/
+const isProp = (ref) => ref.resolved?.defs.some((def) => {
+	const declaringNode = def.node.type === "ArrowFunctionExpression" ? def.node.parent.type === "CallExpression" ? def.node.parent.parent : def.node.parent : def.node;
+	return def.type === "Parameter" && (isReactFunctionalComponent(declaringNode) && !isReactFunctionalHOC(declaringNode) || isCustomHook(declaringNode));
+});
+/**
+* @param {Scope.Reference} ref
+* @returns {boolean}
+*/
+const isConstant = (ref) => (ref.resolved?.defs ?? []).some((def) => def.node.type === "VariableDeclarator" && def.node.init?.type === "Literal" || def.node.init?.type === "TemplateLiteral" || def.node.init?.type === "ArrayExpression" || def.node.init?.type === "ObjectExpression");
+/**
+* @param {Scope.Reference} ref
+* @returns {boolean}
+*/
+const isUseRef = (ref) => ref.identifier.type === "Identifier" && ref.identifier.name === "useRef" || ref.identifier.parent.type === "MemberExpression" && ref.identifier.parent.object.name === "React" && ref.identifier.parent.property.name === "useRef";
+/**
+* @param {Scope.Reference} ref
+* @returns {boolean}
+*/
+const isRef = (ref) => ref.resolved?.defs.some((def) => def.node.type === "VariableDeclarator" && def.node.init?.type === "CallExpression" && (def.node.init.callee.type === "Identifier" && def.node.init.callee.name === "useRef" || def.node.init.callee.type === "MemberExpression" && def.node.init.callee.object.name === "React" && def.node.init.callee.property.name === "useRef"));
+/**
+* Whether the reference's `current` property is being accessed.
+* Heuristic for whether the reference is a React ref object.
+* Because we don't always have access to the `useRef` call itself.
+* For example when receiving a ref from props.
+*
+* @param {Scope.Reference} ref
+* @returns {boolean}
+*/
+const isRefCurrent = (ref) => ref.identifier.parent.type === "MemberExpression" && ref.identifier.parent.property.type === "Identifier" && ref.identifier.parent.property.name === "current";
+/**
+* Does not include `useLayoutEffect`.
+* When used correctly, it interacts with the DOM = external system = (probably) valid effect.
+* When used incorrectly, it's probably too difficult to accurately analyze anyway.
+*
+* @param {Rule.Node} node
+* @returns {boolean}
+*/
+const isUseEffect = (node) => node.type === "CallExpression" && (node.callee.type === "Identifier" && node.callee.name === "useEffect" || node.callee.type === "MemberExpression" && node.callee.object.name === "React" && node.callee.property.name === "useEffect");
+/**
+* @param {Rule.Node} node - The `useEffect` `CallExpression` node
+* @returns {Rule.Node | undefined}
+*/
+const getEffectFn = (node) => {
+	const effectFn = node.arguments[0];
+	if (effectFn?.type !== "ArrowFunctionExpression" && effectFn?.type !== "FunctionExpression") return;
+	return effectFn;
+};
+/**
+* @param {Rule.RuleContext} context
+* @param {Rule.Node} node - The `useEffect` `CallExpression` node
+* @returns {Scope.Reference[] | undefined}
+*/
+const getEffectFnRefs = (context, node) => {
+	const effectFn = getEffectFn(node);
+	return effectFn ? getDownstreamRefs(context, effectFn) : void 0;
+};
+/**
+* @param {Rule.RuleContext} context
+* @param {Rule.Node} node - The `useEffect` `CallExpression` node
+* @returns {Scope.Reference[] | undefined}
+*/
+function getEffectDepsRefs(context, node) {
+	const depsArr = node.arguments[1];
+	if (depsArr?.type !== "ArrayExpression") return;
+	return getDownstreamRefs(context, depsArr);
+}
+/**
+* @param {Rule.RuleContext} context
+* @param {Scope.Reference} ref
+* @returns {boolean} Whether this reference eventually calls a state setter function or a method on state.
+*/
+const callsStateSetter = (context, ref) => isEventualCallTo(context, ref, isStateSetter);
+/**
+* @param {Rule.RuleContext} context
+* @param {Scope.Reference} ref
+* @returns {boolean} Whether this reference eventually calls a prop function or a method on a prop.
+*/
+const callsProp = (context, ref) => isEventualCallTo(context, ref, isProp);
+/**
+* @param {Rule.RuleContext} context
+* @param {Scope.Reference} ref
+* @returns {boolean} Whether this reference eventually calls a method on a ref.
+*/
+const callsRef = (context, ref) => isEventualCallTo(context, ref, (ref$1) => isRefCurrent(ref$1) || isRef(ref$1));
+/**
+* @param context {Rule.RuleContext}
+* @param {Scope.Reference} ref
+* @returns {Rule.Node | undefined} The `VariableDeclarator` node of the `useState` call.
+*/
+const getUseStateDecl = (context, ref) => {
+	let node = getUpstreamRefs(context, ref).find((ref$1) => isUseState(ref$1))?.identifier;
+	while (node && node.type !== "VariableDeclarator") node = node.parent;
+	return node;
+};
+/**
+* While it *could* be an anti-pattern or unnecessary, effects *are* meant to synchronize systems.
+* So we presume that a "subscription effect" is usually valid, or at least may be more readable.
+*
+* TODO: We might be able to use this more granularly, e.g. ignore state setters inside a subscription effect,
+* instead of ignoring the whole effect...? But it'd have to be more complicated, like also ignore the same state setters called in the body.
+*
+* @param {Rule.Node} node - The `useEffect` `CallExpression` node
+* @returns {boolean}
+*/
+const hasCleanup = (node) => {
+	const effectFn = node.arguments[0];
+	return (effectFn.type === "ArrowFunctionExpression" || effectFn.type === "FunctionExpression") && effectFn.body.type === "BlockStatement" && effectFn.body.body.some((stmt) => stmt.type === "ReturnStatement" && stmt.argument);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.8.1_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/rules/no-empty-effect.js
+/**
+* @type {import("eslint").Rule.RuleModule}
+*/
+var no_empty_effect_default = {
+	meta: {
+		type: "suggestion",
+		docs: { description: "Disallow empty effects." },
+		schema: [],
+		messages: { avoidEmptyEffect: "This effect is empty and could be removed." }
+	},
+	create: (context) => ({ CallExpression: (node) => {
+		if (!isUseEffect(node)) return;
+		if (node.arguments?.length === 0 || getEffectFnRefs(context, node)?.length === 0) context.report({
+			node,
+			messageId: "avoidEmptyEffect"
+		});
+	} })
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.8.1_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/rules/no-adjust-state-on-prop-change.js
+/**
+* @type {import("eslint").Rule.RuleModule}
+*/
+var no_adjust_state_on_prop_change_default = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Disallow adjusting state in an effect when a prop changes.",
+			url: "https://react.dev/learn/you-might-not-need-an-effect#adjusting-some-state-when-a-prop-changes"
+		},
+		schema: [],
+		messages: { avoidAdjustingStateWhenAPropChanges: "Avoid adjusting state when a prop changes. Instead, adjust the state directly during render, or refactor your state to avoid this need entirely." }
+	},
+	create: (context) => ({ CallExpression: (node) => {
+		if (!isUseEffect(node)) return;
+		const effectFnRefs = getEffectFnRefs(context, node);
+		const depsRefs = getEffectDepsRefs(context, node);
+		if (!effectFnRefs || !depsRefs) return;
+		const isSomeDepsProps = depsRefs.flatMap((ref) => getUpstreamRefs(context, ref)).some((ref) => isProp(ref));
+		effectFnRefs.filter((ref) => callsStateSetter(context, ref)).filter((ref) => isSynchronous(ref.identifier, getEffectFn(node))).forEach((ref) => {
+			const callExpr = getCallExpr(ref);
+			const isSomeArgsProps = getArgsUpstreamRefs(context, ref).some((ref$1) => isProp(ref$1));
+			if (isSomeDepsProps && !isSomeArgsProps) context.report({
+				node: callExpr,
+				messageId: "avoidAdjustingStateWhenAPropChanges"
+			});
+		});
+	} })
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.8.1_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/rules/no-reset-all-state-on-prop-change.js
+/**
+* @type {import("eslint").Rule.RuleModule}
+*/
+var no_reset_all_state_on_prop_change_default = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Disallow resetting all state in an effect when a prop changes.",
+			url: "https://react.dev/learn/you-might-not-need-an-effect#resetting-all-state-when-a-prop-changes"
+		},
+		schema: [],
+		messages: { avoidResettingAllStateWhenAPropChanges: "Avoid resetting all state when a prop changes. If \"{{prop}}\" is a key, pass it as `key` instead so React will reset the component." }
+	},
+	create: (context) => ({ CallExpression: (node) => {
+		if (!isUseEffect(node)) return;
+		const effectFnRefs = getEffectFnRefs(context, node);
+		const depsRefs = getEffectDepsRefs(context, node);
+		if (!effectFnRefs || !depsRefs) return;
+		const containingNode = findContainingNode(node);
+		if (containingNode && isCustomHook(containingNode)) return;
+		const propUsedToResetAllState = findPropUsedToResetAllState(context, effectFnRefs, depsRefs, node);
+		if (propUsedToResetAllState) context.report({
+			node,
+			messageId: "avoidResettingAllStateWhenAPropChanges",
+			data: { prop: propUsedToResetAllState.identifier.name }
+		});
+	} })
+};
+const findPropUsedToResetAllState = (context, effectFnRefs, depsRefs, useEffectNode) => {
+	const stateSetterRefs = effectFnRefs.filter((ref) => callsStateSetter(context, ref));
+	return stateSetterRefs.length > 0 && stateSetterRefs.every((ref) => isSetStateToInitialValue(context, ref)) && stateSetterRefs.length === countUseStates(context, findContainingNode(useEffectNode)) ? depsRefs.flatMap((ref) => getUpstreamRefs(context, ref)).find((ref) => isProp(ref)) : void 0;
+};
+const isSetStateToInitialValue = (context, setterRef) => {
+	const setStateToValue = getCallExpr(setterRef).arguments[0];
+	const stateInitialValue = getUseStateDecl(context, setterRef).init.arguments[0];
+	const isUndefined = (node) => node === void 0 || node.name === "undefined";
+	if (isUndefined(setStateToValue) && isUndefined(stateInitialValue)) return true;
+	if (setStateToValue === null && stateInitialValue === null) return true;
+	else if (setStateToValue && !stateInitialValue || !setStateToValue && stateInitialValue) return false;
+	return context.sourceCode.getText(setStateToValue) === context.sourceCode.getText(stateInitialValue);
+};
+const countUseStates = (context, componentNode) => {
+	if (!componentNode) return 0;
+	return getDownstreamRefs(context, componentNode).filter((ref) => isState(ref)).length;
+};
+const findContainingNode = (node) => {
+	if (!node) return;
+	else if (isReactFunctionalComponent(node) || isReactFunctionalHOC(node) || isCustomHook(node)) return node;
+	else return findContainingNode(node.parent);
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.8.1_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/rules/no-event-handler.js
+/**
+* @type {import("eslint").Rule.RuleModule}
+*/
+var no_event_handler_default = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Disallow using state and an effect as an event handler.",
+			url: "https://react.dev/learn/you-might-not-need-an-effect#sharing-logic-between-event-handlers"
+		},
+		schema: [],
+		messages: { avoidEventHandler: "Avoid using state and effects as an event handler. Instead, call the event handling code directly when the event occurs." }
+	},
+	create: (context) => ({ CallExpression: (node) => {
+		if (!isUseEffect(node) || hasCleanup(node)) return;
+		const effectFnRefs = getEffectFnRefs(context, node);
+		const depsRefs = getEffectDepsRefs(context, node);
+		if (!effectFnRefs || !depsRefs) return;
+		findDownstreamNodes(context, node, "IfStatement").filter((ifNode) => !ifNode.alternate).filter((ifNode) => getDownstreamRefs(context, ifNode.test).flatMap((ref) => getUpstreamRefs(context, ref)).some((ref) => isState(ref))).forEach((ifNode) => {
+			context.report({
+				node: ifNode.test,
+				messageId: "avoidEventHandler"
+			});
+		});
+	} })
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.8.1_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/rules/no-pass-live-state-to-parent.js
+/**
+* @type {import("eslint").Rule.RuleModule}
+*/
+var no_pass_live_state_to_parent_default = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Disallow passing live state to parent components in an effect.",
+			url: "https://react.dev/learn/you-might-not-need-an-effect#notifying-parent-components-about-state-changes"
+		},
+		schema: [],
+		messages: { avoidPassingLiveStateToParent: "Avoid passing live state to parents in an effect. Instead, lift the state to the parent and pass it down to the child as a prop." }
+	},
+	create: (context) => ({ CallExpression: (node) => {
+		if (!isUseEffect(node)) return;
+		const effectFnRefs = getEffectFnRefs(context, node);
+		const depsRefs = getEffectDepsRefs(context, node);
+		if (!effectFnRefs || !depsRefs) return;
+		effectFnRefs.filter((ref) => callsProp(context, ref)).filter((ref) => isSynchronous(ref.identifier, getEffectFn(node))).forEach((ref) => {
+			const callExpr = getCallExpr(ref);
+			if (getArgsUpstreamRefs(context, ref).some((ref$1) => isState(ref$1))) context.report({
+				node: callExpr,
+				messageId: "avoidPassingLiveStateToParent"
+			});
+		});
+	} })
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.8.1_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/rules/no-initialize-state.js
+/**
+* @type {import("eslint").Rule.RuleModule}
+*/
+var no_initialize_state_default = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Disallow initializing state in an effect.",
+			url: "https://tkdodo.eu/blog/avoiding-hydration-mismatches-with-use-sync-external-store"
+		},
+		schema: [],
+		messages: { avoidInitializingState: "Avoid initializing state in an effect. Instead, initialize \"{{state}}\"'s `useState()` with \"{{arguments}}\". For SSR hydration, prefer `useSyncExternalStore()`." }
+	},
+	create: (context) => ({ CallExpression: (node) => {
+		if (!isUseEffect(node)) return;
+		const effectFnRefs = getEffectFnRefs(context, node);
+		const depsRefs = getEffectDepsRefs(context, node);
+		if (!effectFnRefs || !depsRefs) return;
+		if (depsRefs.length > 0) return;
+		effectFnRefs.filter((ref) => callsStateSetter(context, ref)).filter((ref) => isSynchronous(ref.identifier, getEffectFn(node))).forEach((ref) => {
+			const callExpr = getCallExpr(ref);
+			const useStateNode = getUseStateDecl(context, ref);
+			const stateName = (useStateNode.id.elements[0] ?? useStateNode.id.elements[1])?.name;
+			const argumentText = callExpr.arguments[0] ? context.sourceCode.getText(callExpr.arguments[0]) : "undefined";
+			context.report({
+				node: getCallExpr(ref),
+				messageId: "avoidInitializingState",
+				data: {
+					state: stateName,
+					arguments: argumentText
+				}
+			});
+		});
+	} })
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.8.1_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/rules/no-chain-state-updates.js
+/**
+* @type {import("eslint").Rule.RuleModule}
+*/
+var no_chain_state_updates_default = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Disallow chaining state changes in an effect.",
+			url: "https://react.dev/learn/you-might-not-need-an-effect#chains-of-computations"
+		},
+		schema: [],
+		messages: { avoidChainingStateUpdates: "Avoid chaining state changes. When possible, update all relevant state simultaneously." }
+	},
+	create: (context) => ({ CallExpression: (node) => {
+		if (!isUseEffect(node) || hasCleanup(node)) return;
+		const effectFnRefs = getEffectFnRefs(context, node);
+		const depsRefs = getEffectDepsRefs(context, node);
+		if (!effectFnRefs || !depsRefs) return;
+		const isSomeDepsState = depsRefs.flatMap((ref) => getUpstreamRefs(context, ref)).some((ref) => isState(ref));
+		effectFnRefs.filter((ref) => callsStateSetter(context, ref)).filter((ref) => isSynchronous(ref.identifier, getEffectFn(node))).forEach((ref) => {
+			const callExpr = getCallExpr(ref);
+			const isSomeArgsState = getArgsUpstreamRefs(context, ref).some((ref$1) => isState(ref$1));
+			if (isSomeDepsState && !isSomeArgsState) context.report({
+				node: callExpr,
+				messageId: "avoidChainingStateUpdates"
+			});
+		});
+	} })
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.8.1_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/rules/no-derived-state.js
+/**
+* @type {import('eslint').Rule.RuleModule}
+*/
+var no_derived_state_default = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Disallow storing derived state in an effect.",
+			url: "https://react.dev/learn/you-might-not-need-an-effect#updating-state-based-on-props-or-state"
+		},
+		schema: [],
+		messages: {
+			avoidDerivedState: "Avoid storing derived state. Compute \"{{state}}\" directly during render, optionally with `useMemo` if it's expensive.",
+			avoidSingleSetter: "Avoid storing derived state. \"{{state}}\" is only set here, and thus could be computed directly during render."
+		}
+	},
+	create: (context) => ({ CallExpression: (node) => {
+		if (!isUseEffect(node) || hasCleanup(node)) return;
+		const effectFnRefs = getEffectFnRefs(context, node);
+		const depsRefs = getEffectDepsRefs(context, node);
+		if (!effectFnRefs || !depsRefs) return;
+		effectFnRefs.filter((ref) => callsStateSetter(context, ref)).filter((ref) => isSynchronous(ref.identifier, getEffectFn(node))).forEach((ref) => {
+			const callExpr = getCallExpr(ref);
+			const useStateNode = getUseStateDecl(context, ref);
+			const stateName = (useStateNode?.id.elements[0] ?? useStateNode?.id.elements[1])?.name;
+			const argsUpstreamRefs = getArgsUpstreamRefs(context, ref);
+			const depsUpstreamRefs = depsRefs.flatMap((ref$1) => getUpstreamRefs(context, ref$1));
+			const isSomeArgsInternal = argsUpstreamRefs.some((ref$1) => isState(ref$1) || isProp(ref$1));
+			const isValueAlwaysInSync = argsUpstreamRefs.length && argsUpstreamRefs.every((argRef) => depsUpstreamRefs.some((depRef) => argRef.resolved == depRef.resolved)) && countCalls(ref) === 1;
+			if (isSomeArgsInternal) context.report({
+				node: callExpr,
+				messageId: "avoidDerivedState",
+				data: { state: stateName }
+			});
+			else if (isValueAlwaysInSync) context.report({
+				node: callExpr,
+				messageId: "avoidSingleSetter",
+				data: { state: stateName }
+			});
+		});
+	} })
+};
+const countCalls = (ref) => ref.resolved.references.filter((ref$1) => ref$1.identifier.parent.type === "CallExpression").length;
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.8.1_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/rules/no-pass-data-to-parent.js
+/**
+* @type {import("eslint").Rule.RuleModule}
+*/
+var no_pass_data_to_parent_default = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Disallow passing data to parents in an effect.",
+			url: "https://react.dev/learn/you-might-not-need-an-effect#passing-data-to-the-parent"
+		},
+		schema: [],
+		messages: { avoidPassingDataToParent: "Avoid passing data to parents in an effect. Instead, let the parent fetch the data itself and pass it down to the child as a prop." }
+	},
+	create: (context) => ({ CallExpression: (node) => {
+		if (!isUseEffect(node) || hasCleanup(node)) return;
+		const effectFnRefs = getEffectFnRefs(context, node);
+		const depsRefs = getEffectDepsRefs(context, node);
+		if (!effectFnRefs || !depsRefs) return;
+		effectFnRefs.filter((ref) => callsProp(context, ref)).filter((ref) => !callsRef(context, ref)).filter((ref) => isSynchronous(ref.identifier, getEffectFn(node))).forEach((ref) => {
+			const callExpr = getCallExpr(ref);
+			if (getUpstreamRefs(context, ref).map((ref$1) => getCallExpr(ref$1)).filter(Boolean).flatMap((callExpr$1) => callExpr$1.arguments).flatMap((arg) => getDownstreamRefs(context, arg)).flatMap((ref$1) => getUpstreamRefs(context, ref$1, "leaf")).some((ref$1) => !isUseState(ref$1) && !isProp(ref$1) && !isUseRef(ref$1) && !isRefCurrent(ref$1) && !isConstant(ref$1))) context.report({
+				node: callExpr,
+				messageId: "avoidPassingDataToParent"
+			});
+		});
+	} })
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.8.1_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/rules/no-pass-ref-to-parent.js
+/**
+* @type {import("eslint").Rule.RuleModule}
+*/
+var no_pass_ref_to_parent_default = {
+	meta: {
+		type: "suggestion",
+		docs: {
+			description: "Disallow passing refs, or data from callbacks registered on them, to parents in an effect. Use `forwardRef` instead.",
+			url: "https://react.dev/reference/react/forwardRef"
+		},
+		schema: [],
+		messages: {
+			avoidPassingRefToParent: "Avoid passing refs to parents in an effect. Use `forwardRef` instead.",
+			avoidPropCallbackInRefCallback: "Avoid calling props inside callbacks registered on refs in an effect. Use `forwardRef` to register the callback in the parent instead.",
+			avoidReceivingRefFromParent: "Avoid receiving refs from parents to use in an effect. Use `forwardRef` instead."
+		}
+	},
+	create: (context) => ({ CallExpression: (node) => {
+		if (!isUseEffect(node) || hasCleanup(node)) return;
+		const effectFnRefs = getEffectFnRefs(context, node);
+		const depsRefs = getEffectDepsRefs(context, node);
+		if (!effectFnRefs || !depsRefs) return;
+		effectFnRefs.filter((ref) => callsProp(context, ref)).forEach((ref) => {
+			const callExpr = getCallExpr(ref);
+			if (getArgsUpstreamRefs(context, ref).some((ref$1) => isRef(ref$1))) context.report({
+				node: callExpr,
+				messageId: "avoidPassingRefToParent"
+			});
+		});
+		effectFnRefs.filter((ref) => callsRef(context, ref)).forEach((ref) => {
+			const callExpr = getCallExpr(ref);
+			if (getArgsUpstreamRefs(context, ref).some((ref$1) => callsProp(context, ref$1))) context.report({
+				node: callExpr,
+				messageId: "avoidPropCallbackInRefCallback"
+			});
+		});
+		effectFnRefs.filter((ref) => callsProp(context, ref) && callsRef(context, ref)).forEach((ref) => {
+			const callExpr = getCallExpr(ref);
+			context.report({
+				node: callExpr,
+				messageId: "avoidReceivingRefFromParent"
+			});
+		});
+	} })
+};
+
+//#endregion
+//#region ../../node_modules/.pnpm/eslint-plugin-react-you-might-not-need-an-effect@0.8.1_eslint@9.39.2_jiti@2.6.1_/node_modules/eslint-plugin-react-you-might-not-need-an-effect/src/index.js
+/**
+* @type {import("eslint").ESLint.Plugin}
+*/
+const plugin = {
+	meta: { name: "react-you-might-not-need-an-effect" },
+	configs: {},
+	rules: {
+		"no-empty-effect": no_empty_effect_default,
+		"no-adjust-state-on-prop-change": no_adjust_state_on_prop_change_default,
+		"no-reset-all-state-on-prop-change": no_reset_all_state_on_prop_change_default,
+		"no-event-handler": no_event_handler_default,
+		"no-pass-live-state-to-parent": no_pass_live_state_to_parent_default,
+		"no-pass-data-to-parent": no_pass_data_to_parent_default,
+		"no-pass-ref-to-parent": no_pass_ref_to_parent_default,
+		"no-initialize-state": no_initialize_state_default,
+		"no-chain-state-updates": no_chain_state_updates_default,
+		"no-derived-state": no_derived_state_default
+	}
+};
+const recommendedRules = Object.keys(plugin.rules).reduce((acc, ruleName) => {
+	acc[plugin.meta.name + "/" + ruleName] = "warn";
+	return acc;
+}, {});
+const languageOptions = {
+	globals: { ...globals.browser },
+	parserOptions: { ecmaFeatures: { jsx: true } }
+};
+Object.assign(plugin.configs, {
+	recommended: {
+		files: ["**/*.{js,jsx,mjs,cjs,ts,tsx,mts,cts}"],
+		plugins: { [plugin.meta.name]: plugin },
+		rules: recommendedRules,
+		languageOptions
+	},
+	"legacy-recommended": {
+		plugins: [plugin.meta.name],
+		rules: recommendedRules,
+		...languageOptions
+	}
+});
+var src_default = plugin;
+
+//#endregion
+export { src_default as default };
+//# sourceMappingURL=src-BncWNtPe.js.map