@atlaskit/rovo-triggers 1.0.0

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

@@ -0,0 +1,121 @@
+import { ROVO_PARAM_PREFIX, ROVO_VALID_PARAMS } from './constants';
+export const firstCharUpper = str => str.charAt(0).toUpperCase() + str.slice(1);
+export const firstCharLower = str => str.charAt(0).toLowerCase() + str.slice(1);
+const isValidURL = url => {
+  try {
+    new URL(url);
+    return true;
+  } catch (error) {
+    return false;
+  }
+};
+
+// For new style camelCase params
+export const addPrefix = param => `${ROVO_PARAM_PREFIX}${firstCharUpper(param)}`;
+export const removePrefix = param => {
+  return firstCharLower(param.replace(ROVO_PARAM_PREFIX, ''));
+};
+
+// Creates RovoChatParams from URLSearchParams
+// Optionally filter to specific params
+const processParams = (input, options = {
+  filter: []
+}) => {
+  const output = {};
+  const safeSearchParamsInput = typeof input === 'string' ? isValidURL(input) ? new URLSearchParams(new URL(input).search) : new URLSearchParams(input) : input;
+  const processedInput = new URLSearchParams(safeSearchParamsInput);
+  const extracted = new URLSearchParams();
+  safeSearchParamsInput.forEach((value, key) => {
+    var _options$filter;
+    // Only look at rovoChat params
+    if (!key.startsWith(ROVO_PARAM_PREFIX)) {
+      return;
+    }
+    const 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);
+  });
+  const combinedQueryString = [processedInput, extracted].map(params => params.toString()).filter(part => part.length > 0).join('&');
+  return {
+    processed: processedInput,
+    rovoParams: output,
+    combinedQueryString
+  };
+};
+
+// Get all rovoChat params from a URL or the current window location if undefined
+export const getRovoParams = url => {
+  try {
+    const search = url ? new URL(url).search : window.location.search;
+    const q = new URLSearchParams(search);
+    return processParams(q).rovoParams;
+  } catch (error) {
+    return {};
+  }
+};
+
+// Update the address bar without reloading the page
+export const updatePageRovoParams = params => {
+  window.history.pushState({}, '', addRovoParamsToUrl(window.location.pathname, params));
+};
+
+// Add any valid rovoChat params to a URL
+export const addRovoParamsToUrl = (url, params) => {
+  const {
+    processed,
+    rovoParams
+  } = processParams(url);
+  const rovoParamsWithExisting = {
+    ...rovoParams,
+    ...params
+  };
+  const baseUrl = url.includes('?') ? url.split('?')[0] : url;
+  const baseQuery = Array.from(processed).length ? `?${processed.toString()}&` : '?';
+  const updatedRovoParamsString = encodeRovoParams(rovoParamsWithExisting);
+  return `${baseUrl}${baseQuery}${updatedRovoParamsString}`;
+};
+export const encodeRovoParams = (params, encodeAsObject) => {
+  if (encodeAsObject) {
+    return Object.entries(params).reduce((acc, [key, value]) => {
+      acc[addPrefix(key)] = encodeURIComponent(value);
+      return acc;
+    }, {});
+  }
+  return Object.entries(params).map(([key, value]) => {
+    return `${addPrefix(key)}=${encodeURIComponent(value)}`;
+  }).join('&');
+};
+export const assertOnlySpecificFieldsDefined = (params, fields) => {
+  return Object.entries(params).every(([key, value]) => {
+    const field = fields.find(field => field === key);
+    if (field) {
+      return value !== undefined;
+    } else {
+      return value === undefined;
+    }
+  });
+};
+export const getListOfRovoParams = ({
+  resourceRouterQuery = false
+} = {}) => {
+  /*
+  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'
+  */
+  const suffix = resourceRouterQuery ? '!=false' : '';
+  return ROVO_VALID_PARAMS.map(param => `${addPrefix(param)}${suffix}`);
+};

package/dist/es2019/index.js

@@ -0,0 +1,2 @@
+export { usePublish, useSubscribe, useSubscribeAll, Subscriber } from './main';
+export { getRovoParams, updatePageRovoParams, addRovoParamsToUrl, assertOnlySpecificFieldsDefined, encodeRovoParams, getListOfRovoParams } from './common/utils/params';

package/dist/es2019/main.js

@@ -0,0 +1,159 @@
+import { useCallback, useEffect, useLayoutEffect, useRef } from 'react';
+const ignoredTriggerLatestEvents = new Set(['editor-context-payload']);
+const createPubSub = () => {
+  let subscribedEvents = {};
+  let publishQueue = {};
+  let wildcardEvents = [];
+  const subscribe = ({
+    topic,
+    triggerLatest
+  }, callback) => {
+    var _subscribedEvents$top;
+    const events = (_subscribedEvents$top = subscribedEvents[topic]) !== null && _subscribedEvents$top !== void 0 ? _subscribedEvents$top : [];
+    const subId = events.length.toString();
+    const subExists = events.some(({
+      id
+    }) => id === subId);
+
+    // Push to Topic stack if not already there
+    if (!subExists) {
+      subscribedEvents = {
+        ...subscribedEvents,
+        [topic]: [...events, {
+          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]) {
+        const payload = publishQueue[topic];
+        callback(payload);
+        delete publishQueue[topic];
+      }
+    }
+    return () => {
+      // Remove from Topic stack
+      subscribedEvents = {
+        ...subscribedEvents,
+        [topic]: (subscribedEvents[topic] || []).filter(({
+          id
+        }) => id !== subId)
+      };
+    };
+  };
+  const subscribeAll = callback => {
+    const subId = wildcardEvents.length.toString();
+    wildcardEvents = [...wildcardEvents, {
+      callback,
+      id: subId
+    }];
+    return () => {
+      wildcardEvents = wildcardEvents.filter(({
+        id
+      }) => id !== subId);
+    };
+  };
+  const 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(({
+      callback
+    }) => callback(payload));
+    const 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(({
+      callback
+    }) => callback(payload));
+  };
+  const flushQueue = () => {
+    publishQueue = {};
+  };
+  return {
+    subscribe,
+    subscribeAll,
+    publish,
+    flushQueue
+  };
+};
+const pubSub = createPubSub();
+const usePubSub = () => {
+  return pubSub;
+};
+export const useSubscribe = ({
+  topic,
+  triggerLatest
+}, callback) => {
+  const {
+    subscribe
+  } = usePubSub();
+  const callbackRef = useRef(callback);
+  callbackRef.current = callback;
+  useEffect(() => {
+    const unsubscribe = subscribe({
+      topic,
+      triggerLatest
+    }, (...args) => callbackRef.current(...args));
+    return unsubscribe;
+  },
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  [topic]);
+};
+export const useSubscribeAll = callback => {
+  const {
+    subscribeAll
+  } = usePubSub();
+  const callbackRef = useRef(callback);
+  callbackRef.current = callback;
+  useEffect(() => {
+    const unsubscribe = subscribeAll((...args) => callbackRef.current(...args));
+    return unsubscribe;
+  },
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  []);
+};
+const useFlushOnUnmount = (active = false) => {
+  const {
+    flushQueue
+  } = usePubSub();
+  useLayoutEffect(() => {
+    return () => {
+      if (active) {
+        flushQueue();
+      }
+    };
+  }, [active, flushQueue]);
+};
+export const usePublish = topic => {
+  const {
+    publish
+  } = usePubSub();
+  const publishFn = useCallback(payload => publish(topic, payload), [publish, topic]);
+  return publishFn;
+};
+export const Subscriber = ({
+  topic,
+  triggerLatest,
+  onEvent,
+  flushQueueOnUnmount
+}) => {
+  useSubscribe({
+    topic,
+    triggerLatest
+  }, onEvent);
+  useFlushOnUnmount(flushQueueOnUnmount);
+  return null;
+};

package/dist/es2019/types.js

@@ -0,0 +1,9 @@
+export const 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/esm/common/utils/params/constants.js

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

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

@@ -0,0 +1,146 @@
+import _slicedToArray from "@babel/runtime/helpers/slicedToArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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; }
+import { ROVO_PARAM_PREFIX, ROVO_VALID_PARAMS } from './constants';
+export var firstCharUpper = function firstCharUpper(str) {
+  return str.charAt(0).toUpperCase() + str.slice(1);
+};
+export var 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
+export var addPrefix = function addPrefix(param) {
+  return "".concat(ROVO_PARAM_PREFIX).concat(firstCharUpper(param));
+};
+export var removePrefix = function removePrefix(param) {
+  return firstCharLower(param.replace(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(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
+export var 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
+export var updatePageRovoParams = function updatePageRovoParams(params) {
+  window.history.pushState({}, '', addRovoParamsToUrl(window.location.pathname, params));
+};
+
+// Add any valid rovoChat params to a URL
+export var 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);
+};
+export var encodeRovoParams = function encodeRovoParams(params, encodeAsObject) {
+  if (encodeAsObject) {
+    return Object.entries(params).reduce(function (acc, _ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+        key = _ref2[0],
+        value = _ref2[1];
+      acc[addPrefix(key)] = encodeURIComponent(value);
+      return acc;
+    }, {});
+  }
+  return Object.entries(params).map(function (_ref3) {
+    var _ref4 = _slicedToArray(_ref3, 2),
+      key = _ref4[0],
+      value = _ref4[1];
+    return "".concat(addPrefix(key), "=").concat(encodeURIComponent(value));
+  }).join('&');
+};
+export var assertOnlySpecificFieldsDefined = function assertOnlySpecificFieldsDefined(params, fields) {
+  return Object.entries(params).every(function (_ref5) {
+    var _ref6 = _slicedToArray(_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;
+    }
+  });
+};
+export var 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 ROVO_VALID_PARAMS.map(function (param) {
+    return "".concat(addPrefix(param)).concat(suffix);
+  });
+};

package/dist/esm/index.js

@@ -0,0 +1,2 @@
+export { usePublish, useSubscribe, useSubscribeAll, Subscriber } from './main';
+export { getRovoParams, updatePageRovoParams, addRovoParamsToUrl, assertOnlySpecificFieldsDefined, encodeRovoParams, getListOfRovoParams } from './common/utils/params';

package/dist/esm/main.js

@@ -0,0 +1,162 @@
+import _toConsumableArray from "@babel/runtime/helpers/toConsumableArray";
+import _defineProperty from "@babel/runtime/helpers/defineProperty";
+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; }
+import { useCallback, useEffect, useLayoutEffect, useRef } from 'react';
+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), {}, _defineProperty({}, topic, [].concat(_toConsumableArray(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), {}, _defineProperty({}, 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(_toConsumableArray(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;
+};
+export var useSubscribe = function useSubscribe(_ref7, callback) {
+  var topic = _ref7.topic,
+    triggerLatest = _ref7.triggerLatest;
+  var _usePubSub = usePubSub(),
+    subscribe = _usePubSub.subscribe;
+  var callbackRef = useRef(callback);
+  callbackRef.current = callback;
+  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]);
+};
+export var useSubscribeAll = function useSubscribeAll(callback) {
+  var _usePubSub2 = usePubSub(),
+    subscribeAll = _usePubSub2.subscribeAll;
+  var callbackRef = useRef(callback);
+  callbackRef.current = callback;
+  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;
+  useLayoutEffect(function () {
+    return function () {
+      if (active) {
+        flushQueue();
+      }
+    };
+  }, [active, flushQueue]);
+};
+export var usePublish = function usePublish(topic) {
+  var _usePubSub4 = usePubSub(),
+    publish = _usePubSub4.publish;
+  var publishFn = useCallback(function (payload) {
+    return publish(topic, payload);
+  }, [publish, topic]);
+  return publishFn;
+};
+export var 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/esm/types.js

@@ -0,0 +1,9 @@
+export var 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/types/common/utils/params/constants.d.ts

@@ -0,0 +1,3 @@
+import { type ValidParam, type ValidPrefix } from './types';
+export declare const ROVO_PARAM_PREFIX: ValidPrefix;
+export declare const ROVO_VALID_PARAMS: ValidParam[];

package/dist/types/common/utils/params/index.d.ts

@@ -0,0 +1,15 @@
+import { type RovoChatParams, type ValidParam } from './types';
+export declare const firstCharUpper: (str: string) => string;
+export declare const firstCharLower: (str: string) => string;
+export declare const addPrefix: (param: ValidParam) => string;
+export declare const removePrefix: (param: string) => string;
+export declare const getRovoParams: (url?: string) => RovoChatParams;
+export declare const updatePageRovoParams: (params: RovoChatParams) => void;
+export declare const addRovoParamsToUrl: (url: string, params: RovoChatParams) => string;
+export declare const encodeRovoParams: (params: RovoChatParams, encodeAsObject?: boolean) => string | {
+    [key: string]: string;
+};
+export declare const assertOnlySpecificFieldsDefined: (params: RovoChatParams, fields: (keyof RovoChatParams)[]) => boolean;
+export declare const getListOfRovoParams: ({ resourceRouterQuery }?: {
+    resourceRouterQuery?: boolean | undefined;
+}) => string[];

package/dist/types/common/utils/params/types.d.ts

@@ -0,0 +1,20 @@
+export type RovoChatPathway = 'chat' | 'agents-browse' | 'agents-create';
+export interface BaseRovoChatParams {
+    pathway: RovoChatPathway;
+    agentId: string;
+    conversationId: string;
+    prompt: string;
+    cloudId: string;
+    triggerOpen: boolean;
+}
+export type ValidPrefix = 'rovoChat';
+export type ValidParam = keyof BaseRovoChatParams;
+export type ValidPrefixedParam = `${ValidPrefix}${ValidParam}`;
+type RovoParams<T extends RovoChatPathway, P = object> = BaseRovoChatParams & {
+    pathway: T;
+} & P;
+type ChatParams = RovoParams<'chat'>;
+type AgentBrowseParams = RovoParams<'agents-browse'>;
+type AgentCreateParams = RovoParams<'agents-create'>;
+export type RovoChatParams = Partial<ChatParams | AgentCreateParams | AgentBrowseParams>;
+export {};

package/dist/types/index.d.ts

@@ -0,0 +1,4 @@
+export { usePublish, useSubscribe, useSubscribeAll, Subscriber } from './main';
+export type { Payload, Callback, Topic, EditorContextPayloadData, BrowserContextPayloadData, } from './types';
+export { getRovoParams, updatePageRovoParams, addRovoParamsToUrl, assertOnlySpecificFieldsDefined, encodeRovoParams, getListOfRovoParams, } from './common/utils/params';
+export type { RovoChatParams, RovoChatPathway } from './common/utils/params/types';