@atlaskit/mention 27.17.1 → 27.18.1

package/CHANGELOG.md

@@ -1,5 +1,45 @@
 # @atlaskit/mention
 
+## 27.18.1
+
+### Patch Changes
+
+- Updated dependencies
+
+## 27.18.0
+
+### Minor Changes
+
+- [`febe6719dffd4`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/febe6719dffd4) -
+  Apply Volt multi-export standards via `volt-migrate-package`. `@atlaskit/mention` already resolved
+  its subpaths directly to `./src/*`, so the `exports` map is **unchanged** — all 24 public subpaths
+  keep their existing targets. What changed is the module layout: multi-export modules were split so
+  each shippable module owns a single export (for example `api/AbstractResource.ts`,
+  `api/DefaultMentionNameResolver.ts`, `api/HttpError.ts`, `is-special-mention.ts`,
+  `is-promise.ts`), with `@deprecated` compatibility re-exports left behind on the original module.
+
+  ### No public API was removed
+
+  Every symbol that moved is still exported from the subpath that previously exposed it, so existing
+  imports keep working:
+
+  ```ts
+  // Still valid — no change required, but deprecated
+  import { AbstractMentionResource } from '@atlaskit/mention/resource';
+  ```
+
+  A few subpaths now expose additional symbols as a result of the split:
+  - `./analytics` — `MENTION_ANALYTICS_PREFIX`, `packageName`, `packageVersion`
+  - `./mention-name-resolver` — the `Callback` and `Queue` types
+  - `./presence-resource` — `PresenceResource` as a named export alongside its default
+
+  ### Note for consumers that mock these modules
+
+  Internal cross-module imports now point at the split modules rather than the module that used to
+  declare everything. If your tests `jest.mock()` a `@atlaskit/mention` subpath to intercept a
+  symbol that mention itself consumes internally, the mock may no longer take effect — mock the
+  module that now owns the export instead.
+
 ## 27.17.1
 
 ### Patch Changes

package/dist/cjs/api/AbstractMentionResource.js

@@ -0,0 +1,111 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AbstractMentionResource = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _logger = _interopRequireDefault(require("../util/logger"));
+var _AbstractResource2 = require("./AbstractResource");
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(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; })(); }
+var MAX_NOTIFIED_ITEMS = 20;
+var AbstractMentionResource = exports.AbstractMentionResource = /*#__PURE__*/function (_AbstractResource) {
+  function AbstractMentionResource() {
+    (0, _classCallCheck2.default)(this, AbstractMentionResource);
+    return _callSuper(this, AbstractMentionResource, arguments);
+  }
+  (0, _inherits2.default)(AbstractMentionResource, _AbstractResource);
+  return (0, _createClass2.default)(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) {
+      (0, _logger.default)('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
+          (0, _logger.default)("error from listener '".concat(key, "', ignoring"), e);
+        }
+      });
+    }
+  }, {
+    key: "_notifyAllResultsListeners",
+    value: function _notifyAllResultsListeners(mentionsResult) {
+      (0, _logger.default)('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
+          (0, _logger.default)("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
+          (0, _logger.default)("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
+          (0, _logger.default)("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
+          (0, _logger.default)("error from listener '".concat(key, "', ignoring"), e);
+        }
+      });
+    }
+  }]);
+}(_AbstractResource2.AbstractResource);

package/dist/cjs/api/AbstractPresenceResource.js

@@ -0,0 +1,41 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AbstractPresenceResource = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var _possibleConstructorReturn2 = _interopRequireDefault(require("@babel/runtime/helpers/possibleConstructorReturn"));
+var _getPrototypeOf2 = _interopRequireDefault(require("@babel/runtime/helpers/getPrototypeOf"));
+var _inherits2 = _interopRequireDefault(require("@babel/runtime/helpers/inherits"));
+var _logger = _interopRequireDefault(require("../util/logger"));
+var _AbstractResource2 = require("./AbstractResource");
+function _callSuper(t, o, e) { return o = (0, _getPrototypeOf2.default)(o), (0, _possibleConstructorReturn2.default)(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], (0, _getPrototypeOf2.default)(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; })(); }
+var AbstractPresenceResource = exports.AbstractPresenceResource = /*#__PURE__*/function (_AbstractResource) {
+  function AbstractPresenceResource() {
+    (0, _classCallCheck2.default)(this, AbstractPresenceResource);
+    return _callSuper(this, AbstractPresenceResource, arguments);
+  }
+  (0, _inherits2.default)(AbstractPresenceResource, _AbstractResource);
+  return (0, _createClass2.default)(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
+          (0, _logger.default)("error from listener '".concat(key, "', ignoring"), e);
+        }
+      });
+    }
+  }]);
+}(_AbstractResource2.AbstractResource);

package/dist/cjs/api/AbstractResource.js

@@ -0,0 +1,48 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.AbstractResource = void 0;
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+var AbstractResource = exports.AbstractResource = /*#__PURE__*/function () {
+  function AbstractResource() {
+    (0, _classCallCheck2.default)(this, AbstractResource);
+    this.changeListeners = new Map();
+    this.allResultsListeners = new Map();
+    this.errListeners = new Map();
+    this.infoListeners = new Map();
+    this.analyticsListeners = new Map();
+  }
+  return (0, _createClass2.default)(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/cjs/api/Callback.js

@@ -0,0 +1,5 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});

package/dist/cjs/api/DefaultMentionNameResolver.js

@@ -0,0 +1,178 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DefaultMentionNameResolver = void 0;
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+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 _types = require("../types");
+var _fireAnalyticsMentionHydrationEvent = require("../util/fire-analytics-mention-hydration-event");
+var _mergeNameResolverQueues = require("./mergeNameResolverQueues");
+var DefaultMentionNameResolver = exports.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 () {};
+    (0, _classCallCheck2.default)(this, DefaultMentionNameResolver);
+    (0, _defineProperty2.default)(this, "nameCache", new Map());
+    (0, _defineProperty2.default)(this, "nameQueue", new Map());
+    (0, _defineProperty2.default)(this, "nameStartTime", new Map());
+    (0, _defineProperty2.default)(this, "processingQueue", new Map());
+    (0, _defineProperty2.default)(this, "debounce", 0);
+    (0, _defineProperty2.default)(this, "debounceOnResolve", null);
+    (0, _defineProperty2.default)(this, "isOnResolvedAllCalled", false);
+    (0, _defineProperty2.default)(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 = (0, _mergeNameResolverQueues.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: _types.MentionNameStatus.UNKNOWN
+          });
+        });
+      }).catch(function () {
+        // Service completely failed, reject all items in the queue
+        queue.forEach(function (_callback, id) {
+          _this.resolveQueueItem({
+            id: id,
+            status: _types.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 = (0, _fireAnalyticsMentionHydrationEvent.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 (0, _createClass2.default)(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((0, _toConsumableArray2.default)(processingItems), [resolve]));
+        }
+        var queuedItems = _this2.nameQueue.get(id) || [];
+        _this2.nameQueue.set(id, [].concat((0, _toConsumableArray2.default)(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: _types.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 === _types.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);
+    }
+  }]);
+}();
+(0, _defineProperty2.default)(DefaultMentionNameResolver, "waitForBatch", 100);
+// ms
+(0, _defineProperty2.default)(DefaultMentionNameResolver, "waitForResolveAll", 800);

package/dist/cjs/api/DefaultPresenceCache.js

@@ -0,0 +1,159 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DefaultPresenceCache = void 0;
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+var CacheEntry = /*#__PURE__*/function () {
+  function CacheEntry(pres, timeout) {
+    (0, _classCallCheck2.default)(this, CacheEntry);
+    this.presence = pres;
+    this.expiry = Date.now() + timeout;
+  }
+  return (0, _createClass2.default)(CacheEntry, [{
+    key: "expired",
+    value: function expired() {
+      return Date.now() > this.expiry;
+    }
+  }]);
+}();
+var DefaultPresenceCache = exports.DefaultPresenceCache = /*#__PURE__*/function () {
+  function DefaultPresenceCache(cacheTimeout, cacheTrigger) {
+    (0, _classCallCheck2.default)(this, DefaultPresenceCache);
+    this.expiryInMillis = cacheTimeout ? cacheTimeout : DefaultPresenceCache.defaultTimeout;
+    this.flushTrigger = cacheTrigger ? cacheTrigger : DefaultPresenceCache.defaultFlushTrigger;
+    this.cache = {};
+    this.size = 0;
+  }
+
+  /**
+   * Precondition: _delete is only called internally if userId exists in cache
+   * Removes cache entry
+   * @param userId
+   */
+  return (0, _createClass2.default)(DefaultPresenceCache, [{
+    key: "_delete",
+    value: function _delete(userId) {
+      delete this.cache[userId];
+      this.size--;
+    }
+
+    /**
+     * Checks a cache entry and calls delete if the info has expired
+     * @param userId
+     */
+  }, {
+    key: "_deleteIfExpired",
+    value: function _deleteIfExpired(userId) {
+      if (this.contains(userId) && this.cache[userId].expired()) {
+        this._delete(userId);
+      }
+    }
+
+    /**
+     * Cleans expired entries from cache
+     */
+  }, {
+    key: "_removeExpired",
+    value: function _removeExpired() {
+      var _this = this;
+      Object.keys(this.cache).forEach(function (id) {
+        _this._deleteIfExpired(id);
+      });
+    }
+
+    /**
+     * Checks if a user exists in the cache
+     * @param userId
+     */
+  }, {
+    key: "contains",
+    value: function contains(userId) {
+      return this.cache.hasOwnProperty(userId);
+    }
+
+    /**
+     * Retrieves a presence from the cache after checking for expired entries
+     * @param userId - to index the cache
+     * @returns Presence - the presence that matches the userId
+     */
+  }, {
+    key: "get",
+    value: function get(userId) {
+      this._deleteIfExpired(userId);
+      if (!this.contains(userId)) {
+        return {};
+      }
+      return this.cache[userId].presence;
+    }
+
+    /**
+     * Retrieve multiple presences at once from the cache
+     * @param userIds - to index the cache
+     * @returns PresenceMap - A map of userIds to cached Presences
+     */
+  }, {
+    key: "getBulk",
+    value: function getBulk(userIds) {
+      var presences = {};
+      var _iterator = _createForOfIteratorHelper(userIds),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _userId = _step.value;
+          if (this.contains(_userId)) {
+            presences[_userId] = this.get(_userId);
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return presences;
+    }
+
+    /**
+     * For a given list of ids, returns a subset
+     * of all the ids with missing cache entries.
+     * @param userIds - to index the cache
+     * @returns string[] - ids missing from the cache
+     */
+  }, {
+    key: "getMissingUserIds",
+    value: function getMissingUserIds(userIds) {
+      var _this2 = this;
+      return userIds.filter(function (id) {
+        return !_this2.contains(id);
+      });
+    }
+
+    /**
+     * Precondition: presMap only contains ids of users not in cache
+     *               expired users must first be removed then reinserted with updated presence
+     * Updates the cache by adding the new Presence entries and setting the expiry time
+     * @param presMap
+     */
+  }, {
+    key: "update",
+    value: function update(presMap) {
+      var _this3 = this;
+      if (this.size >= this.flushTrigger) {
+        this._removeExpired();
+      }
+      Object.keys(presMap).forEach(function (userId) {
+        _this3.cache[userId] = new CacheEntry(presMap[userId], _this3.expiryInMillis);
+        _this3.size++;
+      });
+    }
+  }]);
+}();
+(0, _defineProperty2.default)(DefaultPresenceCache, "defaultTimeout", 20000);
+(0, _defineProperty2.default)(DefaultPresenceCache, "defaultFlushTrigger", 50);

package/dist/cjs/api/DefaultPresenceParser.js

@@ -0,0 +1,91 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.DefaultPresenceParser = 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"));
+function _createForOfIteratorHelper(r, e) { var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"]; if (!t) { if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) { t && (r = t); var _n = 0, F = function F() {}; return { s: F, n: function n() { return _n >= r.length ? { done: !0 } : { done: !1, value: r[_n++] }; }, e: function e(r) { throw r; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var o, a = !0, u = !1; return { s: function s() { t = t.call(r); }, n: function n() { var r = t.next(); return a = r.done, r; }, e: function e(r) { u = !0, o = r; }, f: function f() { try { a || null == t.return || t.return(); } finally { if (u) throw o; } } }; }
+function _unsupportedIterableToArray(r, a) { if (r) { if ("string" == typeof r) return _arrayLikeToArray(r, a); var t = {}.toString.call(r).slice(8, -1); return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0; } }
+function _arrayLikeToArray(r, a) { (null == a || a > r.length) && (a = r.length); for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e]; return n; }
+var DefaultPresenceParser = exports.DefaultPresenceParser = /*#__PURE__*/function () {
+  function DefaultPresenceParser() {
+    (0, _classCallCheck2.default)(this, DefaultPresenceParser);
+  }
+  return (0, _createClass2.default)(DefaultPresenceParser, [{
+    key: "mapState",
+    value: function mapState(state) {
+      if (state === 'unavailable') {
+        return 'offline';
+      } else if (state === 'available') {
+        return 'online';
+      } else {
+        return state;
+      }
+    }
+  }, {
+    key: "parse",
+    value: function parse(response) {
+      var presences = {};
+      if (response.hasOwnProperty('data') && response['data'].hasOwnProperty('PresenceBulk')) {
+        var results = response['data'].PresenceBulk;
+        // Store map of state and time indexed by userId.  Ignore null results.
+        var _iterator = _createForOfIteratorHelper(results),
+          _step;
+        try {
+          for (_iterator.s(); !(_step = _iterator.n()).done;) {
+            var user = _step.value;
+            if (user.userId && user.state) {
+              var state = DefaultPresenceParser.extractState(user) || user.state;
+              presences[user.userId] = {
+                status: this.mapState(state)
+              };
+            } else if (!user.hasOwnProperty('userId') || !user.hasOwnProperty('state')) {
+              // eslint-disable-next-line no-console
+              console.error('Unexpected response from presence service contains keys: ' + Object.keys(user));
+            }
+          }
+        } catch (err) {
+          _iterator.e(err);
+        } finally {
+          _iterator.f();
+        }
+      }
+      return presences;
+    }
+  }], [{
+    key: "extractState",
+    value: function extractState(presence) {
+      if (DefaultPresenceParser.isFocusState(presence)) {
+        return DefaultPresenceParser.FOCUS_STATE;
+      }
+      return presence.state;
+    }
+
+    /*
+       This is a bit of an odd exception. In the case where a user is in "Focus Mode", their presence state
+       is returned as 'busy' along with a `stateMetadata` object containing a `focus` field.
+       In this case we ignore the value of the `state` field and treat the presence as a 'focus' state.
+      */
+  }, {
+    key: "isFocusState",
+    value: function isFocusState(presence) {
+      if (presence.stateMetadata) {
+        try {
+          var metadata = JSON.parse(presence.stateMetadata);
+          return metadata && !!metadata.focus;
+        } catch (e) {
+          // eslint-disable-next-line no-console
+          console.error("Failed to parse presence's stateMetadata for user with id ".concat(presence.userId, ": ").concat(presence.stateMetadata));
+          // eslint-disable-next-line no-console
+          console.error(e);
+        }
+      }
+      return false;
+    }
+  }]);
+}();
+(0, _defineProperty2.default)(DefaultPresenceParser, "FOCUS_STATE", 'focus');