@atlaskit/global-search/dist/esm/components/common/SearchResults.js

A cross-product search component (batteries included)

import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
import _createClass from "@babel/runtime/helpers/createClass";
import _inherits from "@babel/runtime/helpers/inherits";
import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
import _defineProperty from "@babel/runtime/helpers/defineProperty";

function _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }

function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }

import React from 'react';
import PreQueryState from './PreQueryState';
import { isEmpty } from '../SearchResultsUtil';
import { PostQueryAnalyticsComponent } from './ScreenAnalyticsHelper';
import ResultGroupsComponent, { ResultGroupType } from './ResultGroupsComponent';
import SearchError from '../SearchError';
import deepEqual from 'deep-equal';
export var SearchResultsState;

(function (SearchResultsState) {
  SearchResultsState[SearchResultsState["PreQueryLoading"] = 0] = "PreQueryLoading";
  SearchResultsState[SearchResultsState["PreQueryResults"] = 1] = "PreQueryResults";
  SearchResultsState[SearchResultsState["PreQueryNoResults"] = 2] = "PreQueryNoResults";
  SearchResultsState[SearchResultsState["PostQueryResults"] = 3] = "PostQueryResults";
  SearchResultsState[SearchResultsState["PostQueryNoResults"] = 4] = "PostQueryNoResults";
  SearchResultsState[SearchResultsState["IntermediateResults"] = 5] = "IntermediateResults";
  SearchResultsState[SearchResultsState["IntermediateNoResults"] = 6] = "IntermediateNoResults";
})(SearchResultsState || (SearchResultsState = {}));

export var getSearchResultState = function getSearchResultState(_ref) {
  var isPreQuery = _ref.isPreQuery,
      isLoading = _ref.isLoading,
      hasResults = _ref.hasResults;

  if (isPreQuery) {
    // Pre query
    if (isLoading) {
      return SearchResultsState.PreQueryLoading;
    }

    if (!hasResults) {
      return SearchResultsState.PreQueryNoResults;
    }

    return SearchResultsState.PreQueryResults;
  } else if (isLoading) {
    // Intermediate
    if (!hasResults) {
      return SearchResultsState.IntermediateNoResults;
    }

    return SearchResultsState.IntermediateResults;
  } else {
    // Post query
    if (!hasResults) {
      return SearchResultsState.PostQueryNoResults;
    }

    return SearchResultsState.PostQueryResults;
  }
};

var SearchResults = /*#__PURE__*/function (_React$Component) {
  _inherits(SearchResults, _React$Component);

  var _super = _createSuper(SearchResults);

  function SearchResults() {
    _classCallCheck(this, SearchResults);

    return _super.apply(this, arguments);
  }

  _createClass(SearchResults, [{
    key: "shouldComponentUpdate",
    value: function shouldComponentUpdate(nextProps) {
      return !deepEqual(nextProps, this.props);
    }
  }, {
    key: "hasNoResult",
    value: function hasNoResult() {
      var _this$props = this.props,
          isPreQuery = _this$props.isPreQuery,
          isLoading = _this$props.isLoading,
          keepPreQueryState = _this$props.keepPreQueryState,
          getPreQueryGroups = _this$props.getPreQueryGroups,
          getPostQueryGroups = _this$props.getPostQueryGroups;
      var results = isPreQuery || isLoading && keepPreQueryState ? getPreQueryGroups() : getPostQueryGroups();
      return results.map(function (_ref2) {
        var items = _ref2.items;
        return items;
      }).every(isEmpty);
    }
  }, {
    key: "renderNoResult",
    value: function renderNoResult() {
      var _this$props2 = this.props,
          renderNoResult = _this$props2.renderNoResult,
          postQueryScreenCounter = _this$props2.postQueryScreenCounter,
          searchSessionId = _this$props2.searchSessionId,
          referralContextIdentifiers = _this$props2.referralContextIdentifiers;
      return /*#__PURE__*/React.createElement(React.Fragment, null, renderNoResult(), /*#__PURE__*/React.createElement(PostQueryAnalyticsComponent, {
        screenCounter: postQueryScreenCounter,
        searchSessionId: searchSessionId,
        referralContextIdentifiers: referralContextIdentifiers,
        key: "post-query-analytics"
      }));
    }
  }, {
    key: "renderPreQueryState",
    value: function renderPreQueryState() {
      var _this$props3 = this.props,
          searchSessionId = _this$props3.searchSessionId,
          preQueryScreenCounter = _this$props3.preQueryScreenCounter,
          renderNoRecentActivity = _this$props3.renderNoRecentActivity,
          referralContextIdentifiers = _this$props3.referralContextIdentifiers,
          renderBeforePreQueryState = _this$props3.renderBeforePreQueryState,
          renderAdvancedSearchGroup = _this$props3.renderAdvancedSearchGroup,
          getPreQueryGroups = _this$props3.getPreQueryGroups;
      return /*#__PURE__*/React.createElement(React.Fragment, null, renderBeforePreQueryState && renderBeforePreQueryState(), /*#__PURE__*/React.createElement(PreQueryState, {
        resultsGroups: getPreQueryGroups(),
        renderNoRecentActivity: renderNoRecentActivity,
        searchSessionId: searchSessionId,
        screenCounter: preQueryScreenCounter,
        referralContextIdentifiers: referralContextIdentifiers,
        renderAdvancedSearchGroup: renderAdvancedSearchGroup
      }));
    }
  }, {
    key: "renderSearchResultsState",
    value: function renderSearchResultsState() {
      var _this$props4 = this.props,
          searchSessionId = _this$props4.searchSessionId,
          referralContextIdentifiers = _this$props4.referralContextIdentifiers,
          renderAdvancedSearchGroup = _this$props4.renderAdvancedSearchGroup,
          getPostQueryGroups = _this$props4.getPostQueryGroups,
          postQueryScreenCounter = _this$props4.postQueryScreenCounter,
          searchMore = _this$props4.searchMore,
          onSearchMoreAdvancedSearchClicked = _this$props4.onSearchMoreAdvancedSearchClicked,
          query = _this$props4.query,
          getFilterComponent = _this$props4.getFilterComponent,
          isLoading = _this$props4.isLoading,
          currentFilters = _this$props4.currentFilters,
          onFilterChanged = _this$props4.onFilterChanged;
      var resultGroups = getPostQueryGroups();
      var topGroup = resultGroups.length > 0 ? resultGroups[0] : null;
      return /*#__PURE__*/React.createElement(React.Fragment, null, topGroup && getFilterComponent({
        latestSearchQuery: query,
        searchResultsTotalSize: topGroup.totalSize,
        isLoading: isLoading,
        searchSessionId: searchSessionId,
        currentFilters: currentFilters,
        onFilterChanged: onFilterChanged
      }), /*#__PURE__*/React.createElement(ResultGroupsComponent, {
        query: query,
        type: ResultGroupType.PostQuery,
        renderAdvancedSearch: renderAdvancedSearchGroup,
        resultsGroups: resultGroups,
        searchSessionId: searchSessionId,
        screenCounter: postQueryScreenCounter,
        referralContextIdentifiers: referralContextIdentifiers,
        onShowMoreClicked: searchMore || function () {},
        onSearchMoreAdvancedSearchClicked: onSearchMoreAdvancedSearchClicked
      }));
    }
  }, {
    key: "render",
    value: function render() {
      var _this$props5 = this.props,
          isPreQuery = _this$props5.isPreQuery,
          isError = _this$props5.isError,
          isLoading = _this$props5.isLoading,
          retrySearch = _this$props5.retrySearch,
          keepPreQueryState = _this$props5.keepPreQueryState;

      if (isError) {
        return /*#__PURE__*/React.createElement(SearchError, {
          onRetryClick: retrySearch
        });
      }

      var searchResultState = getSearchResultState({
        isPreQuery: isPreQuery,
        isLoading: isLoading,
        hasResults: !this.hasNoResult()
      });

      switch (searchResultState) {
        case SearchResultsState.PreQueryLoading:
          return null;

        case SearchResultsState.PreQueryNoResults:
          return this.renderPreQueryState();

        case SearchResultsState.PreQueryResults:
          return this.renderPreQueryState();

        case SearchResultsState.IntermediateNoResults:
          return keepPreQueryState ? this.renderPreQueryState() : null;

        case SearchResultsState.IntermediateResults:
          return keepPreQueryState ? this.renderPreQueryState() : this.renderSearchResultsState();

        case SearchResultsState.PostQueryNoResults:
          return this.renderNoResult();

        case SearchResultsState.PostQueryResults:
          return this.renderSearchResultsState();

        default:
          throw new Error('unhandled state');
      }
    }
  }]);

  return SearchResults;
}(React.Component);

_defineProperty(SearchResults, "defaultProps", {
  getFilterComponent: function getFilterComponent() {
    return null;
  }
});

export { SearchResults as default };