@atlaskit/emoji 71.17.1 → 72.0.0

package/dist/esm/api/internal/QueryStringPositionMatchComparator.js

@@ -0,0 +1,36 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import { MAX_ORDINAL } from '../../util/constants';
+/**
+ * A comparator that will sort higher an emoji which matches the query string earliest in the indicated
+ * property.
+ */
+export var QueryStringPositionMatchComparator = /*#__PURE__*/function () {
+  /**
+   * @param query the query to match
+   * @param propertyToCompare the property of EmojiDescription to check for query within
+   */
+  function QueryStringPositionMatchComparator(query, propertyToCompare) {
+    _classCallCheck(this, QueryStringPositionMatchComparator);
+    this.query = query;
+    if (!propertyToCompare) {
+      throw new Error('propertyToCompare is required');
+    }
+    this.propertyName = propertyToCompare;
+  }
+  return _createClass(QueryStringPositionMatchComparator, [{
+    key: "getScore",
+    value: function getScore(emoji) {
+      // It is fine to do override the null check here because we are checking
+      // it on the constructor.
+      var propertyValue = emoji[this.propertyName];
+      var score = propertyValue ? propertyValue.indexOf(this.query) : MAX_ORDINAL;
+      return score === -1 ? MAX_ORDINAL : score;
+    }
+  }, {
+    key: "compare",
+    value: function compare(e1, e2) {
+      return this.getScore(e1) - this.getScore(e2);
+    }
+  }]);
+}();

package/dist/esm/api/internal/UsageFrequencyComparator.js

@@ -0,0 +1,52 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import { MAX_ORDINAL } from '../../util/constants';
+import { isEmojiVariationDescription } from '../../util/is-emoji-variation-description';
+/**
+ * Order two emoji such as the one which is more frequently used comes first. If neither have any usage
+ * information then leave their order unchanged.
+ */
+export var UsageFrequencyComparator = /*#__PURE__*/function () {
+  // A Map of emoji base Id to their order in a least of most frequently used
+
+  function UsageFrequencyComparator(orderedIds) {
+    var _this = this;
+    _classCallCheck(this, UsageFrequencyComparator);
+    this.positionLookup = new Map();
+    // Make ordering start from 1 to avoid having zero in the map (which is falsey)
+    orderedIds.map(function (id, index) {
+      return _this.positionLookup.set(id, index + 1);
+    });
+  }
+  return _createClass(UsageFrequencyComparator, [{
+    key: "compare",
+    value: function compare(e1, e2) {
+      if (!e1.id || !e2.id) {
+        return 0; // this shouldn't occur. Leave position unchanged if there is any missing id.
+      }
+      var i1 = this.getPositionInOrder(e1);
+      var i2 = this.getPositionInOrder(e2);
+      return i1 - i2;
+    }
+
+    /**
+     * Get the ordinal representing the position of this emoji.
+     *
+     * @param id the id of the emoji
+     */
+  }, {
+    key: "getPositionInOrder",
+    value: function getPositionInOrder(emoji) {
+      var id = emoji.id ? emoji.id : '0';
+      if (isEmojiVariationDescription(emoji)) {
+        id = emoji.baseId;
+      }
+      var position = this.positionLookup.get(id);
+      if (position) {
+        return position;
+      } else {
+        return MAX_ORDINAL;
+      }
+    }
+  }]);
+}();

package/dist/esm/api/internal/UsageFrequencyTracker.js

@@ -3,11 +3,12 @@ import _createClass from "@babel/runtime/helpers/createClass";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-import { isEmojiVariationDescription } from '../../util/type-helpers';
-import { localStoragePrefix } from '../../util/constants';
 import DuplicateLimitedQueue from '../../util/DuplicateLimitedQueue';
 import StoredDuplicateLimitedQueue from '../../util/StoredDuplicateLimitedQueue';
+import { localStoragePrefix } from '../../util/constants';
+import { isEmojiVariationDescription } from '../../util/is-emoji-variation-description';
 import storageAvailable from '../../util/storage-available';
+import { Gateway } from './Gateway';
 
 /**
  * Keeps track of the last 150 emoji usages, although limiting the maximum count for a single emoji to 25 to
@@ -83,47 +84,4 @@ _defineProperty(UsageFrequencyTracker, "queueOptions", {
   storagePrefix: localStoragePrefix,
   maxDuplicates: 25,
   minUniqueItems: 5
-});
-export var Gateway = /*#__PURE__*/function () {
-  function Gateway(maximumPermitted) {
-    _classCallCheck(this, Gateway);
-    if (maximumPermitted < 1) {
-      throw new RangeError('The maximumPermitted parameter must be 1 or more.');
-    }
-    this.maximumPermitted = maximumPermitted;
-    this.count = 0;
-  }
-
-  /**
-   * Run the supplied function if the count of already submitted work allows it. Drop the work
-   * if it's not allowed to run.
-   *
-   * Will return true if the function has been submitted or false if it was not submitted.
-   */
-  return _createClass(Gateway, [{
-    key: "submit",
-    value: function submit(f) {
-      var _this2 = this;
-      if (this.count >= this.maximumPermitted) {
-        return false;
-      }
-      this.count++;
-      var wrappedFunc = function wrappedFunc() {
-        try {
-          f();
-        } finally {
-          _this2.completed();
-        }
-      };
-      if (typeof window !== 'undefined') {
-        window.setTimeout(wrappedFunc);
-      }
-      return true;
-    }
-  }, {
-    key: "completed",
-    value: function completed() {
-      this.count--;
-    }
-  }]);
-}();
+});

package/dist/esm/api/internal/createSearchEmojiComparator.js

@@ -0,0 +1,40 @@
+import _construct from "@babel/runtime/helpers/construct";
+import { AlphabeticalShortnameComparator } from './AlphabeticalShortnameComparator';
+import { AsciiMatchComparator } from './AsciiMatchComparator';
+import { ChainedEmojiComparator } from './ChainedEmojiComparator';
+import { ExactShortNameMatchComparator } from './ExactShortNameMatchComparator';
+import { OrderComparator } from './OrderComparator';
+import { QueryStringPositionMatchComparator } from './QueryStringPositionMatchComparator';
+import { UsageFrequencyComparator } from './UsageFrequencyComparator';
+
+/**
+ * Create the default sort comparator to be used for the user queries against emoji
+ *
+ * @param query the query used in the search to be sorted. Any colons will be stripped from the query and it will be
+ * converted to lowercase.
+ * @param orderedIds the id of emoji ordered by how frequently they are used
+ */
+export function createSearchEmojiComparator(query, orderedIds) {
+  var textQuery = query ? query.replace(/:/g, '').toLowerCase().trim() : undefined;
+  var comparators = [];
+  if (query) {
+    comparators.push(new AsciiMatchComparator(query));
+  }
+
+  // Add the comparators to the 'chain'. The order of adding each comparator is important to the sort that is applied by the
+  // ChainedEmojiComparator. (Which is why you may see the same 'if' a few times.)
+
+  if (textQuery) {
+    comparators.push(new ExactShortNameMatchComparator(textQuery));
+  }
+  if (orderedIds && orderedIds.length) {
+    comparators.push(new UsageFrequencyComparator(orderedIds));
+  }
+  if (textQuery) {
+    comparators.push(new QueryStringPositionMatchComparator(textQuery, 'shortName'), new QueryStringPositionMatchComparator(textQuery, 'name'));
+  }
+  comparators.push(OrderComparator.Instance, AlphabeticalShortnameComparator.Instance);
+  var comparator = _construct(ChainedEmojiComparator, comparators);
+  comparator.compare = comparator.compare.bind(comparator);
+  return comparator;
+}

package/dist/esm/api/internal/createUsageOnlyEmojiComparator.js

@@ -0,0 +1,9 @@
+import { ChainedEmojiComparator } from './ChainedEmojiComparator';
+import { EmojiTypeComparator } from './EmojiTypeComparator';
+import { OrderComparator } from './OrderComparator';
+import { UsageFrequencyComparator } from './UsageFrequencyComparator';
+export function createUsageOnlyEmojiComparator(orderedIds) {
+  var comparator = new ChainedEmojiComparator(new UsageFrequencyComparator(orderedIds), new EmojiTypeComparator(), OrderComparator.Instance);
+  comparator.compare = comparator.compare.bind(comparator);
+  return comparator;
+}

package/dist/esm/api/isMediaApiUrl.js

@@ -0,0 +1,3 @@
+export var isMediaApiUrl = function isMediaApiUrl(url, meta) {
+  return !!(meta && meta.mediaApiToken && url.indexOf(meta.mediaApiToken.url) === 0);
+};

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

@@ -0,0 +1,80 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { isMediaRepresentation } from '../../util/is-media-representation';
+import debug from '../../util/logger';
+import { getRequiredRepresentation } from './getRequiredRepresentation';
+var isUnsupportedBrowser = function isUnsupportedBrowser() {
+  var isIE = /*@cc_on!@*/false || !!document.documentMode; // Internet Explorer 6-11
+  var isEdge = !isIE && !!window.StyleMedia; // Edge 20+
+
+  return isIE || isEdge;
+};
+
+/**
+ * For browsers that support caching for resources
+ * regardless of originally supplied headers (basically everything but Firefox).
+ */
+export var BrowserCacheStrategy = /*#__PURE__*/function () {
+  function BrowserCacheStrategy(mediaImageLoader) {
+    _classCallCheck(this, BrowserCacheStrategy);
+    _defineProperty(this, "cachedImageUrls", new Set());
+    debug('BrowserCacheStrategy');
+    this.mediaImageLoader = mediaImageLoader;
+  }
+  return _createClass(BrowserCacheStrategy, [{
+    key: "loadEmoji",
+    value: function loadEmoji(emoji, useAlt) {
+      var _this = this;
+      var representation = getRequiredRepresentation(emoji, useAlt);
+      if (!isMediaRepresentation(representation)) {
+        return emoji;
+      }
+      var mediaPath = representation.mediaPath;
+      if (this.cachedImageUrls.has(mediaPath)) {
+        // Already cached
+        return emoji;
+      }
+      return this.mediaImageLoader.loadMediaImage(mediaPath).then(function () {
+        // Media is loaded, can use original URL now, so just return original emoji
+        _this.cachedImageUrls.add(mediaPath);
+        return emoji;
+      }).catch(function () {
+        return undefined;
+      });
+    }
+  }, {
+    key: "optimisticRendering",
+    value: function optimisticRendering() {
+      return true;
+    }
+  }], [{
+    key: "supported",
+    value: function supported(mediaPath, mediaImageLoader) {
+      // IE/Edge uses memory cache strategy else images can fail to load
+      // from a clean cache/if they are downloaded from the service
+      // TODO: fix as a part of FS-1592
+      if (isUnsupportedBrowser()) {
+        return Promise.resolve(false);
+      }
+      return mediaImageLoader.loadMediaImage(mediaPath).then(function () {
+        return (
+          // Image should be cached in browser, if supported it should be accessible from the cache by an <img/>
+          // Try to load without via image to confirm this support (this fails in Firefox)
+          new Promise(function (resolve) {
+            var img = new Image();
+            img.addEventListener('load', function () {
+              resolve(true);
+            });
+            img.addEventListener('error', function () {
+              resolve(false);
+            });
+            img.src = mediaPath;
+          })
+        );
+      }).catch(function () {
+        return false;
+      });
+    }
+  }]);
+}();

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

@@ -1,142 +1,17 @@
 import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
 import _createClass from "@babel/runtime/helpers/createClass";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import { convertMediaToImageEmoji, isMediaRepresentation, isPromise } from '../../util/type-helpers';
-import MediaImageLoader from './MediaImageLoader';
+import { isMediaRepresentation } from '../../util/is-media-representation';
+import { isPromise } from '../../util/is-promise';
 import debug from '../../util/logger';
-import { LRUMap } from 'lru_map';
-var getRequiredRepresentation = function getRequiredRepresentation(emoji, useAlt) {
-  return useAlt ? emoji.altRepresentation : emoji.representation;
-};
-var isUnsupportedBrowser = function isUnsupportedBrowser() {
-  var isIE = /*@cc_on!@*/false || !!document.documentMode; // Internet Explorer 6-11
-  var isEdge = !isIE && !!window.StyleMedia; // Edge 20+
+import { BrowserCacheStrategy } from './BrowserCacheStrategy';
+import { getRequiredRepresentation } from './getRequiredRepresentation';
+import MediaImageLoader from './MediaImageLoader';
+import { MemoryCacheStrategy } from './MemoryCacheStrategy';
+export var maxImageCached = 1000;
 
-  return isIE || isEdge;
-};
-/**
- * For browsers that support caching for resources
- * regardless of originally supplied headers (basically everything but Firefox).
- */
-export var BrowserCacheStrategy = /*#__PURE__*/function () {
-  function BrowserCacheStrategy(mediaImageLoader) {
-    _classCallCheck(this, BrowserCacheStrategy);
-    _defineProperty(this, "cachedImageUrls", new Set());
-    debug('BrowserCacheStrategy');
-    this.mediaImageLoader = mediaImageLoader;
-  }
-  return _createClass(BrowserCacheStrategy, [{
-    key: "loadEmoji",
-    value: function loadEmoji(emoji, useAlt) {
-      var _this = this;
-      var representation = getRequiredRepresentation(emoji, useAlt);
-      if (!isMediaRepresentation(representation)) {
-        return emoji;
-      }
-      var mediaPath = representation.mediaPath;
-      if (this.cachedImageUrls.has(mediaPath)) {
-        // Already cached
-        return emoji;
-      }
-      return this.mediaImageLoader.loadMediaImage(mediaPath).then(function () {
-        // Media is loaded, can use original URL now, so just return original emoji
-        _this.cachedImageUrls.add(mediaPath);
-        return emoji;
-      }).catch(function () {
-        return undefined;
-      });
-    }
-  }, {
-    key: "optimisticRendering",
-    value: function optimisticRendering() {
-      return true;
-    }
-  }], [{
-    key: "supported",
-    value: function supported(mediaPath, mediaImageLoader) {
-      // IE/Edge uses memory cache strategy else images can fail to load
-      // from a clean cache/if they are downloaded from the service
-      // TODO: fix as a part of FS-1592
-      if (isUnsupportedBrowser()) {
-        return Promise.resolve(false);
-      }
-      return mediaImageLoader.loadMediaImage(mediaPath).then(function () {
-        return (
-          // Image should be cached in browser, if supported it should be accessible from the cache by an <img/>
-          // Try to load without via image to confirm this support (this fails in Firefox)
-          new Promise(function (resolve) {
-            var img = new Image();
-            img.addEventListener('load', function () {
-              resolve(true);
-            });
-            img.addEventListener('error', function () {
-              resolve(false);
-            });
-            img.src = mediaPath;
-          })
-        );
-      }).catch(function () {
-        return false;
-      });
-    }
-  }]);
-}();
-var maxImageCached = 1000;
 // Don't cache images large than this - dataUrl size in characters
-var maxImageSize = 10000;
-
-/**
- * For browsers that do no cache images without equivalent headers (e.g. Firefox).
- *
- * Images are cached in memory in a LRU cache. Images considered too large,
- * are not cached, but retrieved each time.
- *
- * Images are still cached by the browser, but loading in asynchronous with
- * small delay noticable to the end user.
- */
-export var MemoryCacheStrategy = /*#__PURE__*/function () {
-  function MemoryCacheStrategy(mediaImageLoader) {
-    _classCallCheck(this, MemoryCacheStrategy);
-    debug('MemoryCacheStrategy');
-    this.mediaImageLoader = mediaImageLoader;
-    this.dataURLCache = new LRUMap(maxImageCached);
-  }
-  return _createClass(MemoryCacheStrategy, [{
-    key: "loadEmoji",
-    value: function loadEmoji(emoji, useAlt) {
-      var _this2 = this;
-      var representation = getRequiredRepresentation(emoji, useAlt);
-      if (!isMediaRepresentation(representation)) {
-        return emoji;
-      }
-      var mediaPath = representation.mediaPath;
-      var dataURL = this.dataURLCache.get(mediaPath);
-      if (dataURL) {
-        // Already cached
-        return convertMediaToImageEmoji(emoji, dataURL, useAlt);
-      }
-
-      // Not cached, load
-      return this.mediaImageLoader.loadMediaImage(mediaPath).then(function (dataURL) {
-        var loadedEmoji = convertMediaToImageEmoji(emoji, dataURL, useAlt);
-        if (dataURL.length <= maxImageSize) {
-          // Only cache if not large than max size
-          _this2.dataURLCache.set(mediaPath, dataURL);
-        } else {
-          debug('No caching as image is too large', dataURL.length, dataURL.slice(0, 15), emoji.shortName);
-        }
-        return loadedEmoji;
-      }).catch(function () {
-        return undefined;
-      });
-    }
-  }, {
-    key: "optimisticRendering",
-    value: function optimisticRendering() {
-      return false;
-    }
-  }]);
-}();
+export var maxImageSize = 10000;
 
 /**
  * Provides a cache for Media Emoji.
@@ -188,18 +63,18 @@ var MediaEmojiCache = /*#__PURE__*/function () {
   }, {
     key: "getCache",
     value: function getCache(url) {
-      var _this3 = this;
+      var _this = this;
       if (this.cache) {
         return this.cache;
       }
       this.waitingInitUrls.push(url);
       if (!this.cacheLoading) {
         this.cacheLoading = this.initCache().then(function (cache) {
-          _this3.cache = cache;
-          _this3.cacheLoading = undefined;
+          _this.cache = cache;
+          _this.cacheLoading = undefined;
           return cache;
         }).catch(function (err) {
-          _this3.cacheLoading = undefined;
+          _this.cacheLoading = undefined;
           throw err;
         });
       }
@@ -208,20 +83,20 @@ var MediaEmojiCache = /*#__PURE__*/function () {
   }, {
     key: "initCache",
     value: function initCache() {
-      var _this4 = this;
+      var _this2 = this;
       var url = this.waitingInitUrls.pop();
       if (!url) {
         return Promise.reject('Unable to initialise cache based on provided url(s)');
       }
       return BrowserCacheStrategy.supported(url, this.mediaImageLoader).then(function (supported) {
-        _this4.waitingInitUrls = []; // clear
-        _this4.cacheLoading = undefined;
+        _this2.waitingInitUrls = []; // clear
+        _this2.cacheLoading = undefined;
         if (supported) {
-          return new BrowserCacheStrategy(_this4.mediaImageLoader);
+          return new BrowserCacheStrategy(_this2.mediaImageLoader);
         }
-        return new MemoryCacheStrategy(_this4.mediaImageLoader);
+        return new MemoryCacheStrategy(_this2.mediaImageLoader);
       }).catch(function () {
-        return _this4.initCache();
+        return _this2.initCache();
       });
     }
   }]);

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

@@ -0,0 +1,61 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import { LRUMap } from 'lru_map';
+import { convertMediaToImageEmoji } from '../../util/convert-media-to-image-emoji';
+import { isMediaRepresentation } from '../../util/is-media-representation';
+import debug from '../../util/logger';
+import { maxImageCached, maxImageSize } from './MediaEmojiCache';
+import { getRequiredRepresentation } from './getRequiredRepresentation';
+
+/**
+ * For browsers that do no cache images without equivalent headers (e.g. Firefox).
+ *
+ * Images are cached in memory in a LRU cache. Images considered too large,
+ * are not cached, but retrieved each time.
+ *
+ * Images are still cached by the browser, but loading in asynchronous with
+ * small delay noticable to the end user.
+ */
+export var MemoryCacheStrategy = /*#__PURE__*/function () {
+  function MemoryCacheStrategy(mediaImageLoader) {
+    _classCallCheck(this, MemoryCacheStrategy);
+    debug('MemoryCacheStrategy');
+    this.mediaImageLoader = mediaImageLoader;
+    this.dataURLCache = new LRUMap(maxImageCached);
+  }
+  return _createClass(MemoryCacheStrategy, [{
+    key: "loadEmoji",
+    value: function loadEmoji(emoji, useAlt) {
+      var _this = this;
+      var representation = getRequiredRepresentation(emoji, useAlt);
+      if (!isMediaRepresentation(representation)) {
+        return emoji;
+      }
+      var mediaPath = representation.mediaPath;
+      var dataURL = this.dataURLCache.get(mediaPath);
+      if (dataURL) {
+        // Already cached
+        return convertMediaToImageEmoji(emoji, dataURL, useAlt);
+      }
+
+      // Not cached, load
+      return this.mediaImageLoader.loadMediaImage(mediaPath).then(function (dataURL) {
+        var loadedEmoji = convertMediaToImageEmoji(emoji, dataURL, useAlt);
+        if (dataURL.length <= maxImageSize) {
+          // Only cache if not large than max size
+          _this.dataURLCache.set(mediaPath, dataURL);
+        } else {
+          debug('No caching as image is too large', dataURL.length, dataURL.slice(0, 15), emoji.shortName);
+        }
+        return loadedEmoji;
+      }).catch(function () {
+        return undefined;
+      });
+    }
+  }, {
+    key: "optimisticRendering",
+    value: function optimisticRendering() {
+      return false;
+    }
+  }]);
+}();

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

@@ -8,14 +8,20 @@ var _excluded = ["altRepresentations"];
 import _regeneratorRuntime from "@babel/runtime/regenerator";
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
-import { utils as serviceUtils } from '@atlaskit/util-service-support';
 import { getMediaClient } from '@atlaskit/media-client-react';
 import { fg } from '@atlaskit/platform-feature-flags/fg';
-import { buildEmojiDescriptionWithAltRepresentation, isMediaRepresentation, isMediaEmoji, convertImageToMediaRepresentation, isLoadedMediaEmoji } from '../../util/type-helpers';
+import { utils as serviceUtils } from '@atlaskit/util-service-support';
+import { buildEmojiDescriptionWithAltRepresentation } from '../../util/build-emoji-description-with-alt-representation';
+import { convertImageToMediaRepresentation } from '../../util/convert-image-to-media-representation';
+import { isLoadedMediaEmoji } from '../../util/is-loaded-media-emoji';
+import { isMediaEmoji } from '../../util/is-media-emoji';
+import { isMediaRepresentation } from '../../util/is-media-representation';
+import debug from '../../util/logger';
+import { denormaliseEmojiServiceResponse } from '../denormaliseEmojiServiceResponse';
+import { emojiRequest } from '../emojiRequest';
+import { getAltRepresentation } from '../getAltRepresentation';
 import MediaEmojiCache from './MediaEmojiCache';
-import { denormaliseEmojiServiceResponse, emojiRequest, getAltRepresentation } from '../EmojiUtils';
 import TokenManager from './TokenManager';
-import debug from '../../util/logger';
 // Assume media is 95% of total upload time.
 export var mediaProportionOfProgress = 95 / 100;
 var SiteEmojiResource = /*#__PURE__*/function () {

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

@@ -0,0 +1,3 @@
+export var getRequiredRepresentation = function getRequiredRepresentation(emoji, useAlt) {
+  return useAlt ? emoji.altRepresentation : emoji.representation;
+};

package/dist/esm/api/shouldUseAltRepresentation.js

@@ -0,0 +1,7 @@
+import { getPixelRatio } from './getPixelRatio';
+var getHeight = function getHeight(fitToHeight) {
+  return getPixelRatio() > 1 ? fitToHeight * 2 : fitToHeight;
+};
+export var shouldUseAltRepresentation = function shouldUseAltRepresentation(emoji, fitToHeight) {
+  return !!(fitToHeight && emoji.altRepresentation && emoji.representation && 'height' in emoji.representation && getHeight(fitToHeight) > emoji.representation.height);
+};

package/dist/esm/api/supportsUploadFeature.js

@@ -0,0 +1,11 @@
+/**
+ * Checks if the emojiProvider can support uploading at a feature level.
+ *
+ * Follow this up with an isUploadSupported() check to see if the provider is actually
+ * configured to support uploads.
+ * https://www.typescriptlang.org/docs/handbook/2/narrowing.html#using-type-predicates
+ */
+export var supportsUploadFeature = function supportsUploadFeature(emojiProvider) {
+  var emojiUploadProvider = emojiProvider;
+  return !!emojiUploadProvider.isUploadSupported && !!emojiUploadProvider.uploadCustomEmoji && !!emojiUploadProvider.prepareForUpload;
+};

package/dist/esm/components/common/AddOwnEmoji.compiled.css

@@ -0,0 +1,6 @@
+._18u019bv{margin-left:10px}
+._18u0r5cr{margin-left:var(--ds-space-negative-050,-4px)}
+._1wpz1h6o{align-self:center}
+._2hwx1i6y{margin-right:var(--ds-space-negative-025,-2px)}
+._otyr19bv{margin-bottom:10px}
+._p12f3sup{max-width:285px}

package/dist/esm/components/common/AddOwnEmoji.js

@@ -0,0 +1,53 @@
+/* AddOwnEmoji.tsx generated by @compiled/babel-plugin v2.0.0 */
+import "./AddOwnEmoji.compiled.css";
+import * as React from 'react';
+import { ax, ix } from "@compiled/react/runtime";
+import { Fragment, useCallback } from 'react';
+import { FormattedMessage } from 'react-intl';
+import AkButton from '@atlaskit/button/standard-button';
+import AddIcon from '@atlaskit/icon/core/add';
+import { fg } from '@atlaskit/platform-feature-flags';
+import { Box } from '@atlaskit/primitives/compiled';
+import { messages } from '../i18n';
+import { uploadEmojiTestId } from './EmojiActions';
+import { isRefreshEmojiPickerEnabled } from './isRefreshEmojiPickerEnabled';
+import { emojiPickerAddEmoji } from './styles';
+var styles = {
+  icon: "_18u0r5cr _2hwx1i6y"
+};
+var addCustomEmoji = null;
+var addCustomEmojiButton = null;
+export var AddOwnEmoji = function AddOwnEmoji(props) {
+  var onOpenUpload = props.onOpenUpload,
+    uploadEnabled = props.uploadEnabled;
+  var handleOpenUpload = useCallback(function (event) {
+    if (fg('platform_emoji_keep_picker_open_on_upload') || isRefreshEmojiPickerEnabled()) {
+      event.preventDefault();
+      event.stopPropagation();
+    }
+    onOpenUpload();
+  }, [onOpenUpload]);
+  return /*#__PURE__*/React.createElement(Fragment, null, uploadEnabled && /*#__PURE__*/React.createElement("div", {
+    "data-testid": uploadEmojiTestId,
+    className: ax(["_1wpz1h6o _18u019bv _otyr19bv"])
+  }, /*#__PURE__*/React.createElement(FormattedMessage, messages.addCustomEmojiLabel, function (label) {
+    return /*#__PURE__*/React.createElement(AkButton, {
+      onClick: handleOpenUpload,
+      iconBefore: /*#__PURE__*/React.createElement(Box, {
+        xcss: styles.icon
+      }, /*#__PURE__*/React.createElement(AddIcon, {
+        color: "currentColor",
+        label: ""
+      })),
+      appearance: "subtle"
+      // TODO: (from codemod) Buttons with "component", "css" or "style" prop can't be automatically migrated with codemods. Please migrate it manually.
+      // eslint-disable-next-line @atlaskit/design-system/no-unsafe-style-overrides
+      ,
+
+      // eslint-disable-next-line @atlaskit/ui-styling-standard/no-classname-prop, @atlaskit/design-system/no-unsafe-style-overrides -- Ignored via go/DSP-18766
+      className: ax(["_p12f3sup", emojiPickerAddEmoji]),
+      tabIndex: 0,
+      id: "add-custom-emoji"
+    }, label);
+  })));
+};