@atlaskit/global-search/dist/esm/api/prefetchResults.js

A cross-product search component (batteries included)

import _defineProperty from "@babel/runtime/helpers/defineProperty";
import _regeneratorRuntime from "@babel/runtime/regenerator";
import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
import { AnalyticsType } from '../model/Result';
import configureSearchClients from './configureSearchClients';
import { EMPTY_CROSS_PRODUCT_SEARCH_RESPONSE } from './CrossProductSearchClient';
import { mapJiraItemToResult } from './JiraItemMapper';
import { Scope } from './types';

var prefetchConfluence = /*#__PURE__*/function () {
  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(confluenceClient) {
    var _yield$Promise$all, _yield$Promise$all2, objects, spaces;

    return _regeneratorRuntime.wrap(function _callee$(_context) {
      while (1) {
        switch (_context.prev = _context.next) {
          case 0:
            _context.next = 2;
            return Promise.all([confluenceClient.getRecentItems(), confluenceClient.getRecentSpaces()]);

          case 2:
            _yield$Promise$all = _context.sent;
            _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 2);
            objects = _yield$Promise$all2[0];
            spaces = _yield$Promise$all2[1];
            return _context.abrupt("return", {
              objects: {
                items: objects,
                totalSize: objects.length
              },
              spaces: {
                items: spaces,
                totalSize: spaces.length
              },
              people: {
                items: [],
                totalSize: 0
              }
            });

          case 7:
          case "end":
            return _context.stop();
        }
      }
    }, _callee);
  }));

  return function prefetchConfluence(_x) {
    return _ref.apply(this, arguments);
  };
}();

var prefetchJira = /*#__PURE__*/function () {
  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(crossProductSearchClient) {
    var _yield$crossProductSe, results;

    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
      while (1) {
        switch (_context2.prev = _context2.next) {
          case 0:
            _context2.next = 2;
            return crossProductSearchClient.getRecentItems({
              context: 'jira',
              modelParams: [],
              resultLimit: 250,
              mapItemToResult: function mapItemToResult(_, item) {
                return mapJiraItemToResult(AnalyticsType.RecentJira)(item);
              }
            });

          case 2:
            _yield$crossProductSe = _context2.sent;
            results = _yield$crossProductSe.results;
            return _context2.abrupt("return", results);

          case 5:
          case "end":
            return _context2.stop();
        }
      }
    }, _callee2);
  }));

  return function prefetchJira(_x2) {
    return _ref2.apply(this, arguments);
  };
}();

export var getConfluencePrefetchedData = function getConfluencePrefetchedData(cloudId, confluenceUrl) {
  var config = confluenceUrl ? {
    confluenceUrl: confluenceUrl
  } : {};

  var _configureSearchClien = configureSearchClients(cloudId, config, false),
      confluenceClient = _configureSearchClien.confluenceClient,
      crossProductSearchClient = _configureSearchClien.crossProductSearchClient; // Pre-call the relevant endpoints to cache the results


  return {
    confluenceRecentItemsPromise: prefetchConfluence(confluenceClient),
    abTestPromise: _defineProperty({}, Scope.ConfluencePageBlogAttachment, crossProductSearchClient.getAbTestData(Scope.ConfluencePageBlogAttachment)),
    crossProductRecentItemsPromise: Promise.resolve(EMPTY_CROSS_PRODUCT_SEARCH_RESPONSE.results)
  };
};
export var getJiraPrefetchedData = function getJiraPrefetchedData(cloudId, isUserAnonymous, jiraUrl) {
  var config = jiraUrl ? {
    jiraUrl: jiraUrl
  } : {};

  var _configureSearchClien2 = configureSearchClients(cloudId, config, isUserAnonymous),
      crossProductSearchClient = _configureSearchClien2.crossProductSearchClient;

  return {
    crossProductRecentItemsPromise: prefetchJira(crossProductSearchClient),
    abTestPromise: _defineProperty({}, Scope.JiraIssue, crossProductSearchClient.getAbTestData(Scope.JiraIssue))
  };
};