@atlaskit/smart-user-picker 4.0.0

package/dist/esm/service/default-value-hydration-client.js

@@ -0,0 +1,261 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+import { UserType } from '@atlaskit/user-picker';
+import { getConfig } from '../config';
+import getHydratedUsersFromPrs from './users-client';
+import hydrateTeamFromLegion from './teams-client';
+import { UNKNOWN } from './constants';
+
+var getHydratedUsersFromProducts = function getHydratedUsersFromProducts(request) {
+  var url = "".concat(getConfig().getUsersServiceUrl(request.productKey, request.baseUrl));
+  var params = new URLSearchParams();
+  request.accountIds.map(function (id) {
+    return params.append('accountId', id);
+  });
+  params.append('maxResults', '2000');
+  return fetch("".concat(url, "?").concat(params), {
+    method: 'GET',
+    credentials: 'include',
+    headers: {
+      'content-type': 'application/json'
+    }
+  }).then(function (response) {
+    if (response.status === 200) {
+      return response.json();
+    }
+
+    return Promise.reject({
+      message: "error calling users service, statusCode=".concat(response.status, ", statusText=").concat(response.statusText)
+    });
+  }).then(request.productKey === 'jira' ? transformJiraUsers : transformConfluenceUsers);
+};
+
+var transformJiraUsers = function transformJiraUsers(userResponse) {
+  return userResponse.values.map(transformJiraUser).filter(function (user) {
+    return !!user;
+  }).map(function (user) {
+    return user;
+  });
+};
+
+var transformJiraUser = function transformJiraUser(item) {
+  if (!item) {
+    return null;
+  }
+
+  return {
+    id: item.accountId,
+    type: UserType,
+    avatarUrl: item.avatarUrls ? item.avatarUrls['16x16'] : '',
+    name: item.displayName,
+    email: item.emailAddress
+  };
+};
+
+var transformConfluenceUsers = function transformConfluenceUsers(userResponse) {
+  return userResponse.results.map(transformConfluenceUser).filter(function (user) {
+    return !!user;
+  }).map(function (user) {
+    return user;
+  });
+};
+
+var transformConfluenceUser = function transformConfluenceUser(item) {
+  if (!item) {
+    return null;
+  }
+
+  return {
+    id: item.accountId,
+    type: UserType,
+    avatarUrl: item.profilePicture ? item.profilePicture.path : '',
+    name: item.publicName,
+    email: item.email
+  };
+};
+
+var sortResults = function sortResults(options, sortIds) {
+  var resultsMap = new Map(options.map(function (option) {
+    return [option && option.id, option];
+  }));
+  return sortIds.map(function (option) {
+    var user = resultsMap.get(option.id);
+
+    if (user) {
+      return user;
+    }
+
+    return {
+      id: option.id,
+      type: option.type,
+      name: UNKNOWN
+    };
+  });
+};
+
+var isOptionData = function isOptionData(option) {
+  return option.name !== undefined;
+};
+
+var hydrateTeamIds = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(baseUrl, values) {
+    var legionPromises;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            if (!(values.length === 0)) {
+              _context.next = 2;
+              break;
+            }
+
+            return _context.abrupt("return", []);
+
+          case 2:
+            legionPromises = values.map(function (value) {
+              return hydrateTeamFromLegion({
+                baseUrl: baseUrl,
+                id: value.id
+              });
+            });
+            _context.next = 5;
+            return Promise.all(legionPromises);
+
+          case 5:
+            return _context.abrupt("return", _context.sent);
+
+          case 6:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function hydrateTeamIds(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+var hydrateAccountIds = /*#__PURE__*/function () {
+  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(baseUrl, productKey, values) {
+    var accountIds;
+    return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            if (!(values.length === 0)) {
+              _context2.next = 2;
+              break;
+            }
+
+            return _context2.abrupt("return", []);
+
+          case 2:
+            accountIds = values.map(function (val) {
+              return val.id;
+            }); //if we are not jira or confluence then use PRS platform hydration
+
+            if (!(productKey === 'jira' || productKey === 'confluence')) {
+              _context2.next = 9;
+              break;
+            }
+
+            _context2.next = 6;
+            return getHydratedUsersFromProducts({
+              baseUrl: baseUrl,
+              productKey: productKey,
+              accountIds: accountIds
+            });
+
+          case 6:
+            _context2.t0 = _context2.sent;
+            _context2.next = 12;
+            break;
+
+          case 9:
+            _context2.next = 11;
+            return getHydratedUsersFromPrs(baseUrl, accountIds);
+
+          case 11:
+            _context2.t0 = _context2.sent;
+
+          case 12:
+            return _context2.abrupt("return", _context2.t0);
+
+          case 13:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  }));
+
+  return function hydrateAccountIds(_x3, _x4, _x5) {
+    return _ref2.apply(this, arguments);
+  };
+}();
+
+function hydrateDefaultValues(_x6, _x7, _x8) {
+  return _hydrateDefaultValues.apply(this, arguments);
+}
+
+function _hydrateDefaultValues() {
+  _hydrateDefaultValues = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(baseUrl, value, productKey) {
+    var values, _yield$Promise$all, _yield$Promise$all2, hydratedUsers, hydratedTeams, hydratedOptions;
+
+    return _regeneratorRuntime.wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            if (!(!value || Array.isArray(value) && value.length === 0)) {
+              _context3.next = 2;
+              break;
+            }
+
+            return _context3.abrupt("return", []);
+
+          case 2:
+            values = Array.isArray(value) ? value : [value]; // return if all hydrated
+
+            if (values.some(function (val) {
+              return !isOptionData(val);
+            })) {
+              _context3.next = 5;
+              break;
+            }
+
+            return _context3.abrupt("return", value);
+
+          case 5:
+            _context3.next = 7;
+            return Promise.all([hydrateAccountIds(baseUrl, productKey, values.filter(function (val) {
+              return !isOptionData(val) && val.type === 'user';
+            })), hydrateTeamIds(baseUrl, values.filter(function (val) {
+              return !isOptionData(val) && val.type === 'team';
+            }))]);
+
+          case 7:
+            _yield$Promise$all = _context3.sent;
+            _yield$Promise$all2 = _slicedToArray(_yield$Promise$all, 2);
+            hydratedUsers = _yield$Promise$all2[0];
+            hydratedTeams = _yield$Promise$all2[1];
+            hydratedOptions = values.filter(function (val) {
+              return isOptionData(val);
+            }).map(function (val) {
+              return val;
+            }).concat(hydratedUsers).concat(hydratedTeams);
+            return _context3.abrupt("return", sortResults(hydratedOptions, values));
+
+          case 13:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3);
+  }));
+  return _hydrateDefaultValues.apply(this, arguments);
+}
+
+export default hydrateDefaultValues;

package/dist/esm/service/graphqlUtils.js

@@ -0,0 +1,41 @@
+var buildHeaders = function buildHeaders() {
+  var headers = new Headers();
+  headers.append('Content-Type', 'application/json');
+  return headers;
+};
+
+/**
+ * @param {string} serviceUrl - GraphQL service endpoint
+ * @param {Query} query - GraphQL query
+ */
+export function graphqlQuery(serviceUrl, query) {
+  var headers = buildHeaders();
+  return fetch(new Request("".concat(serviceUrl), {
+    method: 'POST',
+    credentials: 'include',
+    mode: 'cors',
+    headers: headers,
+    body: JSON.stringify(query)
+  })).then(function (response) {
+    if (!response.ok) {
+      return Promise.reject({
+        code: response.status,
+        reason: response.statusText
+      });
+    }
+
+    return response;
+  }).then(function (response) {
+    return response.json();
+  }).then(function (json) {
+    if (json.errors) {
+      var _json$errors$;
+
+      return Promise.reject({
+        reason: ((_json$errors$ = json.errors[0]) === null || _json$errors$ === void 0 ? void 0 : _json$errors$.category) || 'default'
+      });
+    }
+
+    return json.data;
+  });
+}

package/dist/esm/service/index.js

@@ -0,0 +1,2 @@
+export { default as getUserRecommendations } from './recommendation-client';
+export { default as hydrateDefaultValues } from './default-value-hydration-client';

package/dist/esm/service/recommendation-client.js

@@ -0,0 +1,60 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+import { transformUsers } from './users-transformer';
+import { getConfig } from '../config';
+
+var getUserRecommendations = function getUserRecommendations(request, intl) {
+  var _request$context, _request$context$prod;
+
+  var url = getConfig().getRecommendationServiceUrl(request.baseUrl || '');
+  return fetch(url, {
+    method: 'POST',
+    credentials: 'include',
+    headers: {
+      'content-type': 'application/json'
+    },
+    body: JSON.stringify({
+      context: request.context,
+      includeUsers: request.includeUsers,
+      includeGroups: request.includeGroups,
+      includeTeams: request.includeTeams,
+      maxNumberOfResults: request.maxNumberOfResults,
+      performSearchQueryOnly: false,
+      searchQuery: _objectSpread(_objectSpread({
+        cpusQueryHighlights: {
+          query: '',
+          field: ''
+        }
+      }, ((_request$context = request.context) === null || _request$context === void 0 ? void 0 : (_request$context$prod = _request$context.productAttributes) === null || _request$context$prod === void 0 ? void 0 : _request$context$prod.isEntitledConfluenceExternalCollaborator) && {
+        productAccessPermissionIds: ['write', 'external-collaborator-write']
+      }), {}, {
+        customQuery: '',
+        customerDirectoryId: '',
+        filter: request.searchQueryFilter || '',
+        minimumAccessLevel: 'APPLICATION',
+        queryString: request.query,
+        restrictTo: {
+          userIds: [],
+          groupIds: []
+        },
+        searchUserbase: false
+      })
+    })
+  }).then(function (response) {
+    if (response.status === 200) {
+      return response.json();
+    }
+
+    return Promise.reject({
+      message: "error calling smart service, statusCode=".concat(response.status, ", statusText=").concat(response.statusText)
+    });
+  }).then(function (response) {
+    return transformUsers(response, intl);
+  });
+};
+
+export default getUserRecommendations;

package/dist/esm/service/teams-client.js

@@ -0,0 +1,45 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+import { getConfig } from '../config';
+import { UNKNOWN_TEAM } from './constants';
+
+var transformTeam = function transformTeam(team, id) {
+  return {
+    id: id,
+    name: team.displayName,
+    type: 'team',
+    avatarUrl: team.smallAvatarImageUrl
+  };
+};
+
+var hydrateTeamFromLegion = function hydrateTeamFromLegion(request) {
+  var url = "".concat(getConfig().getTeamsUrl(request.baseUrl), "/").concat(request.id);
+  return fetch(url, {
+    method: 'GET',
+    credentials: 'include',
+    headers: {
+      'content-type': 'application/json'
+    }
+  }).then(function (response) {
+    if (response.status === 200) {
+      return response.json();
+    }
+
+    return Promise.reject({
+      message: "error calling Legion, statusCode=".concat(response.status, ", statusText=").concat(response.statusText)
+    });
+  }).then(function (response) {
+    return transformTeam(response, request.id);
+  }).catch(function () {
+    return _objectSpread(_objectSpread({}, UNKNOWN_TEAM), {}, {
+      // on network error, return original team with label 'Unknown'
+      id: request.id
+    });
+  });
+};
+
+export default hydrateTeamFromLegion;

package/dist/esm/service/users-client.js

@@ -0,0 +1,83 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _regeneratorRuntime from "@babel/runtime/regenerator";
+import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+import { UNKNOWN_USER } from './constants';
+import { graphqlQuery } from './graphqlUtils';
+import { getConfig } from '../config';
+
+/**
+ * @param  {string} accountIds ids to hydrate
+ * @return GraphQL Query
+ */
+var buildUsersQuery = function buildUsersQuery(accountIds) {
+  return {
+    query: "query usersQuery($accountIds: [ID!]!) {\n    users(accountIds: $accountIds) {\n      name\n      accountId\n      picture\n    }\n  }",
+    variables: {
+      accountIds: accountIds
+    }
+  };
+};
+
+var makeRequest = /*#__PURE__*/function () {
+  var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(url, accountIds) {
+    var query;
+    return _regeneratorRuntime.wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            query = buildUsersQuery(accountIds);
+            _context.next = 3;
+            return graphqlQuery(url, query);
+
+          case 3:
+            return _context.abrupt("return", _context.sent);
+
+          case 4:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+
+  return function makeRequest(_x, _x2) {
+    return _ref.apply(this, arguments);
+  };
+}();
+
+var modifyResponse = function modifyResponse(users) {
+  return users.map(function (_ref2) {
+    var accountId = _ref2.accountId,
+        name = _ref2.name,
+        picture = _ref2.picture;
+    return {
+      avatarUrl: picture,
+      id: accountId,
+      name: name,
+      type: 'user'
+    };
+  });
+};
+
+var getHydratedUsers = function getHydratedUsers(baseUrl, userIds) {
+  var url = getConfig().getGraphQLUrl(baseUrl);
+  return new Promise(function (resolve) {
+    makeRequest(url, userIds).then(function (data) {
+      resolve(modifyResponse(data.users));
+    }).catch(function () {
+      // on network error, return original list with label 'Unknown'
+      resolve(userIds.map(function (id) {
+        return _objectSpread(_objectSpread({}, UNKNOWN_USER), {}, {
+          id: id
+        });
+      }));
+    });
+  });
+};
+
+export default getHydratedUsers;

package/dist/esm/service/users-transformer.js

@@ -0,0 +1,83 @@
+import { TeamType, UserType, GroupType } from '@atlaskit/user-picker';
+import { messages } from '../i18n';
+var EntityType;
+
+(function (EntityType) {
+  EntityType["USER"] = "USER";
+  EntityType["TEAM"] = "TEAM";
+  EntityType["GROUP"] = "GROUP";
+})(EntityType || (EntityType = {}));
+
+var getLozenzeProperties = function getLozenzeProperties(entity, intl) {
+  var _entity$attributes, _entity$attributes2;
+
+  if ((_entity$attributes = entity.attributes) !== null && _entity$attributes !== void 0 && _entity$attributes.workspaceMember) {
+    return intl.formatMessage(messages.memberLozengeText);
+  }
+
+  if ((_entity$attributes2 = entity.attributes) !== null && _entity$attributes2 !== void 0 && _entity$attributes2.isConfluenceExternalCollaborator) {
+    var lozengeTooltipMessage = entity.entityType === EntityType.GROUP ? messages.guestGroupLozengeTooltip : messages.guestUserLozengeTooltip;
+    return {
+      text: intl.formatMessage(messages.guestLozengeText),
+      tooltip: intl.formatMessage(lozengeTooltipMessage),
+      appearance: 'new'
+    };
+  }
+
+  return undefined;
+};
+
+var transformUser = function transformUser(item, intl) {
+  var type = item.entityType;
+
+  if (type === EntityType.USER) {
+    var user = item;
+    var lozenge = getLozenzeProperties(user, intl);
+    return {
+      id: user.id,
+      type: UserType,
+      avatarUrl: user.avatarUrl,
+      name: user.name,
+      email: user.email,
+      lozenge: lozenge
+    };
+  }
+
+  if (type === EntityType.TEAM) {
+    var team = item;
+    return {
+      id: team.id,
+      type: TeamType,
+      description: team.description || '',
+      name: team.displayName || '',
+      memberCount: team.memberCount,
+      includesYou: team.includesYou,
+      avatarUrl: team.largeAvatarImageUrl || team.smallAvatarImageUrl
+    };
+  }
+
+  if (type === EntityType.GROUP) {
+    var group = item;
+
+    var _lozenge = getLozenzeProperties(group, intl);
+
+    return {
+      id: group.id,
+      type: GroupType,
+      name: group.name || '',
+      lozenge: _lozenge
+    };
+  }
+
+  return;
+};
+
+export var transformUsers = function transformUsers(serverResponse, intl) {
+  return (serverResponse.recommendedUsers || []).map(function (item) {
+    return transformUser(item, intl);
+  }).filter(function (user) {
+    return !!user;
+  }).map(function (user) {
+    return user;
+  });
+};

package/dist/esm/types.js

@@ -0,0 +1,7 @@
+export var EntityType;
+
+(function (EntityType) {
+  EntityType["USER"] = "USER";
+  EntityType["TEAM"] = "TEAM";
+  EntityType["GROUP"] = "GROUP";
+})(EntityType || (EntityType = {}));

package/dist/esm/ufoExperiences.js

@@ -0,0 +1,26 @@
+import { ExperiencePerformanceTypes, ExperienceTypes, ConcurrentExperience } from '@atlaskit/ufo';
+import { useEffect, useState } from 'react';
+var COMPONENT_NAME = 'smart-user-picker';
+export var smartUserPickerRenderedUfoExperience = new ConcurrentExperience('smart-user-picker-rendered', {
+  platform: {
+    component: COMPONENT_NAME
+  },
+  type: ExperienceTypes.Load,
+  performanceType: ExperiencePerformanceTypes.PageSegmentLoad
+});
+export var useUFOConcurrentExperience = function useUFOConcurrentExperience(experience, id) {
+  var experienceForId = experience.getInstance(id); // Equivalent to componentWillMount - replace with @atlaskit/ufo's
+  // useUFOComponentExperience when it supports ConcurrentExperience.
+
+  useState(function () {
+    experienceForId.start();
+  }); // Replace with @atlaskit/ufo's <ExperienceSuccess> when it supports ConcurrentExperience
+
+  useEffect(function () {
+    experienceForId.success();
+    return function () {
+      experienceForId.abort();
+    }; // We only want this useEffect to run once after component mount, so no deps are needed.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
+};