text: "use strict";
  
  var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
  
  exports.__esModule = true;
  exports.useBaseQuery = useBaseQuery;
  
  var _react = _interopRequireDefault(require("react"));
  
  var _notifyManager = require("../core/notifyManager");
  
  var _QueryErrorResetBoundary = require("./QueryErrorResetBoundary");
  
  var _QueryClientProvider = require("./QueryClientProvider");
  
  var _utils = require("./utils");
  
  function useBaseQuery(options, Observer) {
    var mountedRef = _react.default.useRef(false);
  
    var _React$useState = _react.default.useState(0),
        forceUpdate = _React$useState[1];
  
    var queryClient = (0, _QueryClientProvider.useQueryClient)();
    var errorResetBoundary = (0, _QueryErrorResetBoundary.useQueryErrorResetBoundary)();
    var defaultedOptions = queryClient.defaultQueryObserverOptions(options); // Make sure results are optimistically set in fetching state before subscribing or updating options
  
    defaultedOptions.optimisticResults = true; // Include callbacks in batch renders
  
    if (defaultedOptions.onError) {
      defaultedOptions.onError = _notifyManager.notifyManager.batchCalls(defaultedOptions.onError);
    }
  
    if (defaultedOptions.onSuccess) {
      defaultedOptions.onSuccess = _notifyManager.notifyManager.batchCalls(defaultedOptions.onSuccess);
    }
  
    if (defaultedOptions.onSettled) {
      defaultedOptions.onSettled = _notifyManager.notifyManager.batchCalls(defaultedOptions.onSettled);
    }
  
    if (defaultedOptions.suspense) {
      // Always set stale time when using suspense to prevent
      // fetching again when directly mounting after suspending
      if (typeof defaultedOptions.staleTime !== 'number') {
        defaultedOptions.staleTime = 1000;
      }
    }
  
    if (defaultedOptions.suspense || defaultedOptions.useErrorBoundary) {
      // Prevent retrying failed query if the error boundary has not been reset yet
      if (!errorResetBoundary.isReset()) {
        defaultedOptions.retryOnMount = false;
      }
    }
  
    var _React$useState2 = _react.default.useState(function () {
      return new Observer(queryClient, defaultedOptions);
    }),
        observer = _React$useState2[0];
  
    var result = observer.getOptimisticResult(defaultedOptions);
  
    _react.default.useEffect(function () {
      mountedRef.current = true;
      errorResetBoundary.clearReset();
      var unsubscribe = observer.subscribe(_notifyManager.notifyManager.batchCalls(function () {
        if (mountedRef.current) {
          forceUpdate(function (x) {
            return x + 1;
          });
        }
      })); // Update result to make sure we did not miss any query updates
      // between creating the observer and subscribing to it.
  
      observer.updateResult();
      return function () {
        mountedRef.current = false;
        unsubscribe();
      };
    }, [errorResetBoundary, observer]);
  
    _react.default.useEffect(function () {
      // Do not notify on updates because of changes in the options because
      // these changes should already be reflected in the optimistic result.
      observer.setOptions(defaultedOptions, {
        listeners: false
      });
    }, [defaultedOptions, observer]); // Handle suspense
  
  
    if (defaultedOptions.suspense && result.isLoading) {
      throw observer.fetchOptimistic(defaultedOptions).then(function (_ref) {
        var data = _ref.data;
        defaultedOptions.onSuccess == null ? void 0 : defaultedOptions.onSuccess(data);
        defaultedOptions.onSettled == null ? void 0 : defaultedOptions.onSettled(data, null);
      }).catch(function (error) {
        errorResetBoundary.clearReset();
        defaultedOptions.onError == null ? void 0 : defaultedOptions.onError(error);
        defaultedOptions.onSettled == null ? void 0 : defaultedOptions.onSettled(undefined, error);
      });
    } // Handle error boundary
  
  
    if (result.isError && !result.isFetching && (0, _utils.shouldThrowError)(defaultedOptions.suspense, defaultedOptions.useErrorBoundary, result.error)) {
      throw result.error;
    } // Handle result property usage tracking
  
  
    if (defaultedOptions.notifyOnChangeProps === 'tracked') {
      result = observer.trackResult(result);
    }
  
    return result;
  }