@mggarofalo/eslint-plugin-react-hook-stability 0.1.1

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+import type { TSESLint } from "@typescript-eslint/utils";
+declare const _default: {
+    configs: {
+        recommended: {
+            plugins: {
+                "react-hook-stability": {
+                    meta: {
+                        name: string;
+                        version: string;
+                    };
+                    rules: {
+                        "require-stable-hook-returns": TSESLint.RuleModule<"unstableReturn", [], unknown, TSESLint.RuleListener> & {
+                            name: string;
+                        };
+                    };
+                };
+            };
+            rules: {
+                "react-hook-stability/require-stable-hook-returns": "warn";
+            };
+        };
+    };
+    meta: {
+        name: string;
+        version: string;
+    };
+    rules: {
+        "require-stable-hook-returns": TSESLint.RuleModule<"unstableReturn", [], unknown, TSESLint.RuleListener> & {
+            name: string;
+        };
+    };
+};
+export default _default;

package/dist/index.js

@@ -0,0 +1,21 @@
+import { rule } from "./rules/require-stable-hook-returns.js";
+const plugin = {
+    meta: {
+        name: "@mggarofalo/eslint-plugin-react-hook-stability",
+        version: "0.1.0",
+    },
+    rules: {
+        "require-stable-hook-returns": rule,
+    },
+};
+const configs = {
+    recommended: {
+        plugins: {
+            "react-hook-stability": plugin,
+        },
+        rules: {
+            "react-hook-stability/require-stable-hook-returns": "warn",
+        },
+    },
+};
+export default { ...plugin, configs };

package/dist/rules/require-stable-hook-returns.d.ts

@@ -0,0 +1,4 @@
+import { ESLintUtils } from "@typescript-eslint/utils";
+export declare const rule: ESLintUtils.RuleModule<"unstableReturn", [], unknown, ESLintUtils.RuleListener> & {
+    name: string;
+};

package/dist/rules/require-stable-hook-returns.js

@@ -0,0 +1,269 @@
+import { AST_NODE_TYPES, ESLintUtils } from "@typescript-eslint/utils";
+import { isHookName, getFunctionName, isFunctionNode, } from "../utils/ast-helpers.js";
+import { processDeclarator, resolveExpressionKind, } from "../utils/variable-tracker.js";
+import { ensureReactImport } from "../utils/import-manager.js";
+const UNSTABLE_KINDS = new Set([
+    "bare-function",
+    "object-literal",
+    "array-literal",
+]);
+const MESSAGE_MAP = {
+    "bare-function": "useCallback",
+    "object-literal": "useMemo",
+    "array-literal": "useMemo",
+};
+const createRule = ESLintUtils.RuleCreator(() => "https://github.com/mggarofalo/eslint-plugins/tree/main/packages/eslint-plugin-react-hook-stability#require-stable-hook-returns");
+export const rule = createRule({
+    name: "require-stable-hook-returns",
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Require that exported custom hooks return stable references (wrapped in useCallback/useMemo)",
+        },
+        fixable: "code",
+        schema: [],
+        messages: {
+            unstableReturn: 'Hook "{{hookName}}" returns unstable {{kind}} "{{propName}}". Wrap it in {{wrapper}}.',
+        },
+    },
+    defaultOptions: [],
+    create(context) {
+        const exportedHookNames = new Set();
+        const hookScopeStack = [];
+        const sourceCode = context.sourceCode;
+        // We need to track function nodes that correspond to exported hooks so we
+        // can push/pop scope. We collect them in Program then match in function visitors.
+        const hookFunctionNodes = new Set();
+        function currentScope() {
+            return hookScopeStack[hookScopeStack.length - 1];
+        }
+        /**
+         * Pre-scan: collect exported hook names from export declarations.
+         */
+        function collectExportedHooks(program) {
+            for (const node of program.body) {
+                switch (node.type) {
+                    case AST_NODE_TYPES.ExportNamedDeclaration: {
+                        // export function useFoo() {}
+                        if (node.declaration?.type === AST_NODE_TYPES.FunctionDeclaration &&
+                            node.declaration.id &&
+                            isHookName(node.declaration.id.name)) {
+                            exportedHookNames.add(node.declaration.id.name);
+                            hookFunctionNodes.add(node.declaration);
+                        }
+                        // export const useFoo = () => {} or export const useFoo = function() {}
+                        if (node.declaration?.type === AST_NODE_TYPES.VariableDeclaration) {
+                            for (const decl of node.declaration.declarations) {
+                                if (decl.id.type === AST_NODE_TYPES.Identifier &&
+                                    isHookName(decl.id.name) &&
+                                    decl.init &&
+                                    isFunctionNode(decl.init)) {
+                                    exportedHookNames.add(decl.id.name);
+                                    hookFunctionNodes.add(decl.init);
+                                }
+                            }
+                        }
+                        // export { useFoo }
+                        for (const spec of node.specifiers) {
+                            if (spec.type === AST_NODE_TYPES.ExportSpecifier &&
+                                spec.local.type === AST_NODE_TYPES.Identifier &&
+                                isHookName(spec.local.name)) {
+                                exportedHookNames.add(spec.local.name);
+                            }
+                        }
+                        break;
+                    }
+                    case AST_NODE_TYPES.ExportDefaultDeclaration: {
+                        // export default function useFoo() {}
+                        if (node.declaration.type === AST_NODE_TYPES.FunctionDeclaration &&
+                            node.declaration.id &&
+                            isHookName(node.declaration.id.name)) {
+                            exportedHookNames.add(node.declaration.id.name);
+                            hookFunctionNodes.add(node.declaration);
+                        }
+                        // export default useFoo (identifier reference — resolved later)
+                        if (node.declaration.type === AST_NODE_TYPES.Identifier &&
+                            isHookName(node.declaration.name)) {
+                            exportedHookNames.add(node.declaration.name);
+                        }
+                        break;
+                    }
+                }
+            }
+        }
+        /**
+         * For `export { useFoo }` and `export default useFoo` patterns,
+         * we need to find the actual function declarations/expressions in the program scope.
+         */
+        function resolveExportedIdentifiers(program) {
+            for (const node of program.body) {
+                // function useFoo() { ... } (top-level, referenced by export specifier)
+                if (node.type === AST_NODE_TYPES.FunctionDeclaration &&
+                    node.id &&
+                    exportedHookNames.has(node.id.name) &&
+                    !hookFunctionNodes.has(node)) {
+                    hookFunctionNodes.add(node);
+                }
+                // const useFoo = () => { ... } (top-level, referenced by export specifier)
+                if (node.type === AST_NODE_TYPES.VariableDeclaration) {
+                    for (const decl of node.declarations) {
+                        if (decl.id.type === AST_NODE_TYPES.Identifier &&
+                            exportedHookNames.has(decl.id.name) &&
+                            decl.init &&
+                            isFunctionNode(decl.init) &&
+                            !hookFunctionNodes.has(decl.init)) {
+                            hookFunctionNodes.add(decl.init);
+                        }
+                    }
+                }
+            }
+        }
+        function enterFunction(node) {
+            const scope = currentScope();
+            // If we're inside a hook scope, increment nesting depth
+            if (scope) {
+                scope.nestedDepth++;
+                return;
+            }
+            // Check if this function node is an exported hook
+            if (hookFunctionNodes.has(node)) {
+                const name = getFunctionName(node) ?? "anonymous";
+                hookScopeStack.push({
+                    name,
+                    variables: new Map(),
+                    nestedDepth: 0,
+                });
+            }
+        }
+        function exitFunction(node) {
+            const scope = currentScope();
+            if (!scope)
+                return;
+            if (scope.nestedDepth > 0) {
+                scope.nestedDepth--;
+                return;
+            }
+            // We're exiting the hook function itself
+            if (hookFunctionNodes.has(node)) {
+                hookScopeStack.pop();
+            }
+        }
+        function analyzeReturnProperties(properties, scope) {
+            for (const prop of properties) {
+                // Skip spread elements — too dynamic
+                if (prop.type === AST_NODE_TYPES.SpreadElement)
+                    continue;
+                if (prop.type !== AST_NODE_TYPES.Property)
+                    continue;
+                const propName = prop.key.type === AST_NODE_TYPES.Identifier
+                    ? prop.key.name
+                    : sourceCode.getText(prop.key);
+                // For shorthand properties (e.g. { setPage }), the value is the identifier
+                const valueNode = prop.value;
+                const { kind, originNode } = resolveExpressionKind(valueNode, scope.variables);
+                if (!UNSTABLE_KINDS.has(kind))
+                    continue;
+                const wrapper = MESSAGE_MAP[kind];
+                context.report({
+                    node: prop,
+                    messageId: "unstableReturn",
+                    data: {
+                        hookName: scope.name,
+                        kind: kind.replace("-", " "),
+                        propName,
+                        wrapper,
+                    },
+                    fix(fixer) {
+                        const fixes = [];
+                        // Wrap the value
+                        const originText = sourceCode.getText(originNode);
+                        if (kind === "bare-function") {
+                            fixes.push(fixer.replaceText(originNode, `useCallback(${originText}, [] /* TODO: add dependencies */)`));
+                            const importFix = ensureReactImport("useCallback", sourceCode, fixer);
+                            if (importFix)
+                                fixes.push(importFix);
+                        }
+                        else {
+                            // object-literal or array-literal
+                            const needsParens = kind === "object-literal";
+                            const inner = needsParens ? `(${originText})` : originText;
+                            fixes.push(fixer.replaceText(originNode, `useMemo(() => ${inner}, [] /* TODO: add dependencies */)`));
+                            const importFix = ensureReactImport("useMemo", sourceCode, fixer);
+                            if (importFix)
+                                fixes.push(importFix);
+                        }
+                        return fixes;
+                    },
+                });
+            }
+        }
+        return {
+            Program(node) {
+                collectExportedHooks(node);
+                resolveExportedIdentifiers(node);
+            },
+            FunctionDeclaration: enterFunction,
+            FunctionExpression: enterFunction,
+            ArrowFunctionExpression: enterFunction,
+            "FunctionDeclaration:exit": exitFunction,
+            "FunctionExpression:exit": exitFunction,
+            "ArrowFunctionExpression:exit": exitFunction,
+            VariableDeclarator(node) {
+                const scope = currentScope();
+                if (!scope || scope.nestedDepth > 0)
+                    return;
+                processDeclarator(node, scope.variables);
+            },
+            // Handle hoisted function declarations inside hooks
+            // (FunctionDeclaration inside hook body at depth 0 is a local function)
+            "FunctionDeclaration[id]"(node) {
+                // This fires before enterFunction increments depth, so check if
+                // the parent scope (before push) has this as a nested function.
+                // Actually, enterFunction runs first via the same selector. We
+                // need to check the scope AFTER enterFunction has run.
+                // At this point, if we're inside a hook, nestedDepth was just
+                // incremented to 1 by enterFunction. So the current scope has
+                // nestedDepth === 1, meaning this is a direct child function declaration.
+                const scope = currentScope();
+                if (!scope)
+                    return;
+                if (scope.nestedDepth === 1 && node.id) {
+                    // This is a function declaration directly inside the hook body
+                    scope.variables.set(node.id.name, {
+                        kind: "bare-function",
+                        node,
+                    });
+                }
+            },
+            ReturnStatement(node) {
+                const scope = currentScope();
+                if (!scope || scope.nestedDepth > 0)
+                    return;
+                if (!node.argument)
+                    return;
+                let returnObj;
+                if (node.argument.type === AST_NODE_TYPES.ObjectExpression) {
+                    returnObj = node.argument;
+                }
+                else if (node.argument.type === AST_NODE_TYPES.Identifier) {
+                    // Trace through variables to find the object
+                    const origin = scope.variables.get(node.argument.name);
+                    if (origin &&
+                        origin.node.type === AST_NODE_TYPES.ObjectExpression) {
+                        returnObj = origin.node;
+                    }
+                    else if (origin && origin.kind === "object-literal") {
+                        // The variable was classified as object-literal but the node might
+                        // be the init which is an ObjectExpression
+                        if (origin.node.type === AST_NODE_TYPES.ObjectExpression) {
+                            returnObj = origin.node;
+                        }
+                    }
+                }
+                if (returnObj) {
+                    analyzeReturnProperties(returnObj.properties, scope);
+                }
+            },
+        };
+    },
+});

package/dist/types.d.ts

@@ -0,0 +1,11 @@
+export type VariableOriginKind = "stable-hook" | "state-setter" | "dispatch" | "ref" | "other-hook" | "primitive" | "bare-function" | "object-literal" | "array-literal" | "unknown";
+export interface VariableOrigin {
+    kind: VariableOriginKind;
+    /** AST node where the value was defined (for auto-fix) */
+    node: import("@typescript-eslint/utils").TSESTree.Node;
+}
+export interface HookScope {
+    name: string;
+    variables: Map<string, VariableOrigin>;
+    nestedDepth: number;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/ast-helpers.d.ts

@@ -0,0 +1,12 @@
+import { TSESTree } from "@typescript-eslint/utils";
+/** Returns true if name matches the React hook naming convention (use + uppercase letter). */
+export declare function isHookName(name: string): boolean;
+/** Extract callee name from a CallExpression, e.g. `useMemo(...)` → "useMemo". */
+export declare function getCalleeName(node: TSESTree.CallExpression): string | undefined;
+/**
+ * Get the function name for a function-like node.
+ * Handles FunctionDeclaration, named FunctionExpression, and variable-assigned arrows/functions.
+ */
+export declare function getFunctionName(node: TSESTree.FunctionDeclaration | TSESTree.FunctionExpression | TSESTree.ArrowFunctionExpression): string | undefined;
+/** Returns true if the node is a function-like (arrow, expression, declaration). */
+export declare function isFunctionNode(node: TSESTree.Node): node is TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression | TSESTree.FunctionDeclaration;

package/dist/utils/ast-helpers.js

@@ -0,0 +1,43 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+/** Returns true if name matches the React hook naming convention (use + uppercase letter). */
+export function isHookName(name) {
+    return /^use[A-Z]/.test(name);
+}
+/** Extract callee name from a CallExpression, e.g. `useMemo(...)` → "useMemo". */
+export function getCalleeName(node) {
+    if (node.callee.type === AST_NODE_TYPES.Identifier) {
+        return node.callee.name;
+    }
+    // e.g. React.useMemo(...)
+    if (node.callee.type === AST_NODE_TYPES.MemberExpression &&
+        node.callee.property.type === AST_NODE_TYPES.Identifier) {
+        return node.callee.property.name;
+    }
+    return undefined;
+}
+/**
+ * Get the function name for a function-like node.
+ * Handles FunctionDeclaration, named FunctionExpression, and variable-assigned arrows/functions.
+ */
+export function getFunctionName(node) {
+    if (node.type === AST_NODE_TYPES.FunctionDeclaration &&
+        node.id) {
+        return node.id.name;
+    }
+    if (node.type === AST_NODE_TYPES.FunctionExpression &&
+        node.id) {
+        return node.id.name;
+    }
+    // Check parent: const useFoo = () => { ... }
+    if (node.parent?.type === AST_NODE_TYPES.VariableDeclarator &&
+        node.parent.id.type === AST_NODE_TYPES.Identifier) {
+        return node.parent.id.name;
+    }
+    return undefined;
+}
+/** Returns true if the node is a function-like (arrow, expression, declaration). */
+export function isFunctionNode(node) {
+    return (node.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+        node.type === AST_NODE_TYPES.FunctionExpression ||
+        node.type === AST_NODE_TYPES.FunctionDeclaration);
+}

package/dist/utils/import-manager.d.ts

@@ -0,0 +1,10 @@
+import { TSESTree } from "@typescript-eslint/utils";
+import type { RuleFixer, RuleFix } from "@typescript-eslint/utils/ts-eslint";
+/**
+ * Ensure that `specifierName` (e.g. "useCallback") is imported from "react".
+ * Returns a fix that either adds it to an existing import or creates a new one.
+ */
+export declare function ensureReactImport(specifierName: string, sourceCode: {
+    ast: TSESTree.Program;
+    getText(node: TSESTree.Node): string;
+}, fixer: RuleFixer): RuleFix | null;

package/dist/utils/import-manager.js

@@ -0,0 +1,33 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+/**
+ * Ensure that `specifierName` (e.g. "useCallback") is imported from "react".
+ * Returns a fix that either adds it to an existing import or creates a new one.
+ */
+export function ensureReactImport(specifierName, sourceCode, fixer) {
+    // Find existing `import { ... } from 'react'`
+    for (const node of sourceCode.ast.body) {
+        if (node.type === AST_NODE_TYPES.ImportDeclaration &&
+            node.source.value === "react") {
+            // Check if already imported
+            const alreadyImported = node.specifiers.some((s) => s.type === AST_NODE_TYPES.ImportSpecifier &&
+                s.imported.type === AST_NODE_TYPES.Identifier &&
+                s.imported.name === specifierName);
+            if (alreadyImported)
+                return null;
+            // Find the last named specifier and add after it
+            const namedSpecifiers = node.specifiers.filter((s) => s.type === AST_NODE_TYPES.ImportSpecifier);
+            if (namedSpecifiers.length > 0) {
+                const last = namedSpecifiers[namedSpecifiers.length - 1];
+                return fixer.insertTextAfter(last, `, ${specifierName}`);
+            }
+            // Has default import but no named specifiers: `import React from 'react'`
+            const defaultSpecifier = node.specifiers.find((s) => s.type === AST_NODE_TYPES.ImportDefaultSpecifier);
+            if (defaultSpecifier) {
+                return fixer.insertTextAfter(defaultSpecifier, `, { ${specifierName} }`);
+            }
+            return null;
+        }
+    }
+    // No react import at all — insert at top of file
+    return fixer.insertTextBefore(sourceCode.ast.body[0], `import { ${specifierName} } from "react";\n`);
+}

package/dist/utils/variable-tracker.d.ts

@@ -0,0 +1,22 @@
+import { TSESTree } from "@typescript-eslint/utils";
+import type { VariableOrigin, VariableOriginKind } from "../types.js";
+/**
+ * Classify the origin of an init expression in a variable declarator.
+ */
+export declare function classifyInit(init: TSESTree.Expression | null | undefined, variables: Map<string, VariableOrigin>): VariableOriginKind;
+/**
+ * Process a VariableDeclarator and record all bindings into the variables map.
+ * Handles:
+ *   const x = expr
+ *   const [a, b] = useHook()
+ *   const { a, b } = useHook()
+ */
+export declare function processDeclarator(declarator: TSESTree.VariableDeclarator, variables: Map<string, VariableOrigin>): void;
+/**
+ * Resolve the stability kind for a return-object property value.
+ * Handles inline expressions and identifier lookups.
+ */
+export declare function resolveExpressionKind(node: TSESTree.Expression, variables: Map<string, VariableOrigin>): {
+    kind: VariableOriginKind;
+    originNode: TSESTree.Node;
+};

package/dist/utils/variable-tracker.js

@@ -0,0 +1,132 @@
+import { AST_NODE_TYPES } from "@typescript-eslint/utils";
+import { getCalleeName, isHookName } from "./ast-helpers.js";
+/**
+ * Classify the origin of an init expression in a variable declarator.
+ */
+export function classifyInit(init, variables) {
+    if (!init)
+        return "unknown";
+    switch (init.type) {
+        case AST_NODE_TYPES.Literal:
+            return "primitive";
+        case AST_NODE_TYPES.TemplateLiteral:
+            return "primitive";
+        case AST_NODE_TYPES.ArrowFunctionExpression:
+        case AST_NODE_TYPES.FunctionExpression:
+            return "bare-function";
+        case AST_NODE_TYPES.ObjectExpression:
+            return "object-literal";
+        case AST_NODE_TYPES.ArrayExpression:
+            return "array-literal";
+        case AST_NODE_TYPES.CallExpression: {
+            const callee = getCalleeName(init);
+            if (!callee)
+                return "unknown";
+            if (callee === "useCallback" || callee === "useMemo")
+                return "stable-hook";
+            if (callee === "useRef")
+                return "ref";
+            if (isHookName(callee))
+                return "other-hook";
+            return "unknown";
+        }
+        case AST_NODE_TYPES.Identifier: {
+            // Trace through variables
+            const origin = variables.get(init.name);
+            return origin ? origin.kind : "unknown";
+        }
+        default:
+            return "unknown";
+    }
+}
+/**
+ * Process a VariableDeclarator and record all bindings into the variables map.
+ * Handles:
+ *   const x = expr
+ *   const [a, b] = useHook()
+ *   const { a, b } = useHook()
+ */
+export function processDeclarator(declarator, variables) {
+    const { id, init } = declarator;
+    if (id.type === AST_NODE_TYPES.Identifier) {
+        const kind = classifyInit(init, variables);
+        variables.set(id.name, { kind, node: init ?? id });
+        return;
+    }
+    // Array destructuring: const [state, setState] = useState()
+    if (id.type === AST_NODE_TYPES.ArrayPattern && init) {
+        const callee = init.type === AST_NODE_TYPES.CallExpression
+            ? getCalleeName(init)
+            : undefined;
+        for (let i = 0; i < id.elements.length; i++) {
+            const el = id.elements[i];
+            if (!el || el.type !== AST_NODE_TYPES.Identifier)
+                continue;
+            let kind;
+            if (callee === "useState" && i === 1) {
+                kind = "state-setter";
+            }
+            else if (callee === "useReducer" && i === 1) {
+                kind = "dispatch";
+            }
+            else if (callee && isHookName(callee)) {
+                kind = "other-hook";
+            }
+            else {
+                kind = "unknown";
+            }
+            variables.set(el.name, { kind, node: el });
+        }
+        return;
+    }
+    // Object destructuring: const { data, refetch } = useQuery()
+    if (id.type === AST_NODE_TYPES.ObjectPattern && init) {
+        const callee = init.type === AST_NODE_TYPES.CallExpression
+            ? getCalleeName(init)
+            : undefined;
+        for (const prop of id.properties) {
+            if (prop.type === AST_NODE_TYPES.Property &&
+                prop.value.type === AST_NODE_TYPES.Identifier) {
+                const kind = callee && isHookName(callee) ? "other-hook" : "unknown";
+                variables.set(prop.value.name, { kind, node: prop.value });
+            }
+        }
+        return;
+    }
+}
+/**
+ * Resolve the stability kind for a return-object property value.
+ * Handles inline expressions and identifier lookups.
+ */
+export function resolveExpressionKind(node, variables) {
+    switch (node.type) {
+        case AST_NODE_TYPES.ArrowFunctionExpression:
+        case AST_NODE_TYPES.FunctionExpression:
+            return { kind: "bare-function", originNode: node };
+        case AST_NODE_TYPES.ObjectExpression:
+            return { kind: "object-literal", originNode: node };
+        case AST_NODE_TYPES.ArrayExpression:
+            return { kind: "array-literal", originNode: node };
+        case AST_NODE_TYPES.Literal:
+        case AST_NODE_TYPES.TemplateLiteral:
+            return { kind: "primitive", originNode: node };
+        case AST_NODE_TYPES.CallExpression: {
+            const callee = getCalleeName(node);
+            if (callee === "useCallback" || callee === "useMemo")
+                return { kind: "stable-hook", originNode: node };
+            if (callee === "useRef")
+                return { kind: "ref", originNode: node };
+            if (callee && isHookName(callee))
+                return { kind: "other-hook", originNode: node };
+            return { kind: "unknown", originNode: node };
+        }
+        case AST_NODE_TYPES.Identifier: {
+            const origin = variables.get(node.name);
+            if (origin)
+                return { kind: origin.kind, originNode: origin.node };
+            return { kind: "unknown", originNode: node };
+        }
+        default:
+            return { kind: "unknown", originNode: node };
+    }
+}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@mggarofalo/eslint-plugin-react-hook-stability",
+  "version": "0.1.1",
+  "description": "ESLint plugin to detect unstable references returned from React hooks",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "test": "vitest run",
+    "test:watch": "vitest"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mggarofalo/eslint-plugins.git",
+    "directory": "packages/eslint-plugin-react-hook-stability"
+  },
+  "homepage": "https://github.com/mggarofalo/eslint-plugins/tree/main/packages/eslint-plugin-react-hook-stability",
+  "bugs": {
+    "url": "https://github.com/mggarofalo/eslint-plugins/issues"
+  },
+  "peerDependencies": {
+    "eslint": ">=9.0.0"
+  },
+  "dependencies": {
+    "@typescript-eslint/utils": "^8.0.0"
+  },
+  "devDependencies": {
+    "@typescript-eslint/rule-tester": "^8.0.0",
+    "eslint": "^9.0.0",
+    "typescript": "^5.5.0",
+    "vitest": "^3.0.0"
+  },
+  "keywords": [
+    "eslint",
+    "eslintplugin",
+    "react",
+    "hooks",
+    "useCallback",
+    "useMemo",
+    "stability"
+  ],
+  "license": "MIT"
+}