@atlaskit/mention 27.17.1 → 27.18.0

package/dist/es2019/util/i18n.js

@@ -1,172 +1,9 @@
-import _extends from "@babel/runtime/helpers/extends";
-import React from 'react';
-import { FormattedMessage, useIntl } from 'react-intl';
 import { messages } from '../components/i18n';
-export const propFormatter = messageDescriptor => ({
-  values,
-  children
-}) => {
-  const {
-    formatMessage
-  } = useIntl();
-  const message = formatMessage(messageDescriptor, values);
-  if (typeof children === 'function') {
-    return children(message);
-  }
-  return /*#__PURE__*/React.createElement(FormattedMessage, _extends({
-    values: values
-  }, messageDescriptor));
-};
+import { propFormatter } from './prop-formatter';
 export const UnknownUserError = propFormatter(messages.unknownUserError);
 export const NoAccessWarning = propFormatter(messages.noAccessWarning);
 export const NoAccessLabel = propFormatter(messages.noAccessLabel);
 export const DefaultHeadline = propFormatter(messages.defaultHeadline);
 export const DefaultAdvisedAction = propFormatter(messages.defaultAdvisedAction);
 export const LoginAgain = propFormatter(messages.loginAgain);
-export const DifferentText = propFormatter(messages.differentText);
-
-/**
- * Tries to get the most specific messages bundle for a given locale.
- *
- * Strategy:
- * 1. Try to find messages with the exact string (i.e. 'fr_FR')
- * 2. If that doesn't work, try to find messages for the country locale (i.e. 'fr')
- * 3. If that doesn't work, return english messages as a fallback.
- *
- * @param locale string specifying the locale like 'en_GB', or 'fr'.
- */
-export const getMessagesForLocale = async locale => {
-  switch (locale) {
-    case 'cs':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-cs" */'../i18n/cs').then(mod => mod.default);
-      }
-    case 'da':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-da" */'../i18n/da').then(mod => mod.default);
-      }
-    case 'de':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-de" */'../i18n/de').then(mod => mod.default);
-      }
-    case 'en':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-en" */'../i18n/en').then(mod => mod.default);
-      }
-    case 'en_GB':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-en_GB" */'../i18n/en_GB').then(mod => mod.default);
-      }
-    case 'en_ZZ':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-en_ZZ" */'../i18n/en_ZZ').then(mod => mod.default);
-      }
-    case 'es':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-es" */'../i18n/es').then(mod => mod.default);
-      }
-    case 'et':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-et" */'../i18n/et').then(mod => mod.default);
-      }
-    case 'fi':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-fi" */'../i18n/fi').then(mod => mod.default);
-      }
-    case 'fr':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-fr" */'../i18n/fr').then(mod => mod.default);
-      }
-    case 'hu':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-hu" */'../i18n/hu').then(mod => mod.default);
-      }
-    case 'is':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-is" */'../i18n/is').then(mod => mod.default);
-      }
-    case 'it':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-it" */'../i18n/it').then(mod => mod.default);
-      }
-    case 'ja':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-ja" */'../i18n/ja').then(mod => mod.default);
-      }
-    case 'ko':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-ko" */'../i18n/ko').then(mod => mod.default);
-      }
-    case 'nb':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-nb" */'../i18n/nb').then(mod => mod.default);
-      }
-    case 'nl':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-nl" */'../i18n/nl').then(mod => mod.default);
-      }
-    case 'pl':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-pl" */'../i18n/pl').then(mod => mod.default);
-      }
-    case 'pt_BR':
-    case 'pt-BR':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-pt_BR" */'../i18n/pt_BR').then(mod => mod.default);
-      }
-    case 'pt_PT':
-    case 'pt-PT':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-pt_PT" */'../i18n/pt_PT').then(mod => mod.default);
-      }
-    case 'ro':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-ro" */'../i18n/ro').then(mod => mod.default);
-      }
-    case 'ru':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-ru" */'../i18n/ru').then(mod => mod.default);
-      }
-    case 'sk':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-sk" */'../i18n/sk').then(mod => mod.default);
-      }
-    case 'sv':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-sv" */'../i18n/sv').then(mod => mod.default);
-      }
-    case 'th':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-th" */'../i18n/th').then(mod => mod.default);
-      }
-    case 'tr':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-tr" */'../i18n/tr').then(mod => mod.default);
-      }
-    case 'uk':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-uk" */'../i18n/uk').then(mod => mod.default);
-      }
-    case 'vi':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-vi" */'../i18n/vi').then(mod => mod.default);
-      }
-    case 'zh_TW':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-zh_TW" */'../i18n/zh_TW').then(mod => mod.default);
-      }
-    case 'zh':
-      {
-        return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-zh" */'../i18n/zh').then(mod => mod.default);
-      }
-    default:
-      {
-        const fragments = locale.split(/[_-]/);
-        if (fragments.length === 2) {
-          return getMessagesForLocale(fragments[0]);
-        } else {
-          return import( /* webpackChunkName: "@atlaskit-internal_mention-i18n-en" */'../i18n/en').then(mod => mod.default);
-        }
-      }
-  }
-};
+export const DifferentText = propFormatter(messages.differentText);

package/dist/es2019/util/left-click.js

@@ -0,0 +1,3 @@
+export function leftClick(event) {
+  return event.button === 0 && !event.altKey && !event.ctrlKey && !event.metaKey && !event.shiftKey;
+}

package/dist/es2019/util/mouse-location.js

@@ -0,0 +1,6 @@
+export function mouseLocation(event) {
+  return {
+    x: event.clientX,
+    y: event.clientY
+  };
+}

package/dist/es2019/util/mouse.js

@@ -1,18 +0,0 @@
-export function mouseLocation(event) {
-  return {
-    x: event.clientX,
-    y: event.clientY
-  };
-}
-
-// Used to prevent invalid mouse move detection on scroll
-// lastPosition is object (x, y)
-export function actualMouseMove(oldPosition, newPosition) {
-  if (!oldPosition || oldPosition.x !== newPosition.x || oldPosition.y !== newPosition.y) {
-    return true;
-  }
-  return false;
-}
-export function leftClick(event) {
-  return event.button === 0 && !event.altKey && !event.ctrlKey && !event.metaKey && !event.shiftKey;
-}

package/dist/es2019/util/package-name.js

@@ -0,0 +1 @@
+export const packageName = "@atlaskit/mention";

package/dist/es2019/util/package-version.js

@@ -0,0 +1 @@
+export const packageVersion = "27.17.1";

package/dist/es2019/util/prop-formatter.js

@@ -0,0 +1,18 @@
+import _extends from "@babel/runtime/helpers/extends";
+import React from 'react';
+import { FormattedMessage, useIntl } from 'react-intl';
+export const propFormatter = messageDescriptor => ({
+  values,
+  children
+}) => {
+  const {
+    formatMessage
+  } = useIntl();
+  const message = formatMessage(messageDescriptor, values);
+  if (typeof children === 'function') {
+    return children(message);
+  }
+  return /*#__PURE__*/React.createElement(FormattedMessage, _extends({
+    values: values
+  }, messageDescriptor));
+};

package/dist/esm/api/AbstractMentionResource.js

@@ -0,0 +1,104 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/inherits";
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+import debug from '../util/logger';
+import { AbstractResource } from './AbstractResource';
+var MAX_NOTIFIED_ITEMS = 20;
+export var AbstractMentionResource = /*#__PURE__*/function (_AbstractResource) {
+  function AbstractMentionResource() {
+    _classCallCheck(this, AbstractMentionResource);
+    return _callSuper(this, AbstractMentionResource, arguments);
+  }
+  _inherits(AbstractMentionResource, _AbstractResource);
+  return _createClass(AbstractMentionResource, [{
+    key: "shouldHighlightMention",
+    value: function shouldHighlightMention(_mention) {
+      return false;
+    }
+
+    // eslint-disable-next-line class-methods-use-this
+  }, {
+    key: "filter",
+    value: function filter(query) {
+      throw new Error("not yet implemented.\nParams: query=".concat(query));
+    }
+
+    // eslint-disable-next-line class-methods-use-this, no-unused-vars
+  }, {
+    key: "recordMentionSelection",
+    value: function recordMentionSelection(_mention) {
+      // Do nothing
+    }
+  }, {
+    key: "isFiltering",
+    value: function isFiltering(_query) {
+      return false;
+    }
+  }, {
+    key: "_notifyListeners",
+    value: function _notifyListeners(mentionsResult, stats) {
+      debug('ak-mention-resource._notifyListeners', mentionsResult && mentionsResult.mentions && mentionsResult.mentions.length, this.changeListeners);
+      this.changeListeners.forEach(function (listener, key) {
+        try {
+          listener(mentionsResult.mentions.slice(0, MAX_NOTIFIED_ITEMS), mentionsResult.query, stats);
+        } catch (e) {
+          // ignore error from listener
+          debug("error from listener '".concat(key, "', ignoring"), e);
+        }
+      });
+    }
+  }, {
+    key: "_notifyAllResultsListeners",
+    value: function _notifyAllResultsListeners(mentionsResult) {
+      debug('ak-mention-resource._notifyAllResultsListeners', mentionsResult && mentionsResult.mentions && mentionsResult.mentions.length, this.changeListeners);
+      this.allResultsListeners.forEach(function (listener, key) {
+        try {
+          listener(mentionsResult.mentions.slice(0, MAX_NOTIFIED_ITEMS), mentionsResult.query);
+        } catch (e) {
+          // ignore error from listener
+          debug("error from listener '".concat(key, "', ignoring"), e);
+        }
+      });
+    }
+  }, {
+    key: "_notifyErrorListeners",
+    value: function _notifyErrorListeners(error, query) {
+      this.errListeners.forEach(function (listener, key) {
+        try {
+          listener(error, query);
+        } catch (e) {
+          // ignore error from listener
+          debug("error from listener '".concat(key, "', ignoring"), e);
+        }
+      });
+    }
+  }, {
+    key: "_notifyInfoListeners",
+    value: function _notifyInfoListeners(info) {
+      this.infoListeners.forEach(function (listener, key) {
+        try {
+          listener(info);
+        } catch (e) {
+          // ignore error fromr listener
+          debug("error from listener '".concat(key, "', ignoring"), e);
+        }
+      });
+    }
+  }, {
+    key: "_notifyAnalyticsListeners",
+    value: function _notifyAnalyticsListeners(event, actionSubject, action, attributes) {
+      this.analyticsListeners.forEach(function (listener, key) {
+        try {
+          listener(event, actionSubject, action, attributes);
+        } catch (e) {
+          // ignore error from listener
+          debug("error from listener '".concat(key, "', ignoring"), e);
+        }
+      });
+    }
+  }]);
+}(AbstractResource);

package/dist/esm/api/AbstractPresenceResource.js

@@ -0,0 +1,34 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _possibleConstructorReturn from "@babel/runtime/helpers/possibleConstructorReturn";
+import _getPrototypeOf from "@babel/runtime/helpers/getPrototypeOf";
+import _inherits from "@babel/runtime/helpers/inherits";
+function _callSuper(t, o, e) { return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e)); }
+function _isNativeReflectConstruct() { try { var t = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); } catch (t) {} return (_isNativeReflectConstruct = function _isNativeReflectConstruct() { return !!t; })(); }
+import debug from '../util/logger';
+import { AbstractResource } from './AbstractResource';
+export var AbstractPresenceResource = /*#__PURE__*/function (_AbstractResource) {
+  function AbstractPresenceResource() {
+    _classCallCheck(this, AbstractPresenceResource);
+    return _callSuper(this, AbstractPresenceResource, arguments);
+  }
+  _inherits(AbstractPresenceResource, _AbstractResource);
+  return _createClass(AbstractPresenceResource, [{
+    key: "refreshPresence",
+    value: function refreshPresence(userIds) {
+      throw new Error("not yet implemented.\nParams: userIds=".concat(userIds));
+    }
+  }, {
+    key: "notifyListeners",
+    value: function notifyListeners(presences) {
+      this.changeListeners.forEach(function (listener, key) {
+        try {
+          listener(presences);
+        } catch (e) {
+          // ignore error from listener
+          debug("error from listener '".concat(key, "', ignoring"), e);
+        }
+      });
+    }
+  }]);
+}(AbstractResource);

package/dist/esm/api/AbstractResource.js

@@ -0,0 +1,41 @@
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+export var AbstractResource = /*#__PURE__*/function () {
+  function AbstractResource() {
+    _classCallCheck(this, AbstractResource);
+    this.changeListeners = new Map();
+    this.allResultsListeners = new Map();
+    this.errListeners = new Map();
+    this.infoListeners = new Map();
+    this.analyticsListeners = new Map();
+  }
+  return _createClass(AbstractResource, [{
+    key: "subscribe",
+    value: function subscribe(key, callback, errCallback, infoCallback, allResultsCallback, analyticsListeners) {
+      if (callback) {
+        this.changeListeners.set(key, callback);
+      }
+      if (errCallback) {
+        this.errListeners.set(key, errCallback);
+      }
+      if (infoCallback) {
+        this.infoListeners.set(key, infoCallback);
+      }
+      if (allResultsCallback) {
+        this.allResultsListeners.set(key, allResultsCallback);
+      }
+      if (analyticsListeners) {
+        this.analyticsListeners.set(key, analyticsListeners);
+      }
+    }
+  }, {
+    key: "unsubscribe",
+    value: function unsubscribe(key) {
+      this.changeListeners.delete(key);
+      this.errListeners.delete(key);
+      this.infoListeners.delete(key);
+      this.allResultsListeners.delete(key);
+      this.analyticsListeners.delete(key);
+    }
+  }]);
+}();

package/dist/esm/api/Callback.js

@@ -0,0 +1 @@
+export {};

package/dist/esm/api/DefaultMentionNameResolver.js

@@ -0,0 +1,171 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _classCallCheck from "@babel/runtime/helpers/classCallCheck";
+import _createClass from "@babel/runtime/helpers/createClass";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import { MentionNameStatus } from '../types';
+import { fireAnalyticsMentionHydrationEvent } from '../util/fire-analytics-mention-hydration-event';
+import { mergeNameResolverQueues } from './mergeNameResolverQueues';
+export var DefaultMentionNameResolver = /*#__PURE__*/function () {
+  function DefaultMentionNameResolver(client) {
+    var _this = this;
+    var analyticsProps = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var onResolvedAll = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : function () {};
+    _classCallCheck(this, DefaultMentionNameResolver);
+    _defineProperty(this, "nameCache", new Map());
+    _defineProperty(this, "nameQueue", new Map());
+    _defineProperty(this, "nameStartTime", new Map());
+    _defineProperty(this, "processingQueue", new Map());
+    _defineProperty(this, "debounce", 0);
+    _defineProperty(this, "debounceOnResolve", null);
+    _defineProperty(this, "isOnResolvedAllCalled", false);
+    _defineProperty(this, "processQueue", function () {
+      clearTimeout(_this.debounce);
+      _this.debounce = 0;
+      var _this$splitQueueAtLim = _this.splitQueueAtLimit(),
+        queue = _this$splitQueueAtLim.queue,
+        extraQueue = _this$splitQueueAtLim.extraQueue;
+      _this.nameQueue = extraQueue;
+      _this.processingQueue = mergeNameResolverQueues(_this.processingQueue, queue);
+      _this.client.lookupMentionNames(Array.from(queue.keys())).then(function (response) {
+        response.forEach(function (mentionDetail) {
+          var id = mentionDetail.id;
+          queue.delete(id);
+          _this.resolveQueueItem(mentionDetail);
+        });
+        queue.forEach(function (_callback, id) {
+          // No response from client for these ids treat as unknown
+          _this.resolveQueueItem({
+            id: id,
+            status: MentionNameStatus.UNKNOWN
+          });
+        });
+      }).catch(function () {
+        // Service completely failed, reject all items in the queue
+        queue.forEach(function (_callback, id) {
+          _this.resolveQueueItem({
+            id: id,
+            status: MentionNameStatus.SERVICE_ERROR
+          });
+        });
+      });
+
+      // Make sure anything left in the queue gets processed.
+      if (_this.nameQueue.size > 0) {
+        _this.scheduleProcessQueue();
+      } else {
+        _this.scheduleOnAllResolved();
+      }
+    });
+    this.client = client;
+    this.fireHydrationEvent = fireAnalyticsMentionHydrationEvent(analyticsProps);
+    // If provided, this will be called once all pending mentions in the queue are resolved.
+    // A sample usage is scrolling to a mention on page load, after the mentions have loadad.
+    this.onResolvedAll = onResolvedAll;
+  }
+  return _createClass(DefaultMentionNameResolver, [{
+    key: "lookupName",
+    value: function lookupName(id) {
+      var _this2 = this;
+      var name = this.nameCache.get(id);
+      if (name) {
+        this.fireAnalytics(true, name);
+        if (this.nameQueue.size === 0) {
+          this.scheduleOnAllResolved();
+        }
+        return name;
+      }
+      return new Promise(function (resolve) {
+        var processingItems = _this2.processingQueue.get(id);
+        if (processingItems) {
+          _this2.processingQueue.set(id, [].concat(_toConsumableArray(processingItems), [resolve]));
+        }
+        var queuedItems = _this2.nameQueue.get(id) || [];
+        _this2.nameQueue.set(id, [].concat(_toConsumableArray(queuedItems), [resolve]));
+        if (queuedItems.length === 0 && !processingItems) {
+          _this2.nameStartTime.set(id, Date.now());
+        }
+        _this2.scheduleProcessQueue();
+        if (_this2.isQueueAtLimit()) {
+          _this2.processQueue();
+        }
+      });
+    }
+  }, {
+    key: "cacheName",
+    value: function cacheName(id, name) {
+      this.nameCache.set(id, {
+        id: id,
+        name: name,
+        status: MentionNameStatus.OK
+      });
+    }
+  }, {
+    key: "scheduleProcessQueue",
+    value: function scheduleProcessQueue() {
+      if (!this.debounce) {
+        this.debounce = window.setTimeout(this.processQueue, DefaultMentionNameResolver.waitForBatch);
+      }
+    }
+  }, {
+    key: "scheduleOnAllResolved",
+    value: function scheduleOnAllResolved() {
+      var _this3 = this;
+      if (this.debounceOnResolve) {
+        clearTimeout(this.debounceOnResolve);
+      }
+      this.debounceOnResolve = window.setTimeout(function () {
+        if (_this3.isOnResolvedAllCalled) {
+          return;
+        }
+        _this3.onResolvedAll();
+        _this3.isOnResolvedAllCalled = true;
+      }, DefaultMentionNameResolver.waitForResolveAll);
+    }
+  }, {
+    key: "isQueueAtLimit",
+    value: function isQueueAtLimit() {
+      return this.nameQueue.size >= this.client.getLookupLimit();
+    }
+  }, {
+    key: "splitQueueAtLimit",
+    value: function splitQueueAtLimit() {
+      var values = Array.from(this.nameQueue.entries());
+      var splitPoint = this.client.getLookupLimit();
+      return {
+        queue: new Map(values.slice(0, splitPoint)),
+        extraQueue: new Map(values.slice(splitPoint))
+      };
+    }
+  }, {
+    key: "resolveQueueItem",
+    value: function resolveQueueItem(mentionDetail) {
+      var id = mentionDetail.id;
+      var resolvers = this.processingQueue.get(id);
+      if (resolvers) {
+        this.processingQueue.delete(id);
+        this.nameCache.set(id, mentionDetail);
+        resolvers.forEach(function (resolve) {
+          try {
+            resolve(mentionDetail);
+          } catch (_unused) {
+            // ignore - exception in consumer
+          }
+        });
+        this.fireAnalytics(false, mentionDetail);
+      }
+    }
+  }, {
+    key: "fireAnalytics",
+    value: function fireAnalytics(fromCache, mentionDetail) {
+      var id = mentionDetail.id;
+      var action = mentionDetail.status === MentionNameStatus.OK ? 'completed' : 'failed';
+      var start = this.nameStartTime.get(id);
+      var duration = start ? Date.now() - start : 0;
+      this.nameStartTime.delete(id);
+      this.fireHydrationEvent(action, id, fromCache, duration);
+    }
+  }]);
+}();
+_defineProperty(DefaultMentionNameResolver, "waitForBatch", 100);
+// ms
+_defineProperty(DefaultMentionNameResolver, "waitForResolveAll", 800);