text: /**
   * Copyright (c) Facebook, Inc. and its affiliates.
   *
   * This source code is licensed under the MIT license found in the
   * LICENSE file in the root directory of this source tree.
   *
   * @flow
   */
  
  import {enableProfilerTimer} from 'shared/ReactFeatureFlags';
  
  import type {Fiber, FiberRoot} from './ReactInternalTypes';
  import type {ReactNodeList} from 'shared/ReactTypes';
  import type {EventPriority} from './ReactEventPriorities.new';
  
  import {DidCapture} from './ReactFiberFlags';
  import {
    DiscreteEventPriority,
    ContinuousEventPriority,
    DefaultEventPriority,
    IdleEventPriority,
  } from './ReactEventPriorities.new';
  import {
    ImmediatePriority as ImmediateSchedulerPriority,
    UserBlockingPriority as UserBlockingSchedulerPriority,
    NormalPriority as NormalSchedulerPriority,
    IdlePriority as IdleSchedulerPriority,
  } from './Scheduler';
  
  declare var __REACT_DEVTOOLS_GLOBAL_HOOK__: Object | void;
  
  let rendererID = null;
  let injectedHook = null;
  let hasLoggedError = false;
  
  export const isDevToolsPresent =
    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ !== 'undefined';
  
  export function injectInternals(internals: Object): boolean {
    if (typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ === 'undefined') {
      // No DevTools
      return false;
    }
    const hook = __REACT_DEVTOOLS_GLOBAL_HOOK__;
    if (hook.isDisabled) {
      // This isn't a real property on the hook, but it can be set to opt out
      // of DevTools integration and associated warnings and logs.
      // https://github.com/facebook/react/issues/3877
      return true;
    }
    if (!hook.supportsFiber) {
      if (__DEV__) {
        console.error(
          'The installed version of React DevTools is too old and will not work ' +
            'with the current version of React. Please update React DevTools. ' +
            'https://reactjs.org/link/react-devtools',
        );
      }
      // DevTools exists, even though it doesn't support Fiber.
      return true;
    }
    try {
      rendererID = hook.inject(internals);
      // We have successfully injected, so now it is safe to set up hooks.
      injectedHook = hook;
    } catch (err) {
      // Catch all errors because it is unsafe to throw during initialization.
      if (__DEV__) {
        console.error('React instrumentation encountered an error: %s.', err);
      }
    }
    // DevTools exists
    return true;
  }
  
  export function onScheduleRoot(root: FiberRoot, children: ReactNodeList) {
    if (__DEV__) {
      if (
        injectedHook &&
        typeof injectedHook.onScheduleFiberRoot === 'function'
      ) {
        try {
          injectedHook.onScheduleFiberRoot(rendererID, root, children);
        } catch (err) {
          if (__DEV__ && !hasLoggedError) {
            hasLoggedError = true;
            console.error('React instrumentation encountered an error: %s', err);
          }
        }
      }
    }
  }
  
  export function onCommitRoot(root: FiberRoot, eventPriority: EventPriority) {
    if (injectedHook && typeof injectedHook.onCommitFiberRoot === 'function') {
      try {
        const didError = (root.current.flags & DidCapture) === DidCapture;
        if (enableProfilerTimer) {
          let schedulerPriority;
          switch (eventPriority) {
            case DiscreteEventPriority:
              schedulerPriority = ImmediateSchedulerPriority;
              break;
            case ContinuousEventPriority:
              schedulerPriority = UserBlockingSchedulerPriority;
              break;
            case DefaultEventPriority:
              schedulerPriority = NormalSchedulerPriority;
              break;
            case IdleEventPriority:
              schedulerPriority = IdleSchedulerPriority;
              break;
            default:
              schedulerPriority = NormalSchedulerPriority;
              break;
          }
          injectedHook.onCommitFiberRoot(
            rendererID,
            root,
            schedulerPriority,
            didError,
          );
        } else {
          injectedHook.onCommitFiberRoot(rendererID, root, undefined, didError);
        }
      } catch (err) {
        if (__DEV__) {
          if (!hasLoggedError) {
            hasLoggedError = true;
            console.error('React instrumentation encountered an error: %s', err);
          }
        }
      }
    }
  }
  
  export function onPostCommitRoot(root: FiberRoot) {
    if (
      injectedHook &&
      typeof injectedHook.onPostCommitFiberRoot === 'function'
    ) {
      try {
        injectedHook.onPostCommitFiberRoot(rendererID, root);
      } catch (err) {
        if (__DEV__) {
          if (!hasLoggedError) {
            hasLoggedError = true;
            console.error('React instrumentation encountered an error: %s', err);
          }
        }
      }
    }
  }
  
  export function onCommitUnmount(fiber: Fiber) {
    if (injectedHook && typeof injectedHook.onCommitFiberUnmount === 'function') {
      try {
        injectedHook.onCommitFiberUnmount(rendererID, fiber);
      } catch (err) {
        if (__DEV__) {
          if (!hasLoggedError) {
            hasLoggedError = true;
            console.error('React instrumentation encountered an error: %s', err);
          }
        }
      }
    }
  }
  