@atlaskit/rovo-triggers 1.0.0

package/CHANGELOG.md

@@ -0,0 +1,9 @@
+# @atlaskit/rovo-triggers
+
+## 1.0.0
+
+### Major Changes
+
+- [#153462](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/pull-requests/153462)
+  [`6c079f0811ae0`](https://stash.atlassian.com/projects/CONFCLOUD/repos/confluence-frontend/commits/6c079f0811ae0) -
+  Initialize rovo-triggers

package/LICENSE.md

@@ -0,0 +1,11 @@
+Copyright 2023 Atlassian Pty Ltd
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
+compliance with the License. You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the License is
+distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+implied. See the License for the specific language governing permissions and limitations under the
+License.

package/README.md

@@ -0,0 +1,172 @@
+# Rovo Triggers
+
+_(formerly conversation-assistant-pubsub)_
+
+Provides various trigger events to drive Rovo Chat functionality, such as a publish-subscribe and
+URL parameter hooks
+
+## Example usage
+
+### Publish
+
+```ts
+import { usePublish } from "@atlaskit/rovo-triggers";
+
+const YourComponent = () => {
+    const publish = usePublish('ai-mate');
+
+    const handleClick = () => {
+        publish({
+            type: "message-send",
+            data: "hello Rovo Chat",
+            source: "my-source", // source is used for analytics
+        })
+    }
+
+    return (
+        <div>
+            <button onClick={handleClick}>
+                Send message onbehalf of user in Rovo Chat
+            </button>
+        </div>
+    );
+}
+```
+
+### Subscribe
+
+```ts
+import { useSubscribe } from "@atlaskit/rovo-triggers";
+
+const YourComponent = () => {
+    const [message, setMessage] = useState('Waiting for messages...');
+
+    useSubscribe({ topic: 'ai-mate' }, ({ type, data }) => {
+        if(type === 'message-received') {
+            setMessage(data)
+        }
+    });
+
+    return (<div>{message}</div>);
+}
+```
+
+#### Subscribe (TriggerLatest)
+
+```ts
+import { useSubscribe } from "@atlaskit/rovo-triggers";
+
+const YourComponent = () => {
+    const [message, setMessage] = useState('Waiting for messages...');
+
+    // This subscription will trigger immediately if an event has already been published to the 'ai-mate' topic
+    useSubscribe({ topic: 'ai-mate', triggerLatest: true }, ({ type, data, source }) => {
+        if(type === 'message-received') {
+            setMessage(data)
+        }
+    });
+
+    return (<div>{message}</div>);
+}
+```
+
+### Subscribe All
+
+**Note** - Avoid using this. Right now it's only intended to be a proxy for Rovo Chat to trigger
+open when new events are published, if it isn't already open.
+
+```ts
+import { useSubscribeAll } from "@atlaskit/rovo-triggers";
+
+const YourComponent = () => {
+    useSubscribeAll(() => {
+        console.log('pubsub received an event')
+        // do something like open the Rovo Chat panel
+    });
+  });
+}
+```
+
+### Conditionally run subscriptions
+
+You can conditionally call a subscription that uses `triggerLatest` by conditionally rendering the
+`<Subscriber />` component. This can be useful to ensure your state is in the optimal place before
+triggering it's the subscription (e.g no longer loading)
+
+```ts
+const YourComponent = ({ startSubscription }: { startSubscription: boolean }) => startSubscription ? (
+        <Subscriber
+          topic={topic}
+          triggerLatest={true}
+          onEvent={({ type, data }) => {
+            if (type === 'message-send') {
+              setMsg(`${data} received at ${new Date().toLocaleTimeString()}`);
+              setCount(count + 1);
+            }
+          }}
+        />
+      ) : null
+```
+
+## Registering new events
+
+Events are a combination of a topic and an event type. As such you can register a new event type by
+either:
+
+- Creating a new `Topic`, and leveraging the existing `EventTypes`
+- Creating a new `Topic`, and also creating some new `EventTypes` to be used
+- Creating another `EventType` to be used against an existing `Topic`
+
+This may change as the utility and typings evolve when continuing to build integrations with this
+package.
+
+### Topics
+
+The `ai-mate` topic is reserved for `conversation-assistant` events and is the only one that
+currently exists. Watch this space.
+
+### EventTypes
+
+Event types represent actions that have taken place in Rovo Chat, or actions you'd like to trigger
+within Rovo Chat. As long as there's a registered `publish` event to the `ai-mate` topic, you can
+subscribe to it.
+
+This will be documented as integrations are developed.
+
+## Params utility
+
+Rovo Chat uses a strongly typed set of query params encoded to `rovoChat` which can be used
+consistently across products.
+
+These values can be used to trigger state changes, routing, actions, for example.
+
+- `clearPageRovoParams` - Removes rovoChat param and it’s value from the address bar.
+
+- `updatePageRovoParams` - Easily add properties to the `rovoChat` param in the address bar; this is
+  helpful to continually update the URL for bookmarking or sharing. This method uses
+  `addRovoParamsToUrl` under the hood.
+
+- `addRovoParamsToUrl` - The previous function uses this under the hood, but you can call it
+  directly to add them to an arbitrary URL string, so let’s say you want to redirect from embedded
+  panel to Atlas and do a certain thing, you can call this and pass all the required data to ensure
+  its’ picked up and triggers the right thing on Atlas
+
+- `getRovoParams` - The main method you’d use to execute on the values in the rovo params, so you
+  can do Atlas page routing, or trigger actions in the embedded experience (differentiated by
+  `UIConfig.fullScreen=false`)
+
+Here are some examples of how you might use `getRovoParams` resulting value:
+
+- Open new chat `{ pathway: 'chat' }`
+- Open specific chat `{ pathway: 'chat', conversationId: '123' }`
+- Open new chat with specific agent `{ pathway: 'chat', agentId: '456' }`
+- Open specific chat with specific agent
+  `{ pathway: 'chat', conversationId: '123', agentId: '456' }`
+- Open new chat and send message `{ pathway: 'chat', prompt: 'What should I work on next?' }`
+- Open specific chat and send message
+  `{ pathway: 'chat', conversationId: '123', prompt: 'What should I work on next?' }`
+- Open specific chat with specific agent and send message
+  `{ pathway: 'chat', conversationId: '123', agentId: '456', prompt: 'What should I work on next?' }`
+- Browse agents `{ pathway: 'agents-browse' }`
+- View agent details `{ pathway: 'agents-browse', agentId: '456' }`
+- Open create agent experience `{ pathway: 'agents-create' }`

package/dist/cjs/common/utils/params/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.ROVO_VALID_PARAMS = exports.ROVO_PARAM_PREFIX = void 0;
+var ROVO_PARAM_PREFIX = exports.ROVO_PARAM_PREFIX = 'rovoChat';
+var ROVO_VALID_PARAMS = exports.ROVO_VALID_PARAMS = ['pathway', 'agentId', 'conversationId', 'prompt', 'cloudId', 'triggerOpen'];

package/dist/cjs/common/utils/params/index.js

@@ -0,0 +1,153 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.updatePageRovoParams = exports.removePrefix = exports.getRovoParams = exports.getListOfRovoParams = exports.firstCharUpper = exports.firstCharLower = exports.encodeRovoParams = exports.assertOnlySpecificFieldsDefined = exports.addRovoParamsToUrl = exports.addPrefix = void 0;
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+var _constants = require("./constants");
+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; }
+var firstCharUpper = exports.firstCharUpper = function firstCharUpper(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};
+var firstCharLower = exports.firstCharLower = function firstCharLower(str) {
+  return str.charAt(0).toLowerCase() + str.slice(1);
+};
+var isValidURL = function isValidURL(url) {
+  try {
+    new URL(url);
+    return true;
+  } catch (error) {
+    return false;
+  }
+};
+
+// For new style camelCase params
+var addPrefix = exports.addPrefix = function addPrefix(param) {
+  return "".concat(_constants.ROVO_PARAM_PREFIX).concat(firstCharUpper(param));
+};
+var removePrefix = exports.removePrefix = function removePrefix(param) {
+  return firstCharLower(param.replace(_constants.ROVO_PARAM_PREFIX, ''));
+};
+
+// Creates RovoChatParams from URLSearchParams
+// Optionally filter to specific params
+var processParams = function processParams(input) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {
+    filter: []
+  };
+  var output = {};
+  var safeSearchParamsInput = typeof input === 'string' ? isValidURL(input) ? new URLSearchParams(new URL(input).search) : new URLSearchParams(input) : input;
+  var processedInput = new URLSearchParams(safeSearchParamsInput);
+  var extracted = new URLSearchParams();
+  safeSearchParamsInput.forEach(function (value, key) {
+    var _options$filter;
+    // Only look at rovoChat params
+    if (!key.startsWith(_constants.ROVO_PARAM_PREFIX)) {
+      return;
+    }
+    var paramKey = removePrefix(key);
+    if (options !== null && options !== void 0 && (_options$filter = options.filter) !== null && _options$filter !== void 0 && _options$filter.length) {
+      if (options.filter.includes(paramKey)) {
+        output[paramKey] = decodeURIComponent(value);
+        extracted.append(key, value);
+      }
+    } else {
+      output[paramKey] = decodeURIComponent(value);
+    }
+
+    // Remove rovoParam from processed input
+    processedInput.delete(key);
+  });
+  var combinedQueryString = [processedInput, extracted].map(function (params) {
+    return params.toString();
+  }).filter(function (part) {
+    return part.length > 0;
+  }).join('&');
+  return {
+    processed: processedInput,
+    rovoParams: output,
+    combinedQueryString: combinedQueryString
+  };
+};
+
+// Get all rovoChat params from a URL or the current window location if undefined
+var getRovoParams = exports.getRovoParams = function getRovoParams(url) {
+  try {
+    var search = url ? new URL(url).search : window.location.search;
+    var q = new URLSearchParams(search);
+    return processParams(q).rovoParams;
+  } catch (error) {
+    return {};
+  }
+};
+
+// Update the address bar without reloading the page
+var updatePageRovoParams = exports.updatePageRovoParams = function updatePageRovoParams(params) {
+  window.history.pushState({}, '', addRovoParamsToUrl(window.location.pathname, params));
+};
+
+// Add any valid rovoChat params to a URL
+var addRovoParamsToUrl = exports.addRovoParamsToUrl = function addRovoParamsToUrl(url, params) {
+  var _processParams = processParams(url),
+    processed = _processParams.processed,
+    rovoParams = _processParams.rovoParams;
+  var rovoParamsWithExisting = _objectSpread(_objectSpread({}, rovoParams), params);
+  var baseUrl = url.includes('?') ? url.split('?')[0] : url;
+  var baseQuery = Array.from(processed).length ? "?".concat(processed.toString(), "&") : '?';
+  var updatedRovoParamsString = encodeRovoParams(rovoParamsWithExisting);
+  return "".concat(baseUrl).concat(baseQuery).concat(updatedRovoParamsString);
+};
+var encodeRovoParams = exports.encodeRovoParams = function encodeRovoParams(params, encodeAsObject) {
+  if (encodeAsObject) {
+    return Object.entries(params).reduce(function (acc, _ref) {
+      var _ref2 = (0, _slicedToArray2.default)(_ref, 2),
+        key = _ref2[0],
+        value = _ref2[1];
+      acc[addPrefix(key)] = encodeURIComponent(value);
+      return acc;
+    }, {});
+  }
+  return Object.entries(params).map(function (_ref3) {
+    var _ref4 = (0, _slicedToArray2.default)(_ref3, 2),
+      key = _ref4[0],
+      value = _ref4[1];
+    return "".concat(addPrefix(key), "=").concat(encodeURIComponent(value));
+  }).join('&');
+};
+var assertOnlySpecificFieldsDefined = exports.assertOnlySpecificFieldsDefined = function assertOnlySpecificFieldsDefined(params, fields) {
+  return Object.entries(params).every(function (_ref5) {
+    var _ref6 = (0, _slicedToArray2.default)(_ref5, 2),
+      key = _ref6[0],
+      value = _ref6[1];
+    var field = fields.find(function (field) {
+      return field === key;
+    });
+    if (field) {
+      return value !== undefined;
+    } else {
+      return value === undefined;
+    }
+  });
+};
+var getListOfRovoParams = exports.getListOfRovoParams = function getListOfRovoParams() {
+  var _ref7 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},
+    _ref7$resourceRouterQ = _ref7.resourceRouterQuery,
+    resourceRouterQuery = _ref7$resourceRouterQ === void 0 ? false : _ref7$resourceRouterQ;
+  /*
+  For products using react-resource-router (e.g Atlas) to
+  pass as the value of `query` on the route definition. It ensures that our parameters
+  are not stripped from the URL when loading the page, or through redirect hops
+  Any new parameters we want to maintain should be added here as well, which means
+  only a version bump is needed in those products to support the latest param list
+  The !=false simply means that the parameter is supported but is optional, and should
+  not contain a value of 'false'
+  */
+  var suffix = resourceRouterQuery ? '!=false' : '';
+  return _constants.ROVO_VALID_PARAMS.map(function (param) {
+    return "".concat(addPrefix(param)).concat(suffix);
+  });
+};

package/dist/cjs/common/utils/params/types.js

@@ -0,0 +1 @@
+"use strict";

package/dist/cjs/index.js

@@ -0,0 +1,67 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+Object.defineProperty(exports, "Subscriber", {
+  enumerable: true,
+  get: function get() {
+    return _main.Subscriber;
+  }
+});
+Object.defineProperty(exports, "addRovoParamsToUrl", {
+  enumerable: true,
+  get: function get() {
+    return _params.addRovoParamsToUrl;
+  }
+});
+Object.defineProperty(exports, "assertOnlySpecificFieldsDefined", {
+  enumerable: true,
+  get: function get() {
+    return _params.assertOnlySpecificFieldsDefined;
+  }
+});
+Object.defineProperty(exports, "encodeRovoParams", {
+  enumerable: true,
+  get: function get() {
+    return _params.encodeRovoParams;
+  }
+});
+Object.defineProperty(exports, "getListOfRovoParams", {
+  enumerable: true,
+  get: function get() {
+    return _params.getListOfRovoParams;
+  }
+});
+Object.defineProperty(exports, "getRovoParams", {
+  enumerable: true,
+  get: function get() {
+    return _params.getRovoParams;
+  }
+});
+Object.defineProperty(exports, "updatePageRovoParams", {
+  enumerable: true,
+  get: function get() {
+    return _params.updatePageRovoParams;
+  }
+});
+Object.defineProperty(exports, "usePublish", {
+  enumerable: true,
+  get: function get() {
+    return _main.usePublish;
+  }
+});
+Object.defineProperty(exports, "useSubscribe", {
+  enumerable: true,
+  get: function get() {
+    return _main.useSubscribe;
+  }
+});
+Object.defineProperty(exports, "useSubscribeAll", {
+  enumerable: true,
+  get: function get() {
+    return _main.useSubscribeAll;
+  }
+});
+var _main = require("./main");
+var _params = require("./common/utils/params");

package/dist/cjs/main.js

@@ -0,0 +1,169 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+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 _react = require("react");
+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; }
+var ignoredTriggerLatestEvents = new Set(['editor-context-payload']);
+var createPubSub = function createPubSub() {
+  var subscribedEvents = {};
+  var publishQueue = {};
+  var wildcardEvents = [];
+  var subscribe = function subscribe(_ref, callback) {
+    var _subscribedEvents$top;
+    var topic = _ref.topic,
+      triggerLatest = _ref.triggerLatest;
+    var events = (_subscribedEvents$top = subscribedEvents[topic]) !== null && _subscribedEvents$top !== void 0 ? _subscribedEvents$top : [];
+    var subId = events.length.toString();
+    var subExists = events.some(function (_ref2) {
+      var id = _ref2.id;
+      return id === subId;
+    });
+
+    // 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,
+        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);
+        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;
+        return id !== subId;
+      })));
+    };
+  };
+  var subscribeAll = function subscribeAll(callback) {
+    var subId = wildcardEvents.length.toString();
+    wildcardEvents = [].concat((0, _toConsumableArray2.default)(wildcardEvents), [{
+      callback: callback,
+      id: subId
+    }]);
+    return function () {
+      wildcardEvents = wildcardEvents.filter(function (_ref4) {
+        var id = _ref4.id;
+        return id !== subId;
+      });
+    };
+  };
+  var publish = function publish(topic, 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 (!ignoredTriggerLatestEvents.has(payload.type)) {
+      publishQueue[topic] = payload;
+    }
+
+    // Notify `subscribeAll` subscribers as they are Topic agnostic
+    wildcardEvents.forEach(function (_ref5) {
+      var callback = _ref5.callback;
+      return callback(payload);
+    });
+    var topicSubs = subscribedEvents[topic] || [];
+
+    // If there are no subscribers for this Topic, nothing to do.
+    if (!topicSubs.length) {
+      return;
+    }
+
+    // Notify all Topic subscribers of this event
+    topicSubs.forEach(function (_ref6) {
+      var callback = _ref6.callback;
+      return callback(payload);
+    });
+  };
+  var flushQueue = function flushQueue() {
+    publishQueue = {};
+  };
+  return {
+    subscribe: subscribe,
+    subscribeAll: subscribeAll,
+    publish: publish,
+    flushQueue: flushQueue
+  };
+};
+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 _usePubSub = usePubSub(),
+    subscribe = _usePubSub.subscribe;
+  var callbackRef = (0, _react.useRef)(callback);
+  callbackRef.current = callback;
+  (0, _react.useEffect)(function () {
+    var unsubscribe = subscribe({
+      topic: topic,
+      triggerLatest: triggerLatest
+    }, function () {
+      return callbackRef.current.apply(callbackRef, arguments);
+    });
+    return unsubscribe;
+  },
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  [topic]);
+};
+var useSubscribeAll = exports.useSubscribeAll = function useSubscribeAll(callback) {
+  var _usePubSub2 = usePubSub(),
+    subscribeAll = _usePubSub2.subscribeAll;
+  var callbackRef = (0, _react.useRef)(callback);
+  callbackRef.current = callback;
+  (0, _react.useEffect)(function () {
+    var unsubscribe = subscribeAll(function () {
+      return callbackRef.current.apply(callbackRef, arguments);
+    });
+    return unsubscribe;
+  },
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  []);
+};
+var useFlushOnUnmount = function useFlushOnUnmount() {
+  var active = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+  var _usePubSub3 = usePubSub(),
+    flushQueue = _usePubSub3.flushQueue;
+  (0, _react.useLayoutEffect)(function () {
+    return function () {
+      if (active) {
+        flushQueue();
+      }
+    };
+  }, [active, flushQueue]);
+};
+var usePublish = exports.usePublish = function usePublish(topic) {
+  var _usePubSub4 = usePubSub(),
+    publish = _usePubSub4.publish;
+  var publishFn = (0, _react.useCallback)(function (payload) {
+    return publish(topic, payload);
+  }, [publish, topic]);
+  return publishFn;
+};
+var Subscriber = exports.Subscriber = function Subscriber(_ref8) {
+  var topic = _ref8.topic,
+    triggerLatest = _ref8.triggerLatest,
+    onEvent = _ref8.onEvent,
+    flushQueueOnUnmount = _ref8.flushQueueOnUnmount;
+  useSubscribe({
+    topic: topic,
+    triggerLatest: triggerLatest
+  }, onEvent);
+  useFlushOnUnmount(flushQueueOnUnmount);
+  return null;
+};

package/dist/cjs/types.js

@@ -0,0 +1,15 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Topics = void 0;
+var Topics = exports.Topics = {
+  AI_MATE: 'ai-mate'
+};
+
+// Not using the PayloadCore because the `data: type | undefined` is necessary
+// but `| undefined` will cause `data` to be removed by PayloadCore
+
+// Not using the PayloadCore because the `data: type | undefined` is necessary
+// but `| undefined` will cause `data` to be removed by PayloadCore

package/dist/es2019/common/utils/params/constants.js

@@ -0,0 +1,2 @@
+export const ROVO_PARAM_PREFIX = 'rovoChat';
+export const ROVO_VALID_PARAMS = ['pathway', 'agentId', 'conversationId', 'prompt', 'cloudId', 'triggerOpen'];