@atlaskit/rovo-triggers 7.2.0 → 7.3.0

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # @atlaskit/rovo-triggers
 
+## 7.3.0
+
+### Minor Changes
+
+- [`8740b2dde71e7`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/8740b2dde71e7) -
+  Add opt-in consume-once pubsub delivery so mounted Rovo Chat listeners can deduplicate action
+  events from a single publish.
+- [`925c8d1b15bba`](https://bitbucket.org/atlassian/atlassian-frontend-monorepo/commits/925c8d1b15bba) -
+  Add optional parameter to exported API: Optional `projectContext` when `chat-open` is emitted in
+  the conversation assistant package.
+
 ## 7.2.0
 
 ### Minor Changes

package/README.md

@@ -70,6 +70,42 @@ const YourComponent = () => {
 }
 ```
 
+#### Consume once
+
+Publishers can mark an event as `consumeOnce: true` when only one mounted instance of a
+consumer should process that event. Subscribers opt into this behavior with a stable
+`consumeOnceKey`; subscribers sharing the same key will process a `consumeOnce` event once total.
+Subscribers without a `consumeOnceKey` continue to observe the event normally.
+
+The delivery id used to deduplicate a publish is generated internally by `rovo-triggers` and is not
+exposed in the event payload. This deduplicates one publish fanout across multiple mounted
+subscribers; separate publish calls are treated as separate events.
+
+```ts
+const YourComponent = () => {
+    useSubscribe({ topic: 'ai-mate', consumeOnceKey: 'your-consumer' }, ({ type, data }) => {
+        if(type === 'message-send') {
+            sendMessage(data)
+        }
+    });
+}
+```
+
+```ts
+const AnotherComponent = () => {
+    const publish = usePublish('ai-mate');
+
+    const handleClick = () => {
+        publish({
+            type: 'message-send',
+            source: 'my-source',
+            consumeOnce: true,
+            data: { prompt: 'hello Rovo Chat' },
+        })
+    }
+}
+```
+
 ### Subscribe All
 
 **Note** - Avoid using this. Right now it's only intended to be a proxy for Rovo Chat to trigger

package/dist/cjs/main.js

@@ -5,12 +5,15 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.useSubscribeAll = exports.useSubscribe = exports.usePublish = exports.Subscriber = void 0;
-var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _toArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toArray"));
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
 var _react = require("react");
 var _platformFeatureFlags = require("@atlaskit/platform-feature-flags");
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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 MAX_CONSUMED_EVENT_KEYS = 5000;
 var ignoredTriggerLatestEvents = new Set(['editor-context-payload', 'agent-changed',
 // Internal signals that must never overwrite the publish queue — they would
 // cause `triggerLatest` subscribers (e.g. PubSubListener) to replay them
@@ -27,39 +30,86 @@ var createPubSub = function createPubSub() {
   var subscribedEvents = {};
   var publishQueue = {};
   var wildcardEvents = [];
+  var consumedEventKeys = new Set();
+  var consumedEventKeyQueue = [];
   var subIdCounter = 0;
+  var eventIdCounter = 0;
   var generateSubId = function generateSubId() {
     subIdCounter += 1;
     return subIdCounter.toString();
   };
-  var subscribe = function subscribe(_ref, callback) {
+  var createEvent = function createEvent(payload) {
+    eventIdCounter += 1;
+    return {
+      id: eventIdCounter.toString(),
+      payload: payload
+    };
+  };
+  var rememberConsumedEventKey = function rememberConsumedEventKey(claimKey) {
+    consumedEventKeys.add(claimKey);
+    consumedEventKeyQueue = [].concat((0, _toConsumableArray2.default)(consumedEventKeyQueue), [claimKey]);
+    if (consumedEventKeyQueue.length > MAX_CONSUMED_EVENT_KEYS) {
+      var _consumedEventKeyQueu = consumedEventKeyQueue,
+        _consumedEventKeyQueu2 = (0, _toArray2.default)(_consumedEventKeyQueu),
+        oldestClaimKey = _consumedEventKeyQueu2[0],
+        remainingClaimKeys = _arrayLikeToArray(_consumedEventKeyQueu2).slice(1);
+      consumedEventKeyQueue = remainingClaimKeys;
+      if (oldestClaimKey) {
+        consumedEventKeys.delete(oldestClaimKey);
+      }
+    }
+  };
+  var claimConsumeOnceEvent = function claimConsumeOnceEvent(_ref) {
+    var event = _ref.event,
+      consumeOnceKey = _ref.consumeOnceKey;
+    if (!event.payload.consumeOnce || !consumeOnceKey) {
+      return true;
+    }
+    var claimKey = "".concat(consumeOnceKey, ":").concat(event.id);
+    if (consumedEventKeys.has(claimKey)) {
+      return false;
+    }
+    rememberConsumedEventKey(claimKey);
+    return true;
+  };
+  var subscribe = function subscribe(_ref2, callback) {
     var _subscribedEvents$top;
-    var topic = _ref.topic,
-      triggerLatest = _ref.triggerLatest;
+    var topic = _ref2.topic,
+      triggerLatest = _ref2.triggerLatest,
+      consumeOnceKey = _ref2.consumeOnceKey;
     var events = (_subscribedEvents$top = subscribedEvents[topic]) !== null && _subscribedEvents$top !== void 0 ? _subscribedEvents$top : [];
     var subId = generateSubId();
-    var subExists = events.some(function (_ref2) {
-      var id = _ref2.id;
+    var subExists = events.some(function (_ref3) {
+      var id = _ref3.id;
       return id === subId;
     });
+    var callbackWithConsumption = function callbackWithConsumption(event) {
+      if (!claimConsumeOnceEvent({
+        event: event,
+        consumeOnceKey: consumeOnceKey
+      })) {
+        return;
+      }
+      callback(event.payload);
+    };
 
     // Push to Topic stack if not already there
     if (!subExists) {
       subscribedEvents = _objectSpread(_objectSpread({}, subscribedEvents), {}, (0, _defineProperty2.default)({}, topic, [].concat((0, _toConsumableArray2.default)(events), [{
-        callback: callback,
+        callback: callbackWithConsumption,
         id: subId
       }])));
       // If this Topic already has a published event and `triggerLatest` is true, trigger the callback then clear the publishQueue for that Topic
       if (triggerLatest && !!publishQueue[topic]) {
-        var _payload = publishQueue[topic];
-        callback(_payload);
+        var _event = publishQueue[topic];
+        callbackWithConsumption(_event);
         delete publishQueue[topic];
       }
     }
     return function () {
       // Remove from Topic stack
-      subscribedEvents = _objectSpread(_objectSpread({}, subscribedEvents), {}, (0, _defineProperty2.default)({}, topic, (subscribedEvents[topic] || []).filter(function (_ref3) {
-        var id = _ref3.id;
+      subscribedEvents = _objectSpread(_objectSpread({}, subscribedEvents), {}, (0, _defineProperty2.default)({}, topic, (subscribedEvents[topic] || []).filter(function (_ref4) {
+        var id = _ref4.id;
         return id !== subId;
       })));
     };
@@ -71,26 +121,28 @@ var createPubSub = function createPubSub() {
       id: subId
     }]);
     return function () {
-      wildcardEvents = wildcardEvents.filter(function (_ref4) {
-        var id = _ref4.id;
+      wildcardEvents = wildcardEvents.filter(function (_ref5) {
+        var id = _ref5.id;
         return id !== subId;
       });
     };
   };
   var publish = function publish(topic, payload) {
+    var event = createEvent(payload);
+
     /**
      * Log that this Topic received a published event, regardless of whether it has subscribers or not.
      * This ensures new subscribers can trigger their callback if `triggerLatest` is true, and the event hasn't already been triggered.
      */
     // This `ignoredTriggerLatestEvents` is a quick fix to prevent triggering the latest event for certain events
     if (!isIgnoredForTriggerLatest(payload.type)) {
-      publishQueue[topic] = payload;
+      publishQueue[topic] = event;
     }
 
     // Notify `subscribeAll` subscribers as they are Topic agnostic
-    wildcardEvents.forEach(function (_ref5) {
-      var callback = _ref5.callback;
-      return callback(payload);
+    wildcardEvents.forEach(function (_ref6) {
+      var callback = _ref6.callback;
+      return callback(event.payload);
     });
     var topicSubs = subscribedEvents[topic] || [];
 
@@ -100,9 +152,9 @@ var createPubSub = function createPubSub() {
     }
 
     // Notify all Topic subscribers of this event
-    topicSubs.forEach(function (_ref6) {
-      var callback = _ref6.callback;
-      return callback(payload);
+    topicSubs.forEach(function (_ref7) {
+      var callback = _ref7.callback;
+      return callback(event);
     });
   };
   var flushQueue = function flushQueue() {
@@ -119,9 +171,10 @@ var pubSub = createPubSub();
 var usePubSub = function usePubSub() {
   return pubSub;
 };
-var useSubscribe = exports.useSubscribe = function useSubscribe(_ref7, callback) {
-  var topic = _ref7.topic,
-    triggerLatest = _ref7.triggerLatest;
+var useSubscribe = exports.useSubscribe = function useSubscribe(_ref8, callback) {
+  var topic = _ref8.topic,
+    triggerLatest = _ref8.triggerLatest,
+    consumeOnceKey = _ref8.consumeOnceKey;
   var _usePubSub = usePubSub(),
     subscribe = _usePubSub.subscribe;
   var callbackRef = (0, _react.useRef)(callback);
@@ -129,14 +182,15 @@ var useSubscribe = exports.useSubscribe = function useSubscribe(_ref7, callback)
   (0, _react.useEffect)(function () {
     var unsubscribe = subscribe({
       topic: topic,
-      triggerLatest: triggerLatest
+      triggerLatest: triggerLatest,
+      consumeOnceKey: consumeOnceKey
     }, function () {
       return callbackRef.current.apply(callbackRef, arguments);
     });
     return unsubscribe;
   },
   // eslint-disable-next-line react-hooks/exhaustive-deps
-  [topic]);
+  [topic, consumeOnceKey]);
 };
 var useSubscribeAll = exports.useSubscribeAll = function useSubscribeAll(callback) {
   var _usePubSub2 = usePubSub(),
@@ -172,14 +226,16 @@ var usePublish = exports.usePublish = function usePublish(topic) {
   }, [publish, topic]);
   return publishFn;
 };
-var Subscriber = exports.Subscriber = function Subscriber(_ref8) {
-  var topic = _ref8.topic,
-    triggerLatest = _ref8.triggerLatest,
-    onEvent = _ref8.onEvent,
-    flushQueueOnUnmount = _ref8.flushQueueOnUnmount;
+var Subscriber = exports.Subscriber = function Subscriber(_ref9) {
+  var topic = _ref9.topic,
+    triggerLatest = _ref9.triggerLatest,
+    onEvent = _ref9.onEvent,
+    flushQueueOnUnmount = _ref9.flushQueueOnUnmount,
+    consumeOnceKey = _ref9.consumeOnceKey;
   useSubscribe({
     topic: topic,
-    triggerLatest: triggerLatest
+    triggerLatest: triggerLatest,
+    consumeOnceKey: consumeOnceKey
   }, onEvent);
   useFlushOnUnmount(flushQueueOnUnmount);
   return null;

package/dist/es2019/main.js

@@ -1,5 +1,6 @@
 import { useCallback, useEffect, useLayoutEffect, useRef } from 'react';
 import { fg } from '@atlaskit/platform-feature-flags';
+const MAX_CONSUMED_EVENT_KEYS = 5000;
 const ignoredTriggerLatestEvents = new Set(['editor-context-payload', 'agent-changed',
 // Internal signals that must never overwrite the publish queue — they would
 // cause `triggerLatest` subscribers (e.g. PubSubListener) to replay them
@@ -16,14 +17,50 @@ const createPubSub = () => {
   let subscribedEvents = {};
   let publishQueue = {};
   let wildcardEvents = [];
+  let consumedEventKeys = new Set();
+  let consumedEventKeyQueue = [];
   let subIdCounter = 0;
+  let eventIdCounter = 0;
   const generateSubId = () => {
     subIdCounter += 1;
     return subIdCounter.toString();
   };
+  const createEvent = payload => {
+    eventIdCounter += 1;
+    return {
+      id: eventIdCounter.toString(),
+      payload
+    };
+  };
+  const rememberConsumedEventKey = claimKey => {
+    consumedEventKeys.add(claimKey);
+    consumedEventKeyQueue = [...consumedEventKeyQueue, claimKey];
+    if (consumedEventKeyQueue.length > MAX_CONSUMED_EVENT_KEYS) {
+      const [oldestClaimKey, ...remainingClaimKeys] = consumedEventKeyQueue;
+      consumedEventKeyQueue = remainingClaimKeys;
+      if (oldestClaimKey) {
+        consumedEventKeys.delete(oldestClaimKey);
+      }
+    }
+  };
+  const claimConsumeOnceEvent = ({
+    event,
+    consumeOnceKey
+  }) => {
+    if (!event.payload.consumeOnce || !consumeOnceKey) {
+      return true;
+    }
+    const claimKey = `${consumeOnceKey}:${event.id}`;
+    if (consumedEventKeys.has(claimKey)) {
+      return false;
+    }
+    rememberConsumedEventKey(claimKey);
+    return true;
+  };
   const subscribe = ({
     topic,
-    triggerLatest
+    triggerLatest,
+    consumeOnceKey
   }, callback) => {
     var _subscribedEvents$top;
     const events = (_subscribedEvents$top = subscribedEvents[topic]) !== null && _subscribedEvents$top !== void 0 ? _subscribedEvents$top : [];
@@ -31,20 +68,29 @@ const createPubSub = () => {
     const subExists = events.some(({
       id
     }) => id === subId);
+    const callbackWithConsumption = event => {
+      if (!claimConsumeOnceEvent({
+        event,
+        consumeOnceKey
+      })) {
+        return;
+      }
+      callback(event.payload);
+    };
 
     // Push to Topic stack if not already there
     if (!subExists) {
       subscribedEvents = {
         ...subscribedEvents,
         [topic]: [...events, {
-          callback,
+          callback: callbackWithConsumption,
           id: subId
         }]
       };
       // If this Topic already has a published event and `triggerLatest` is true, trigger the callback then clear the publishQueue for that Topic
       if (triggerLatest && !!publishQueue[topic]) {
-        const payload = publishQueue[topic];
-        callback(payload);
+        const event = publishQueue[topic];
+        callbackWithConsumption(event);
         delete publishQueue[topic];
       }
     }
@@ -71,19 +117,21 @@ const createPubSub = () => {
     };
   };
   const publish = (topic, payload) => {
+    const event = createEvent(payload);
+
     /**
      * Log that this Topic received a published event, regardless of whether it has subscribers or not.
      * This ensures new subscribers can trigger their callback if `triggerLatest` is true, and the event hasn't already been triggered.
      */
     // This `ignoredTriggerLatestEvents` is a quick fix to prevent triggering the latest event for certain events
     if (!isIgnoredForTriggerLatest(payload.type)) {
-      publishQueue[topic] = payload;
+      publishQueue[topic] = event;
     }
 
     // Notify `subscribeAll` subscribers as they are Topic agnostic
     wildcardEvents.forEach(({
       callback
-    }) => callback(payload));
+    }) => callback(event.payload));
     const topicSubs = subscribedEvents[topic] || [];
 
     // If there are no subscribers for this Topic, nothing to do.
@@ -94,7 +142,7 @@ const createPubSub = () => {
     // Notify all Topic subscribers of this event
     topicSubs.forEach(({
       callback
-    }) => callback(payload));
+    }) => callback(event));
   };
   const flushQueue = () => {
     publishQueue = {};
@@ -112,7 +160,8 @@ const usePubSub = () => {
 };
 export const useSubscribe = ({
   topic,
-  triggerLatest
+  triggerLatest,
+  consumeOnceKey
 }, callback) => {
   const {
     subscribe
@@ -122,12 +171,13 @@ export const useSubscribe = ({
   useEffect(() => {
     const unsubscribe = subscribe({
       topic,
-      triggerLatest
+      triggerLatest,
+      consumeOnceKey
     }, (...args) => callbackRef.current(...args));
     return unsubscribe;
   },
   // eslint-disable-next-line react-hooks/exhaustive-deps
-  [topic]);
+  [topic, consumeOnceKey]);
 };
 export const useSubscribeAll = callback => {
   const {
@@ -165,11 +215,13 @@ export const Subscriber = ({
   topic,
   triggerLatest,
   onEvent,
-  flushQueueOnUnmount
+  flushQueueOnUnmount,
+  consumeOnceKey
 }) => {
   useSubscribe({
     topic,
-    triggerLatest
+    triggerLatest,
+    consumeOnceKey
   }, onEvent);
   useFlushOnUnmount(flushQueueOnUnmount);
   return null;

package/dist/esm/main.js

@@ -1,9 +1,12 @@
-import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 import _defineProperty from "@babel/runtime/helpers/defineProperty";
+import _toArray from "@babel/runtime/helpers/toArray";
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
 function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
 function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+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; }
 import { useCallback, useEffect, useLayoutEffect, useRef } from 'react';
 import { fg } from '@atlaskit/platform-feature-flags';
+var MAX_CONSUMED_EVENT_KEYS = 5000;
 var ignoredTriggerLatestEvents = new Set(['editor-context-payload', 'agent-changed',
 // Internal signals that must never overwrite the publish queue — they would
 // cause `triggerLatest` subscribers (e.g. PubSubListener) to replay them
@@ -20,39 +23,86 @@ var createPubSub = function createPubSub() {
   var subscribedEvents = {};
   var publishQueue = {};
   var wildcardEvents = [];
+  var consumedEventKeys = new Set();
+  var consumedEventKeyQueue = [];
   var subIdCounter = 0;
+  var eventIdCounter = 0;
   var generateSubId = function generateSubId() {
     subIdCounter += 1;
     return subIdCounter.toString();
   };
-  var subscribe = function subscribe(_ref, callback) {
+  var createEvent = function createEvent(payload) {
+    eventIdCounter += 1;
+    return {
+      id: eventIdCounter.toString(),
+      payload: payload
+    };
+  };
+  var rememberConsumedEventKey = function rememberConsumedEventKey(claimKey) {
+    consumedEventKeys.add(claimKey);
+    consumedEventKeyQueue = [].concat(_toConsumableArray(consumedEventKeyQueue), [claimKey]);
+    if (consumedEventKeyQueue.length > MAX_CONSUMED_EVENT_KEYS) {
+      var _consumedEventKeyQueu = consumedEventKeyQueue,
+        _consumedEventKeyQueu2 = _toArray(_consumedEventKeyQueu),
+        oldestClaimKey = _consumedEventKeyQueu2[0],
+        remainingClaimKeys = _arrayLikeToArray(_consumedEventKeyQueu2).slice(1);
+      consumedEventKeyQueue = remainingClaimKeys;
+      if (oldestClaimKey) {
+        consumedEventKeys.delete(oldestClaimKey);
+      }
+    }
+  };
+  var claimConsumeOnceEvent = function claimConsumeOnceEvent(_ref) {
+    var event = _ref.event,
+      consumeOnceKey = _ref.consumeOnceKey;
+    if (!event.payload.consumeOnce || !consumeOnceKey) {
+      return true;
+    }
+    var claimKey = "".concat(consumeOnceKey, ":").concat(event.id);
+    if (consumedEventKeys.has(claimKey)) {
+      return false;
+    }
+    rememberConsumedEventKey(claimKey);
+    return true;
+  };
+  var subscribe = function subscribe(_ref2, callback) {
     var _subscribedEvents$top;
-    var topic = _ref.topic,
-      triggerLatest = _ref.triggerLatest;
+    var topic = _ref2.topic,
+      triggerLatest = _ref2.triggerLatest,
+      consumeOnceKey = _ref2.consumeOnceKey;
     var events = (_subscribedEvents$top = subscribedEvents[topic]) !== null && _subscribedEvents$top !== void 0 ? _subscribedEvents$top : [];
     var subId = generateSubId();
-    var subExists = events.some(function (_ref2) {
-      var id = _ref2.id;
+    var subExists = events.some(function (_ref3) {
+      var id = _ref3.id;
       return id === subId;
     });
+    var callbackWithConsumption = function callbackWithConsumption(event) {
+      if (!claimConsumeOnceEvent({
+        event: event,
+        consumeOnceKey: consumeOnceKey
+      })) {
+        return;
+      }
+      callback(event.payload);
+    };
 
     // Push to Topic stack if not already there
     if (!subExists) {
       subscribedEvents = _objectSpread(_objectSpread({}, subscribedEvents), {}, _defineProperty({}, topic, [].concat(_toConsumableArray(events), [{
-        callback: callback,
+        callback: callbackWithConsumption,
         id: subId
       }])));
       // If this Topic already has a published event and `triggerLatest` is true, trigger the callback then clear the publishQueue for that Topic
       if (triggerLatest && !!publishQueue[topic]) {
-        var _payload = publishQueue[topic];
-        callback(_payload);
+        var _event = publishQueue[topic];
+        callbackWithConsumption(_event);
         delete publishQueue[topic];
       }
     }
     return function () {
       // Remove from Topic stack
-      subscribedEvents = _objectSpread(_objectSpread({}, subscribedEvents), {}, _defineProperty({}, topic, (subscribedEvents[topic] || []).filter(function (_ref3) {
-        var id = _ref3.id;
+      subscribedEvents = _objectSpread(_objectSpread({}, subscribedEvents), {}, _defineProperty({}, topic, (subscribedEvents[topic] || []).filter(function (_ref4) {
+        var id = _ref4.id;
         return id !== subId;
       })));
     };
@@ -64,26 +114,28 @@ var createPubSub = function createPubSub() {
       id: subId
     }]);
     return function () {
-      wildcardEvents = wildcardEvents.filter(function (_ref4) {
-        var id = _ref4.id;
+      wildcardEvents = wildcardEvents.filter(function (_ref5) {
+        var id = _ref5.id;
         return id !== subId;
       });
     };
   };
   var publish = function publish(topic, payload) {
+    var event = createEvent(payload);
+
     /**
      * Log that this Topic received a published event, regardless of whether it has subscribers or not.
      * This ensures new subscribers can trigger their callback if `triggerLatest` is true, and the event hasn't already been triggered.
      */
     // This `ignoredTriggerLatestEvents` is a quick fix to prevent triggering the latest event for certain events
     if (!isIgnoredForTriggerLatest(payload.type)) {
-      publishQueue[topic] = payload;
+      publishQueue[topic] = event;
     }
 
     // Notify `subscribeAll` subscribers as they are Topic agnostic
-    wildcardEvents.forEach(function (_ref5) {
-      var callback = _ref5.callback;
-      return callback(payload);
+    wildcardEvents.forEach(function (_ref6) {
+      var callback = _ref6.callback;
+      return callback(event.payload);
     });
     var topicSubs = subscribedEvents[topic] || [];
 
@@ -93,9 +145,9 @@ var createPubSub = function createPubSub() {
     }
 
     // Notify all Topic subscribers of this event
-    topicSubs.forEach(function (_ref6) {
-      var callback = _ref6.callback;
-      return callback(payload);
+    topicSubs.forEach(function (_ref7) {
+      var callback = _ref7.callback;
+      return callback(event);
     });
   };
   var flushQueue = function flushQueue() {
@@ -112,9 +164,10 @@ var pubSub = createPubSub();
 var usePubSub = function usePubSub() {
   return pubSub;
 };
-export var useSubscribe = function useSubscribe(_ref7, callback) {
-  var topic = _ref7.topic,
-    triggerLatest = _ref7.triggerLatest;
+export var useSubscribe = function useSubscribe(_ref8, callback) {
+  var topic = _ref8.topic,
+    triggerLatest = _ref8.triggerLatest,
+    consumeOnceKey = _ref8.consumeOnceKey;
   var _usePubSub = usePubSub(),
     subscribe = _usePubSub.subscribe;
   var callbackRef = useRef(callback);
@@ -122,14 +175,15 @@ export var useSubscribe = function useSubscribe(_ref7, callback) {
   useEffect(function () {
     var unsubscribe = subscribe({
       topic: topic,
-      triggerLatest: triggerLatest
+      triggerLatest: triggerLatest,
+      consumeOnceKey: consumeOnceKey
     }, function () {
       return callbackRef.current.apply(callbackRef, arguments);
     });
     return unsubscribe;
   },
   // eslint-disable-next-line react-hooks/exhaustive-deps
-  [topic]);
+  [topic, consumeOnceKey]);
 };
 export var useSubscribeAll = function useSubscribeAll(callback) {
   var _usePubSub2 = usePubSub(),
@@ -165,14 +219,16 @@ export var usePublish = function usePublish(topic) {
   }, [publish, topic]);
   return publishFn;
 };
-export var Subscriber = function Subscriber(_ref8) {
-  var topic = _ref8.topic,
-    triggerLatest = _ref8.triggerLatest,
-    onEvent = _ref8.onEvent,
-    flushQueueOnUnmount = _ref8.flushQueueOnUnmount;
+export var Subscriber = function Subscriber(_ref9) {
+  var topic = _ref9.topic,
+    triggerLatest = _ref9.triggerLatest,
+    onEvent = _ref9.onEvent,
+    flushQueueOnUnmount = _ref9.flushQueueOnUnmount,
+    consumeOnceKey = _ref9.consumeOnceKey;
   useSubscribe({
     topic: topic,
-    triggerLatest: triggerLatest
+    triggerLatest: triggerLatest,
+    consumeOnceKey: consumeOnceKey
   }, onEvent);
   useFlushOnUnmount(flushQueueOnUnmount);
   return null;

package/dist/types/main.d.ts

@@ -2,14 +2,16 @@ import type { Callback, Payload, Topic } from './types';
 interface SubscribeOptions {
     topic: Topic;
     triggerLatest?: boolean;
+    consumeOnceKey?: string;
 }
-export declare const useSubscribe: ({ topic, triggerLatest }: SubscribeOptions, callback: Callback) => void;
+export declare const useSubscribe: ({ topic, triggerLatest, consumeOnceKey }: SubscribeOptions, callback: Callback) => void;
 export declare const useSubscribeAll: (callback: Callback) => void;
 export declare const usePublish: (topic: Topic) => ((payload: Payload) => void);
-export declare const Subscriber: ({ topic, triggerLatest, onEvent, flushQueueOnUnmount, }: {
+export declare const Subscriber: ({ topic, triggerLatest, onEvent, flushQueueOnUnmount, consumeOnceKey, }: {
     topic: Topic;
     triggerLatest?: boolean;
     onEvent: Callback;
     flushQueueOnUnmount?: boolean;
+    consumeOnceKey?: string;
 }) => null;
 export {};

package/dist/types/types.d.ts

@@ -18,6 +18,12 @@ export type PayloadCore<TKey extends string, TData = void> = {
     openChatMode?: 'sidebar' | 'mini-modal';
     product?: string;
     interactionSource?: string;
+    /**
+     * When true, subscribers that opt into the same consumeOnceKey should process this
+     * logical event once total. The delivery id used for deduplication is internal to
+     * rovo-triggers and is generated for each publish call.
+     */
+    consumeOnce?: boolean;
 } & (TData extends void ? {} : {
     data: TData;
 });
@@ -208,6 +214,7 @@ export type ChatOpenPayload = PayloadCore<'chat-open', {
     avatarUrl?: string;
     resetActiveMenu?: boolean;
     openAgentSelector?: boolean;
+    aiFeatureContext?: Record<string, unknown>;
 }>;
 export type ForgeAppAuthSuccess = PayloadCore<'forge-auth-success', {
     is3pActionAuth?: boolean;

package/dist/types-ts4.5/main.d.ts

@@ -2,14 +2,16 @@ import type { Callback, Payload, Topic } from './types';
 interface SubscribeOptions {
     topic: Topic;
     triggerLatest?: boolean;
+    consumeOnceKey?: string;
 }
-export declare const useSubscribe: ({ topic, triggerLatest }: SubscribeOptions, callback: Callback) => void;
+export declare const useSubscribe: ({ topic, triggerLatest, consumeOnceKey }: SubscribeOptions, callback: Callback) => void;
 export declare const useSubscribeAll: (callback: Callback) => void;
 export declare const usePublish: (topic: Topic) => ((payload: Payload) => void);
-export declare const Subscriber: ({ topic, triggerLatest, onEvent, flushQueueOnUnmount, }: {
+export declare const Subscriber: ({ topic, triggerLatest, onEvent, flushQueueOnUnmount, consumeOnceKey, }: {
     topic: Topic;
     triggerLatest?: boolean;
     onEvent: Callback;
     flushQueueOnUnmount?: boolean;
+    consumeOnceKey?: string;
 }) => null;
 export {};

package/dist/types-ts4.5/types.d.ts

@@ -18,6 +18,12 @@ export type PayloadCore<TKey extends string, TData = void> = {
     openChatMode?: 'sidebar' | 'mini-modal';
     product?: string;
     interactionSource?: string;
+    /**
+     * When true, subscribers that opt into the same consumeOnceKey should process this
+     * logical event once total. The delivery id used for deduplication is internal to
+     * rovo-triggers and is generated for each publish call.
+     */
+    consumeOnce?: boolean;
 } & (TData extends void ? {} : {
     data: TData;
 });
@@ -208,6 +214,7 @@ export type ChatOpenPayload = PayloadCore<'chat-open', {
     avatarUrl?: string;
     resetActiveMenu?: boolean;
     openAgentSelector?: boolean;
+    aiFeatureContext?: Record<string, unknown>;
 }>;
 export type ForgeAppAuthSuccess = PayloadCore<'forge-auth-success', {
     is3pActionAuth?: boolean;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@atlaskit/rovo-triggers",
-	"version": "7.2.0",
+	"version": "7.3.0",
 	"description": "Provides various trigger events to drive Rovo Chat functionality, such as a publish-subscribe and URL parameter hooks",
 	"author": "Atlassian Pty Ltd",
 	"publishConfig": {