@atlaskit/emoji 67.0.3 → 67.0.5

package/dist/es2019/api/internal/Comparators.js

@@ -1,6 +1,5 @@
 import { MAX_ORDINAL } from '../../util/constants';
 import { isEmojiVariationDescription } from '../../util/type-helpers';
-
 /**
  * Create the default sort comparator to be used for the user queries against emoji
  *
@@ -11,25 +10,22 @@ import { isEmojiVariationDescription } from '../../util/type-helpers';
 export function createSearchEmojiComparator(query, orderedIds) {
   const textQuery = query ? query.replace(/:/g, '').toLowerCase().trim() : undefined;
   const 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.)
+  }
 
+  // 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);
   const comparator = new ChainedEmojiComparator(...comparators);
   comparator.compare = comparator.compare.bind(comparator);
@@ -40,6 +36,7 @@ export function createUsageOnlyEmojiComparator(orderedIds) {
   comparator.compare = comparator.compare.bind(comparator);
   return comparator;
 }
+
 /**
  * Returns a number representing the result of comparing e1 and e2.
  * Compatible with Array.sort, which is to say -
@@ -59,55 +56,46 @@ export class ChainedEmojiComparator {
   constructor(...comparators) {
     this.chain = comparators;
   }
-
   compare(e1, e2) {
     for (let i = 0; i < this.chain.length; i++) {
       const result = this.chain[i].compare(e1, e2);
-
       if (result !== 0) {
         return result;
       }
     }
-
     return 0;
   }
-
 }
+
 /**
  * Orders two emoji such that if one of them has an ascii representation that exactly matches the query then it will
  * be ordered first.
  */
-
 export class AsciiMatchComparator {
   constructor(query) {
     this.query = query;
   }
-
   compare(e1, e2) {
     const e1HasAscii = e1.ascii && e1.ascii.indexOf(this.query) !== -1;
     const e2HasAscii = e2.ascii && e2.ascii.indexOf(this.query) !== -1;
-
     if (e1HasAscii && !e2HasAscii) {
       return -1;
     } else if (!e1HasAscii && e2HasAscii) {
       return 1;
     }
-
     return 0;
   }
-
 }
+
 /**
  * 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.
  */
-
 export class ExactShortNameMatchComparator {
   constructor(query) {
     this.colonQuery = `:${query}:`;
     this.typeComparator = new EmojiTypeComparator(true);
   }
-
   compare(e1, e2) {
     if (e1.shortName === this.colonQuery && e2.shortName === this.colonQuery) {
       return this.typeComparator.compare(e1, e2);
@@ -116,18 +104,16 @@ export class ExactShortNameMatchComparator {
     } else if (e2.shortName === this.colonQuery) {
       return 1;
     }
-
     return 0;
   }
-
 }
+
 /**
  * Orders two emoji based on their type, with the types being STANDARD, ATLASSIAN and SITE (in that order).
  * If the comparator is configured to 'reverse' then the order will be SITE, ATLASSIAN, STANDARD.
  *
  * Regardless of the reverse setting, an unknown type will always come last.
  */
-
 export class EmojiTypeComparator {
   constructor(reverse) {
     if (reverse) {
@@ -136,35 +122,30 @@ export class EmojiTypeComparator {
       this.typeToNumber = new Map([['STANDARD', 0], ['ATLASSIAN', 1], ['SITE', 2]]);
     }
   }
-
   compare(e1, e2) {
     return this.emojiTypeToOrdinal(e1) - this.emojiTypeToOrdinal(e2);
   }
-
   emojiTypeToOrdinal(emoji) {
     let ordinal = this.typeToNumber.get(emoji.type);
-
     if (ordinal === undefined) {
       ordinal = 10;
     }
-
     return ordinal;
   }
-
 }
+
 /**
  * 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 class UsageFrequencyComparator {
   // A Map of emoji base Id to their order in a least of most frequently used
-  constructor(orderedIds) {
-    this.positionLookup = new Map(); // Make ordering start from 1 to avoid having zero in the map (which is falsey)
 
+  constructor(orderedIds) {
+    this.positionLookup = new Map();
+    // Make ordering start from 1 to avoid having zero in the map (which is falsey)
     orderedIds.map((id, index) => this.positionLookup.set(id, index + 1));
   }
-
   compare(e1, e2) {
     if (!e1.id || !e2.id) {
       return 0; // this shouldn't occur. Leave position unchanged if there is any missing id.
@@ -174,31 +155,25 @@ export class UsageFrequencyComparator {
     let i2 = this.getPositionInOrder(e2);
     return i1 - i2;
   }
+
   /**
    * Get the ordinal representing the position of this emoji.
    *
    * @param id the id of the emoji
    */
-
-
   getPositionInOrder(emoji) {
     let id = emoji.id ? emoji.id : '0';
-
     if (isEmojiVariationDescription(emoji)) {
       id = emoji.baseId;
     }
-
     const position = this.positionLookup.get(id);
-
     if (position) {
       return position;
     } else {
       return MAX_ORDINAL;
     }
   }
-
 }
-
 /**
  * A comparator that will sort higher an emoji which matches the query string earliest in the indicated
  * property.
@@ -210,14 +185,11 @@ export class QueryStringPositionMatchComparator {
    */
   constructor(query, propertyToCompare) {
     this.query = query;
-
     if (!propertyToCompare) {
       throw new Error('propertyToCompare is required');
     }
-
     this.propertyName = propertyToCompare;
   }
-
   getScore(emoji) {
     // It is fine to do override the null check here because we are checking
     // it on the constructor.
@@ -225,35 +197,27 @@ export class QueryStringPositionMatchComparator {
     const score = propertyValue ? propertyValue.indexOf(this.query) : MAX_ORDINAL;
     return score === -1 ? MAX_ORDINAL : score;
   }
-
   compare(e1, e2) {
     return this.getScore(e1) - this.getScore(e2);
   }
-
 }
 export class OrderComparator {
   constructor() {}
-
   static get Instance() {
     return this.INSTANCE || (this.INSTANCE = new this());
   }
-
   compare(e1, e2) {
     let o1 = e1.order ? e1.order : MAX_ORDINAL;
     let o2 = e2.order ? e2.order : MAX_ORDINAL;
     return o1 - o2;
   }
-
 }
 export class AlphabeticalShortnameComparator {
   constructor() {}
-
   static get Instance() {
     return this.INSTANCE || (this.INSTANCE = new this());
   }
-
   compare(e1, e2) {
     return e1.shortName.localeCompare(e2.shortName);
   }
-
 }

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

@@ -4,6 +4,7 @@ import { localStoragePrefix } from '../../util/constants';
 import DuplicateLimitedQueue from '../../util/DuplicateLimitedQueue';
 import StoredDuplicateLimitedQueue from '../../util/StoredDuplicateLimitedQueue';
 import storageAvailable from '../../util/storage-available';
+
 /**
  * Keeps track of the last 150 emoji usages, although limiting the maximum count for a single emoji to 25 to
  * ensure we don't end up with only a single emoji being recorded. Usage is persisted to local storage for
@@ -13,38 +14,33 @@ import storageAvailable from '../../util/storage-available';
  * variations are not collapsed in this way and will be tracked per gender. This decision reflects the UI of
  * the EmojiPicker component.
  */
-
 export class UsageFrequencyTracker {
   constructor(useStorageIfPossible = true) {
     const options = UsageFrequencyTracker.queueOptions;
-
     if (useStorageIfPossible && options.storage) {
-      const queueOptions = { ...options,
+      const queueOptions = {
+        ...options,
         storage: options.storage
       };
       this.queue = new StoredDuplicateLimitedQueue(queueOptions);
     } else {
       this.queue = new DuplicateLimitedQueue(options);
     }
-
     this.gateway = new Gateway(10);
   }
+
   /**
    * Record the fact that the supplied emoji was used. You should note that usage is updated asynchronously so you can not
    * count on getOrder() reflecting this usage immediately.
    *
    * @param emoji the emoji who's usage is to be recorded. If the emoji has no id then no usage will be recorded
    */
-
-
   recordUsage(emoji) {
     let emojiId = emoji.id;
-
     if (emojiId) {
       if (isEmojiVariationDescription(emoji)) {
         emojiId = emoji.baseId;
       }
-
       this.gateway.submit(() => {
         if (emojiId) {
           this.queue.enqueue(emojiId);
@@ -52,57 +48,48 @@ export class UsageFrequencyTracker {
       });
     }
   }
+
   /**
    * Returns an array of emoji id (without skin tone variations) sorted by most used to least used. If there
    * are no usages then an empty array will be returned.
    */
-
-
   getOrder() {
     return this.queue.getItemsOrderedByDuplicateCount();
   }
+
   /**
    * Exposed for testing only. Clear any recorded usage.
    */
-
-
   clear() {
     this.queue.clear();
   }
-
 }
-
 _defineProperty(UsageFrequencyTracker, "queueOptions", {
   storage: storageAvailable('localStorage') ? window.localStorage : undefined,
   storagePrefix: localStoragePrefix,
   maxDuplicates: 25,
   minUniqueItems: 5
 });
-
 export class Gateway {
   constructor(maximumPermitted) {
     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.
    */
-
-
   submit(f) {
     if (this.count >= this.maximumPermitted) {
       return false;
     }
-
     this.count++;
-
     const wrappedFunc = () => {
       try {
         f();
@@ -110,16 +97,12 @@ export class Gateway {
         this.completed();
       }
     };
-
     if (typeof window !== 'undefined') {
       window.setTimeout(wrappedFunc);
     }
-
     return true;
   }
-
   completed() {
     this.count--;
   }
-
 }

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

@@ -3,19 +3,13 @@ import { convertMediaToImageEmoji, isMediaRepresentation, isPromise } from '../.
 import MediaImageLoader from './MediaImageLoader';
 import debug from '../../util/logger';
 import { LRUMap } from 'lru_map';
-
 const getRequiredRepresentation = (emoji, useAlt) => useAlt ? emoji.altRepresentation : emoji.representation;
-
 const isUnsupportedBrowser = () => {
-  const isIE =
-  /*@cc_on!@*/
-  false || !!document.documentMode; // Internet Explorer 6-11
-
+  const isIE = /*@cc_on!@*/false || !!document.documentMode; // Internet Explorer 6-11
   const 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).
@@ -23,27 +17,21 @@ const isUnsupportedBrowser = () => {
 export class BrowserCacheStrategy {
   constructor(mediaImageLoader) {
     _defineProperty(this, "cachedImageUrls", new Set());
-
     debug('BrowserCacheStrategy');
     this.mediaImageLoader = mediaImageLoader;
   }
-
   loadEmoji(emoji, useAlt) {
     const representation = getRequiredRepresentation(emoji, useAlt);
-
     if (!isMediaRepresentation(representation)) {
       return emoji;
     }
-
     const {
       mediaPath
     } = representation;
-
     if (this.cachedImageUrls.has(mediaPath)) {
       // Already cached
       return emoji;
     }
-
     return this.mediaImageLoader.loadMediaImage(mediaPath).then(() => {
       // Media is loaded, can use original URL now, so just return original emoji
       this.cachedImageUrls.add(mediaPath);
@@ -52,11 +40,9 @@ export class BrowserCacheStrategy {
       return undefined;
     });
   }
-
   optimisticRendering() {
     return true;
   }
-
   static 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
@@ -64,8 +50,8 @@ export class BrowserCacheStrategy {
     if (isUnsupportedBrowser()) {
       return Promise.resolve(false);
     }
-
-    return mediaImageLoader.loadMediaImage(mediaPath).then(() => // Image should be cached in browser, if supported it should be accessible from the cache by an <img/>
+    return mediaImageLoader.loadMediaImage(mediaPath).then(() =>
+    // 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(resolve => {
       const img = new Image();
@@ -78,11 +64,11 @@ export class BrowserCacheStrategy {
       img.src = mediaPath;
     })).catch(() => false);
   }
-
 }
-const maxImageCached = 1000; // Don't cache images large than this - dataUrl size in characters
-
+const maxImageCached = 1000;
+// Don't cache images large than this - dataUrl size in characters
 const maxImageSize = 10000;
+
 /**
  * For browsers that do no cache images without equivalent headers (e.g. Firefox).
  *
@@ -92,53 +78,45 @@ const maxImageSize = 10000;
  * Images are still cached by the browser, but loading in asynchronous with
  * small delay noticable to the end user.
  */
-
 export class MemoryCacheStrategy {
   constructor(mediaImageLoader) {
     debug('MemoryCacheStrategy');
     this.mediaImageLoader = mediaImageLoader;
     this.dataURLCache = new LRUMap(maxImageCached);
   }
-
   loadEmoji(emoji, useAlt) {
     const representation = getRequiredRepresentation(emoji, useAlt);
-
     if (!isMediaRepresentation(representation)) {
       return emoji;
     }
-
     const {
       mediaPath
     } = representation;
     const dataURL = this.dataURLCache.get(mediaPath);
-
     if (dataURL) {
       // Already cached
       return convertMediaToImageEmoji(emoji, dataURL, useAlt);
-    } // Not cached, load
-
+    }
 
+    // Not cached, load
     return this.mediaImageLoader.loadMediaImage(mediaPath).then(dataURL => {
       const 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(() => {
       return undefined;
     });
   }
-
   optimisticRendering() {
     return false;
   }
-
 }
+
 /**
  * Provides a cache for Media Emoji.
  *
@@ -146,53 +124,40 @@ export class MemoryCacheStrategy {
  *
  * Otherwise, they are loaded and returned via a promise.
  */
-
 export default class MediaEmojiCache {
   constructor(tokenManager) {
     _defineProperty(this, "waitingInitUrls", []);
-
     debug('MediaEmojiCache');
     this.mediaImageLoader = new MediaImageLoader(tokenManager);
   }
-
   loadEmoji(emoji, useAlt) {
     const representation = getRequiredRepresentation(emoji, useAlt);
-
     if (!isMediaRepresentation(representation)) {
       return emoji;
     }
-
     const {
       mediaPath
     } = representation;
     const emojiCache = this.getCache(mediaPath);
-
     if (isPromise(emojiCache)) {
       // Promise based
       return emojiCache.then(cache => cache.loadEmoji(emoji, useAlt)).catch(() => undefined);
     }
-
     return emojiCache.loadEmoji(emoji, useAlt);
   }
-
   optimisticRendering(url) {
     const emojiCache = this.getCache(url);
-
     if (isPromise(emojiCache)) {
       // Promise based
       return emojiCache.then(cache => cache.optimisticRendering()).catch(() => false);
     }
-
     return emojiCache.optimisticRendering();
   }
-
   getCache(url) {
     if (this.cache) {
       return this.cache;
     }
-
     this.waitingInitUrls.push(url);
-
     if (!this.cacheLoading) {
       this.cacheLoading = this.initCache().then(cache => {
         this.cache = cache;
@@ -203,30 +168,22 @@ export default class MediaEmojiCache {
         throw err;
       });
     }
-
     return this.cacheLoading;
   }
-
   initCache() {
     const 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(supported => {
       this.waitingInitUrls = []; // clear
-
       this.cacheLoading = undefined;
-
       if (supported) {
         return new BrowserCacheStrategy(this.mediaImageLoader);
       }
-
       return new MemoryCacheStrategy(this.mediaImageLoader);
     }).catch(() => {
       return this.initCache();
     });
   }
-
 }

package/dist/es2019/api/media/MediaImageLoader.js

@@ -6,22 +6,16 @@ const defaultMaxRetriesOnNotFound = 2;
 export default class MediaImageLoader {
   constructor(tokenManager, options) {
     _defineProperty(this, "mediaImageQueue", []);
-
     _defineProperty(this, "activeProcessing", 0);
-
     _defineProperty(this, "pendingRequests", new Map());
-
     this.concurrentDownloadLimit = options && options.concurrentDownloadLimit || defaultConcurrentDownloadLimit;
     this.tokenManager = tokenManager;
   }
-
   loadMediaImage(url) {
     const maybePending = this.pendingRequests.get(url);
-
     if (maybePending !== undefined) {
       return maybePending;
     }
-
     const pending = new Promise((resolve, reject) => {
       this.mediaImageQueue.push({
         url,
@@ -39,15 +33,12 @@ export default class MediaImageLoader {
     this.pendingRequests.set(url, pending);
     return pending;
   }
-
   getQueueSize() {
     return this.mediaImageQueue.length;
   }
-
   getActiveDownloads() {
     return this.activeProcessing;
   }
-
   processFromQueue() {
     while (this.activeProcessing < this.concurrentDownloadLimit && this.mediaImageQueue.length > 0) {
       this.activeProcessing++;
@@ -72,16 +63,13 @@ export default class MediaImageLoader {
       });
     }
   }
-
   completedItem() {
     this.activeProcessing--;
     this.processFromQueue();
   }
-
   delay(durationInMillis) {
     return new Promise(resolve => setTimeout(resolve, durationInMillis));
   }
-
   requestMediaEmoji(url, token, retryOnAuthError, retriesOnNotFound = defaultMaxRetriesOnNotFound) {
     return imageAcceptHeader().then(acceptHeader => {
       // Media REST API: https://media-api-internal.atlassian.io/api.html#file__fileId__image_get
@@ -103,20 +91,18 @@ export default class MediaImageLoader {
         } else if (response.ok) {
           return response.blob().then(blob => this.readBlob(blob));
         }
-
         throw new Error(`Unable to load media image. Status=${response.status} ${response.statusText}`);
       });
     });
   }
-
   readBlob(blob) {
     return new Promise((resolve, reject) => {
-      const reader = new FileReader(); // TODO: [ts30] Add proper handling for null and ArrayBuffer
+      const reader = new FileReader();
 
+      // TODO: [ts30] Add proper handling for null and ArrayBuffer
       reader.addEventListener('load', () => resolve(reader.result));
       reader.addEventListener('error', () => reject(reader.error));
       reader.readAsDataURL(blob);
     });
   }
-
 }