@webex/internal-plugin-conversation 3.0.0-beta.8 → 3.0.0-bnr.0

package/dist/types/config.d.ts

@@ -0,0 +1,19 @@
+declare namespace _default {
+    namespace conversation {
+        const allowedInboundTags: {
+            'webex-mention': string[];
+        };
+        const allowedOutboundTags: {
+            'webex-mention': string[];
+        };
+        function inboundProcessFunc(): void;
+        function outboundProcessFunc(): void;
+        const allowedInboundStyles: any[];
+        const allowedOutboundStyles: any[];
+        const thumbnailMaxHeight: number;
+        const thumbnailMaxWidth: number;
+        const keepEncryptedProperties: boolean;
+        const decryptionFailureMessage: string;
+    }
+}
+export default _default;

package/dist/types/constants.d.ts

@@ -0,0 +1,5 @@
+export const KEY_ROTATION_REQUIRED: 1400087;
+export const KEY_ALREADY_ROTATED: 1409004;
+export const ENCRYPTION_KEY_URL_MISMATCH: 1400049;
+export const DEFAULT_CLUSTER: "urn:TEAM:us-east-2_a";
+export const DEFAULT_CLUSTER_SERVICE: "identityLookup";

package/dist/types/conversation.d.ts

@@ -0,0 +1,2 @@
+export default Conversation;
+declare const Conversation: any;

package/dist/types/convo-error.d.ts

@@ -0,0 +1,10 @@
+/**
+ * General conversation error
+ */
+export class ConversationError {
+}
+/**
+ * InvalidUserCreation thrown when failed to create conversation with invalid user
+ */
+export class InvalidUserCreation extends ConversationError {
+}

package/dist/types/decryption-transforms.d.ts

@@ -0,0 +1 @@
+export const transforms: any[];

package/dist/types/encryption-transforms.d.ts

@@ -0,0 +1 @@
+export const transforms: any[];

package/dist/types/index.d.ts

@@ -0,0 +1,3 @@
+export { default } from "./conversation";
+export { default as ShareActivity } from "./share-activity";
+export { ConversationError, InvalidUserCreation } from "./convo-error";

package/dist/types/share-activity.d.ts

@@ -0,0 +1,7 @@
+export const EMITTER_SYMBOL: unique symbol;
+export const FILE_SYMBOL: unique symbol;
+export default ShareActivity;
+/**
+ * @class
+ */
+declare const ShareActivity: any;

package/dist/types/to-array.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Helper to convert objects into arrays of transforms. probably belongs in
+ * webex-core
+ * @param {string} direction "inbound"|"outbound"
+ * @param {Object} obj
+ * @private
+ * @returns {Array}
+ */
+export default function toArray(direction: string, obj: any): any[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@webex/internal-plugin-conversation",
-  "version": "3.0.0-beta.8",
+  "version": "3.0.0-bnr.0",
   "description": "",
   "license": "MIT",
   "main": "dist/index.js",
@@ -20,26 +20,26 @@
     ]
   },
   "dependencies": {
-    "@webex/common": "3.0.0-beta.8",
-    "@webex/helper-html": "3.0.0-beta.8",
-    "@webex/helper-image": "3.0.0-beta.8",
-    "@webex/internal-plugin-conversation": "3.0.0-beta.8",
-    "@webex/internal-plugin-encryption": "3.0.0-beta.8",
-    "@webex/internal-plugin-user": "3.0.0-beta.8",
-    "@webex/webex-core": "3.0.0-beta.8",
+    "@webex/common": "3.0.0-bnr.0",
+    "@webex/helper-html": "3.0.0-bnr.0",
+    "@webex/helper-image": "3.0.0-bnr.0",
+    "@webex/internal-plugin-conversation": "3.0.0-bnr.0",
+    "@webex/internal-plugin-encryption": "3.0.0-bnr.0",
+    "@webex/internal-plugin-user": "3.0.0-bnr.0",
+    "@webex/webex-core": "3.0.0-bnr.0",
     "crypto-js": "^4.1.1",
     "lodash": "^4.17.21",
     "node-scr": "^0.3.0",
     "uuid": "^3.3.2"
   },
   "devDependencies": {
-    "@webex/test-helper-chai": "3.0.0-beta.8",
-    "@webex/test-helper-file": "3.0.0-beta.8",
-    "@webex/test-helper-make-local-url": "3.0.0-beta.8",
-    "@webex/test-helper-mocha": "3.0.0-beta.8",
-    "@webex/test-helper-mock-webex": "3.0.0-beta.8",
-    "@webex/test-helper-retry": "3.0.0-beta.8",
-    "@webex/test-helper-test-users": "3.0.0-beta.8",
+    "@webex/test-helper-chai": "3.0.0-bnr.0",
+    "@webex/test-helper-file": "3.0.0-bnr.0",
+    "@webex/test-helper-make-local-url": "3.0.0-bnr.0",
+    "@webex/test-helper-mocha": "3.0.0-bnr.0",
+    "@webex/test-helper-mock-webex": "3.0.0-bnr.0",
+    "@webex/test-helper-retry": "3.0.0-bnr.0",
+    "@webex/test-helper-test-users": "3.0.0-bnr.0",
     "sinon": "^9.2.4"
   }
 }

package/src/activities.js

@@ -14,7 +14,7 @@ export const ACTIVITY_TYPES = {
   CREATE: 'CREATE',
   TOMBSTONE: 'TOMBSTONE',
   DELETE: 'DELETE',
-  REPLY_EDIT: 'REPLY_EDIT'
+  REPLY_EDIT: 'REPLY_EDIT',
 };
 
 const REPLY = 'reply';
@@ -59,9 +59,11 @@ export const getPublishedDate = (activity = {}) => new Date(activity.published).
  * @param {Object} activity2
  * @returns {boolean} true if first activity is newer than second
  */
-export const isNewer = (activity1, activity2) => getPublishedDate(activity1) > getPublishedDate(activity2);
+export const isNewer = (activity1, activity2) =>
+  getPublishedDate(activity1) > getPublishedDate(activity2);
 
-export const sortActivitiesByPublishedDate = (activities) => sortBy(activities, (activity) => getPublishedDate(activity));
+export const sortActivitiesByPublishedDate = (activities) =>
+  sortBy(activities, (activity) => getPublishedDate(activity));
 
 export const getParentId = (activity) => activity?.parent?.id;
 
@@ -83,7 +85,8 @@ export const sanitizeActivity = (activity) => {
   return final;
 };
 
-export const getIsActivityOrphaned = (activity, activities) => activity.parent && activity.parent.id && !activities[activity.parent.id];
+export const getIsActivityOrphaned = (activity, activities) =>
+  activity.parent && activity.parent.id && !activities[activity.parent.id];
 
 const getIsReplyEditActivity = (activity, activities) => {
   const parentId = activity.parent.id;
@@ -111,7 +114,7 @@ export const createRootActivity = (activity) => activity;
 export const createReplyActivity = (activity) => {
   const replyAct = {
     ...activity,
-    replyParent: activity.parent
+    replyParent: activity.parent,
   };
 
   return replyAct;
@@ -128,7 +131,7 @@ export const createEditActivity = (editActivity, activities) => {
     parent: editActParentObj,
     editParent: editActParentObj,
     object: editActivity.object,
-    published: editActivity.published
+    published: editActivity.published,
   };
 
   return joinedEditAct;
@@ -147,7 +150,7 @@ export const createReplyEditActivity = (editActivity, activities) => {
     editParent: editActParentObj,
     replyParent: parentReplyAct.parent,
     object: editActivity.object,
-    published: editActivity.published
+    published: editActivity.published,
   };
 
   return joinedReplyEditActivity;

package/src/activity-thread-ordering.js

@@ -9,7 +9,7 @@ import {
   NEWER,
   OLDER,
   INITIAL,
-  MID
+  MID,
 } from './activities';
 
 export const defaultMinDisplayableActivities = 20;
@@ -32,7 +32,8 @@ export const setValue = (destination, key, value) => destination.set(key, value)
  */
 export const getValue = (source, key) => source.get(key);
 
-export const getActivityObjectsFromMap = (hashMap) => Array.from(hashMap).map(([, activity]) => activity);
+export const getActivityObjectsFromMap = (hashMap) =>
+  Array.from(hashMap).map(([, activity]) => activity);
 /**
  * creates maps for various activity types and defines handlers for working with stored activities
  * utilizes revealing module pattern to close over state and only expose certain necessary functions for altering state
@@ -53,8 +54,7 @@ export const activityManager = () => {
 
     if (existingReplyHash) {
       setValue(existingReplyHash, replyAct.id, replyAct);
-    }
-    else {
+    } else {
       const replyHash = new Map();
 
       setValue(replyHash, replyAct.id, replyAct);
@@ -98,23 +98,25 @@ export const activityManager = () => {
     reactionHelper(reactionSelfAct, reactionSelfActivityHash);
   };
 
-  const getActivityHandlerByKey = (key) => ({
-    [ACTIVITY_TYPES.REACTION]: handleNewReaction,
-    [ACTIVITY_TYPES.REACTION_SELF]: handleNewReactionSelf,
-    [ACTIVITY_TYPES.EDIT]: handleNewEdit,
-    [ACTIVITY_TYPES.REPLY]: handleNewReply
-  }[key]);
-
-  const getActivityByTypeAndParentId = (type, id) => ({
-    [ACTIVITY_TYPES.EDIT]: getValue(editActivityHash, id),
-    [ACTIVITY_TYPES.REPLY]: getValue(replyActivityHash, id),
-    [ACTIVITY_TYPES.REACTION]: getValue(reactionActivityHash, id),
-    [ACTIVITY_TYPES.REACTION_SELF]: getValue(reactionSelfActivityHash, id)
-  }[type]);
+  const getActivityHandlerByKey = (key) =>
+    ({
+      [ACTIVITY_TYPES.REACTION]: handleNewReaction,
+      [ACTIVITY_TYPES.REACTION_SELF]: handleNewReactionSelf,
+      [ACTIVITY_TYPES.EDIT]: handleNewEdit,
+      [ACTIVITY_TYPES.REPLY]: handleNewReply,
+    }[key]);
+
+  const getActivityByTypeAndParentId = (type, id) =>
+    ({
+      [ACTIVITY_TYPES.EDIT]: getValue(editActivityHash, id),
+      [ACTIVITY_TYPES.REPLY]: getValue(replyActivityHash, id),
+      [ACTIVITY_TYPES.REACTION]: getValue(reactionActivityHash, id),
+      [ACTIVITY_TYPES.REACTION_SELF]: getValue(reactionSelfActivityHash, id),
+    }[type]);
 
   return {
     getActivityHandlerByKey,
-    getActivityByTypeAndParentId
+    getActivityByTypeAndParentId,
   };
 };
 
@@ -133,8 +135,7 @@ export const bookendManager = () => {
   const setOldestAct = (act) => {
     if (!oldestAct) {
       oldestAct = act;
-    }
-    else if (isNewer(oldestAct, act)) {
+    } else if (isNewer(oldestAct, act)) {
       oldestAct = act;
     }
   };
@@ -142,8 +143,7 @@ export const bookendManager = () => {
   const setNewestAct = (act) => {
     if (!newestAct) {
       newestAct = act;
-    }
-    else if (isNewer(act, newestAct)) {
+    } else if (isNewer(act, newestAct)) {
       newestAct = act;
     }
   };
@@ -161,7 +161,7 @@ export const bookendManager = () => {
   return {
     setBookends,
     getNewestAct,
-    getOldestAct
+    getOldestAct,
   };
 };
 
@@ -204,7 +204,7 @@ export const noMoreActivitiesManager = () => {
     getNoMoreActs,
     checkAndSetNoMoreActs,
     checkAndSetNoNewerActs,
-    checkAndSetNoOlderActs
+    checkAndSetNoOlderActs,
   };
 };
 
@@ -223,7 +223,7 @@ export const rootActivityManager = () => {
 
   return {
     addNewRoot,
-    getRootActivityHash
+    getRootActivityHash,
   };
 };
 
@@ -249,9 +249,7 @@ export const getLoopCounterFailsafe = () => {
  * @returns {object}
  */
 export const getQuery = (type, queryOptions) => {
-  const {
-    newestPublishedDate, oldestPublishedDate, batchSize, activityToSearch = {}
-  } = queryOptions;
+  const {newestPublishedDate, oldestPublishedDate, batchSize, activityToSearch = {}} = queryOptions;
 
   switch (type) {
     case NEWER: {
@@ -266,8 +264,7 @@ export const getQuery = (type, queryOptions) => {
 
       if (searchType === ACTIVITY_TYPES.REPLY || searchType === ACTIVITY_TYPES.EDIT) {
         midDate = activityToSearch.parent.published;
-      }
-      else {
+      } else {
         midDate = activityToSearch.published;
       }
 

package/src/activity-threading.md

@@ -3,22 +3,24 @@
 Activity thread ordering (or "threading") is the act of flattening the hierarchical relationship of thread parents and thread replies.
 
 ## Why Thread Order?
+
 When a client fetches activities from conversation service, convo returns chronologically ordered activities (by published date). If you are a client that attempts to display activities to a user, this is mostly useless. An example:
 
 Client: hey convo, give me 10 activities
 
 Convo: here.
-  1. reaction
-  2. root
-  3. reaction
-  4. reply
-  5. edit
-  6. edit
-  7. reply
-  8. reaction
-  9. meeting
-  10. reply
-  
+
+1. reaction
+2. root
+3. reaction
+4. reply
+5. edit
+6. edit
+7. reply
+8. reaction
+9. meeting
+10. reply
+
 Client: ...
 
 Convo: ...
@@ -28,17 +30,18 @@ By contrast, thread ordering returns activities in _thread order_, otherwise kno
 Client: hey convo, give me 10 activities in thread order
 
 Convo: here.
-  1. root 4
-  2. reply to root 4
-  3. reply to root 4
-  4. root 3
-  5. reply to root 3
-  6. reply to root 3
-  7. root 2
-  8. reply to root 2
-  9. reply to root 2
-  10. root 1 (newest root activity)
-  
+
+1. root 4
+2. reply to root 4
+3. reply to root 4
+4. root 3
+5. reply to root 3
+6. reply to root 3
+7. root 2
+8. reply to root 2
+9. reply to root 2
+10. root 1 (newest root activity)
+
 Client: 👍
 
 Convo: 👍
@@ -57,6 +60,7 @@ As you can see, thread ordering is useful, and as you may _not_ see, it is diffi
 # The Code
 
 Thread ordering methods live in the internal converation plugin
+
 ```
 webex.internal.conversation[*]
 ```
@@ -64,36 +68,39 @@ webex.internal.conversation[*]
 There are two methods that compose thread ordering, a public and private method. The public method is simply a facade of the private method, abstracting the complex away from the caller.
 
 ### `_listActivitiesThreadOrdered(options)` (private)
+
 The `_listActivitiesThreadOrdered` method is a stateful async generator function that fetches thread ordered activities.
 
 #### Description
-The `_listActivitiesThreadOrdered` method instantiates a generator function that yields a promise. It yields results in an infinite loop for the life of the generator (until the instance is no longer referenced and JS garbage collects). This means when the method yields a result it pauses execution until its next invocation, freezing its current state to be used by the next invocation. The generator instance internally tracks the oldest and newest activities it has fetched, using them as the timestamps to query the next set of results in either direction, thus the caller is not required to maintain any state to fetch older and newer activities. This method does not cache all fetched activities, therefore the caller is still required to store their fetched activities or be forced to refetch them. 
+
+The `_listActivitiesThreadOrdered` method instantiates a generator function that yields a promise. It yields results in an infinite loop for the life of the generator (until the instance is no longer referenced and JS garbage collects). This means when the method yields a result it pauses execution until its next invocation, freezing its current state to be used by the next invocation. The generator instance internally tracks the oldest and newest activities it has fetched, using them as the timestamps to query the next set of results in either direction, thus the caller is not required to maintain any state to fetch older and newer activities. This method does not cache all fetched activities, therefore the caller is still required to store their fetched activities or be forced to refetch them.
 
 The generator's returned `next` method accepts arguments as well, which allows the caller to change the direction of their querying from newer messages to older ones without creating a new generator instance. `next`
 
 #### Parameters
+
 _generator initialization options_
 
 options
 
-  options.url: the conversation's convo URL
+options.url: the conversation's convo URL
 
-  options.minActivities: the minimum number of activities you would like in your batch
+options.minActivities: the minimum number of activities you would like in your batch
 
-  options.queryType: the direction to fetch activities. One of 'newer', 'older', 'mid'
+options.queryType: the direction to fetch activities. One of 'newer', 'older', 'mid'
 
-  options.search: a server activity object to return as the middle point of the batch, along with its surrounding activities
+options.search: a server activity object to return as the middle point of the batch, along with its surrounding activities
 
 _parameters accepted by the generator's `next` method_
 
 options
 
-  options.queryType: see above
-
-  options.search: see above
+options.queryType: see above
 
+options.search: see above
 
 #### Return value
+
 Calling `_listActivitiesThreadOrdered` returns the generator instance, and does not execute any work. The generator returned has a `next` method that begins the first round of work and returns a `done` boolean and a `value`, the asked-for thread ordered activities.
 
 ```
@@ -109,6 +116,7 @@ value: IActivity[]
 ```
 
 #### Examples
+
 ```
 const options = {
   url: 'myconvourl.com',
@@ -123,31 +131,35 @@ await threadOrderedFetcher.next() // => { done: boolean, value: IActivity[] }
 #### The nitty gritty: design
 
 There are 3 main phases of the method, with one major subphase:
+
 1. initialization: up to the ` while (true)` loop
 2. execution: the ` while (true)` loop
 3. (subphase of execution) fetching: the ` while (!getNoMoreActs())` loop
 4. re-calculation: after the ` yield`
 
 ##### initialization
+
 Parsing the arguments and initializing state is done in this first phase, before the generator's first execution. State that must be retained independent of each execution loop (the code run by the generator's `next` method) is instantiated here. The following variables (or grouped of variables) are created and maintained for the life of the generator:
 
-* oldestAct - the oldest activity (by published date) that has been fetched by the gen. instance
-* newestAct - the newest activity that has been fetched by the gen. instance
-* batchSize - the number of activities to fetch to achieve minActivities. This value is set lower in cases where we fetch children, because adding the children to their parents may help us reach minActivities count
-* query - initialize fetching query. The first query will be forced to fetch newest activities in a space to initialize the activity states, unless a search is requested
-* ***ActivityHash(es): cache objects for children activities. These caches store all child activity types returned from convo fetches in order to keep track of "orphans", or child activities that come in before their parent activity
+- oldestAct - the oldest activity (by published date) that has been fetched by the gen. instance
+- newestAct - the newest activity that has been fetched by the gen. instance
+- batchSize - the number of activities to fetch to achieve minActivities. This value is set lower in cases where we fetch children, because adding the children to their parents may help us reach minActivities count
+- query - initialize fetching query. The first query will be forced to fetch newest activities in a space to initialize the activity states, unless a search is requested
+- \*\*\*ActivityHash(es): cache objects for children activities. These caches store all child activity types returned from convo fetches in order to keep track of "orphans", or child activities that come in before their parent activity
 
 ##### execution
+
 The execution phase will be run for every call to `next` method. Its job is to fetch activities until the minimum activity limit is reached, then it will build the ordered list of activities and yield them to the caller. Similar to init phase, execution phase has variables declared outside the fetching loop in order to keep track of what we have fetched so far, and whether continuing to fetch is necessary. The execuction phase runs the fetching subphase. The following state variables are tracked by this outer loop, before the fetching phase:
 
-* rootActivityHash - the data structure used to track root activities we have fetched in a given batch
-* [* helpers] - many helper functions are declared. They close over state variables and are used to group functionality used by the fetching loop, and for self-documenting purposes
-* fetchLoopCount - track count of fetch loops run. Used to break out of loop in unlikely case that we fetch the same query over and over.
+- rootActivityHash - the data structure used to track root activities we have fetched in a given batch
+- [* helpers] - many helper functions are declared. They close over state variables and are used to group functionality used by the fetching loop, and for self-documenting purposes
+- fetchLoopCount - track count of fetch loops run. Used to break out of loop in unlikely case that we fetch the same query over and over.
 
 ##### fetching
-The fetching phase is contained within the execution phase, and is a loop that will run until we run out of activities to fetch, or explicitly break the loop when we reach the minActivities count with what we've fetched so far. Each fetch loop begins by setting up the query and passing options to `#listActivities` method. All query types depend on a first query to activities to get N root activities. midDate queries (aliased MID) and sinceDate queries (aliased NEWER) also must recursively fetch children to ensure we don't return to caller a root activity that is missing children.*
 
-*NOTE: These sometimes-necessary children queries depend on the addition of a new method, `#listAllChildActivitiesByParentId`. This method is similar to `listChildActivitiesByParentId`, but this method recursively fetches all the chilren of a certain type, rather than forcing the calling method to fetch 10 children at a time (as is the current child limit set by underlying convo API).
+The fetching phase is contained within the execution phase, and is a loop that will run until we run out of activities to fetch, or explicitly break the loop when we reach the minActivities count with what we've fetched so far. Each fetch loop begins by setting up the query and passing options to `#listActivities` method. All query types depend on a first query to activities to get N root activities. midDate queries (aliased MID) and sinceDate queries (aliased NEWER) also must recursively fetch children to ensure we don't return to caller a root activity that is missing children.\*
+
+\*NOTE: These sometimes-necessary children queries depend on the addition of a new method, `#listAllChildActivitiesByParentId`. This method is similar to `listChildActivitiesByParentId`, but this method recursively fetches all the chilren of a certain type, rather than forcing the calling method to fetch 10 children at a time (as is the current child limit set by underlying convo API).
 
 Activities returned to us by convo fetches are sorted and placed into maps based off their activity type. Root activities are stored on a per-batch basis, whereas children are stored globally (prevents orphans). Root activities are keyed by their ID, where children are keyed by their parent's ID (`activity.parent.id`).
 
@@ -156,24 +168,29 @@ When reactions are fetched, however, we call a _different_ convo API that helps
 Fetching loop can be explicitly broken out of when we have decided we have the necessary activities for the current batch. If we _don't_ have enough activities, we initialize a new query derived from the former query and return to the top of the fetching loop to continue building our list.
 
 ##### execution (revisited)
-After a successful series of fetches have given us the activities necessary for the current batch, we initialize an empty array that acts as our ordered list. To begin, the current batch's root activities are sorted by their published date, and using the ordered list of IDs, we begin to loop over the rootActivityHash. 
+
+After a successful series of fetches have given us the activities necessary for the current batch, we initialize an empty array that acts as our ordered list. To begin, the current batch's root activities are sorted by their published date, and using the ordered list of IDs, we begin to loop over the rootActivityHash.
 
 For every root activity, the ID of the root is used to check all the child hashes (keyed by _parent ID_, recall), and implement IActivity. When a root activity has replies, a similar process is undergone for the reply activity: sorting it by published date, checking its ID against the edits and reactions hash, and sanitizing to implement IActivity. Replies are then looped over and added to the ordered list before moving on to the next root.
 
 We have successfully finished a batch, and will now yield the ordered list to the caller.
 
 ##### recalculation
+
 The generator's `next` method may accepts arguments in order to alter the behavior of the existing generator. Assigning `yield` to a variable captures the arguments passed into `next` method. The `next` method accepts a new value for minActivities, as well as an override for `queryType`. This allows the same generator (and its state) to be used for multiple queries that build one upon another.
 
 The first call to `next` (the first call) is initialized automatically as an INITIAL fetch, to populate the generator state, but subsequent calls to `next` method without a passed-in `queryType` will close the generator.
 
 ### `listActivitiesThreadOrdered(options)` (public)
+
 The public facade exposes wrappers for ease of managing an instance of the generator. All methods implement the iterator protocol The following methods are exposed:
 
 #### `getOlder()`
+
 Implements iterator protocol. Returns oldest activities, then returns any older activities than the oldest fetched.
 
 example:
+
 ```
 const myGen = webex.internal.conversation.listActivitiesThreadOrdered(opts);
 const firstBatch = await myGen.getOlder();
@@ -195,9 +212,11 @@ console.log(secondBatch)
 ```
 
 #### jumpToActivity(searchActivity)
-Implements iterator protocol. Returns searched activity as the middle activity in a batch, with older and newer activities surrounding. 
 
-example: 
+Implements iterator protocol. Returns searched activity as the middle activity in a batch, with older and newer activities surrounding.
+
+example:
+
 ```
 const activitySearchResult = IServerActivity // actual activity object returned by server, most commonly returned by activity search
 const myGen = webex.internal.conversation.listActivitiesThreadOrdered(opts);
@@ -210,10 +229,13 @@ console.log(results)
 }
 */
 ```
-#### `getNewer()` 
+
+#### `getNewer()`
+
 Implements iterator protocol. Returns most recent activities, then returns any newer activities than the newest fetched.
 
 example:
+
 ```
 const myGen = webex.internal.conversation.listActivitiesThreadOrdered(opts);
 const firstBatch = await myGen.getNewer();
@@ -234,7 +256,9 @@ console.log(secondBatch)
 }
 */
 ```
+
 `getNewer()` is of limited use at first, but consider the following example, when used in conjunction with `jumpToActivity`:
+
 ```
 const activitySearchResult = IServerActivity // actual activity object returned by server, most commonly returned by activity search
 const myGen = webex.internal.conversation.listActivitiesThreadOrdered(opts);
@@ -256,8 +280,3 @@ console.log(secondBatch);
 }
 */
 ```
-
-
-
-
-

package/src/config.js

@@ -5,10 +5,10 @@
 export default {
   conversation: {
     allowedInboundTags: {
-      'webex-mention': ['data-object-type', 'data-object-id', 'data-object-url']
+      'webex-mention': ['data-object-type', 'data-object-id', 'data-object-url'],
     },
     allowedOutboundTags: {
-      'webex-mention': ['data-object-type', 'data-object-id', 'data-object-url']
+      'webex-mention': ['data-object-type', 'data-object-id', 'data-object-url'],
     },
     // eslint-disable-next-line no-empty-function
     inboundProcessFunc: () => {},
@@ -27,11 +27,11 @@ export default {
      */
     thumbnailMaxWidth: 640,
     /**
-      * Primarily for testing. When true, decrypting an activity will create a
+     * Primarily for testing. When true, decrypting an activity will create a
      * sister property with the original encrypted string
      * @type {Boolean}
      */
     keepEncryptedProperties: false,
-    decryptionFailureMessage: 'This message cannot be decrypted'
-  }
+    decryptionFailureMessage: 'This message cannot be decrypted',
+  },
 };