@atlaskit/emoji 64.7.1 → 65.0.0

package/dist/esm/api/EmojiResource.js

@@ -1,4 +1,3 @@
-import _regeneratorRuntime from "@babel/runtime/regenerator";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
@@ -13,12 +12,14 @@ function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (O
 
 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 _regeneratorRuntime from "@babel/runtime/regenerator";
+
 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 { AbstractResource, utils as serviceUtils } from '@atlaskit/util-service-support';
-import { selectedToneStorageKey } from '../util/constants';
+import { SAMPLING_RATE_EMOJI_RESOURCE_FETCHED_EXP, selectedToneStorageKey } from '../util/constants';
 import { isMediaEmoji, isMediaRepresentation, isPromise, toEmojiId } from '../util/type-helpers';
 import storageAvailable from '../util/storage-available';
 import { ProviderTypes } from '../types';
@@ -26,7 +27,7 @@ import debug from '../util/logger';
 import EmojiLoader from './EmojiLoader';
 import EmojiRepository from './EmojiRepository';
 import SiteEmojiResource from './media/SiteEmojiResource';
-import { ufoExperiences } from '../util/analytics';
+import { sampledUfoEmojiResourceFetched } from '../util/analytics/ufoExperiences';
 
 /**
  * Checks if the emojiProvider can support uploading at a feature level.
@@ -55,69 +56,231 @@ export var EmojiResource = /*#__PURE__*/function (_AbstractResource) {
 
     _defineProperty(_assertThisInitialized(_this), "retries", new Map());
 
+    _defineProperty(_assertThisInitialized(_this), "isInitialised", false);
+
+    _defineProperty(_assertThisInitialized(_this), "getOptimisticImageURL", function (emojiId) {
+      if (_this.emojiProviderConfig.optimisticImageApi) {
+        return _this.emojiProviderConfig.optimisticImageApi.getUrl(emojiId);
+      }
+
+      return;
+    });
+
     _defineProperty(_assertThisInitialized(_this), "isLoaded", function () {
       return _this.activeLoaders === 0 && _this.emojiRepository;
     });
 
+    _this.emojiProviderConfig = config;
     _this.recordConfig = config.recordConfig;
-    _this.currentUser = config.currentUser; // Ensure order is retained by tracking until all done.
+    _this.currentUser = config.currentUser;
 
-    var emojiResponses = [];
-    _this.activeLoaders = config.providers.length;
-    config.providers.forEach(function (provider, index) {
-      var providerType = _this.getProviderType(provider);
+    if (storageAvailable('localStorage')) {
+      _this.selectedTone = _this.loadStoredTone();
+    }
 
-      ufoExperiences['emoji-resource-fetched'].getInstance(providerType).start();
-      ufoExperiences['emoji-resource-fetched'].getInstance(providerType).addMetadata({
-        type: providerType
-      });
-      var loader = new EmojiLoader(provider);
-      var emojis = loader.loadEmoji();
-      emojis.then(function (emojiResponse) {
-        emojiResponses[index] = emojiResponse;
+    if (config.providers.length === 0) {
+      throw new Error('No providers specified');
+    }
 
-        _this.initEmojiRepository(emojiResponses);
+    return _this;
+  }
 
-        _this.initSiteEmojiResource(emojiResponse, provider).then(function () {
-          _this.activeLoaders--;
+  _createClass(EmojiResource, [{
+    key: "fetchEmojiProvider",
+    value: function fetchEmojiProvider(force) {
+      var _this2 = this;
 
-          _this.performRetries();
+      // unless (re-)fetch is being forced, fetching will only
+      // happen if no emojiRepository exists
+      // in case this method is called and emojiRepository has already been populated
+      // the method will just return the existing emojiRepository
+      if (force || !this.emojiRepository && !this.isInitialised) {
+        this.isInitialised = true; // Ensure order is retained by tracking until all done.
+
+        var emojiResponses = [];
+        this.activeLoaders = this.emojiProviderConfig.providers.length;
+        this.emojiProviderConfig.providers.forEach( /*#__PURE__*/function () {
+          var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(provider, index) {
+            var providerType, loader, emojis;
+            return _regeneratorRuntime.wrap(function _callee$(_context) {
+              while (1) {
+                switch (_context.prev = _context.next) {
+                  case 0:
+                    providerType = _this2.getProviderType(provider);
+                    sampledUfoEmojiResourceFetched(providerType).start({
+                      samplingRate: SAMPLING_RATE_EMOJI_RESOURCE_FETCHED_EXP
+                    });
+                    sampledUfoEmojiResourceFetched(providerType).addMetadata({
+                      type: providerType
+                    });
+                    loader = new EmojiLoader(provider);
+                    emojis = loader.loadEmoji();
+                    _context.next = 7;
+                    return emojis.then(function (emojiResponse) {
+                      emojiResponses[index] = emojiResponse;
+
+                      _this2.initEmojiRepository(emojiResponses);
+
+                      _this2.initSiteEmojiResource(emojiResponse, provider).then(function () {
+                        _this2.activeLoaders--;
+
+                        _this2.performRetries();
+
+                        _this2.refreshLastFilter(); // if not site emoji it would still resolve
+                        // TODO: improve the logic in future
+
+
+                        sampledUfoEmojiResourceFetched(providerType).success();
+                      });
+                    }).catch(function (reason) {
+                      _this2.activeLoaders--;
+
+                      _this2.notifyError(reason);
+
+                      sampledUfoEmojiResourceFetched(providerType).failure({
+                        metadata: {
+                          reason: reason,
+                          source: 'EmojiProvider',
+                          data: {
+                            providerUrl: provider.url
+                          }
+                        }
+                      });
+                    });
+
+                  case 7:
+                  case "end":
+                    return _context.stop();
+                }
+              }
+            }, _callee);
+          }));
+
+          return function (_x, _x2) {
+            return _ref.apply(this, arguments);
+          };
+        }());
+      }
 
-          _this.refreshLastFilter(); // if not site emoji it would still resolve
-          // TODO: improve the logic in future
+      return Promise.resolve(this.emojiRepository);
+    }
+  }, {
+    key: "fetchByEmojiId",
+    value: function () {
+      var _fetchByEmojiId = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee2(emojiId, optimistic) {
+        var _emoji, provider, loader, loadEmoji, _emoji2, emoji;
 
+        return _regeneratorRuntime.wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                if (!(this.emojiRepository && this.isLoaded())) {
+                  _context2.next = 6;
+                  break;
+                }
 
-          ufoExperiences['emoji-resource-fetched'].getInstance(providerType).success();
-        });
-      }).catch(function (reason) {
-        _this.activeLoaders--;
+                _context2.next = 3;
+                return this.findByEmojiId(emojiId);
 
-        _this.notifyError(reason);
+              case 3:
+                _emoji = _context2.sent;
 
-        ufoExperiences['emoji-resource-fetched'].getInstance(providerType).failure({
-          metadata: {
-            reason: reason,
-            source: 'EmojiProvider',
-            data: {
-              providerUrl: provider.url
-            }
-          }
-        });
-      });
-    });
+                if (!_emoji) {
+                  _context2.next = 6;
+                  break;
+                }
 
-    if (storageAvailable('localStorage')) {
-      _this.selectedTone = _this.loadStoredTone();
-    }
+                return _context2.abrupt("return", Promise.resolve(this.getMediaEmojiDescriptionURLWithInlineToken(_emoji)));
 
-    if (config.providers.length === 0) {
-      throw new Error('No providers specified');
-    }
+              case 6:
+                if (!(this.emojiProviderConfig.singleEmojiApi && optimistic)) {
+                  _context2.next = 29;
+                  break;
+                }
 
-    return _this;
-  }
+                // if config has singleEmojiApi then fetch single emoji
+                provider = {
+                  url: this.emojiProviderConfig.singleEmojiApi.getUrl(emojiId),
+                  securityProvider: this.emojiProviderConfig.singleEmojiApi.securityProvider
+                };
+                loader = new EmojiLoader(provider);
+                _context2.prev = 9;
+                _context2.next = 12;
+                return loader.loadEmoji();
+
+              case 12:
+                loadEmoji = _context2.sent;
+
+                if (loadEmoji.emojis[0]) {
+                  _context2.next = 15;
+                  break;
+                }
 
-  _createClass(EmojiResource, [{
+                return _context2.abrupt("return");
+
+              case 15:
+                if (this.siteEmojiResource) {
+                  _context2.next = 18;
+                  break;
+                }
+
+                _context2.next = 18;
+                return this.initSiteEmojiResource(loadEmoji, provider);
+
+              case 18:
+                return _context2.abrupt("return", this.getMediaEmojiDescriptionURLWithInlineToken(loadEmoji.emojis[0]));
+
+              case 21:
+                _context2.prev = 21;
+                _context2.t0 = _context2["catch"](9);
+                _context2.next = 25;
+                return this.findByEmojiId(emojiId);
+
+              case 25:
+                _emoji2 = _context2.sent;
+
+                if (_emoji2) {
+                  _context2.next = 28;
+                  break;
+                }
+
+                return _context2.abrupt("return");
+
+              case 28:
+                return _context2.abrupt("return", this.getMediaEmojiDescriptionURLWithInlineToken(_emoji2));
+
+              case 29:
+                _context2.next = 31;
+                return this.findByEmojiId(emojiId);
+
+              case 31:
+                emoji = _context2.sent;
+
+                if (emoji) {
+                  _context2.next = 34;
+                  break;
+                }
+
+                return _context2.abrupt("return");
+
+              case 34:
+                return _context2.abrupt("return", this.getMediaEmojiDescriptionURLWithInlineToken(emoji));
+
+              case 35:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this, [[9, 21]]);
+      }));
+
+      function fetchByEmojiId(_x3, _x4) {
+        return _fetchByEmojiId.apply(this, arguments);
+      }
+
+      return fetchByEmojiId;
+    }()
+  }, {
     key: "getProviderType",
     value: function getProviderType(provider) {
       if (provider.url.includes('/site')) {
@@ -215,11 +378,11 @@ export var EmojiResource = /*#__PURE__*/function (_AbstractResource) {
   }, {
     key: "retryIfLoading",
     value: function retryIfLoading(retry, defaultResponse) {
-      var _this2 = this;
+      var _this3 = this;
 
       if (!this.isLoaded()) {
         return new Promise(function (resolve, reject) {
-          _this2.retries.set(retry, {
+          _this3.retries.set(retry, {
             resolve: resolve,
             reject: reject
           });
@@ -242,40 +405,40 @@ export var EmojiResource = /*#__PURE__*/function (_AbstractResource) {
   }, {
     key: "getMediaEmojiDescriptionURLWithInlineToken",
     value: function () {
-      var _getMediaEmojiDescriptionURLWithInlineToken = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee(emoji) {
+      var _getMediaEmojiDescriptionURLWithInlineToken = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime.mark(function _callee3(emoji) {
         var tokenisedMediaPath;
-        return _regeneratorRuntime.wrap(function _callee$(_context) {
+        return _regeneratorRuntime.wrap(function _callee3$(_context3) {
           while (1) {
-            switch (_context.prev = _context.next) {
+            switch (_context3.prev = _context3.next) {
               case 0:
                 if (!(this.siteEmojiResource && isMediaRepresentation(emoji.representation))) {
-                  _context.next = 5;
+                  _context3.next = 5;
                   break;
                 }
 
-                _context.next = 3;
+                _context3.next = 3;
                 return this.siteEmojiResource.generateTokenisedMediaURL(emoji);
 
               case 3:
-                tokenisedMediaPath = _context.sent;
-                return _context.abrupt("return", _objectSpread(_objectSpread({}, emoji), {}, {
+                tokenisedMediaPath = _context3.sent;
+                return _context3.abrupt("return", _objectSpread(_objectSpread({}, emoji), {}, {
                   representation: _objectSpread(_objectSpread({}, emoji.representation), {}, {
                     mediaPath: tokenisedMediaPath
                   })
                 }));
 
               case 5:
-                return _context.abrupt("return", emoji);
+                return _context3.abrupt("return", emoji);
 
               case 6:
               case "end":
-                return _context.stop();
+                return _context3.stop();
             }
           }
-        }, _callee, this);
+        }, _callee3, this);
       }));
 
-      function getMediaEmojiDescriptionURLWithInlineToken(_x) {
+      function getMediaEmojiDescriptionURLWithInlineToken(_x5) {
         return _getMediaEmojiDescriptionURLWithInlineToken.apply(this, arguments);
       }
 
@@ -329,7 +492,7 @@ export var EmojiResource = /*#__PURE__*/function (_AbstractResource) {
   }, {
     key: "findByShortName",
     value: function findByShortName(shortName) {
-      var _this3 = this;
+      var _this4 = this;
 
       if (this.isLoaded()) {
         // Wait for all emoji to load before looking by shortName (to ensure correct priority)
@@ -337,13 +500,13 @@ export var EmojiResource = /*#__PURE__*/function (_AbstractResource) {
       }
 
       return this.retryIfLoading(function () {
-        return _this3.findByShortName(shortName);
+        return _this4.findByShortName(shortName);
       }, undefined);
     }
   }, {
     key: "findByEmojiId",
     value: function findByEmojiId(emojiId) {
-      var _this4 = this;
+      var _this5 = this;
 
       var id = emojiId.id,
           shortName = emojiId.shortName;
@@ -364,10 +527,10 @@ export var EmojiResource = /*#__PURE__*/function (_AbstractResource) {
                 if (!emoji) {
                   // if not, fallback to searching by shortName to
                   // at least render an alternative
-                  return _this4.findByShortName(shortName);
+                  return _this5.findByShortName(shortName);
                 }
 
-                _this4.addUnknownEmoji(emoji);
+                _this5.addUnknownEmoji(emoji);
 
                 return emoji;
               });
@@ -384,59 +547,59 @@ export var EmojiResource = /*#__PURE__*/function (_AbstractResource) {
       }
 
       return this.retryIfLoading(function () {
-        return _this4.findByEmojiId(emojiId);
+        return _this5.findByEmojiId(emojiId);
       }, undefined);
     }
   }, {
     key: "findById",
     value: function findById(id) {
-      var _this5 = this;
+      var _this6 = this;
 
       if (this.isLoaded()) {
         return this.emojiRepository.findById(id);
       }
 
       return this.retryIfLoading(function () {
-        return _this5.findById(id);
+        return _this6.findById(id);
       }, undefined);
     }
   }, {
     key: "findInCategory",
     value: function findInCategory(categoryId) {
-      var _this6 = this;
+      var _this7 = this;
 
       if (this.isLoaded()) {
         return Promise.resolve(this.emojiRepository.findInCategory(categoryId));
       }
 
       return this.retryIfLoading(function () {
-        return _this6.findInCategory(categoryId);
+        return _this7.findInCategory(categoryId);
       }, []);
     }
   }, {
     key: "getAsciiMap",
     value: function getAsciiMap() {
-      var _this7 = this;
+      var _this8 = this;
 
       if (this.isLoaded()) {
         return Promise.resolve(this.emojiRepository.getAsciiMap());
       }
 
       return this.retryIfLoading(function () {
-        return _this7.getAsciiMap();
+        return _this8.getAsciiMap();
       }, new Map());
     }
   }, {
     key: "getFrequentlyUsed",
     value: function getFrequentlyUsed(options) {
-      var _this8 = this;
+      var _this9 = this;
 
       if (this.isLoaded()) {
         return Promise.resolve(this.emojiRepository.getFrequentlyUsed(options));
       }
 
       return this.retryIfLoading(function () {
-        return _this8.getFrequentlyUsed(options);
+        return _this9.getFrequentlyUsed(options);
       }, []);
     }
     /**
@@ -474,12 +637,12 @@ export var EmojiResource = /*#__PURE__*/function (_AbstractResource) {
   }, {
     key: "deleteSiteEmoji",
     value: function deleteSiteEmoji(emoji) {
-      var _this9 = this;
+      var _this10 = this;
 
       if (this.siteEmojiResource && emoji.id) {
         return this.siteEmojiResource.deleteEmoji(emoji).then(function (success) {
-          if (success && _this9.emojiRepository) {
-            _this9.emojiRepository.delete(emoji);
+          if (success && _this10.emojiRepository) {
+            _this10.emojiRepository.delete(emoji);
 
             return true;
           }
@@ -493,7 +656,7 @@ export var EmojiResource = /*#__PURE__*/function (_AbstractResource) {
       }
 
       return this.retryIfLoading(function () {
-        return _this9.deleteSiteEmoji(emoji);
+        return _this10.deleteSiteEmoji(emoji);
       }, false);
     }
   }, {
@@ -522,14 +685,14 @@ export var EmojiResource = /*#__PURE__*/function (_AbstractResource) {
   }, {
     key: "calculateDynamicCategories",
     value: function calculateDynamicCategories() {
-      var _this10 = this;
+      var _this11 = this;
 
       if (this.isLoaded()) {
         return Promise.resolve(this.emojiRepository.getDynamicCategoryList());
       }
 
       return this.retryIfLoading(function () {
-        return _this10.calculateDynamicCategories();
+        return _this11.calculateDynamicCategories();
       }, []);
     }
   }, {
@@ -555,19 +718,19 @@ var UploadingEmojiResource = /*#__PURE__*/function (_EmojiResource) {
   var _super2 = _createSuper(UploadingEmojiResource);
 
   function UploadingEmojiResource(config) {
-    var _this11;
+    var _this12;
 
     _classCallCheck(this, UploadingEmojiResource);
 
-    _this11 = _super2.call(this, config);
-    _this11.allowUpload = !!config.allowUpload;
-    return _this11;
+    _this12 = _super2.call(this, config);
+    _this12.allowUpload = !!config.allowUpload;
+    return _this12;
   }
 
   _createClass(UploadingEmojiResource, [{
     key: "isUploadSupported",
     value: function isUploadSupported() {
-      var _this12 = this;
+      var _this13 = this;
 
       if (!this.allowUpload) {
         return Promise.resolve(false);
@@ -578,23 +741,24 @@ var UploadingEmojiResource = /*#__PURE__*/function (_EmojiResource) {
       }
 
       return this.retryIfLoading(function () {
-        return _this12.isUploadSupported();
+        return _this13.isUploadSupported();
       }, false);
     }
   }, {
     key: "uploadCustomEmoji",
     value: function uploadCustomEmoji(upload) {
-      var _this13 = this;
+      var _this14 = this;
 
+      var retry = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
       return this.isUploadSupported().then(function (supported) {
-        if (!supported || !_this13.siteEmojiResource) {
+        if (!supported || !_this14.siteEmojiResource) {
           return Promise.reject('No media api support is configured');
         }
 
-        return _this13.siteEmojiResource.uploadEmoji(upload).then(function (emoji) {
-          _this13.addUnknownEmoji(emoji);
+        return _this14.siteEmojiResource.uploadEmoji(upload, retry).then(function (emoji) {
+          _this14.addUnknownEmoji(emoji);
 
-          _this13.refreshLastFilter();
+          _this14.refreshLastFilter();
 
           return emoji;
         });
@@ -603,14 +767,14 @@ var UploadingEmojiResource = /*#__PURE__*/function (_EmojiResource) {
   }, {
     key: "prepareForUpload",
     value: function prepareForUpload() {
-      var _this14 = this;
+      var _this15 = this;
 
       if (this.siteEmojiResource) {
         this.siteEmojiResource.prepareForUpload();
       }
 
       return this.retryIfLoading(function () {
-        return _this14.prepareForUpload();
+        return _this15.prepareForUpload();
       }, undefined);
     }
   }]);

package/dist/esm/api/media/SiteEmojiResource.js

@@ -1,10 +1,10 @@
-import _regeneratorRuntime from "@babel/runtime/regenerator";
 import _asyncToGenerator from "@babel/runtime/helpers/asyncToGenerator";
 import _objectWithoutProperties from "@babel/runtime/helpers/objectWithoutProperties";
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 var _excluded = ["altRepresentations"];
+import _regeneratorRuntime from "@babel/runtime/regenerator";
 
 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; }
 
@@ -156,11 +156,13 @@ var SiteEmojiResource = /*#__PURE__*/function () {
     }
   }, {
     key: "uploadEmoji",
-    value: function uploadEmoji(upload, progressCallback) {
+    value: function uploadEmoji(upload) {
       var _this2 = this;
 
+      var retry = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
+      var progressCallback = arguments.length > 2 ? arguments[2] : undefined;
       var startTime = Date.now();
-      return this.tokenManager.getToken('upload').then(function (uploadToken) {
+      return this.tokenManager.getToken('upload', retry).then(function (uploadToken) {
         var tokenLoadTime = Date.now() - startTime;
         debug('upload token load time', tokenLoadTime);
         return new Promise(function (resolve, reject) {

package/dist/esm/api/media/TokenManager.js

@@ -24,6 +24,13 @@ var TokenManager = /*#__PURE__*/function () {
 
       return false;
     }
+  }, {
+    key: "fetchNewToken",
+    value: function fetchNewToken(type) {
+      return serviceUtils.requestService(this.siteServiceConfig, {
+        path: "token/".concat(type)
+      });
+    }
   }, {
     key: "addToken",
     value: function addToken(type, mediaApiToken) {
@@ -52,22 +59,16 @@ var TokenManager = /*#__PURE__*/function () {
         }
 
         if (activeTokenRefresh) {
-          // refresh already active, return that
+          // refresh token promise already active, return that
           return activeTokenRefresh;
-        } // clear expired token
-
-
-        tokenDetail.mediaApiToken = undefined;
-      }
+        }
+      } // request a new token and track the promise for future requests until completed
 
-      var path = "token/".concat(type); // request a new token and track the promise for future requests until completed
 
-      tokenDetail.activeTokenRefresh = serviceUtils.requestService(this.siteServiceConfig, {
-        path: path
-      }).then(function (mediaApiToken) {
+      tokenDetail.activeTokenRefresh = this.fetchNewToken(type).then(function (token) {
+        tokenDetail.mediaApiToken = token;
         tokenDetail.activeTokenRefresh = undefined;
-        tokenDetail.mediaApiToken = mediaApiToken;
-        return mediaApiToken;
+        return token;
       });
       return tokenDetail.activeTokenRefresh;
     }