@atlaskit/global-search/dist/es2019/components/GlobalQuickSearchWrapper.js

A cross-product search component (batteries included)

import _extends from "@babel/runtime/helpers/extends";
import _defineProperty from "@babel/runtime/helpers/defineProperty";
import React from 'react';
import ConfluenceQuickSearchContainer from './confluence/ConfluenceQuickSearchContainer';
import JiraQuickSearchContainer from './jira/JiraQuickSearchContainer';
import configureSearchClients from '../api/configureSearchClients';
import MessagesIntlProvider from './MessagesIntlProvider';
import { GlobalSearchPreFetchContext } from './PrefetchedResultsProvider';
import { createFeatures } from '../util/features';
import { ABTestProvider } from './AbTestProvider';
import { withFeedbackButton } from './feedback/withFeedbackButton';
import FeaturesProvider from './FeaturesProvider';
const DEFAULT_NOOP_LOGGER = {
  safeInfo() {},

  safeWarn() {},

  safeError() {}

};
const ConfluenceContainerWithFeedback = withFeedbackButton(ConfluenceQuickSearchContainer);
/**
 * Component that exposes the public API for global quick search. Its only purpose is to offer a simple, user-friendly API to the outside and hide the implementation detail of search clients etc.
 */

export default class GlobalQuickSearchWrapper extends React.Component {
  constructor(...args) {
    super(...args);

    _defineProperty(this, "onAdvancedSearch", (e, entity, query, searchSessionId, spaces = []) => {
      if (this.props.onAdvancedSearch) {
        let preventEventDefault = false;
        this.props.onAdvancedSearch({
          preventDefault: () => preventEventDefault = true,
          query,
          // query entered by the user
          category: entity,
          originalEvent: e,
          searchSessionId,
          spaces
        });

        if (preventEventDefault && e) {
          e.preventDefault();
          e.stopPropagation();
        }
      }
    });
  }

  makeConfig() {
    const config = {};
    const {
      activityServiceUrl,
      searchAggregatorServiceUrl,
      directoryServiceUrl,
      confluenceUrl,
      autocompleteUrl
    } = this.props;

    if (activityServiceUrl) {
      config.activityServiceUrl = activityServiceUrl;
    }

    if (searchAggregatorServiceUrl) {
      config.searchAggregatorServiceUrl = searchAggregatorServiceUrl;
    }

    if (directoryServiceUrl) {
      config.directoryServiceUrl = directoryServiceUrl;
    }

    if (confluenceUrl) {
      config.confluenceUrl = confluenceUrl;
    }

    if (autocompleteUrl) {
      config.autocompleteUrl = autocompleteUrl;
    }

    return config;
  }

  shouldComponentUpdate(nextProps, nextState) {
    return Object.keys({ ...nextProps,
      ...this.props
    }).map(key => this.props[key] !== nextProps[key]).reduce((acc, value) => acc || value, false) || this.state !== nextState;
  }

  createFeatures(abTest) {
    const {
      disableJiraPreQueryPeopleSearch,
      enablePreQueryFromAggregator,
      useUrsForBootstrapping,
      isAutocompleteEnabled,
      isNavAutocompleteEnabled
    } = this.props;
    return createFeatures({
      abTest,
      useUrsForBootstrapping: !!useUrsForBootstrapping,
      disableJiraPreQueryPeopleSearch: !!disableJiraPreQueryPeopleSearch,
      enablePreQueryFromAggregator: !!enablePreQueryFromAggregator,
      isAutocompleteEnabled: !!isAutocompleteEnabled,
      isNavAutocompleteEnabled: !!isNavAutocompleteEnabled
    });
  }

  renderSearchContainer(searchClients, abTest) {
    const {
      linkComponent,
      referralContextIdentifiers,
      logger,
      inputControls,
      appPermission,
      modelContext,
      showFeedbackCollector,
      feedbackCollectorProps,
      confluenceUrl,
      isJiraPeopleProfilesEnabled
    } = this.props;
    const commonProps = { ...searchClients,
      linkComponent: linkComponent,
      referralContextIdentifiers: referralContextIdentifiers,
      logger: logger || DEFAULT_NOOP_LOGGER,
      onAdvancedSearch: this.onAdvancedSearch
    };

    if (this.props.context === 'confluence') {
      if (showFeedbackCollector) {
        return (
          /*#__PURE__*/
          // Same as below but missing input controls which is injected by the feedback button
          React.createElement(ConfluenceContainerWithFeedback, _extends({}, commonProps, feedbackCollectorProps, {
            modelContext: modelContext,
            confluenceUrl: confluenceUrl || ''
          }))
        );
      }

      return /*#__PURE__*/React.createElement(ConfluenceQuickSearchContainer, _extends({}, commonProps, feedbackCollectorProps, {
        modelContext: modelContext,
        inputControls: inputControls,
        confluenceUrl: confluenceUrl || ''
      }));
    } else if (this.props.context === 'jira') {
      return /*#__PURE__*/React.createElement(JiraQuickSearchContainer, _extends({}, commonProps, {
        appPermission: appPermission,
        isJiraPeopleProfilesEnabled: isJiraPeopleProfilesEnabled
      }));
    } else {
      const errorMessage = `Invalid product type, product ${this.props.context} is unsupported`;

      if (logger) {
        logger.safeError(errorMessage);
      }

      throw new Error(errorMessage);
    }
  }

  render() {
    return /*#__PURE__*/React.createElement(MessagesIntlProvider, null, /*#__PURE__*/React.createElement(GlobalSearchPreFetchContext.Consumer, null, prefetchedResults => {
      const searchClients = configureSearchClients(this.props.cloudId, this.makeConfig(), this.props.userId === null, prefetchedResults);
      const {
        context
      } = this.props;
      return /*#__PURE__*/React.createElement(ABTestProvider, {
        context: context,
        crossProductSearchClient: searchClients.crossProductSearchClient
      }, abTest => /*#__PURE__*/React.createElement(FeaturesProvider, {
        features: this.createFeatures(abTest)
      }, this.renderSearchContainer(searchClients, abTest)));
    }));
  }

}

_defineProperty(GlobalQuickSearchWrapper, "defaultProps", {
  logger: DEFAULT_NOOP_LOGGER
});