@wix/bex-core 1.402.0

package/dist/cjs/state/CollectionState.js

@@ -0,0 +1,1136 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+exports.__esModule = true;
+exports.CollectionState = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _model = require("../model");
+var _core = require("react-query/core");
+var _mobx = require("mobx");
+var _events = require("events");
+var _QueryState = require("./QueryState");
+var _QueryResultState = require("./QueryResultState");
+var _BulkSelectState = require("./BulkSelectState");
+var _PromisesState = require("./PromisesState");
+var _Pagination = require("./Pagination");
+var _PaginationMode = require("./PaginationMode");
+var _TaskState = require("./TaskState");
+var _util = require("../util");
+var _TransitionState = require("./TransitionState");
+class CollectionState {
+  get queryKeyOptions() {
+    const {
+      query
+    } = this;
+    return {
+      queryKey: this._queryKey(query.asComputed)
+    };
+  }
+  isOnline() {
+    return this.onlineState.isOnline;
+  }
+  get optimisticActions() {
+    if (this._optimisticActions == null && process.env.NODE_ENV !== 'production') {
+      throw new Error('optimisticActions is not initialized');
+    }
+    return this._optimisticActions;
+  }
+  constructor(params) {
+    (0, _defineProperty2.default)(this, "query", void 0);
+    (0, _defineProperty2.default)(this, "_paginationModeRef", void 0);
+    (0, _defineProperty2.default)(this, "_paginationMode", void 0);
+    (0, _defineProperty2.default)(this, "selectionConsistencyMode", void 0);
+    (0, _defineProperty2.default)(this, "result", void 0);
+    (0, _defineProperty2.default)(this, "bulkSelect", void 0);
+    /**
+     * @deprecated
+     * Use [ToolbarCollectionState.closeCairoSidePanel](/pages/cairo/?path=/story/common-state--toolbarcollectionstate) instead.
+     */
+    (0, _defineProperty2.default)(this, "filtersPanelModal", void 0);
+    (0, _defineProperty2.default)(this, "scrollableContent", null);
+    (0, _defineProperty2.default)(this, "errorMonitor", void 0);
+    (0, _defineProperty2.default)(this, "queryCache", void 0);
+    (0, _defineProperty2.default)(this, "queryClient", void 0);
+    (0, _defineProperty2.default)(this, "queryObserver", void 0);
+    (0, _defineProperty2.default)(this, "queryName", void 0);
+    (0, _defineProperty2.default)(this, "fqdn", void 0);
+    (0, _defineProperty2.default)(this, "fetchErrorMessage", void 0);
+    (0, _defineProperty2.default)(this, "itemName", void 0);
+    (0, _defineProperty2.default)(this, "itemKey", void 0);
+    (0, _defineProperty2.default)(this, "toExtendedFields", void 0);
+    (0, _defineProperty2.default)(this, "translate", void 0);
+    (0, _defineProperty2.default)(this, "fetchData", void 0);
+    (0, _defineProperty2.default)(this, "lodash", void 0);
+    (0, _defineProperty2.default)(this, "deferInitialLoading", void 0);
+    (0, _defineProperty2.default)(this, "persistQueryToUrl", void 0);
+    (0, _defineProperty2.default)(this, "_optimisticActions", void 0);
+    (0, _defineProperty2.default)(this, "beforeSetData", void 0);
+    (0, _defineProperty2.default)(this, "showToast", void 0);
+    (0, _defineProperty2.default)(this, "events", void 0);
+    (0, _defineProperty2.default)(this, "emitter", new _events.EventEmitter());
+    (0, _defineProperty2.default)(this, "onlineState", void 0);
+    (0, _defineProperty2.default)(this, "history", void 0);
+    (0, _defineProperty2.default)(this, "initDependencies", void 0);
+    (0, _defineProperty2.default)(this, "initialPromises", new _PromisesState.PromisesState());
+    (0, _defineProperty2.default)(this, "refreshPromises", new _PromisesState.PromisesState());
+    (0, _defineProperty2.default)(this, "initTask", new _TaskState.TaskState());
+    /**
+     * Possible flows:
+     * result->refresh, refresh->result, result->fetchMore, fetchMore->result, refresh->refresh, fetchMore->fetchMore
+     */
+    (0, _defineProperty2.default)(this, "lifecycleState", 'result');
+    (0, _defineProperty2.default)(this, "_queryKey", asComputed => {
+      const {
+        queryName
+      } = this;
+      const {
+        filters,
+        rawFilters,
+        search,
+        hasActiveFilters,
+        hasNonPersistentActiveFilters,
+        nonPersistentFiltersKey,
+        columns,
+        // Pick only properties relevant to `queryKey` uniqueness
+        ...computedQuery
+      } = asComputed;
+      return [queryName, computedQuery];
+    });
+    (0, _defineProperty2.default)(this, "_queryFn", async computedQuery => {
+      const {
+        items,
+        total,
+        available = null,
+        cursor = null
+      } = await this.fetchData(computedQuery);
+      return {
+        items,
+        total,
+        available,
+        cursor
+      };
+    });
+    (0, _defineProperty2.default)(this, "scheduleSort", void 0);
+    (0, _defineProperty2.default)(this, "scheduleSearch", void 0);
+    (0, _defineProperty2.default)(this, "_runSearch", void 0);
+    (0, _defineProperty2.default)(this, "_runSort", void 0);
+    (0, _defineProperty2.default)(this, "animationFramePromise", () => new Promise(resolve => {
+      requestAnimationFrame(() => {
+        requestAnimationFrame(() => {
+          resolve();
+        });
+      });
+    }));
+    (0, _defineProperty2.default)(this, "onError", (0, _mobx.action)(err => {
+      if (err == null) {
+        return;
+      }
+      const {
+        onlineState,
+        events,
+        errorMonitor
+      } = this;
+      console.error(err);
+      const {
+        isOnline
+      } = onlineState;
+      if (!(err instanceof _util.OfflineError)) {
+        const handled = events.onError == null ? void 0 : events.onError({
+          err,
+          isOnline
+        });
+        if (!handled) {
+          errorMonitor.captureException(err);
+        }
+      }
+      this.getCurrentQuery().invalidate();
+      this._resetReactQuery();
+      this.updateStatus();
+
+      // online manager is responsible for showing offline toast message
+      const message = isOnline ? this.fetchErrorMessage({
+        err,
+        isOnline
+      }) : null;
+      if (message) {
+        this.showToast({
+          type: 'ERROR',
+          message,
+          biName: 'cairo-fetch-error'
+        });
+      }
+    }));
+    (0, _defineProperty2.default)(this, "_currentQueryPromise", void 0);
+    (0, _defineProperty2.default)(this, "fetchNextPage", (0, _mobx.action)(async () => {
+      const {
+        query,
+        result,
+        events: {
+          onNewPageAdded,
+          onNewPageStart
+        },
+        emitter
+      } = this;
+      // if current page has an error, do not skip to next page
+      if (!result.status.isError) {
+        query.pagination.nextPage();
+      }
+      this.lifecycleState = 'fetchMore';
+      const onNewPageAddedListeners = emitter.listeners('newPageStart').map(l => l());
+      const maybeOnNewPageAdded = onNewPageStart == null ? void 0 : onNewPageStart({
+        query: query.asComputed
+      });
+      const {
+        promise,
+        currentQuery,
+        onResultListeners
+      } = this.fetch();
+      await promise;
+      (0, _mobx.runInAction)(() => {
+        if (promise === this._currentQueryPromise) {
+          const updateResultInfo = this.updateResult([currentQuery]);
+          onResultListeners.forEach(l => l == null ? void 0 : l());
+          if (updateResultInfo) {
+            const {
+              newPages
+            } = updateResultInfo;
+            const onNewPageAddedParams = {
+              totalNewItems: newPages.reduce((agg, page) => agg + page.items.length, 0),
+              newPages,
+              query: result.originQuery,
+              result: result.asComputed
+            };
+            onNewPageAddedListeners.forEach(l => l(onNewPageAddedParams));
+            if (maybeOnNewPageAdded != null) {
+              maybeOnNewPageAdded(onNewPageAddedParams);
+            }
+            onNewPageAdded == null || onNewPageAdded(onNewPageAddedParams);
+          }
+        }
+      });
+    }));
+    (0, _defineProperty2.default)(this, "_recoverIfError", (0, _mobx.action)(() => {
+      const {
+        onlineState
+      } = this;
+      const {
+        focusManager
+      } = onlineState;
+      if (focusManager.isFocused() && onlineState.isOnline && this.result.status.isError) {
+        if (this.lifecycleState === 'fetchMore') {
+          // error state is not shown, fetch next page
+          this.fetchNextPageIfNeeded();
+        } else {
+          // error state is shown, move to start
+          this.clearResultAndMoveToStart({
+            force: true
+          });
+        }
+      }
+    }));
+    (0, _defineProperty2.default)(this, "onOnlineStateChange", isOnline => {
+      const currentQuery = this.getCurrentQuery();
+      if (isOnline) {
+        this._recoverIfError();
+      } else if (!isOnline && currentQuery.state.isPaused) {
+        currentQuery.dispatch({
+          type: 'error',
+          error: new _util.OfflineError('CollectionState.onOnlineStateChange: offline')
+        });
+        this.updateStatus();
+      }
+    });
+    (0, _defineProperty2.default)(this, "retryErrorState", (0, _mobx.action)(() => {
+      const {
+        initTask
+      } = this;
+      if (initTask.status.isError) {
+        initTask.runOnce();
+      } else {
+        this.clearResultAndMoveToStart();
+      }
+    }));
+    (0, _defineProperty2.default)(this, "_topNotification", new _TransitionState.TransitionState());
+    this.lodash = params.lodash;
+    this.persistQueryToUrl = params.persistQueryToUrl;
+    this.toExtendedFields = params.toExtendedFields;
+    this.filtersPanelModal = params.filtersPanelModal ?? {
+      _events: new _events.EventEmitter(),
+      open() {},
+      close() {},
+      isOpen: false
+    };
+    (0, _mobx.makeObservable)(this, {
+      fetchNextPageIfNeeded: _mobx.action.bound,
+      clearAndMoveToPage: _mobx.action.bound,
+      clearResultAndMoveToStart: _mobx.action.bound,
+      refreshAllPages: _mobx.action.bound,
+      updateStatus: _mobx.action.bound,
+      updateResult: _mobx.action.bound,
+      search: _mobx.action,
+      sort: _mobx.action,
+      fetch: _mobx.action,
+      init: _mobx.action,
+      setInitialPage: _mobx.action,
+      initialFetch: _mobx.action,
+      totalPages: _mobx.computed,
+      hasAvailableItems: _mobx.computed,
+      showInitialLoader: _mobx.computed,
+      showRefreshLoader: _mobx.computed,
+      showEmptyState: _mobx.computed,
+      showErrorState: _mobx.computed,
+      resetFiltersAndRefresh: _mobx.action.bound,
+      lifecycleState: _mobx.observable.ref,
+      clearResultBeforeRefresh: _mobx.action,
+      scrollableContent: _mobx.observable.ref,
+      _commonDynamicBiParams: _mobx.action
+    });
+    this.queryName = params.queryName;
+    this.fqdn = params.fqdn;
+    this.deferInitialLoading = params.deferInitialLoading;
+    this.queryCache = params.queryCache;
+    this.fetchErrorMessage = params.fetchErrorMessage;
+    this.itemKey = params.itemKey;
+    this.itemName = params.itemName;
+    this.translate = params.translate;
+    this.fetchData = params.fetchData;
+    this.events = params.events ?? {};
+    this.initDependencies = params.initDependencies;
+    this.showToast = params.showToast ?? (() => ({
+      remove: () => {}
+    }));
+    this.query = new _QueryState.QueryState({
+      filters: params.filters,
+      search: params.search,
+      limit: params.limit,
+      history: params.persistQueryToUrl ? params.history : undefined,
+      refreshOnColumnsChange: params.refreshOnColumnsChange
+    });
+    this._paginationModeRef = params.paginationModeRef ?? {
+      current: params.paginationMode
+    };
+    this._paginationMode = new _PaginationMode.PaginationMode(this);
+    this.selectionConsistencyMode = params.selectionConsistencyMode ?? 'preserve';
+    this.result = new _QueryResultState.QueryResultState({
+      itemKey: params.itemKey,
+      originQuery: this.query.toComputed()
+    });
+    this.bulkSelect = new _BulkSelectState.BulkSelectState({
+      disableAutoSelectAllCount: params.disableAutoSelectAllCount,
+      useNewSelectAllLogic: params.useNewSelectAllLogic,
+      collection: this,
+      scrollToTop: () => {
+        var _this$scrollableConte;
+        (_this$scrollableConte = this.scrollableContent) == null || _this$scrollableConte.scrollTo({
+          top: 0,
+          left: 0
+        });
+      }
+    });
+    this.errorMonitor = params.errorMonitor;
+    this.onlineState = params.onlineState;
+    this.history = params.history;
+    const defaultQueryOptions = {
+      queryFn: (0, _mobx.action)(() => this._queryFn(this.query.asComputed)),
+      keepPreviousData: true,
+      suspense: false,
+      enabled: false,
+      retryDelay: 200,
+      staleTime: 120000,
+      onError: this.onError,
+      refetchOnMount: false,
+      retryOnMount: false,
+      ...params.queryOptions
+    };
+    this.queryClient = new _core.QueryClient({
+      queryCache: this.queryCache,
+      defaultOptions: {
+        queries: defaultQueryOptions
+      }
+    });
+    this.queryObserver = new _core.QueryObserver(this.queryClient, {
+      retry: (failureCount, error) => {
+        if ((0, _util.shouldRedirectToLogin)(error, failureCount > 2 && this.isOnline())) {
+          return false;
+        }
+        return failureCount < 3;
+      },
+      ...defaultQueryOptions
+    });
+    this._resetReactQuery();
+    if (params.initialPage) {
+      this.setInitialPage(params.initialPage);
+    }
+    if (params.deferInitialLoading) {
+      this.initialPromises.addPromise(this.animationFramePromise);
+    }
+    this._runSort = (0, _mobx.action)(({
+      clearResult
+    }) => {
+      this.emitter.emit('sort', {
+        clearResult
+      });
+      if (clearResult) {
+        this.clearResultBeforeRefresh();
+      }
+      return this.moveToFirstPage();
+    });
+    this.scheduleSort = this.whenNotIdle(this.lodash.debounce(this._runSort, 300));
+    this._runSearch = (0, _mobx.action)(async clearResult => {
+      const {
+        events: {
+          onSearch,
+          onSearchResults
+        },
+        emitter,
+        query
+      } = this;
+      const searchEndListeners = emitter.listeners('searchStart').map(l => l());
+      onSearch == null || onSearch({
+        query: query.asComputed
+      });
+      emitter.emit('search', {
+        clearResult
+      });
+      if (clearResult) {
+        this.clearResultBeforeRefresh();
+      }
+      if (this.selectionConsistencyMode === 'clear') {
+        this.bulkSelect.resetToDefaults();
+      }
+      return this.moveToFirstPage({
+        onResultUpdated: params => {
+          searchEndListeners.forEach(l => l());
+          onSearchResults == null || onSearchResults(params);
+        }
+      });
+    });
+    this.scheduleSearch = this.lodash.debounce(this._runSearch, 300);
+  }
+  _resetReactQuery() {
+    this.queryObserver.setOptions({
+      ...this.queryObserver.options,
+      ...this.queryKeyOptions,
+      enabled: false
+    }, {
+      onError: true
+    });
+  }
+  setInitialPage(initialPage) {
+    const {
+      items,
+      total: maybeTotal,
+      available = null,
+      cursor = null
+    } = initialPage;
+    const total = maybeTotal ?? items.length;
+    this.queryClient.setQueryData(this.queryKeyOptions.queryKey, {
+      items,
+      total,
+      available,
+      cursor
+    });
+  }
+  getCurrentQuery() {
+    const query = this.queryObserver.getCurrentQuery();
+    return query;
+  }
+  get paginationMode() {
+    return this._paginationMode;
+  }
+  _getProcessedResult({
+    unprocessedPages,
+    unprocessedTotal,
+    currentItemsMap
+  }) {
+    const {
+      emitter,
+      result
+    } = this;
+    const {
+      originQuery
+    } = result;
+    const beforeAddNewPagesListeners = emitter.listeners('beforeAddNewPages');
+    const processedPages = beforeAddNewPagesListeners.reduce((pages, listener) => listener({
+      pages,
+      currentItemsMap,
+      originQuery
+    }), unprocessedPages);
+    const processedTotal = this._getProcessedTotal(unprocessedTotal);
+    return {
+      processedPages,
+      processedTotal
+    };
+  }
+  _getProcessedTotal(unprocessedTotal) {
+    const {
+      emitter,
+      result
+    } = this;
+    const {
+      originQuery
+    } = result;
+    const beforeSetTotalListeners = emitter.listeners('beforeSetTotal');
+    return beforeSetTotalListeners.reduce((total, listener) => listener({
+      total,
+      originQuery
+    }), unprocessedTotal);
+  }
+  updateResult(queries) {
+    const {
+      result,
+      paginationMode,
+      emitter
+    } = this;
+    const newPages = queries.map(reactQuery => reactQuery.state.data).filter(d => d != null);
+    this.updateStatus();
+    if (newPages.length) {
+      emitter.emit('beforeResultUpdated');
+      const lastPage = newPages[newPages.length - 1];
+      const {
+        available,
+        cursor
+      } = lastPage;
+      const unprocessedTotal = lastPage.total ?? lastPage.items.length;
+      const unprocessedPages = newPages.map(data => data.items);
+      const {
+        processedPages,
+        processedTotal
+      } = this._getProcessedResult({
+        unprocessedPages,
+        unprocessedTotal,
+        currentItemsMap: result._keyedItemsMap
+      });
+      result.addPages({
+        unprocessed: unprocessedPages,
+        processed: processedPages
+      });
+      result.setTotals({
+        unprocessed: unprocessedTotal,
+        processed: processedTotal
+      });
+      result.setSupportTotal(lastPage.total != null);
+      paginationMode.setCursor(cursor);
+      if (available != null) {
+        result.available = available;
+      }
+      this.lifecycleState = 'result';
+      emitter.emit('resultUpdated');
+      return {
+        newPages
+      };
+    }
+    return null;
+  }
+  whenNotIdle(fn) {
+    return (...args) => {
+      if (this.result.status.isIdle) {
+        return;
+      }
+      fn(...args);
+    };
+  }
+  updateStatus() {
+    const {
+      queryObserver,
+      result,
+      query
+    } = this;
+    const {
+      status,
+      error,
+      isFetching
+    } = queryObserver.getOptimisticResult(queryObserver.options);
+    result.status = {
+      ..._model.queryStatus[status],
+      isFetching,
+      error
+    };
+    result.originQuery = query.asComputed;
+  }
+  fetch() {
+    const {
+      queryObserver,
+      onlineState,
+      emitter
+    } = this;
+    queryObserver.setOptions({
+      ...queryObserver.options,
+      ...this.queryKeyOptions,
+      enabled: true
+    }, {
+      onError: true
+    });
+    const currentQuery = this.getCurrentQuery();
+    this._currentQueryPromise = new Promise(resolve => {
+      if (currentQuery.promise) {
+        currentQuery.promise.then(() => resolve()).catch(() => resolve());
+      } else {
+        resolve();
+      }
+    });
+    const isStale = currentQuery.isStale();
+    const fetchListeners = emitter.listeners('fetch');
+    const onResultListeners = fetchListeners.map(l => l({
+      isStale
+    }));
+    if (!onlineState.isOnline) {
+      currentQuery.dispatch({
+        type: 'error',
+        error: new _util.OfflineError('CollectionState.fetch: offline')
+      });
+    }
+    this.updateStatus();
+    return {
+      currentQuery,
+      isStale,
+      onResultListeners,
+      promise: this._currentQueryPromise
+    };
+  }
+  get totalPages() {
+    const {
+      result: {
+        _totals: {
+          unprocessed: total
+        }
+      },
+      query: {
+        pagination: {
+          limit
+        }
+      }
+    } = this;
+    return Math.ceil(total / limit);
+  }
+  get fetchedLastPage() {
+    const {
+      paginationMode: {
+        fetchedLastPage
+      }
+    } = this;
+    return fetchedLastPage;
+  }
+  async fetchNextPageIfNeeded() {
+    const {
+      result,
+      fetchedLastPage,
+      lifecycleState
+    } = this;
+    if (lifecycleState !== 'refresh' && !result.status.isFetching && !fetchedLastPage) {
+      await this.fetchNextPage();
+    }
+  }
+
+  // for rendering only a single page (<PaginationTable />)
+  async clearAndMoveToPage(page, options = {}) {
+    let minLoaderTime = 0;
+    const {
+      wait = {
+        min: 200,
+        max: 500
+      }
+    } = options;
+    const {
+      query,
+      result,
+      events: {
+        onNewPageStart
+      }
+    } = this;
+    const {
+      pagination
+    } = query;
+    pagination.page = page;
+    const maybeOnNewPageAdded = onNewPageStart == null ? void 0 : onNewPageStart({
+      query: query.asComputed
+    });
+    const {
+      promise,
+      currentQuery,
+      onResultListeners
+    } = this.fetch();
+    const fetchPromise = promise;
+    let timeoutId = null;
+    const maxWaitPromise = new Promise(resolve => {
+      timeoutId = setTimeout(() => {
+        // timeoutId was not cleared yet, start showing a loader and set minimal time for the loader to show
+        minLoaderTime = wait.min;
+        this.clearResultBeforeRefresh();
+        resolve();
+      }, wait.max);
+    });
+
+    // minimal time to wait (usually scrolling to top time) before applying the new result
+    const minWaitPromise = new Promise(resolve => {
+      setTimeout(resolve, wait.min);
+    });
+    await Promise.race([maxWaitPromise, fetchPromise]);
+    if (timeoutId != null) {
+      clearTimeout(timeoutId);
+    }
+    if (minLoaderTime) {
+      await new Promise(resolve => setTimeout(resolve, minLoaderTime));
+    }
+    await minWaitPromise;
+    await fetchPromise;
+    if (promise === this._currentQueryPromise) {
+      (0, _mobx.runInAction)(() => {
+        result.clear();
+        const updateResultInfo = this.updateResult([currentQuery]);
+        onResultListeners.forEach(l => l == null ? void 0 : l());
+        if (updateResultInfo) {
+          const {
+            newPages
+          } = updateResultInfo;
+          if (maybeOnNewPageAdded != null) {
+            maybeOnNewPageAdded({
+              totalNewItems: newPages.reduce((agg, page) => agg + page.items.length, 0),
+              query: result.originQuery,
+              result: result.asComputed
+            });
+          }
+        }
+      });
+    }
+  }
+  clearResultBeforeRefresh() {
+    const {
+      result
+    } = this;
+    this.lifecycleState = 'refresh';
+    result.clear();
+  }
+  async moveToFirstPage({
+    onResultUpdated
+  } = {}) {
+    const {
+      query: {
+        pagination
+      }
+    } = this;
+    pagination.page = 1;
+    pagination.cursor = _Pagination.initialCursor;
+    await this.fetchAndReplaceResult({
+      onResultUpdated
+    });
+  }
+  invalidate({
+    filters
+  } = {}) {
+    const {
+      queryCache,
+      queryName
+    } = this;
+    const queryLookup = {};
+    if (filters) {
+      Object.assign(queryLookup, {
+        filtersKey: filters
+      });
+    }
+    queryCache.findAll({
+      queryKey: [queryName, queryLookup]
+    }).forEach(q => q.invalidate());
+  }
+  clearResultAndMoveToStart({
+    onResultUpdated,
+    force,
+    filters
+  } = {}) {
+    if (force) {
+      this.invalidate({
+        filters
+      });
+      this._resetReactQuery();
+    }
+    this.clearResultBeforeRefresh();
+    return this.moveToFirstPage({
+      onResultUpdated
+    });
+  }
+  sort(col, params = {}) {
+    const {
+      query,
+      emitter
+    } = this;
+    emitter.emit('beforeSortStart', {
+      origin: 'ColumnHeader'
+    });
+    query.sort.changeSort(col, {
+      multiple: params.multiple
+    });
+    emitter.emit('sortStart', {
+      col
+    });
+    return this.scheduleSort(params);
+  }
+  async fetchAndReplaceResult({
+    onResultUpdated
+  } = {}) {
+    const {
+      result,
+      query,
+      emitter
+    } = this;
+    const {
+      promise,
+      currentQuery,
+      isStale,
+      onResultListeners
+    } = this.fetch();
+    // page=1 means starting over, i.e refresh
+    if (query.pagination.page === 1) {
+      emitter.emit('refresh', {
+        isStale
+      });
+    }
+    await promise;
+    if (promise === this._currentQueryPromise) {
+      (0, _mobx.runInAction)(() => {
+        result.slice(0, query.pagination.page - 1);
+        this.emitter.emit('refreshUpdateResult');
+        this.updateResult([currentQuery]);
+        onResultListeners.forEach(l => l == null ? void 0 : l());
+        onResultUpdated == null || onResultUpdated({
+          query: result.originQuery,
+          result: result.asComputed
+        });
+      });
+    }
+    return currentQuery;
+  }
+  search(value, {
+    force,
+    clearResult
+  } = {}) {
+    const {
+      query
+    } = this;
+    const {
+      search
+    } = query;
+    if (force || value !== search.value) {
+      search.changeValue(value);
+      this.scheduleSearch(clearResult);
+    }
+  }
+  clearSearch() {
+    const {
+      query,
+      events: {
+        onSearchResults
+      },
+      emitter
+    } = this;
+    const {
+      search
+    } = query;
+    if (search.value === '') {
+      return;
+    }
+    search.changeValue('');
+    emitter.emit('clearSearch');
+    if (this.selectionConsistencyMode === 'clear') {
+      this.bulkSelect.resetToDefaults();
+    }
+    return this.clearResultAndMoveToStart({
+      onResultUpdated: onSearchResults
+    });
+  }
+  get filters() {
+    return this.query.filters;
+  }
+  changeItem(newItem) {
+    return this.changeItems([newItem]);
+  }
+  changeItems(newItems) {
+    const changeResult = this.result.changeItems(newItems);
+    if (changeResult != null) {
+      this.invalidate();
+      return changeResult.rollback;
+    }
+    return undefined;
+  }
+  async refreshCurrentPage({
+    noInvalidate
+  } = {}) {
+    const {
+      emitter
+    } = this;
+    if (!noInvalidate) {
+      this.invalidate();
+    }
+    this._resetReactQuery();
+    emitter.emit('refreshCurrentPage');
+    await this.fetchAndReplaceResult();
+  }
+  async refreshAllPages({
+    beforeUpdateResult,
+    filters
+  } = {}) {
+    const {
+      query,
+      result,
+      paginationMode,
+      emitter
+    } = this;
+    const {
+      pagination
+    } = query;
+    const {
+      page: currentPage
+    } = pagination;
+    this.invalidate({
+      filters
+    });
+    const promises = [];
+    pagination.cursor = _Pagination.initialCursor;
+    emitter.emit('refreshAllPages');
+    emitter.emit('refresh', {
+      isStale: true
+    }); // Because of invalidation above, all queries are now stale
+
+    let lastPagePromise = undefined;
+    for (let page = 1; page <= currentPage; page++) {
+      pagination.page = page;
+      this._resetReactQuery();
+      const {
+        currentQuery: pageQuery,
+        promise
+      } = this.fetch();
+      if (pageQuery.promise) {
+        if (paginationMode.id === 'cursor') {
+          await pageQuery.promise;
+          (0, _mobx.runInAction)(() => {
+            var _pageQuery$state$data;
+            return pagination.cursor = ((_pageQuery$state$data = pageQuery.state.data) == null ? void 0 : _pageQuery$state$data.cursor) ?? null;
+          });
+        }
+        promises.push(pageQuery.promise.then(() => pageQuery));
+      }
+      if (page === currentPage) {
+        lastPagePromise = promise;
+      }
+    }
+    this.updateStatus();
+    const results = await Promise.all(promises);
+    (0, _mobx.runInAction)(() => {
+      beforeUpdateResult == null || beforeUpdateResult();
+      if (lastPagePromise === this._currentQueryPromise) {
+        result.slice(currentPage);
+        this.emitter.emit('refreshUpdateResult');
+        this.updateResult(results);
+      }
+    });
+  }
+  get hasAvailableItems() {
+    return this.result.hasAvailableItems;
+  }
+  resetFiltersAndRefresh() {
+    const {
+      query
+    } = this;
+    query.resetFilters({
+      emitEvents: ['change', 'refresh']
+    });
+  }
+  resetCustomFiltersAndRefresh() {
+    const {
+      query
+    } = this;
+    query.resetCustomFilters({
+      emitEvents: ['change', 'refresh']
+    });
+  }
+  async initialFetch() {
+    const {
+      result,
+      events: {
+        onInitialPageFetched
+      },
+      emitter,
+      query: {
+        pagination
+      }
+    } = this;
+    const prevQuery = this.getCurrentQuery();
+    if (!result.status.isIdle && !result.status.isError) {
+      return prevQuery.promise;
+    }
+    pagination.page = 1;
+    pagination.cursor = _Pagination.initialCursor;
+    this.lifecycleState = 'refresh';
+    const isStale = prevQuery.isStale();
+    const beforeInitialFetchListeners = emitter.listeners('beforeInitialFetch');
+    await Promise.all(beforeInitialFetchListeners.map(f => f({
+      isStale
+    })));
+
+    // reset paging state again for any possible edge case caused by external side effect while waiting `beforeInitialFetchListeners`
+    (0, _mobx.runInAction)(() => {
+      pagination.page = 1;
+      pagination.cursor = _Pagination.initialCursor;
+      this.lifecycleState = 'refresh';
+    });
+    const currentQuery = await this.fetchAndReplaceResult();
+    await currentQuery.promise;
+    this.emitter.emit('ready');
+    (0, _mobx.runInAction)(() => {
+      const {
+        total,
+        available
+      } = result;
+      onInitialPageFetched == null || onInitialPageFetched({
+        result: {
+          total,
+          available: available ?? 0
+        },
+        query: result.originQuery
+      });
+    });
+  }
+  init({
+    skipInitialFetch
+  } = {}) {
+    const {
+      bulkSelect,
+      onlineState,
+      query,
+      initTask,
+      result
+    } = this;
+    const {
+      focusManager
+    } = onlineState;
+    result.originQuery = query.asComputed;
+    onlineState.events.on('change', this.onOnlineStateChange);
+    const disposers = [query.init(), this._registerQueryEvents(), bulkSelect.init(),
+    // react-query considers "mounted" only if listeners are subscribed
+    this.queryObserver.subscribe(() => {}), focusManager.subscribe(this._recoverIfError)];
+    initTask.runOnce(async () => {
+      var _this$initDependencie;
+      await Promise.all([skipInitialFetch ? null : this.initialFetch(), (_this$initDependencie = this.initDependencies) == null ? void 0 : _this$initDependencie.call(this)]);
+    });
+    return (0, _mobx.action)(() => {
+      onlineState.events.off('change', this.onOnlineStateChange);
+      disposers.forEach(disposer => disposer());
+      initTask.status = {
+        ..._model.queryStatus.idle
+      };
+    });
+  }
+  _registerQueryEvents() {
+    const {
+      query
+    } = this;
+    const disposers = [(0, _util.addEventListener)(query.events, 'refresh', opts => {
+      if (this.selectionConsistencyMode === 'clear') {
+        this.bulkSelect.resetToDefaults();
+      }
+      if (this.deferInitialLoading) {
+        this.refreshPromises.addPromise(this.animationFramePromise);
+      }
+      if ((opts == null ? void 0 : opts.clearResult) !== false) {
+        this.clearResultBeforeRefresh();
+      } else {
+        var _this$scrollableConte2;
+        (_this$scrollableConte2 = this.scrollableContent) == null || _this$scrollableConte2.scrollTo({
+          top: 0,
+          behavior: 'smooth'
+        });
+      }
+      this.moveToFirstPage();
+    }), (0, _util.addEventListener)(query.events, 'scheduleRefresh', opts => {
+      this.scheduleSearch(opts == null ? void 0 : opts.clearResult);
+    }), ...(query.refreshOnColumnsChange ? [(0, _mobx.reaction)(() => query.fieldsKeyHash, () => {
+      this.clearResultBeforeRefresh();
+      this.moveToFirstPage();
+    })] : [])];
+    return () => {
+      disposers.forEach(d => d());
+    };
+  }
+  get(key) {
+    const keyedItem = this.result.get(key);
+    return keyedItem == null ? void 0 : keyedItem.item;
+  }
+  addRefreshPromise(createPromise) {
+    return this.refreshPromises.addPromise(createPromise);
+  }
+  _commonDynamicBiParams(query = this.result.originQuery) {
+    var _query$sort, _query$sort2;
+    const {
+      result,
+      fqdn
+    } = this;
+    return {
+      ...fqdn,
+      currentFilters: JSON.stringify(query.filtersKey),
+      currentSortOrder: (_query$sort = query.sort) != null && _query$sort.length ? JSON.stringify(query.sort) : undefined,
+      filteredListSize: result.total,
+      initialItems: result.size,
+      numSortedColumns: (_query$sort2 = query.sort) == null ? void 0 : _query$sort2.length
+    };
+  }
+  get showInitialLoader() {
+    const {
+      initTask: {
+        status: {
+          isLoading
+        }
+      },
+      initialPromises: {
+        isLoadingPromises
+      }
+    } = this;
+    return isLoading || isLoadingPromises;
+  }
+  get showRefreshLoader() {
+    const {
+      refreshPromises: {
+        isLoadingPromises
+      },
+      result: {
+        status
+      },
+      lifecycleState
+    } = this;
+    return isLoadingPromises || Boolean(status.isFetching && lifecycleState === 'refresh');
+  }
+  get showEmptyState() {
+    const {
+      lifecycleState,
+      result: {
+        isEmpty
+      }
+    } = this;
+    return lifecycleState === 'result' && isEmpty;
+  }
+  get showErrorState() {
+    const {
+      result: {
+        status
+      },
+      lifecycleState
+    } = this;
+    return !status.isFetching && status.isError && lifecycleState !== 'fetchMore';
+  }
+  get topNotification() {
+    const {
+      _topNotification
+    } = this;
+    return {
+      set text(t) {
+        _topNotification.set(t);
+      },
+      get text() {
+        return (0, _mobx.runInAction)(() => _topNotification.data);
+      },
+      get show() {
+        return (0, _mobx.runInAction)(() => _topNotification.show);
+      }
+    };
+  }
+}
+exports.CollectionState = CollectionState;
+//# sourceMappingURL=CollectionState.js.map