[DevTools] Use the scrollWidth/Height for the root when the root is the documentElement (facebook#34651)

If I can scroll the document due to it overflowing, I should be able to
scroll the suspense tab as much. The real rect for the root when it's
the document is really the full scroll height.

This doesn't fully eliminate the need to do recursive bounding boxes for
the root since it's still possible to have the rects overflow. E.g. if
they're currently resuspended or inside nested scrolls.

~However, maybe we should have the actual paintable root rect just be
this rectangle instead of including the recursive ones.~ Actually never
mind. The root really represents the Transition so it doesn't make sense
to give it any specific rectangle. It's rather the whole background.

DiffTrain build for [554a373](facebook@554a373)

Author: pull[bot]

compiled/eslint-plugin-react-hooks/index.js

@@ -29,17 +29,6 @@ var PluginProposalPrivateMethods = require('@babel/plugin-proposal-private-metho
 var HermesParser = require('hermes-parser');
 var util = require('util');
 
-const SETTINGS_KEY = 'react-hooks';
-const SETTINGS_ADDITIONAL_EFFECT_HOOKS_KEY = 'additionalEffectHooks';
-function getAdditionalEffectHooksFromSettings(settings) {
-    var _a;
-    const additionalHooks = (_a = settings[SETTINGS_KEY]) === null || _a === void 0 ? void 0 : _a[SETTINGS_ADDITIONAL_EFFECT_HOOKS_KEY];
-    if (additionalHooks != null && typeof additionalHooks === 'string') {
-        return new RegExp(additionalHooks);
-    }
-    return undefined;
-}
-
 const rule$1 = {
     meta: {
         type: 'suggestion',
@@ -70,24 +59,23 @@ const rule$1 = {
                     },
                     requireExplicitEffectDeps: {
                         type: 'boolean',
-                    },
+                    }
                 },
             },
         ],
     },
     create(context) {
         const rawOptions = context.options && context.options[0];
-        const settings = context.settings || {};
         const additionalHooks = rawOptions && rawOptions.additionalHooks
             ? new RegExp(rawOptions.additionalHooks)
-            : getAdditionalEffectHooksFromSettings(settings);
+            : undefined;
         const enableDangerousAutofixThisMayCauseInfiniteLoops = (rawOptions &&
             rawOptions.enableDangerousAutofixThisMayCauseInfiniteLoops) ||
             false;
         const experimental_autoDependenciesHooks = rawOptions && Array.isArray(rawOptions.experimental_autoDependenciesHooks)
             ? rawOptions.experimental_autoDependenciesHooks
             : [];
-        const requireExplicitEffectDeps = (rawOptions && rawOptions.requireExplicitEffectDeps) || false;
+        const requireExplicitEffectDeps = rawOptions && rawOptions.requireExplicitEffectDeps || false;
         const options = {
             additionalHooks,
             experimental_autoDependenciesHooks,
@@ -956,7 +944,7 @@ const rule$1 = {
                 reportProblem({
                     node: reactiveHook,
                     message: `React Hook ${reactiveHookName} always requires dependencies. ` +
-                        `Please add a dependency array or an explicit \`undefined\``,
+                        `Please add a dependency array or an explicit \`undefined\``
                 });
             }
             const isAutoDepsHook = options.experimental_autoDependenciesHooks.includes(reactiveHookName);
@@ -1458,7 +1446,9 @@ function isAncestorNodeOf(a, b) {
         a.range[1] >= b.range[1]);
 }
 function isUseEffectEventIdentifier$1(node) {
-    return node.type === 'Identifier' && node.name === 'useEffectEvent';
+    {
+        return node.type === 'Identifier' && node.name === 'useEffectEvent';
+    }
 }
 function getUnknownDependenciesMessage(reactiveHookName) {
     return (`React Hook ${reactiveHookName} received a function whose dependencies ` +
@@ -32123,7 +32113,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(true),
+    enablePreserveExistingMemoizationGuarantees: zod.z.boolean().default(false),
     validatePreserveExistingMemoizationGuarantees: zod.z.boolean().default(true),
     enablePreserveExistingManualUseMemo: zod.z.boolean().default(false),
     enableForest: zod.z.boolean().default(false),
@@ -45363,29 +45353,6 @@ 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,
@@ -54198,6 +54165,20 @@ 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) }));
@@ -54206,6 +54187,7 @@ function runReactCompilerImpl({ sourceCode, filename, userOpts, }) {
         filename,
         userOpts,
         flowSuppressions: [],
+        unusedOptOutDirectives: [],
         events: [],
     };
     const userLogger = options.logger;
@@ -54260,6 +54242,21 @@ function runReactCompilerImpl({ sourceCode, filename, userOpts, }) {
                 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) {
         }
@@ -54429,14 +54426,53 @@ 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,
+    },
+});
 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: {
@@ -57339,26 +57375,13 @@ function getNodeWithoutReactNamespace(node) {
     }
     return node;
 }
-function isEffectIdentifier(node, additionalHooks) {
-    const isBuiltInEffect = node.type === 'Identifier' &&
-        (node.name === 'useEffect' ||
-            node.name === 'useLayoutEffect' ||
-            node.name === 'useInsertionEffect');
-    if (isBuiltInEffect) {
-        return true;
-    }
-    if (additionalHooks && node.type === 'Identifier') {
-        return additionalHooks.test(node.name);
-    }
-    return false;
+function isEffectIdentifier(node) {
+    return node.type === 'Identifier' && (node.name === 'useEffect' || node.name === 'useLayoutEffect' || node.name === 'useInsertionEffect');
 }
 function isUseEffectEventIdentifier(node) {
-    return node.type === 'Identifier' && node.name === 'useEffectEvent';
-}
-function useEffectEventError(fn, called) {
-    return (`\`${fn}\` is a function created with React Hook "useEffectEvent", and can only be called from ` +
-        'Effects and Effect Events in the same component.' +
-        (called ? '' : ' It cannot be assigned to a variable or passed down.'));
+    {
+        return node.type === 'Identifier' && node.name === 'useEffectEvent';
+    }
 }
 function isUseIdentifier(node) {
     return isReactFunction(node, 'use');
@@ -57371,21 +57394,8 @@ const rule = {
             recommended: true,
             url: 'https://react.dev/reference/rules/rules-of-hooks',
         },
-        schema: [
-            {
-                type: 'object',
-                additionalProperties: false,
-                properties: {
-                    additionalHooks: {
-                        type: 'string',
-                    },
-                },
-            },
-        ],
     },
     create(context) {
-        const settings = context.settings || {};
-        const additionalEffectHooks = getAdditionalEffectHooksFromSettings(settings);
         let lastEffect = null;
         const codePathReactHooksMapStack = [];
         const codePathSegmentStack = [];
@@ -57666,15 +57676,19 @@ const rule = {
                     reactHooks.push(node.callee);
                 }
                 const nodeWithoutNamespace = getNodeWithoutReactNamespace(node.callee);
-                if ((isEffectIdentifier(nodeWithoutNamespace, additionalEffectHooks) ||
+                if ((isEffectIdentifier(nodeWithoutNamespace) ||
                     isUseEffectEventIdentifier(nodeWithoutNamespace)) &&
                     node.arguments.length > 0) {
                     lastEffect = node;
                 }
             },
             Identifier(node) {
                 if (lastEffect == null && useEffectEventFunctions.has(node)) {
-                    const message = useEffectEventError(getSourceCode().getText(node), node.parent.type === 'CallExpression');
+                    const message = `\`${getSourceCode().getText(node)}\` is a function created with React Hook "useEffectEvent", and can only be called from ` +
+                        'the same component.' +
+                        (node.parent.type === 'CallExpression'
+                            ? ''
+                            : ' They cannot be assigned to variables or passed down.');
                     context.report({
                         node,
                         message,
@@ -57741,57 +57755,44 @@ 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 basicRuleConfigs = {
-    'react-hooks/rules-of-hooks': 'error',
-    'react-hooks/exhaustive-deps': 'warn',
-};
-const compilerRuleConfigs = Object.fromEntries(Object.entries(recommendedRules).map(([name, ruleConfig]) => {
+const ruleConfigs = Object.assign({ 'react-hooks/rules-of-hooks': 'error', 'react-hooks/exhaustive-deps': 'warn' }, Object.fromEntries(Object.entries(recommendedRules).map(([name, ruleConfig]) => {
     return [
-        `react-hooks/${name}`,
+        'react-hooks/' + name,
         mapErrorSeverityToESlint(ruleConfig.severity),
     ];
-}));
-const allRuleConfigs = Object.assign(Object.assign({}, basicRuleConfigs), compilerRuleConfigs);
+})));
 const plugin = {
     meta: {
         name: 'eslint-plugin-react-hooks',
     },
-    rules,
     configs: {},
+    rules,
 };
 Object.assign(plugin.configs, {
     'recommended-legacy': {
         plugins: ['react-hooks'],
-        rules: basicRuleConfigs,
-    },
-    'recommended-latest-legacy': {
-        plugins: ['react-hooks'],
-        rules: allRuleConfigs,
+        rules: ruleConfigs,
     },
     'flat/recommended': [
         {
             plugins: {
                 'react-hooks': plugin,
             },
-            rules: basicRuleConfigs,
+            rules: ruleConfigs,
         },
     ],
     'recommended-latest': [
         {
             plugins: {
                 'react-hooks': plugin,
             },
-            rules: allRuleConfigs,
-        },
-    ],
-    recommended: [
-        {
-            plugins: {
-                'react-hooks': plugin,
-            },
-            rules: basicRuleConfigs,
+            rules: ruleConfigs,
         },
     ],
+    recommended: {
+        plugins: ['react-hooks'],
+        rules: ruleConfigs,
+    },
 });
 
 module.exports = plugin;

compiled/facebook-www/REVISION

@@ -1 +1 @@
-19f65ff179d377ff0c9284704dff2fce370745be
+554a373d7e0202a6f54e28e8258497bdc3377b21

compiled/facebook-www/REVISION_TRANSFORMS

@@ -1 +1 @@
-19f65ff179d377ff0c9284704dff2fce370745be
+554a373d7e0202a6f54e28e8258497bdc3377b21

compiled/facebook-www/React-dev.classic.js

@@ -1458,7 +1458,7 @@ __DEV__ &&
     exports.useTransition = function () {
       return resolveDispatcher().useTransition();
     };
-    exports.version = "19.3.0-www-classic-19f65ff1-20251002";
+    exports.version = "19.2.0-www-classic-554a373d-20250930";
     "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
       "function" ===
         typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop &&

compiled/facebook-www/React-dev.modern.js

@@ -1458,7 +1458,7 @@ __DEV__ &&
     exports.useTransition = function () {
       return resolveDispatcher().useTransition();
     };
-    exports.version = "19.3.0-www-modern-19f65ff1-20251002";
+    exports.version = "19.2.0-www-modern-554a373d-20250930";
     "undefined" !== typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ &&
       "function" ===
         typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop &&

compiled/facebook-www/React-prod.classic.js

@@ -604,4 +604,4 @@ exports.useSyncExternalStore = function (
 exports.useTransition = function () {
   return ReactSharedInternals.H.useTransition();
 };
-exports.version = "19.3.0-www-classic-19f65ff1-20251002";
+exports.version = "19.2.0-www-classic-554a373d-20250930";

compiled/facebook-www/React-prod.modern.js

@@ -604,4 +604,4 @@ exports.useSyncExternalStore = function (
 exports.useTransition = function () {
   return ReactSharedInternals.H.useTransition();
 };
-exports.version = "19.3.0-www-modern-19f65ff1-20251002";
+exports.version = "19.2.0-www-modern-554a373d-20250930";