@atlaskit/emoji 71.17.0 → 72.0.0

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

@@ -1,222 +1 @@
-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
- *
- * @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) {
-  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.)
-
-  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);
-  return comparator;
-}
-export function createUsageOnlyEmojiComparator(orderedIds) {
-  const comparator = new ChainedEmojiComparator(new UsageFrequencyComparator(orderedIds), new EmojiTypeComparator(), OrderComparator.Instance);
-  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 -
- *   - less than 0 if e1 should come first
- *   - 0 if they are equal; e1 and e2 will be unchanged in position relative to each other
- *   - greater than 0 if e2 should come first.
- */
-
-/**
- * A combinator comparator that applies an ordered chained of sub-comparators. The first comparator that
- * returns a non-zero value stops the chain and causes that value to be returned. If a comparator returns a
- * zero then the next one in the chain is tried.
- *
- * If no comparators in the chain return a non-zero value then zero will be returned.
- */
-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);
-    } else if (e1.shortName === this.colonQuery) {
-      return -1;
-    } 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) {
-      this.typeToNumber = new Map([['SITE', 0], ['ATLASSIAN', 1], ['STANDARD', 2]]);
-    } else {
-      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)
-    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.
-    }
-    let i1 = this.getPositionInOrder(e1);
-    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.
- */
-export class QueryStringPositionMatchComparator {
-  /**
-   * @param query the query to match
-   * @param propertyToCompare the property of EmojiDescription to check for query within
-   */
-  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.
-    const propertyValue = emoji[this.propertyName];
-    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);
-  }
-}
+export {};

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

@@ -0,0 +1,25 @@
+/**
+ * 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) {
+      this.typeToNumber = new Map([['SITE', 0], ['ATLASSIAN', 1], ['STANDARD', 2]]);
+    } else {
+      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;
+  }
+}

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

@@ -0,0 +1,22 @@
+import { EmojiTypeComparator } from './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.
+ */
+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);
+    } else if (e1.shortName === this.colonQuery) {
+      return -1;
+    } else if (e2.shortName === this.colonQuery) {
+      return 1;
+    }
+    return 0;
+  }
+}

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

@@ -0,0 +1,36 @@
+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();
+      } finally {
+        this.completed();
+      }
+    };
+    if (typeof window !== 'undefined') {
+      window.setTimeout(wrappedFunc);
+    }
+    return true;
+  }
+  completed() {
+    this.count--;
+  }
+}

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

@@ -0,0 +1,12 @@
+import { MAX_ORDINAL } from '../../util/constants';
+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;
+  }
+}

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

@@ -0,0 +1,28 @@
+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 class QueryStringPositionMatchComparator {
+  /**
+   * @param query the query to match
+   * @param propertyToCompare the property of EmojiDescription to check for query within
+   */
+  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.
+    const propertyValue = emoji[this.propertyName];
+    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);
+  }
+}

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

@@ -0,0 +1,41 @@
+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 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)
+    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.
+    }
+    let i1 = this.getPositionInOrder(e1);
+    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;
+    }
+  }
+}

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

@@ -1,9 +1,10 @@
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
-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
@@ -70,40 +71,4 @@ _defineProperty(UsageFrequencyTracker, "queueOptions", {
   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();
-      } finally {
-        this.completed();
-      }
-    };
-    if (typeof window !== 'undefined') {
-      window.setTimeout(wrappedFunc);
-    }
-    return true;
-  }
-  completed() {
-    this.count--;
-  }
-}
+});

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

@@ -0,0 +1,39 @@
+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) {
+  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.)
+
+  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);
+  return comparator;
+}

package/dist/es2019/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) {
+  const comparator = new ChainedEmojiComparator(new UsageFrequencyComparator(orderedIds), new EmojiTypeComparator(), OrderComparator.Instance);
+  comparator.compare = comparator.compare.bind(comparator);
+  return comparator;
+}

package/dist/es2019/api/isMediaApiUrl.js

@@ -0,0 +1 @@
+export const isMediaApiUrl = (url, meta) => !!(meta && meta.mediaApiToken && url.indexOf(meta.mediaApiToken.url) === 0);

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

@@ -0,0 +1,66 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { isMediaRepresentation } from '../../util/is-media-representation';
+import debug from '../../util/logger';
+import { getRequiredRepresentation } from './getRequiredRepresentation';
+const isUnsupportedBrowser = () => {
+  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).
+ */
+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);
+      return emoji;
+    }).catch(() => {
+      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
+    // TODO: fix as a part of FS-1592
+    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/>
+    // Try to load without via image to confirm this support (this fails in Firefox)
+    new Promise(resolve => {
+      const img = new Image();
+      img.addEventListener('load', () => {
+        resolve(true);
+      });
+      img.addEventListener('error', () => {
+        resolve(false);
+      });
+      img.src = mediaPath;
+    })).catch(() => false);
+  }
+}