eslint-plugin-react-hooks 6.1.0 → 6.2.0-canary-85c427d8-20251003

package/cjs/eslint-plugin-react-hooks.d.ts

@@ -1,11 +1,10 @@
 import * as estree from 'estree';
-import { Rule } from 'eslint';
+import { Rule, Linter } from 'eslint';
 
 declare const plugin: {
     meta: {
         name: string;
     };
-    configs: {};
     rules: {
         'exhaustive-deps': {
             meta: {
@@ -73,6 +72,19 @@ declare const plugin: {
             };
         };
     };
+    configs: {
+        "recommended-legacy": {
+            plugins: Array<string>;
+            rules: Linter.RulesRecord;
+        };
+        "recommended-latest-legacy": {
+            plugins: Array<string>;
+            rules: Linter.RulesRecord;
+        };
+        "flat/recommended": Array<Linter.Config>;
+        "recommended-latest": Array<Linter.Config>;
+        recommended: Array<Linter.Config>;
+    };
 };
 
 export { plugin as default };

package/cjs/eslint-plugin-react-hooks.development.js

@@ -19,7 +19,6 @@ var BabelParser = require('@babel/parser');
 var zod = require('zod');
 var zodValidationError = require('zod-validation-error');
 var crypto = require('crypto');
-var PluginProposalPrivateMethods = require('@babel/plugin-proposal-private-methods');
 var HermesParser = require('hermes-parser');
 var util = require('util');
 
@@ -32075,7 +32074,7 @@ const EnvironmentConfigSchema = zod.z.object({
     moduleTypeProvider: zod.z.nullable(zod.z.function().args(zod.z.string())).default(null),
     customMacros: zod.z.nullable(zod.z.array(MacroSchema)).default(null),
     enableResetCacheOnSourceFileChanges: zod.z.nullable(zod.z.boolean()).default(null),
-    enablePreserveExistingMemoizationGuarantees: zod.z.boolean().default(false),
+    enablePreserveExistingMemoizationGuarantees: zod.z.boolean().default(true),
     validatePreserveExistingMemoizationGuarantees: zod.z.boolean().default(true),
     enablePreserveExistingManualUseMemo: zod.z.boolean().default(false),
     enableForest: zod.z.boolean().default(false),
@@ -45315,6 +45314,29 @@ function collectNonNullsInBlocks(fn, context) {
                     }
                 }
             }
+            else if (fn.env.config.enablePreserveExistingMemoizationGuarantees &&
+                instr.value.kind === 'StartMemoize' &&
+                instr.value.deps != null) {
+                for (const dep of instr.value.deps) {
+                    if (dep.root.kind === 'NamedLocal') {
+                        if (!isImmutableAtInstr(dep.root.value.identifier, instr.id, context)) {
+                            continue;
+                        }
+                        for (let i = 0; i < dep.path.length; i++) {
+                            const pathEntry = dep.path[i];
+                            if (pathEntry.optional) {
+                                break;
+                            }
+                            const depNode = context.registry.getOrCreateProperty({
+                                identifier: dep.root.value.identifier,
+                                path: dep.path.slice(0, i),
+                                reactive: dep.root.value.reactive,
+                            });
+                            assumedNonNullObjects.add(depNode);
+                        }
+                    }
+                }
+            }
         }
         nodes.set(block.id, {
             block,
@@ -54127,20 +54149,6 @@ function getFlowSuppressions(sourceCode) {
     }
     return results;
 }
-function filterUnusedOptOutDirectives(directives) {
-    const results = [];
-    for (const directive of directives) {
-        if (OPT_OUT_DIRECTIVES.has(directive.value.value) &&
-            directive.loc != null) {
-            results.push({
-                loc: directive.loc,
-                directive: directive.value.value,
-                range: [directive.start, directive.end],
-            });
-        }
-    }
-    return results;
-}
 function runReactCompilerImpl({ sourceCode, filename, userOpts, }) {
     var _a, _b;
     const options = parsePluginOptions(Object.assign(Object.assign(Object.assign({}, COMPILER_OPTIONS), userOpts), { environment: Object.assign(Object.assign({}, COMPILER_OPTIONS.environment), userOpts.environment) }));
@@ -54149,7 +54157,6 @@ function runReactCompilerImpl({ sourceCode, filename, userOpts, }) {
         filename,
         userOpts,
         flowSuppressions: [],
-        unusedOptOutDirectives: [],
         events: [],
     };
     const userLogger = options.logger;
@@ -54196,29 +54203,11 @@ function runReactCompilerImpl({ sourceCode, filename, userOpts, }) {
                 filename,
                 highlightCode: false,
                 retainLines: true,
-                plugins: [
-                    [PluginProposalPrivateMethods.default, { loose: true }],
-                    [BabelPluginReactCompiler, options],
-                ],
+                plugins: [[BabelPluginReactCompiler, options]],
                 sourceType: 'module',
                 configFile: false,
                 babelrc: false,
             });
-            if (results.events.filter(e => e.kind === 'CompileError').length === 0) {
-                core$1.traverse(babelAST, {
-                    FunctionDeclaration(path) {
-                        results.unusedOptOutDirectives.push(...filterUnusedOptOutDirectives(path.node.body.directives));
-                    },
-                    ArrowFunctionExpression(path) {
-                        if (path.node.body.type === 'BlockStatement') {
-                            results.unusedOptOutDirectives.push(...filterUnusedOptOutDirectives(path.node.body.directives));
-                        }
-                    },
-                    FunctionExpression(path) {
-                        results.unusedOptOutDirectives.push(...filterUnusedOptOutDirectives(path.node.body.directives));
-                    },
-                });
-            }
         }
         catch (err) {
         }
@@ -54388,53 +54377,31 @@ function makeRule(rule) {
         create,
     };
 }
-const NoUnusedDirectivesRule = {
-    meta: {
-        type: 'suggestion',
-        docs: {
-            recommended: true,
-        },
-        fixable: 'code',
-        hasSuggestions: true,
-        schema: [{ type: 'object', additionalProperties: true }],
-    },
-    create(context) {
-        const results = getReactCompilerResult(context);
-        for (const directive of results.unusedOptOutDirectives) {
-            context.report({
-                message: `Unused '${directive.directive}' directive`,
-                loc: directive.loc,
-                suggest: [
-                    {
-                        desc: 'Remove the directive',
-                        fix(fixer) {
-                            return fixer.removeRange(directive.range);
-                        },
-                    },
-                ],
-            });
-        }
-        return {};
-    },
-};
 const allRules = LintRules.reduce((acc, rule) => {
     acc[rule.name] = { rule: makeRule(rule), severity: rule.severity };
     return acc;
-}, {
-    'no-unused-directives': {
-        rule: NoUnusedDirectivesRule,
-        severity: ErrorSeverity.Error,
-    },
-});
-LintRules.filter(rule => rule.recommended).reduce((acc, rule) => {
+}, {});
+const recommendedRules = LintRules.filter(rule => rule.recommended).reduce((acc, rule) => {
     acc[rule.name] = { rule: makeRule(rule), severity: rule.severity };
     return acc;
-}, {
-    'no-unused-directives': {
-        rule: NoUnusedDirectivesRule,
-        severity: ErrorSeverity.Error,
-    },
-});
+}, {});
+function mapErrorSeverityToESlint(severity) {
+    switch (severity) {
+        case ErrorSeverity.Error: {
+            return 'error';
+        }
+        case ErrorSeverity.Warning: {
+            return 'warn';
+        }
+        case ErrorSeverity.Hint:
+        case ErrorSeverity.Off: {
+            return 'off';
+        }
+        default: {
+            assertExhaustive(severity, `Unhandled severity: ${severity}`);
+        }
+    }
+}
 
 var assert_1;
 var hasRequiredAssert;
@@ -57722,28 +57689,39 @@ function last(array) {
 }
 
 const rules = Object.assign({ 'exhaustive-deps': rule$1, 'rules-of-hooks': rule }, Object.fromEntries(Object.entries(allRules).map(([name, config]) => [name, config.rule])));
-const ruleConfigs = {
+const basicRuleConfigs = {
     'react-hooks/rules-of-hooks': 'error',
     'react-hooks/exhaustive-deps': 'warn',
 };
+const compilerRuleConfigs = Object.fromEntries(Object.entries(recommendedRules).map(([name, ruleConfig]) => {
+    return [
+        `react-hooks/${name}`,
+        mapErrorSeverityToESlint(ruleConfig.severity),
+    ];
+}));
+const allRuleConfigs = Object.assign(Object.assign({}, basicRuleConfigs), compilerRuleConfigs);
 const plugin = {
     meta: {
         name: 'eslint-plugin-react-hooks',
     },
-    configs: {},
     rules,
+    configs: {},
 };
 Object.assign(plugin.configs, {
     'recommended-legacy': {
         plugins: ['react-hooks'],
-        rules: ruleConfigs,
+        rules: basicRuleConfigs,
+    },
+    'recommended-latest-legacy': {
+        plugins: ['react-hooks'],
+        rules: allRuleConfigs,
     },
     'flat/recommended': [
         {
             plugins: {
                 'react-hooks': plugin,
             },
-            rules: ruleConfigs,
+            rules: basicRuleConfigs,
         },
     ],
     'recommended-latest': [
@@ -57751,13 +57729,17 @@ Object.assign(plugin.configs, {
             plugins: {
                 'react-hooks': plugin,
             },
-            rules: ruleConfigs,
+            rules: allRuleConfigs,
+        },
+    ],
+    recommended: [
+        {
+            plugins: {
+                'react-hooks': plugin,
+            },
+            rules: basicRuleConfigs,
         },
     ],
-    recommended: {
-        plugins: ['react-hooks'],
-        rules: ruleConfigs,
-    },
 });
 
 module.exports = plugin;

package/cjs/eslint-plugin-react-hooks.production.js

@@ -15,7 +15,6 @@ var BabelParser = require('@babel/parser');
 var zod = require('zod');
 var zodValidationError = require('zod-validation-error');
 var crypto = require('crypto');
-var PluginProposalPrivateMethods = require('@babel/plugin-proposal-private-methods');
 var HermesParser = require('hermes-parser');
 var util = require('util');
 
@@ -31902,7 +31901,7 @@ const EnvironmentConfigSchema = zod.z.object({
     moduleTypeProvider: zod.z.nullable(zod.z.function().args(zod.z.string())).default(null),
     customMacros: zod.z.nullable(zod.z.array(MacroSchema)).default(null),
     enableResetCacheOnSourceFileChanges: zod.z.nullable(zod.z.boolean()).default(null),
-    enablePreserveExistingMemoizationGuarantees: zod.z.boolean().default(false),
+    enablePreserveExistingMemoizationGuarantees: zod.z.boolean().default(true),
     validatePreserveExistingMemoizationGuarantees: zod.z.boolean().default(true),
     enablePreserveExistingManualUseMemo: zod.z.boolean().default(false),
     enableForest: zod.z.boolean().default(false),
@@ -45142,6 +45141,29 @@ function collectNonNullsInBlocks(fn, context) {
                     }
                 }
             }
+            else if (fn.env.config.enablePreserveExistingMemoizationGuarantees &&
+                instr.value.kind === 'StartMemoize' &&
+                instr.value.deps != null) {
+                for (const dep of instr.value.deps) {
+                    if (dep.root.kind === 'NamedLocal') {
+                        if (!isImmutableAtInstr(dep.root.value.identifier, instr.id, context)) {
+                            continue;
+                        }
+                        for (let i = 0; i < dep.path.length; i++) {
+                            const pathEntry = dep.path[i];
+                            if (pathEntry.optional) {
+                                break;
+                            }
+                            const depNode = context.registry.getOrCreateProperty({
+                                identifier: dep.root.value.identifier,
+                                path: dep.path.slice(0, i),
+                                reactive: dep.root.value.reactive,
+                            });
+                            assumedNonNullObjects.add(depNode);
+                        }
+                    }
+                }
+            }
         }
         nodes.set(block.id, {
             block,
@@ -53954,20 +53976,6 @@ function getFlowSuppressions(sourceCode) {
     }
     return results;
 }
-function filterUnusedOptOutDirectives(directives) {
-    const results = [];
-    for (const directive of directives) {
-        if (OPT_OUT_DIRECTIVES.has(directive.value.value) &&
-            directive.loc != null) {
-            results.push({
-                loc: directive.loc,
-                directive: directive.value.value,
-                range: [directive.start, directive.end],
-            });
-        }
-    }
-    return results;
-}
 function runReactCompilerImpl({ sourceCode, filename, userOpts, }) {
     var _a, _b;
     const options = parsePluginOptions(Object.assign(Object.assign(Object.assign({}, COMPILER_OPTIONS), userOpts), { environment: Object.assign(Object.assign({}, COMPILER_OPTIONS.environment), userOpts.environment) }));
@@ -53976,7 +53984,6 @@ function runReactCompilerImpl({ sourceCode, filename, userOpts, }) {
         filename,
         userOpts,
         flowSuppressions: [],
-        unusedOptOutDirectives: [],
         events: [],
     };
     const userLogger = options.logger;
@@ -54023,29 +54030,11 @@ function runReactCompilerImpl({ sourceCode, filename, userOpts, }) {
                 filename,
                 highlightCode: false,
                 retainLines: true,
-                plugins: [
-                    [PluginProposalPrivateMethods.default, { loose: true }],
-                    [BabelPluginReactCompiler, options],
-                ],
+                plugins: [[BabelPluginReactCompiler, options]],
                 sourceType: 'module',
                 configFile: false,
                 babelrc: false,
             });
-            if (results.events.filter(e => e.kind === 'CompileError').length === 0) {
-                core$1.traverse(babelAST, {
-                    FunctionDeclaration(path) {
-                        results.unusedOptOutDirectives.push(...filterUnusedOptOutDirectives(path.node.body.directives));
-                    },
-                    ArrowFunctionExpression(path) {
-                        if (path.node.body.type === 'BlockStatement') {
-                            results.unusedOptOutDirectives.push(...filterUnusedOptOutDirectives(path.node.body.directives));
-                        }
-                    },
-                    FunctionExpression(path) {
-                        results.unusedOptOutDirectives.push(...filterUnusedOptOutDirectives(path.node.body.directives));
-                    },
-                });
-            }
         }
         catch (err) {
         }
@@ -54215,53 +54204,31 @@ function makeRule(rule) {
         create,
     };
 }
-const NoUnusedDirectivesRule = {
-    meta: {
-        type: 'suggestion',
-        docs: {
-            recommended: true,
-        },
-        fixable: 'code',
-        hasSuggestions: true,
-        schema: [{ type: 'object', additionalProperties: true }],
-    },
-    create(context) {
-        const results = getReactCompilerResult(context);
-        for (const directive of results.unusedOptOutDirectives) {
-            context.report({
-                message: `Unused '${directive.directive}' directive`,
-                loc: directive.loc,
-                suggest: [
-                    {
-                        desc: 'Remove the directive',
-                        fix(fixer) {
-                            return fixer.removeRange(directive.range);
-                        },
-                    },
-                ],
-            });
-        }
-        return {};
-    },
-};
 const allRules = LintRules.reduce((acc, rule) => {
     acc[rule.name] = { rule: makeRule(rule), severity: rule.severity };
     return acc;
-}, {
-    'no-unused-directives': {
-        rule: NoUnusedDirectivesRule,
-        severity: ErrorSeverity.Error,
-    },
-});
-LintRules.filter(rule => rule.recommended).reduce((acc, rule) => {
+}, {});
+const recommendedRules = LintRules.filter(rule => rule.recommended).reduce((acc, rule) => {
     acc[rule.name] = { rule: makeRule(rule), severity: rule.severity };
     return acc;
-}, {
-    'no-unused-directives': {
-        rule: NoUnusedDirectivesRule,
-        severity: ErrorSeverity.Error,
-    },
-});
+}, {});
+function mapErrorSeverityToESlint(severity) {
+    switch (severity) {
+        case ErrorSeverity.Error: {
+            return 'error';
+        }
+        case ErrorSeverity.Warning: {
+            return 'warn';
+        }
+        case ErrorSeverity.Hint:
+        case ErrorSeverity.Off: {
+            return 'off';
+        }
+        default: {
+            assertExhaustive(severity, `Unhandled severity: ${severity}`);
+        }
+    }
+}
 
 var assert_1;
 var hasRequiredAssert;
@@ -57549,28 +57516,39 @@ function last(array) {
 }
 
 const rules = Object.assign({ 'exhaustive-deps': rule$1, 'rules-of-hooks': rule }, Object.fromEntries(Object.entries(allRules).map(([name, config]) => [name, config.rule])));
-const ruleConfigs = {
+const basicRuleConfigs = {
     'react-hooks/rules-of-hooks': 'error',
     'react-hooks/exhaustive-deps': 'warn',
 };
+const compilerRuleConfigs = Object.fromEntries(Object.entries(recommendedRules).map(([name, ruleConfig]) => {
+    return [
+        `react-hooks/${name}`,
+        mapErrorSeverityToESlint(ruleConfig.severity),
+    ];
+}));
+const allRuleConfigs = Object.assign(Object.assign({}, basicRuleConfigs), compilerRuleConfigs);
 const plugin = {
     meta: {
         name: 'eslint-plugin-react-hooks',
     },
-    configs: {},
     rules,
+    configs: {},
 };
 Object.assign(plugin.configs, {
     'recommended-legacy': {
         plugins: ['react-hooks'],
-        rules: ruleConfigs,
+        rules: basicRuleConfigs,
+    },
+    'recommended-latest-legacy': {
+        plugins: ['react-hooks'],
+        rules: allRuleConfigs,
     },
     'flat/recommended': [
         {
             plugins: {
                 'react-hooks': plugin,
             },
-            rules: ruleConfigs,
+            rules: basicRuleConfigs,
         },
     ],
     'recommended-latest': [
@@ -57578,13 +57556,17 @@ Object.assign(plugin.configs, {
             plugins: {
                 'react-hooks': plugin,
             },
-            rules: ruleConfigs,
+            rules: allRuleConfigs,
+        },
+    ],
+    recommended: [
+        {
+            plugins: {
+                'react-hooks': plugin,
+            },
+            rules: basicRuleConfigs,
         },
     ],
-    recommended: {
-        plugins: ['react-hooks'],
-        rules: ruleConfigs,
-    },
 });
 
 module.exports = plugin;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "eslint-plugin-react-hooks",
   "description": "ESLint rules for React Hooks",
-  "version": "6.1.0",
+  "version": "6.2.0-canary-85c427d8-20251003",
   "repository": {
     "type": "git",
     "url": "https://github.com/facebook/react.git",
@@ -41,7 +41,6 @@
   "dependencies": {
     "@babel/core": "^7.24.4",
     "@babel/parser": "^7.24.4",
-    "@babel/plugin-proposal-private-methods": "^7.18.6",
     "hermes-parser": "^0.25.1",
     "zod": "^3.22.4",
     "zod-validation-error": "^3.0.3"