@atlaskit/emoji 71.17.1 → 72.0.0

package/dist/cjs/api/internal/ExactShortNameMatchComparator.js

@@ -0,0 +1,34 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ExactShortNameMatchComparator = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _EmojiTypeComparator = require("./EmojiTypeComparator");
+/**
+ * Orders two emoji such that the one who's shortname matches the query exactly comes first. If there are matching
+ * shortnames then the type of emoji is taken into account with SITE emoji coming first.
+ */
+var ExactShortNameMatchComparator = exports.ExactShortNameMatchComparator = /*#__PURE__*/function () {
+  function ExactShortNameMatchComparator(query) {
+    (0, _classCallCheck2.default)(this, ExactShortNameMatchComparator);
+    this.colonQuery = ":".concat(query, ":");
+    this.typeComparator = new _EmojiTypeComparator.EmojiTypeComparator(true);
+  }
+  return (0, _createClass2.default)(ExactShortNameMatchComparator, [{
+    key: "compare",
+    value: function compare(e1, e2) {
+      if (e1.shortName === this.colonQuery && e2.shortName === this.colonQuery) {
+        return this.typeComparator.compare(e1, e2);
+      } else if (e1.shortName === this.colonQuery) {
+        return -1;
+      } else if (e2.shortName === this.colonQuery) {
+        return 1;
+      }
+      return 0;
+    }
+  }]);
+}();

package/dist/cjs/api/internal/Gateway.js

@@ -0,0 +1,52 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Gateway = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var Gateway = exports.Gateway = /*#__PURE__*/function () {
+  function Gateway(maximumPermitted) {
+    (0, _classCallCheck2.default)(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 (0, _createClass2.default)(Gateway, [{
+    key: "submit",
+    value: function submit(f) {
+      var _this = this;
+      if (this.count >= this.maximumPermitted) {
+        return false;
+      }
+      this.count++;
+      var wrappedFunc = function wrappedFunc() {
+        try {
+          f();
+        } finally {
+          _this.completed();
+        }
+      };
+      if (typeof window !== 'undefined') {
+        window.setTimeout(wrappedFunc);
+      }
+      return true;
+    }
+  }, {
+    key: "completed",
+    value: function completed() {
+      this.count--;
+    }
+  }]);
+}();

package/dist/cjs/api/internal/OrderComparator.js

@@ -0,0 +1,28 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.OrderComparator = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _constants = require("../../util/constants");
+var OrderComparator = exports.OrderComparator = /*#__PURE__*/function () {
+  function OrderComparator() {
+    (0, _classCallCheck2.default)(this, OrderComparator);
+  }
+  return (0, _createClass2.default)(OrderComparator, [{
+    key: "compare",
+    value: function compare(e1, e2) {
+      var o1 = e1.order ? e1.order : _constants.MAX_ORDINAL;
+      var o2 = e2.order ? e2.order : _constants.MAX_ORDINAL;
+      return o1 - o2;
+    }
+  }], [{
+    key: "Instance",
+    get: function get() {
+      return this.INSTANCE || (this.INSTANCE = new this());
+    }
+  }]);
+}();

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

@@ -0,0 +1,43 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.QueryStringPositionMatchComparator = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _constants = require("../../util/constants");
+/**
+ * A comparator that will sort higher an emoji which matches the query string earliest in the indicated
+ * property.
+ */
+var QueryStringPositionMatchComparator = exports.QueryStringPositionMatchComparator = /*#__PURE__*/function () {
+  /**
+   * @param query the query to match
+   * @param propertyToCompare the property of EmojiDescription to check for query within
+   */
+  function QueryStringPositionMatchComparator(query, propertyToCompare) {
+    (0, _classCallCheck2.default)(this, QueryStringPositionMatchComparator);
+    this.query = query;
+    if (!propertyToCompare) {
+      throw new Error('propertyToCompare is required');
+    }
+    this.propertyName = propertyToCompare;
+  }
+  return (0, _createClass2.default)(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) : _constants.MAX_ORDINAL;
+      return score === -1 ? _constants.MAX_ORDINAL : score;
+    }
+  }, {
+    key: "compare",
+    value: function compare(e1, e2) {
+      return this.getScore(e1) - this.getScore(e2);
+    }
+  }]);
+}();

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

@@ -0,0 +1,59 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.UsageFrequencyComparator = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _constants = require("../../util/constants");
+var _isEmojiVariationDescription = require("../../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.
+ */
+var UsageFrequencyComparator = exports.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;
+    (0, _classCallCheck2.default)(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 (0, _createClass2.default)(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 ((0, _isEmojiVariationDescription.isEmojiVariationDescription)(emoji)) {
+        id = emoji.baseId;
+      }
+      var position = this.positionLookup.get(id);
+      if (position) {
+        return position;
+      } else {
+        return _constants.MAX_ORDINAL;
+      }
+    }
+  }]);
+}();

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

@@ -4,15 +4,16 @@ var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefau
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.UsageFrequencyTracker = exports.Gateway = void 0;
+exports.UsageFrequencyTracker = void 0;
 var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
 var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
-var _typeHelpers = require("../../util/type-helpers");
-var _constants = require("../../util/constants");
 var _DuplicateLimitedQueue = _interopRequireDefault(require("../../util/DuplicateLimitedQueue"));
 var _StoredDuplicateLimitedQueue = _interopRequireDefault(require("../../util/StoredDuplicateLimitedQueue"));
+var _constants = require("../../util/constants");
+var _isEmojiVariationDescription = require("../../util/is-emoji-variation-description");
 var _storageAvailable = _interopRequireDefault(require("../../util/storage-available"));
+var _Gateway = require("./Gateway");
 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) { (0, _defineProperty2.default)(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; }
 /**
@@ -37,7 +38,7 @@ var UsageFrequencyTracker = exports.UsageFrequencyTracker = /*#__PURE__*/functio
     } else {
       this.queue = new _DuplicateLimitedQueue.default(options);
     }
-    this.gateway = new Gateway(10);
+    this.gateway = new _Gateway.Gateway(10);
   }
 
   /**
@@ -52,7 +53,7 @@ var UsageFrequencyTracker = exports.UsageFrequencyTracker = /*#__PURE__*/functio
       var _this = this;
       var emojiId = emoji.id;
       if (emojiId) {
-        if ((0, _typeHelpers.isEmojiVariationDescription)(emoji)) {
+        if ((0, _isEmojiVariationDescription.isEmojiVariationDescription)(emoji)) {
           emojiId = emoji.baseId;
         }
         this.gateway.submit(function () {
@@ -89,47 +90,4 @@ var UsageFrequencyTracker = exports.UsageFrequencyTracker = /*#__PURE__*/functio
   storagePrefix: _constants.localStoragePrefix,
   maxDuplicates: 25,
   minUniqueItems: 5
-});
-var Gateway = exports.Gateway = /*#__PURE__*/function () {
-  function Gateway(maximumPermitted) {
-    (0, _classCallCheck2.default)(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 (0, _createClass2.default)(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/cjs/api/internal/createSearchEmojiComparator.js

@@ -0,0 +1,46 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createSearchEmojiComparator = createSearchEmojiComparator;
+var _construct2 = _interopRequireDefault(require("@babel/runtime/helpers/construct"));
+var _AlphabeticalShortnameComparator = require("./AlphabeticalShortnameComparator");
+var _AsciiMatchComparator = require("./AsciiMatchComparator");
+var _ChainedEmojiComparator = require("./ChainedEmojiComparator");
+var _ExactShortNameMatchComparator = require("./ExactShortNameMatchComparator");
+var _OrderComparator = require("./OrderComparator");
+var _QueryStringPositionMatchComparator = require("./QueryStringPositionMatchComparator");
+var _UsageFrequencyComparator = require("./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
+ */
+function createSearchEmojiComparator(query, orderedIds) {
+  var textQuery = query ? query.replace(/:/g, '').toLowerCase().trim() : undefined;
+  var comparators = [];
+  if (query) {
+    comparators.push(new _AsciiMatchComparator.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.ExactShortNameMatchComparator(textQuery));
+  }
+  if (orderedIds && orderedIds.length) {
+    comparators.push(new _UsageFrequencyComparator.UsageFrequencyComparator(orderedIds));
+  }
+  if (textQuery) {
+    comparators.push(new _QueryStringPositionMatchComparator.QueryStringPositionMatchComparator(textQuery, 'shortName'), new _QueryStringPositionMatchComparator.QueryStringPositionMatchComparator(textQuery, 'name'));
+  }
+  comparators.push(_OrderComparator.OrderComparator.Instance, _AlphabeticalShortnameComparator.AlphabeticalShortnameComparator.Instance);
+  var comparator = (0, _construct2.default)(_ChainedEmojiComparator.ChainedEmojiComparator, comparators);
+  comparator.compare = comparator.compare.bind(comparator);
+  return comparator;
+}

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

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.createUsageOnlyEmojiComparator = createUsageOnlyEmojiComparator;
+var _ChainedEmojiComparator = require("./ChainedEmojiComparator");
+var _EmojiTypeComparator = require("./EmojiTypeComparator");
+var _OrderComparator = require("./OrderComparator");
+var _UsageFrequencyComparator = require("./UsageFrequencyComparator");
+function createUsageOnlyEmojiComparator(orderedIds) {
+  var comparator = new _ChainedEmojiComparator.ChainedEmojiComparator(new _UsageFrequencyComparator.UsageFrequencyComparator(orderedIds), new _EmojiTypeComparator.EmojiTypeComparator(), _OrderComparator.OrderComparator.Instance);
+  comparator.compare = comparator.compare.bind(comparator);
+  return comparator;
+}

package/dist/cjs/api/isMediaApiUrl.js

@@ -0,0 +1,9 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.isMediaApiUrl = void 0;
+var isMediaApiUrl = exports.isMediaApiUrl = function isMediaApiUrl(url, meta) {
+  return !!(meta && meta.mediaApiToken && url.indexOf(meta.mediaApiToken.url) === 0);
+};

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

@@ -0,0 +1,87 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.BrowserCacheStrategy = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _isMediaRepresentation = require("../../util/is-media-representation");
+var _logger = _interopRequireDefault(require("../../util/logger"));
+var _getRequiredRepresentation = require("./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).
+ */
+var BrowserCacheStrategy = exports.BrowserCacheStrategy = /*#__PURE__*/function () {
+  function BrowserCacheStrategy(mediaImageLoader) {
+    (0, _classCallCheck2.default)(this, BrowserCacheStrategy);
+    (0, _defineProperty2.default)(this, "cachedImageUrls", new Set());
+    (0, _logger.default)('BrowserCacheStrategy');
+    this.mediaImageLoader = mediaImageLoader;
+  }
+  return (0, _createClass2.default)(BrowserCacheStrategy, [{
+    key: "loadEmoji",
+    value: function loadEmoji(emoji, useAlt) {
+      var _this = this;
+      var representation = (0, _getRequiredRepresentation.getRequiredRepresentation)(emoji, useAlt);
+      if (!(0, _isMediaRepresentation.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;
+      });
+    }
+  }]);
+}();