react-relay 14.0.0 → 15.0.0

package/lib/relay-hooks/useEntryPointLoader.js

@@ -4,37 +4,29 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+relay
  * 
  * @format
+ * @oncall relay
  */
-// flowlint ambiguous-object-type:error
-'use strict';
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+'use strict';
 
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault")["default"];
 var _createForOfIteratorHelper2 = _interopRequireDefault(require("@babel/runtime/helpers/createForOfIteratorHelper"));
-
 var loadEntryPoint = require('./loadEntryPoint');
-
 var _require = require('./loadQuery'),
-    useTrackLoadQueryInRender = _require.useTrackLoadQueryInRender;
-
+  useTrackLoadQueryInRender = _require.useTrackLoadQueryInRender;
 var useIsMountedRef = require('./useIsMountedRef');
-
 var _require2 = require('react'),
-    useCallback = _require2.useCallback,
-    useEffect = _require2.useEffect,
-    useRef = _require2.useRef,
-    useState = _require2.useState;
-
+  useCallback = _require2.useCallback,
+  useEffect = _require2.useEffect,
+  useRef = _require2.useRef,
+  useState = _require2.useState;
 var initialNullEntryPointReferenceState = {
   kind: 'NullEntryPointReference'
 };
-
 function useLoadEntryPoint(environmentProvider, entryPoint, options) {
   var _options$TEST_ONLY__i, _options$TEST_ONLY__i2, _options$TEST_ONLY__i3, _options$TEST_ONLY__i4;
-
   /**
    * We want to always call `entryPointReference.dispose()` for every call to
    * `setEntryPointReference(loadEntryPoint(...))` so that no leaks of data in Relay
@@ -54,20 +46,18 @@ function useLoadEntryPoint(environmentProvider, entryPoint, options) {
    * Finally, when the hook unmounts, we also dispose of all remaining uncommitted
    * entry point references.
    */
+
   useTrackLoadQueryInRender();
   var initialEntryPointReferenceInternal = (_options$TEST_ONLY__i = options === null || options === void 0 ? void 0 : (_options$TEST_ONLY__i2 = options.TEST_ONLY__initialEntryPointData) === null || _options$TEST_ONLY__i2 === void 0 ? void 0 : _options$TEST_ONLY__i2.entryPointReference) !== null && _options$TEST_ONLY__i !== void 0 ? _options$TEST_ONLY__i : initialNullEntryPointReferenceState;
   var initialEntryPointParamsInternal = (_options$TEST_ONLY__i3 = options === null || options === void 0 ? void 0 : (_options$TEST_ONLY__i4 = options.TEST_ONLY__initialEntryPointData) === null || _options$TEST_ONLY__i4 === void 0 ? void 0 : _options$TEST_ONLY__i4.entryPointParams) !== null && _options$TEST_ONLY__i3 !== void 0 ? _options$TEST_ONLY__i3 : null;
   var isMountedRef = useIsMountedRef();
   var undisposedEntryPointReferencesRef = useRef(new Set([initialEntryPointReferenceInternal]));
-
   var _useState = useState(initialEntryPointReferenceInternal),
-      entryPointReference = _useState[0],
-      setEntryPointReference = _useState[1];
-
+    entryPointReference = _useState[0],
+    setEntryPointReference = _useState[1];
   var _useState2 = useState(initialEntryPointParamsInternal),
-      entryPointParams = _useState2[0],
-      setEntryPointParams = _useState2[1];
-
+    entryPointParams = _useState2[0],
+    setEntryPointParams = _useState2[1];
   var disposeEntryPoint = useCallback(function () {
     if (isMountedRef.current) {
       var nullEntryPointReference = {
@@ -110,13 +100,13 @@ function useLoadEntryPoint(environmentProvider, entryPoint, options) {
       // so that the entryPointReference's queries are correctly re-retained, and
       // potentially refetched if necessary.
       maybeHiddenOrFastRefresh.current = false;
-
       if (entryPointReference.kind !== 'NullEntryPointReference' && entryPointParams != null) {
         entryPointLoaderCallback(entryPointParams);
       }
-
       return;
-    } // When a new entryPointReference is committed, we iterate over all
+    }
+
+    // When a new entryPointReference is committed, we iterate over all
     // entrypoint refs in undisposedEntryPointReferences and dispose all of
     // the refs that aren't the currently committed one. This ensures
     // that we don't leave any dangling entrypoint references for the
@@ -135,24 +125,17 @@ function useLoadEntryPoint(environmentProvider, entryPoint, options) {
     // associated with commits that were initiated prior to the currently
     // committing state change. (A useEffect callback is called during the commit
     // phase.)
-
-
     var undisposedEntryPointReferences = undisposedEntryPointReferencesRef.current;
-
     if (isMountedRef.current) {
       var _iterator = (0, _createForOfIteratorHelper2["default"])(undisposedEntryPointReferences),
-          _step;
-
+        _step;
       try {
         for (_iterator.s(); !(_step = _iterator.n()).done;) {
           var undisposedEntryPointReference = _step.value;
-
           if (undisposedEntryPointReference === entryPointReference) {
             break;
           }
-
           undisposedEntryPointReferences["delete"](undisposedEntryPointReference);
-
           if (undisposedEntryPointReference.kind !== 'NullEntryPointReference') {
             undisposedEntryPointReference.dispose();
           }
@@ -169,12 +152,10 @@ function useLoadEntryPoint(environmentProvider, entryPoint, options) {
       // undisposedEntryPointReferences.current is never reassigned
       // eslint-disable-next-line react-hooks/exhaustive-deps
       var _iterator2 = (0, _createForOfIteratorHelper2["default"])(undisposedEntryPointReferencesRef.current),
-          _step2;
-
+        _step2;
       try {
         for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
           var unhandledStateChange = _step2.value;
-
           if (unhandledStateChange.kind !== 'NullEntryPointReference') {
             unhandledStateChange.dispose();
           }
@@ -188,5 +169,4 @@ function useLoadEntryPoint(environmentProvider, entryPoint, options) {
   }, []);
   return [entryPointReference.kind === 'NullEntryPointReference' ? null : entryPointReference, entryPointLoaderCallback, disposeEntryPoint];
 }
-
 module.exports = useLoadEntryPoint;

package/lib/relay-hooks/useFetchTrackingRef.js

@@ -4,17 +4,18 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+relay
  * 
  * @format
+ * @oncall relay
  */
-// flowlint ambiguous-object-type:error
+
 'use strict';
 
+var useUnsafeRef_DEPRECATED = require('./useUnsafeRef_DEPRECATED');
 var _require = require('react'),
-    useCallback = _require.useCallback,
-    useEffect = _require.useEffect,
-    useRef = _require.useRef;
+  useCallback = _require.useCallback,
+  useEffect = _require.useEffect;
+
 /**
  * This hook returns a mutable React ref that holds the value of whether a
  * fetch request is in flight. The reason this is a mutable ref instead of
@@ -27,17 +28,14 @@ var _require = require('react'),
  * The additional functions returned by this Hook can be used to mutate
  * the ref.
  */
-
-
 function useFetchTrackingRef() {
-  var subscriptionRef = useRef(null);
-  var isFetchingRef = useRef(false);
+  var subscriptionRef = useUnsafeRef_DEPRECATED(null);
+  var isFetchingRef = useUnsafeRef_DEPRECATED(false);
   var disposeFetch = useCallback(function () {
     if (subscriptionRef.current != null) {
       subscriptionRef.current.unsubscribe();
       subscriptionRef.current = null;
     }
-
     isFetchingRef.current = false;
   }, []);
   var startFetch = useCallback(function (subscription) {
@@ -47,8 +45,9 @@ function useFetchTrackingRef() {
   var completeFetch = useCallback(function () {
     subscriptionRef.current = null;
     isFetchingRef.current = false;
-  }, []); // Dipose of ongoing fetch on unmount
+  }, []);
 
+  // Dipose of ongoing fetch on unmount
   useEffect(function () {
     return disposeFetch;
   }, [disposeFetch]);
@@ -59,5 +58,4 @@ function useFetchTrackingRef() {
     completeFetch: completeFetch
   };
 }
-
 module.exports = useFetchTrackingRef;

package/lib/relay-hooks/useFragment.js

@@ -4,38 +4,30 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+relay
  * 
  * @format
+ * @oncall relay
  */
-// flowlint ambiguous-object-type:error
+
 'use strict';
 
 var HooksImplementation = require('./HooksImplementation');
-
 var _require = require('./loadQuery'),
-    useTrackLoadQueryInRender = _require.useTrackLoadQueryInRender;
-
+  useTrackLoadQueryInRender = _require.useTrackLoadQueryInRender;
 var useFragmentNode = require('./useFragmentNode');
-
 var useStaticFragmentNodeWarning = require('./useStaticFragmentNodeWarning');
-
 var _require2 = require('react'),
-    useDebugValue = _require2.useDebugValue;
-
+  useDebugValue = _require2.useDebugValue;
 var _require3 = require('relay-runtime'),
-    getFragment = _require3.getFragment;
-
+  getFragment = _require3.getFragment;
 function useFragment_LEGACY(fragment, key) {
   // We need to use this hook in order to be able to track if
   // loadQuery was called during render
   useTrackLoadQueryInRender();
   var fragmentNode = getFragment(fragment);
   useStaticFragmentNodeWarning(fragmentNode, 'first argument of useFragment()');
-
   var _useFragmentNode = useFragmentNode(fragmentNode, key, 'useFragment()'),
-      data = _useFragmentNode.data;
-
+    data = _useFragmentNode.data;
   if (process.env.NODE_ENV !== "production") {
     // eslint-disable-next-line react-hooks/rules-of-hooks
     useDebugValue({
@@ -43,20 +35,17 @@ function useFragment_LEGACY(fragment, key) {
       data: data
     });
   }
-
   return data;
 }
-
 function useFragment(fragment, key) {
   var impl = HooksImplementation.get();
-
   if (impl) {
     // $FlowFixMe This is safe because impl.useFragment has the type of useFragment...
-    return impl.useFragment(fragment, key); // (i.e. type declared above, but not the supertype used in this function definition)
+    return impl.useFragment(fragment, key);
+    // (i.e. type declared above, but not the supertype used in this function definition)
   } else {
     // eslint-disable-next-line react-hooks/rules-of-hooks
     return useFragment_LEGACY(fragment, key);
   }
 }
-
 module.exports = useFragment;

package/lib/relay-hooks/useFragmentNode.js

@@ -4,72 +4,62 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+relay
  * 
  * @format
+ * @oncall relay
  */
-// flowlint ambiguous-object-type:error
+
 'use strict';
 
 var _require = require('./FragmentResource'),
-    getFragmentResourceForEnvironment = _require.getFragmentResourceForEnvironment;
-
+  getFragmentResourceForEnvironment = _require.getFragmentResourceForEnvironment;
 var useRelayEnvironment = require('./useRelayEnvironment');
-
+var useUnsafeRef_DEPRECATED = require('./useUnsafeRef_DEPRECATED');
 var _require2 = require('react'),
-    useEffect = _require2.useEffect,
-    useRef = _require2.useRef,
-    useState = _require2.useState;
-
+  useEffect = _require2.useEffect,
+  useState = _require2.useState;
 var _require3 = require('relay-runtime'),
-    getFragmentIdentifier = _require3.getFragmentIdentifier;
-
+  getFragmentIdentifier = _require3.getFragmentIdentifier;
 var warning = require("fbjs/lib/warning");
-
 function useFragmentNode(fragmentNode, fragmentRef, componentDisplayName) {
   var environment = useRelayEnvironment();
   var FragmentResource = getFragmentResourceForEnvironment(environment);
-  var isMountedRef = useRef(false);
-
+  var isMountedRef = useUnsafeRef_DEPRECATED(false);
   var _useState = useState(0),
-      forceUpdate = _useState[1];
-
-  var fragmentIdentifier = getFragmentIdentifier(fragmentNode, fragmentRef); // Read fragment data; this might suspend.
+    forceUpdate = _useState[1];
+  var fragmentIdentifier = getFragmentIdentifier(fragmentNode, fragmentRef);
 
+  // Read fragment data; this might suspend.
   var fragmentResult = FragmentResource.readWithIdentifier(fragmentNode, fragmentRef, fragmentIdentifier, componentDisplayName);
-  var isListeningForUpdatesRef = useRef(true);
-
+  var isListeningForUpdatesRef = useUnsafeRef_DEPRECATED(true);
   function enableStoreUpdates() {
     isListeningForUpdatesRef.current = true;
     var didMissUpdates = FragmentResource.checkMissedUpdates(fragmentResult)[0];
-
     if (didMissUpdates) {
       handleDataUpdate();
     }
   }
-
   function disableStoreUpdates() {
     isListeningForUpdatesRef.current = false;
   }
-
   function handleDataUpdate() {
     if (isMountedRef.current === false || isListeningForUpdatesRef.current === false) {
       return;
-    } // React bails out on noop state updates as an optimization.
+    }
+
+    // React bails out on noop state updates as an optimization.
     // If we want to force an update via setState, we need to pass an value.
     // The actual value can be arbitrary though, e.g. an incremented number.
-
-
     forceUpdate(function (count) {
       return count + 1;
     });
-  } // Establish Relay store subscriptions in the commit phase, only if
+  }
+
+  // Establish Relay store subscriptions in the commit phase, only if
   // rendering for the first time, or if we need to subscribe to new data
   // If the fragment identifier changes, it means that the variables on the
   // fragment owner changed, or the fragment ref points to different records.
   // In this case, we need to resubscribe to the Relay store.
-
-
   useEffect(function () {
     isMountedRef.current = true;
     var disposable = FragmentResource.subscribe(fragmentResult, handleDataUpdate);
@@ -80,11 +70,11 @@ function useFragmentNode(fragmentNode, fragmentRef, componentDisplayName) {
       // the Relay store
       isMountedRef.current = false;
       disposable.dispose();
-    }; // NOTE: We disable react-hooks-deps warning because environment and fragmentIdentifier
+    };
+    // NOTE: We disable react-hooks-deps warning because environment and fragmentIdentifier
     // is capturing all information about whether the effect should be re-ran.
     // eslint-disable-next-line react-hooks/exhaustive-deps
   }, [environment, fragmentIdentifier]);
-
   if (process.env.NODE_ENV !== "production") {
     if (fragmentRef != null && (fragmentResult.data === undefined || Array.isArray(fragmentResult.data) && fragmentResult.data.length > 0 && fragmentResult.data.every(function (data) {
       return data === undefined;
@@ -92,7 +82,6 @@ function useFragmentNode(fragmentNode, fragmentRef, componentDisplayName) {
       process.env.NODE_ENV !== "production" ? warning(false, 'Relay: Expected to have been able to read non-null data for ' + 'fragment `%s` declared in ' + '`%s`, since fragment reference was non-null. ' + "Make sure that that `%s`'s parent isn't " + 'holding on to and/or passing a fragment reference for data that ' + 'has been deleted.', fragmentNode.name, componentDisplayName, componentDisplayName) : void 0;
     }
   }
-
   return {
     // $FlowFixMe[incompatible-return]
     data: fragmentResult.data,
@@ -100,5 +89,4 @@ function useFragmentNode(fragmentNode, fragmentRef, componentDisplayName) {
     enableStoreUpdates: enableStoreUpdates
   };
 }
-
 module.exports = useFragmentNode;

package/lib/relay-hooks/useIsMountedRef.js

@@ -4,17 +4,16 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+relay
  * 
  * @format
+ * @oncall relay
  */
-// flowlint ambiguous-object-type:error
+
 'use strict';
 
 var _require = require('react'),
-    useEffect = _require.useEffect,
-    useRef = _require.useRef;
-
+  useEffect = _require.useEffect,
+  useRef = _require.useRef;
 function useIsMountedRef() {
   var isMountedRef = useRef(true);
   useEffect(function () {
@@ -25,5 +24,4 @@ function useIsMountedRef() {
   }, []);
   return isMountedRef;
 }
-
 module.exports = useIsMountedRef;

package/lib/relay-hooks/useIsOperationNodeActive.js

@@ -4,58 +4,47 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+relay
  * 
  * @format
+ * @oncall relay
  */
+
 'use strict';
 
 var useRelayEnvironment = require('./useRelayEnvironment');
-
 var invariant = require('invariant');
-
 var React = require('react');
-
 var _require = require('relay-runtime'),
-    getObservableForActiveRequest = _require.__internal.getObservableForActiveRequest,
-    getSelector = _require.getSelector;
-
+  getObservableForActiveRequest = _require.__internal.getObservableForActiveRequest,
+  getSelector = _require.getSelector;
 var useEffect = React.useEffect,
-    useState = React.useState,
-    useMemo = React.useMemo;
-
+  useState = React.useState,
+  useMemo = React.useMemo;
 function useIsOperationNodeActive(fragmentNode, fragmentRef) {
   var environment = useRelayEnvironment();
   var observable = useMemo(function () {
     var selector = getSelector(fragmentNode, fragmentRef);
-
     if (selector == null) {
       return null;
     }
-
     !(selector.kind === 'SingularReaderSelector') ? process.env.NODE_ENV !== "production" ? invariant(false, 'useIsOperationNodeActive: Plural fragments are not supported.') : invariant(false) : void 0;
     return getObservableForActiveRequest(environment, selector.owner);
   }, [environment, fragmentNode, fragmentRef]);
-
   var _useState = useState(observable != null),
-      isActive = _useState[0],
-      setIsActive = _useState[1];
-
+    isActive = _useState[0],
+    setIsActive = _useState[1];
   useEffect(function () {
     var subscription;
     setIsActive(observable != null);
-
     if (observable != null) {
       var onCompleteOrError = function onCompleteOrError() {
         setIsActive(false);
       };
-
       subscription = observable.subscribe({
         complete: onCompleteOrError,
         error: onCompleteOrError
       });
     }
-
     return function () {
       if (subscription) {
         subscription.unsubscribe();
@@ -64,5 +53,4 @@ function useIsOperationNodeActive(fragmentNode, fragmentRef) {
   }, [observable]);
   return isActive;
 }
-
 module.exports = useIsOperationNodeActive;

package/lib/relay-hooks/useIsParentQueryActive.js

@@ -4,23 +4,20 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+relay
  * 
  * @format
+ * @oncall relay
  */
+
 'use strict';
 
 var useIsOperationNodeActive = require('./useIsOperationNodeActive');
-
 var useStaticFragmentNodeWarning = require('./useStaticFragmentNodeWarning');
-
 var _require = require('relay-runtime'),
-    getFragment = _require.getFragment;
-
+  getFragment = _require.getFragment;
 function useIsParentQueryActive(fragmentInput, fragmentRef) {
   var fragmentNode = getFragment(fragmentInput);
   useStaticFragmentNodeWarning(fragmentNode, 'first argument of useIsParentQueryActive()');
   return useIsOperationNodeActive(fragmentNode, fragmentRef);
 }
-
 module.exports = useIsParentQueryActive;

package/lib/relay-hooks/useLazyLoadQuery.js

@@ -4,31 +4,26 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+relay
  * 
  * @format
+ * @oncall relay
  */
-// flowlint ambiguous-object-type:error
-'use strict';
 
-var HooksImplementation = require('./HooksImplementation');
+'use strict';
 
 var _require = require('./loadQuery'),
-    useTrackLoadQueryInRender = _require.useTrackLoadQueryInRender;
-
+  useTrackLoadQueryInRender = _require.useTrackLoadQueryInRender;
 var useLazyLoadQueryNode = require('./useLazyLoadQueryNode');
-
 var useMemoOperationDescriptor = require('./useMemoOperationDescriptor');
-
 var useRelayEnvironment = require('./useRelayEnvironment');
-
 var _require2 = require('relay-runtime'),
-    fetchQuery = _require2.__internal.fetchQuery; // This separate type export is only needed as long as we are injecting
+  fetchQuery = _require2.__internal.fetchQuery;
+
+// This separate type export is only needed as long as we are injecting
 // a separate hooks implementation in ./HooksImplementation -- it can
 // be removed after we stop doing that.
 
-
-function useLazyLoadQuery_LEGACY(gqlQuery, variables, options) {
+function useLazyLoadQuery(gqlQuery, variables, options) {
   // We need to use this hook in order to be able to track if
   // loadQuery was called during render
   useTrackLoadQueryInRender();
@@ -46,16 +41,4 @@ function useLazyLoadQuery_LEGACY(gqlQuery, variables, options) {
   });
   return data;
 }
-
-function useLazyLoadQuery(gqlQuery, variables, options) {
-  var impl = HooksImplementation.get();
-
-  if (impl) {
-    return impl.useLazyLoadQuery(gqlQuery, variables, options);
-  } else {
-    // eslint-disable-next-line react-hooks/rules-of-hooks
-    return useLazyLoadQuery_LEGACY(gqlQuery, variables, options);
-  }
-}
-
 module.exports = useLazyLoadQuery;

package/lib/relay-hooks/useLazyLoadQueryNode.js

@@ -4,51 +4,41 @@
  * This source code is licensed under the MIT license found in the
  * LICENSE file in the root directory of this source tree.
  *
- * @emails oncall+relay
  * 
  * @format
+ * @oncall relay
  */
-// flowlint ambiguous-object-type:error
+
 'use strict';
 
 var ProfilerContext = require('./ProfilerContext');
-
 var _require = require('./QueryResource'),
-    getQueryCacheIdentifier = _require.getQueryCacheIdentifier,
-    getQueryResourceForEnvironment = _require.getQueryResourceForEnvironment;
-
+  getQueryCacheIdentifier = _require.getQueryCacheIdentifier,
+  getQueryResourceForEnvironment = _require.getQueryResourceForEnvironment;
 var useFetchTrackingRef = require('./useFetchTrackingRef');
-
 var useFragmentNode = require('./useFragmentNode');
-
 var useRelayEnvironment = require('./useRelayEnvironment');
-
 var React = require('react');
-
 var useContext = React.useContext,
-    useEffect = React.useEffect,
-    useState = React.useState,
-    useRef = React.useRef;
-
+  useEffect = React.useEffect,
+  useState = React.useState,
+  useRef = React.useRef;
 function useLazyLoadQueryNode(_ref) {
   var query = _ref.query,
-      componentDisplayName = _ref.componentDisplayName,
-      fetchObservable = _ref.fetchObservable,
-      fetchPolicy = _ref.fetchPolicy,
-      fetchKey = _ref.fetchKey,
-      renderPolicy = _ref.renderPolicy;
+    componentDisplayName = _ref.componentDisplayName,
+    fetchObservable = _ref.fetchObservable,
+    fetchPolicy = _ref.fetchPolicy,
+    fetchKey = _ref.fetchKey,
+    renderPolicy = _ref.renderPolicy;
   var environment = useRelayEnvironment();
   var profilerContext = useContext(ProfilerContext);
   var QueryResource = getQueryResourceForEnvironment(environment);
-
   var _useState = useState(0),
-      forceUpdateKey = _useState[0],
-      forceUpdate = _useState[1];
-
+    forceUpdateKey = _useState[0],
+    forceUpdate = _useState[1];
   var _useFetchTrackingRef = useFetchTrackingRef(),
-      startFetch = _useFetchTrackingRef.startFetch,
-      completeFetch = _useFetchTrackingRef.completeFetch;
-
+    startFetch = _useFetchTrackingRef.startFetch,
+    completeFetch = _useFetchTrackingRef.completeFetch;
   var cacheBreaker = "".concat(forceUpdateKey, "-").concat(fetchKey !== null && fetchKey !== void 0 ? fetchKey : '');
   var cacheIdentifier = getQueryCacheIdentifier(environment, query, fetchPolicy, renderPolicy, cacheBreaker);
   var preparedQueryResult = profilerContext.wrapPrepareQueryResource(function () {
@@ -87,11 +77,11 @@ function useLazyLoadQueryNode(_ref) {
       });
       return;
     }
-
     var disposable = QueryResource.retain(preparedQueryResult, profilerContext);
     return function () {
       disposable.dispose();
-    }; // NOTE: We disable react-hooks-deps warning because the `environment`
+    };
+    // NOTE: We disable react-hooks-deps warning because the `environment`
     // and `cacheIdentifier` identities are capturing all information about whether
     // the effect should be re-executed and the query re-retained.
     // eslint-disable-next-line react-hooks/exhaustive-deps
@@ -100,15 +90,14 @@ function useLazyLoadQueryNode(_ref) {
     // Release any temporary retain that's not released. At this point, if the
     // cacheIdentifier doesn't change, the query is still permanently retained,
     // and the temporary retain is redundant.
-    QueryResource.releaseTemporaryRetain(preparedQueryResult); // This effect is intended to run on every commit, thus no dependency
+    QueryResource.releaseTemporaryRetain(preparedQueryResult);
+    // This effect is intended to run on every commit, thus no dependency
   });
-  var fragmentNode = preparedQueryResult.fragmentNode,
-      fragmentRef = preparedQueryResult.fragmentRef;
 
+  var fragmentNode = preparedQueryResult.fragmentNode,
+    fragmentRef = preparedQueryResult.fragmentRef;
   var _useFragmentNode = useFragmentNode(fragmentNode, fragmentRef, componentDisplayName),
-      data = _useFragmentNode.data;
-
+    data = _useFragmentNode.data;
   return data;
 }
-
 module.exports = useLazyLoadQueryNode;