@atlaskit/mention 27.17.1 → 27.18.1

package/dist/es2019/api/DefaultPresenceCache.js

@@ -0,0 +1,111 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+class CacheEntry {
+  constructor(pres, timeout) {
+    this.presence = pres;
+    this.expiry = Date.now() + timeout;
+  }
+  expired() {
+    return Date.now() > this.expiry;
+  }
+}
+export class DefaultPresenceCache {
+  constructor(cacheTimeout, cacheTrigger) {
+    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
+   */
+  _delete(userId) {
+    delete this.cache[userId];
+    this.size--;
+  }
+
+  /**
+   * Checks a cache entry and calls delete if the info has expired
+   * @param userId
+   */
+  _deleteIfExpired(userId) {
+    if (this.contains(userId) && this.cache[userId].expired()) {
+      this._delete(userId);
+    }
+  }
+
+  /**
+   * Cleans expired entries from cache
+   */
+  _removeExpired() {
+    Object.keys(this.cache).forEach(id => {
+      this._deleteIfExpired(id);
+    });
+  }
+
+  /**
+   * Checks if a user exists in the cache
+   * @param userId
+   */
+  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
+   */
+  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
+   */
+  getBulk(userIds) {
+    const presences = {};
+    for (const userId of userIds) {
+      if (this.contains(userId)) {
+        presences[userId] = this.get(userId);
+      }
+    }
+    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
+   */
+  getMissingUserIds(userIds) {
+    return userIds.filter(id => !this.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
+   */
+  update(presMap) {
+    if (this.size >= this.flushTrigger) {
+      this._removeExpired();
+    }
+    Object.keys(presMap).forEach(userId => {
+      this.cache[userId] = new CacheEntry(presMap[userId], this.expiryInMillis);
+      this.size++;
+    });
+  }
+}
+_defineProperty(DefaultPresenceCache, "defaultTimeout", 20000);
+_defineProperty(DefaultPresenceCache, "defaultFlushTrigger", 50);

package/dist/es2019/api/DefaultPresenceParser.js

@@ -0,0 +1,58 @@
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+export class DefaultPresenceParser {
+  mapState(state) {
+    if (state === 'unavailable') {
+      return 'offline';
+    } else if (state === 'available') {
+      return 'online';
+    } else {
+      return state;
+    }
+  }
+  parse(response) {
+    const presences = {};
+    if (response.hasOwnProperty('data') && response['data'].hasOwnProperty('PresenceBulk')) {
+      const results = response['data'].PresenceBulk;
+      // Store map of state and time indexed by userId.  Ignore null results.
+      for (const user of results) {
+        if (user.userId && user.state) {
+          const 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));
+        }
+      }
+    }
+    return presences;
+  }
+  static 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.
+    */
+  static isFocusState(presence) {
+    if (presence.stateMetadata) {
+      try {
+        const 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 ${presence.userId}: ${presence.stateMetadata}`);
+        // eslint-disable-next-line no-console
+        console.error(e);
+      }
+    }
+    return false;
+  }
+}
+_defineProperty(DefaultPresenceParser, "FOCUS_STATE", 'focus');

package/dist/es2019/api/HttpError.js

@@ -0,0 +1,8 @@
+export class HttpError {
+  constructor(statusCode, statusMessage) {
+    this.statusCode = statusCode;
+    this.message = statusMessage;
+    this.name = 'HttpError';
+    this.stack = new Error().stack;
+  }
+}

package/dist/es2019/api/MentionNameResolver.js

@@ -1,180 +1,17 @@
-import _defineProperty from "@babel/runtime/helpers/defineProperty";
-import { MentionNameStatus } from '../types';
-import { fireAnalyticsMentionHydrationEvent } from '../util/analytics';
-
-/** A queue for user ids */
-
-export class DefaultMentionNameResolver {
-  constructor(client, analyticsProps = {}, onResolvedAll = () => {}) {
-    _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", () => {
-      clearTimeout(this.debounce);
-      this.debounce = 0;
-      const {
-        queue,
-        extraQueue
-      } = this.splitQueueAtLimit();
-      this.nameQueue = extraQueue;
-      this.processingQueue = mergeNameResolverQueues(this.processingQueue, queue);
-      this.client.lookupMentionNames(Array.from(queue.keys())).then(response => {
-        response.forEach(mentionDetail => {
-          const {
-            id
-          } = mentionDetail;
-          queue.delete(id);
-          this.resolveQueueItem(mentionDetail);
-        });
-        queue.forEach((_callback, id) => {
-          // No response from client for these ids treat as unknown
-          this.resolveQueueItem({
-            id,
-            status: MentionNameStatus.UNKNOWN
-          });
-        });
-      }).catch(() => {
-        // Service completely failed, reject all items in the queue
-        queue.forEach((_callback, id) => {
-          this.resolveQueueItem({
-            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;
-  }
-  lookupName(id) {
-    const name = this.nameCache.get(id);
-    if (name) {
-      this.fireAnalytics(true, name);
-      if (this.nameQueue.size === 0) {
-        this.scheduleOnAllResolved();
-      }
-      return name;
-    }
-    return new Promise(resolve => {
-      const processingItems = this.processingQueue.get(id);
-      if (processingItems) {
-        this.processingQueue.set(id, [...processingItems, resolve]);
-      }
-      const queuedItems = this.nameQueue.get(id) || [];
-      this.nameQueue.set(id, [...queuedItems, resolve]);
-      if (queuedItems.length === 0 && !processingItems) {
-        this.nameStartTime.set(id, Date.now());
-      }
-      this.scheduleProcessQueue();
-      if (this.isQueueAtLimit()) {
-        this.processQueue();
-      }
-    });
-  }
-  cacheName(id, name) {
-    this.nameCache.set(id, {
-      id,
-      name,
-      status: MentionNameStatus.OK
-    });
-  }
-  scheduleProcessQueue() {
-    if (!this.debounce) {
-      this.debounce = window.setTimeout(this.processQueue, DefaultMentionNameResolver.waitForBatch);
-    }
-  }
-  scheduleOnAllResolved() {
-    if (this.debounceOnResolve) {
-      clearTimeout(this.debounceOnResolve);
-    }
-    this.debounceOnResolve = window.setTimeout(() => {
-      if (this.isOnResolvedAllCalled) {
-        return;
-      }
-      this.onResolvedAll();
-      this.isOnResolvedAllCalled = true;
-    }, DefaultMentionNameResolver.waitForResolveAll);
-  }
-  isQueueAtLimit() {
-    return this.nameQueue.size >= this.client.getLookupLimit();
-  }
-  splitQueueAtLimit() {
-    const values = Array.from(this.nameQueue.entries());
-    const splitPoint = this.client.getLookupLimit();
-    return {
-      queue: new Map(values.slice(0, splitPoint)),
-      extraQueue: new Map(values.slice(splitPoint))
-    };
-  }
-  resolveQueueItem(mentionDetail) {
-    const {
-      id
-    } = mentionDetail;
-    const resolvers = this.processingQueue.get(id);
-    if (resolvers) {
-      this.processingQueue.delete(id);
-      this.nameCache.set(id, mentionDetail);
-      resolvers.forEach(resolve => {
-        try {
-          resolve(mentionDetail);
-        } catch {
-          // ignore - exception in consumer
-        }
-      });
-      this.fireAnalytics(false, mentionDetail);
-    }
-  }
-  fireAnalytics(fromCache, mentionDetail) {
-    const {
-      id
-    } = mentionDetail;
-    const action = mentionDetail.status === MentionNameStatus.OK ? 'completed' : 'failed';
-    const start = this.nameStartTime.get(id);
-    const duration = start ? Date.now() - start : 0;
-    this.nameStartTime.delete(id);
-    this.fireHydrationEvent(action, id, fromCache, duration);
-  }
-}
+/* eslint-disable @repo/internal/deprecations/deprecation-ticket-required -- VOLTC-139 tracks removal of these deprecated re-export shims. */
 
 /**
- * Merge the two queues making sure to merge callback arrays for items in queueB already in queueA.
- * This addresses [this ticket](https://product-fabric.atlassian.net/browse/QS-3789).
+ * @deprecated Use `import { DefaultMentionNameResolver } from '@atlaskit/mention/mention-name-resolver'` instead.
+ */
+export { DefaultMentionNameResolver } from './DefaultMentionNameResolver';
+/**
+ * @deprecated Use `import { mergeNameResolverQueues } from '@atlaskit/mention/mention-name-resolver'` instead.
+ */
+export { mergeNameResolverQueues } from './mergeNameResolverQueues';
+/**
+ * @deprecated Use `import { Callback } from '@atlaskit/mention/mention-name-resolver'` instead.
  */
-_defineProperty(DefaultMentionNameResolver, "waitForBatch", 100);
-// ms
-_defineProperty(DefaultMentionNameResolver, "waitForResolveAll", 800);
-export function mergeNameResolverQueues(queueA, queueB) {
-  const queueBeingMerged = new Map([...queueA]);
 
-  // now add the items from the second queue that are not already in the
-  //  merged queue being built
-  [...queueB].forEach(item => {
-    const [key, queueBCallbacks] = item;
-    const itemAlreadyInMergedQueue = queueBeingMerged.has(key);
-    if (!itemAlreadyInMergedQueue) {
-      queueBeingMerged.set(key, queueBCallbacks);
-    } else {
-      var _queueBeingMerged$get;
-      // item already in merged queue, merge the callback arrays
-      const queueACallbacks = (_queueBeingMerged$get = queueBeingMerged.get(key)) !== null && _queueBeingMerged$get !== void 0 ? _queueBeingMerged$get : [];
-      const mergedCallbacks = new Set([...queueBCallbacks, ...queueACallbacks]);
-      const deduplicatedCallbacks = Array.from(mergedCallbacks.values()); // prevents calling them twice
-      queueBeingMerged.set(key, deduplicatedCallbacks);
-    }
-  });
-  return queueBeingMerged;
-}
+/**
+ * @deprecated Use `import { Queue } from '@atlaskit/mention/mention-name-resolver'` instead.
+ */

package/dist/es2019/api/MentionResource.js

@@ -1,13 +1,13 @@
+/* eslint-disable @repo/internal/deprecations/deprecation-ticket-required -- VOLTC-139 tracks removal of these deprecated re-export shims. */
+import debounce from 'lodash/debounce';
 import { utils as serviceUtils } from '@atlaskit/util-service-support';
-import { isAppMention, isTeamMention, MentionNameStatus, SliNames, Actions } from '../types';
+import { isAppMention } from '../is-app-mention';
+import { isTeamMention } from '../is-team-mention';
+import { MentionNameStatus, SliNames, Actions } from '../types';
+import { SLI_EVENT_TYPE } from '../util/analytics';
 import debug from '../util/logger';
+import { AbstractMentionResource } from './AbstractMentionResource';
 const MAX_QUERY_ITEMS = 100;
-const MAX_NOTIFIED_ITEMS = 20;
-// Re-exporting types to prevent breaking change
-// Re-exporting types to prevent breaking change
-
-import { SLI_EVENT_TYPE } from '../util/analytics';
-import debounce from 'lodash/debounce';
 
 /**
  * Configuration for the TeamMentionResource, which extends {@link MentionResourceConfig}
@@ -27,110 +27,6 @@ const emptySecurityProvider = () => {
     headers: {}
   };
 };
-class AbstractResource {
-  constructor() {
-    this.changeListeners = new Map();
-    this.allResultsListeners = new Map();
-    this.errListeners = new Map();
-    this.infoListeners = new Map();
-    this.analyticsListeners = new Map();
-  }
-  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);
-    }
-  }
-  unsubscribe(key) {
-    this.changeListeners.delete(key);
-    this.errListeners.delete(key);
-    this.infoListeners.delete(key);
-    this.allResultsListeners.delete(key);
-    this.analyticsListeners.delete(key);
-  }
-}
-class AbstractMentionResource extends AbstractResource {
-  shouldHighlightMention(_mention) {
-    return false;
-  }
-
-  // eslint-disable-next-line class-methods-use-this
-  filter(query) {
-    throw new Error(`not yet implemented.\nParams: query=${query}`);
-  }
-
-  // eslint-disable-next-line class-methods-use-this, no-unused-vars
-  recordMentionSelection(_mention) {
-    // Do nothing
-  }
-  isFiltering(_query) {
-    return false;
-  }
-  _notifyListeners(mentionsResult, stats) {
-    debug('ak-mention-resource._notifyListeners', mentionsResult && mentionsResult.mentions && mentionsResult.mentions.length, this.changeListeners);
-    this.changeListeners.forEach((listener, key) => {
-      try {
-        listener(mentionsResult.mentions.slice(0, MAX_NOTIFIED_ITEMS), mentionsResult.query, stats);
-      } catch (e) {
-        // ignore error from listener
-        debug(`error from listener '${key}', ignoring`, e);
-      }
-    });
-  }
-  _notifyAllResultsListeners(mentionsResult) {
-    debug('ak-mention-resource._notifyAllResultsListeners', mentionsResult && mentionsResult.mentions && mentionsResult.mentions.length, this.changeListeners);
-    this.allResultsListeners.forEach((listener, key) => {
-      try {
-        listener(mentionsResult.mentions.slice(0, MAX_NOTIFIED_ITEMS), mentionsResult.query);
-      } catch (e) {
-        // ignore error from listener
-        debug(`error from listener '${key}', ignoring`, e);
-      }
-    });
-  }
-  _notifyErrorListeners(error, query) {
-    this.errListeners.forEach((listener, key) => {
-      try {
-        listener(error, query);
-      } catch (e) {
-        // ignore error from listener
-        debug(`error from listener '${key}', ignoring`, e);
-      }
-    });
-  }
-  _notifyInfoListeners(info) {
-    this.infoListeners.forEach((listener, key) => {
-      try {
-        listener(info);
-      } catch (e) {
-        // ignore error fromr listener
-        debug(`error from listener '${key}', ignoring`, e);
-      }
-    });
-  }
-  _notifyAnalyticsListeners(event, actionSubject, action, attributes) {
-    this.analyticsListeners.forEach((listener, key) => {
-      try {
-        listener(event, actionSubject, action, attributes);
-      } catch (e) {
-        // ignore error from listener
-        debug(`error from listener '${key}', ignoring`, e);
-      }
-    });
-  }
-}
-
 /**
  * Provides a Javascript API
  */
@@ -342,14 +238,24 @@ export class MentionResource extends AbstractMentionResource {
     };
   }
 }
-export class HttpError {
-  constructor(statusCode, statusMessage) {
-    this.statusCode = statusCode;
-    this.message = statusMessage;
-    this.name = 'HttpError';
-    this.stack = new Error().stack;
-  }
-}
-export const isResolvingMentionProvider = p => !!(p && p.supportsMentionNameResolving && p.supportsMentionNameResolving());
-export { AbstractResource, AbstractMentionResource };
-export default MentionResource;
+export default MentionResource;
+
+/**
+ * @deprecated Use `import { HttpError } from '@atlaskit/mention/mention-resource'` instead.
+ */
+export { HttpError } from './HttpError';
+
+/**
+ * @deprecated Use `import { isResolvingMentionProvider } from '@atlaskit/mention/mention-resource'` instead.
+ */
+export { isResolvingMentionProvider } from './isResolvingMentionProvider';
+
+/**
+ * @deprecated Use `import { AbstractResource } from '@atlaskit/mention/mention-resource'` instead.
+ */
+export { AbstractResource } from './AbstractResource';
+
+/**
+ * @deprecated Use `import { AbstractMentionResource } from '@atlaskit/mention/mention-resource'` instead.
+ */
+export { AbstractMentionResource } from './AbstractMentionResource';