Renamed Store variables based on PR feedback

Author: Brian Vaughn

packages/react-devtools-shared/src/__tests__/store-test.js

@@ -915,17 +915,17 @@ describe('Store', () => {
     const containerA = document.createElement('div');
     const containerB = document.createElement('div');
 
-    expect(store.rootSupportsProfiling).toBe(false);
+    expect(store.rootSupportsBasicProfiling).toBe(false);
 
     act(() => legacyRender(<Component />, containerA));
-    expect(store.rootSupportsProfiling).toBe(true);
+    expect(store.rootSupportsBasicProfiling).toBe(true);
 
     act(() => legacyRender(<Component />, containerB));
     act(() => ReactDOM.unmountComponentAtNode(containerA));
-    expect(store.rootSupportsProfiling).toBe(true);
+    expect(store.rootSupportsBasicProfiling).toBe(true);
 
     act(() => ReactDOM.unmountComponentAtNode(containerB));
-    expect(store.rootSupportsProfiling).toBe(false);
+    expect(store.rootSupportsBasicProfiling).toBe(false);
   });
 
   it('should properly serialize non-string key values', () => {

packages/react-devtools-shared/src/backend/renderer.js

@@ -47,7 +47,7 @@ import {
 } from './utils';
 import {
   __DEBUG__,
-  PROFILING_FLAG_LEGACY_SUPPORT,
+  PROFILING_FLAG_BASIC_SUPPORT,
   PROFILING_FLAG_TIMELINE_SUPPORT,
   SESSION_STORAGE_RELOAD_AND_PROFILE_KEY,
   SESSION_STORAGE_RECORD_CHANGE_DESCRIPTIONS_KEY,
@@ -1915,7 +1915,7 @@ export function attach(
     // Instead let's re-purpose a pre-existing field to carry more information.
     let profilingFlags = 0;
     if (isProfilingSupported) {
-      profilingFlags = PROFILING_FLAG_LEGACY_SUPPORT;
+      profilingFlags = PROFILING_FLAG_BASIC_SUPPORT;
       if (typeof injectProfilingHooks === 'function') {
         profilingFlags |= PROFILING_FLAG_TIMELINE_SUPPORT;
       }

packages/react-devtools-shared/src/constants.js

@@ -25,7 +25,7 @@ export const TREE_OPERATION_UPDATE_ERRORS_OR_WARNINGS = 5;
 export const TREE_OPERATION_REMOVE_ROOT = 6;
 export const TREE_OPERATION_SET_SUBTREE_MODE = 7;
 
-export const PROFILING_FLAG_LEGACY_SUPPORT = 0b01;
+export const PROFILING_FLAG_BASIC_SUPPORT = 0b01;
 export const PROFILING_FLAG_TIMELINE_SUPPORT = 0b10;
 
 export const LOCAL_STORAGE_DEFAULT_TAB_KEY = 'React::DevTools::defaultTab';

packages/react-devtools-shared/src/devtools/store.js

@@ -10,7 +10,7 @@
 import EventEmitter from '../events';
 import {inspect} from 'util';
 import {
-  PROFILING_FLAG_LEGACY_SUPPORT,
+  PROFILING_FLAG_BASIC_SUPPORT,
   PROFILING_FLAG_TIMELINE_SUPPORT,
   TREE_OPERATION_ADD,
   TREE_OPERATION_REMOVE,
@@ -74,8 +74,8 @@ type Config = {|
 |};
 
 export type Capabilities = {|
+  supportsBasicProfiling: boolean,
   hasOwnerMetadata: boolean,
-  supportsProfiling: boolean,
   supportsStrictMode: boolean,
   supportsTimeline: boolean,
 |};
@@ -91,8 +91,8 @@ export default class Store extends EventEmitter<{|
   mutated: [[Array<number>, Map<number, number>]],
   recordChangeDescriptions: [],
   roots: [],
-  rootSupportsProfiling: [],
-  rootSupportsTimeline: [],
+  rootSupportsBasicProfiling: [],
+  rootSupportsTimelineProfiling: [],
   supportsNativeStyleEditor: [],
   supportsReloadAndProfile: [],
   unsupportedBridgeProtocolDetected: [],
@@ -172,8 +172,8 @@ export default class Store extends EventEmitter<{|
   _supportsTraceUpdates: boolean = false;
 
   // These options default to false but may be updated as roots are added and removed.
-  _rootSupportsProfiling: boolean = false;
-  _rootSupportsTimeline: boolean = false;
+  _rootSupportsBasicProfiling: boolean = false;
+  _rootSupportsTimelineProfiling: boolean = false;
 
   _unsupportedBridgeProtocol: BridgeProtocol | null = null;
   _unsupportedRendererVersionDetected: boolean = false;
@@ -410,13 +410,13 @@ export default class Store extends EventEmitter<{|
   }
 
   // At least one of the currently mounted roots support the Legacy profiler.
-  get rootSupportsProfiling(): boolean {
-    return this._rootSupportsProfiling;
+  get rootSupportsBasicProfiling(): boolean {
+    return this._rootSupportsBasicProfiling;
   }
 
   // At least one of the currently mounted roots support the Timeline profiler.
-  get rootSupportsTimeline(): boolean {
-    return this._rootSupportsTimeline;
+  get rootSupportsTimelineProfiling(): boolean {
+    return this._rootSupportsTimelineProfiling;
   }
 
   get supportsNativeInspection(): boolean {
@@ -924,8 +924,8 @@ export default class Store extends EventEmitter<{|
             const isStrictModeCompliant = operations[i] > 0;
             i++;
 
-            const supportsProfiling =
-              (operations[i] & PROFILING_FLAG_LEGACY_SUPPORT) !== 0;
+            const supportsBasicProfiling =
+              (operations[i] & PROFILING_FLAG_BASIC_SUPPORT) !== 0;
             const supportsTimeline =
               (operations[i] & PROFILING_FLAG_TIMELINE_SUPPORT) !== 0;
             i++;
@@ -939,8 +939,8 @@ export default class Store extends EventEmitter<{|
             this._roots = this._roots.concat(id);
             this._rootIDToRendererID.set(id, rendererID);
             this._rootIDToCapabilities.set(id, {
+              supportsBasicProfiling,
               hasOwnerMetadata,
-              supportsProfiling,
               supportsStrictMode,
               supportsTimeline,
             });
@@ -1249,34 +1249,38 @@ export default class Store extends EventEmitter<{|
     }
 
     if (haveRootsChanged) {
-      const prevRootSupportsProfiling = this._rootSupportsProfiling;
-      const prevRootSupportsTimeline = this._rootSupportsTimeline;
+      const prevRootSupportsProfiling = this._rootSupportsBasicProfiling;
+      const prevRootSupportsTimelineProfiling = this
+        ._rootSupportsTimelineProfiling;
 
       this._hasOwnerMetadata = false;
-      this._rootSupportsProfiling = false;
-      this._rootSupportsTimeline = false;
+      this._rootSupportsBasicProfiling = false;
+      this._rootSupportsTimelineProfiling = false;
       this._rootIDToCapabilities.forEach(
-        ({hasOwnerMetadata, supportsProfiling, supportsTimeline}) => {
+        ({supportsBasicProfiling, hasOwnerMetadata, supportsTimeline}) => {
+          if (supportsBasicProfiling) {
+            this._rootSupportsBasicProfiling = true;
+          }
           if (hasOwnerMetadata) {
             this._hasOwnerMetadata = true;
           }
-          if (supportsProfiling) {
-            this._rootSupportsProfiling = true;
-          }
           if (supportsTimeline) {
-            this._rootSupportsTimeline = true;
+            this._rootSupportsTimelineProfiling = true;
           }
         },
       );
 
       this.emit('roots');
 
-      if (this._rootSupportsProfiling !== prevRootSupportsProfiling) {
-        this.emit('rootSupportsProfiling');
+      if (this._rootSupportsBasicProfiling !== prevRootSupportsProfiling) {
+        this.emit('rootSupportsBasicProfiling');
       }
 
-      if (this._rootSupportsTimeline !== prevRootSupportsTimeline) {
-        this.emit('rootSupportsTimeline');
+      if (
+        this._rootSupportsTimelineProfiling !==
+        prevRootSupportsTimelineProfiling
+      ) {
+        this.emit('rootSupportsTimelineProfiling');
       }
     }
 

packages/react-devtools-shared/src/devtools/views/Profiler/ProfilerContext.js

@@ -96,18 +96,18 @@ function ProfilerContextController({children}: Props) {
         isProcessingData: profilerStore.isProcessingData,
         isProfiling: profilerStore.isProfiling,
         profilingData: profilerStore.profilingData,
-        supportsProfiling: store.rootSupportsProfiling,
+        supportsProfiling: store.rootSupportsBasicProfiling,
       }),
       subscribe: (callback: Function) => {
         profilerStore.addListener('profilingData', callback);
         profilerStore.addListener('isProcessingData', callback);
         profilerStore.addListener('isProfiling', callback);
-        store.addListener('rootSupportsProfiling', callback);
+        store.addListener('rootSupportsBasicProfiling', callback);
         return () => {
           profilerStore.removeListener('profilingData', callback);
           profilerStore.removeListener('isProcessingData', callback);
           profilerStore.removeListener('isProfiling', callback);
-          store.removeListener('rootSupportsProfiling', callback);
+          store.removeListener('rootSupportsBasicProfiling', callback);
         };
       },
     }),

packages/react-devtools-timeline/src/TimelineContext.js

@@ -48,13 +48,13 @@ function TimelineContextController({children}: Props) {
 
   const isTimelineSupported = useSyncExternalStore<boolean>(
     function subscribe(callback) {
-      store.addListener('rootSupportsTimeline', callback);
+      store.addListener('rootSupportsTimelineProfiling', callback);
       return function unsubscribe() {
-        store.removeListener('rootSupportsTimeline', callback);
+        store.removeListener('rootSupportsTimelineProfiling', callback);
       };
     },
     function getState() {
-      return store.rootSupportsTimeline;
+      return store.rootSupportsTimelineProfiling;
     },
   );