@pitcher/js-api 1.22.0-alpha.6 → 1.22.0-beta.0

package/js-api.esm.js

@@ -1,4 +1,4 @@
-import { camelCase, snakeCase, cloneDeep } from 'lodash-es';
+import { camelCase, snakeCase, pickBy, cloneDeep, isEqual } from 'lodash-es';
 
 function _mergeNamespaces(n, m) {
 	for (var i = 0; i < m.length; i++) {
@@ -2409,8 +2409,17 @@ function createCanvas$1(payload) {
 function deleteCanvas(payload) {
   return this.API.request("delete_canvas", payload);
 }
-function updateCanvas$1(payload) {
-  return this.API.request("update_canvas", payload);
+function updateCanvas$2(payload) {
+  let shouldDebug = false;
+  if (typeof window !== "undefined") {
+    const urlParams = new URLSearchParams(window.location.search);
+    shouldDebug = urlParams.get("debug") === "true" || !!window.debug;
+  }
+  shouldDebug && console.info("JS API UPDATE CANVAS", payload);
+  return this.API.request("update_canvas", payload).then((res) => {
+    shouldDebug && console.info("JS API UPDATE CANVAS RESPONSE", res);
+    return res;
+  });
 }
 function getCanvas$1(payload) {
   return this.API.request("get_canvas", payload);
@@ -2419,7 +2428,7 @@ function shareCanvas(payload) {
   return this.API.request("share_canvas", payload);
 }
 
-function getFiles(payload) {
+function getFiles$1(payload) {
   const p = { ...payload };
   if (p.type) {
     p.type = Array.isArray(p.type) ? p.type : [p.type];
@@ -2435,11 +2444,12 @@ function getRecentFiles(payload) {
 function downloadFile(payload) {
   return this.API.request("download_file", payload);
 }
-function getAppConfig(payload) {
+function getAppConfig$1(payload) {
   return this.API.request("get_app_config", payload);
 }
-function getFile(payload) {
-  return this.API.request("get_file", payload);
+function getFile$1(payload) {
+  const { id, file_id } = payload;
+  return this.API.request("get_file", { file_id: id || file_id });
 }
 function updateFile(payload) {
   return this.API.request("update_file", payload);
@@ -2462,7 +2472,10 @@ function getUsers(payload) {
   return this.API.request("get_users", payload);
 }
 function refreshServiceToken(payload) {
-  return this.API.request("refresh_service_token", payload);
+  return this.API.request("refresh_service_token", payload ?? {});
+}
+function refreshAccessToken() {
+  return this.API.request("refresh_access_token");
 }
 
 function fetchDocumentInfo(payload) {
@@ -2472,7 +2485,7 @@ function renderPageAsImage(payload) {
   return this.API.request("render_page_as_image", payload);
 }
 
-function toast$1(payload) {
+function toast$2(payload) {
   return this.API.request("toast", payload);
 }
 
@@ -2551,14 +2564,14 @@ const modules = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
 	deleteFolder,
 	downloadFile,
 	fetchDocumentInfo,
-	getAppConfig,
+	getAppConfig: getAppConfig$1,
 	getCanvas: getCanvas$1,
 	getCanvases: getCanvases$1,
 	getEnv: getEnv$2,
 	getEvents,
 	getFavorites,
-	getFile,
-	getFiles,
+	getFile: getFile$1,
+	getFiles: getFiles$1,
 	getFolder,
 	getInstanceMetadataTemplates: getInstanceMetadataTemplates$1,
 	getLanguages,
@@ -2570,16 +2583,17 @@ const modules = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
 	openExternalUrl,
 	openWebViewAlwaysOnTop,
 	query,
+	refreshAccessToken,
 	refreshServiceToken,
 	renderPageAsImage,
 	search,
 	selectDeviceFile,
 	shareCanvas,
 	submitUserFeedback,
-	toast: toast$1,
+	toast: toast$2,
 	track,
 	triggerNonFilesSync,
-	updateCanvas: updateCanvas$1,
+	updateCanvas: updateCanvas$2,
 	updateEvent,
 	updateFile,
 	updateFolder,
@@ -2761,6 +2775,29 @@ const snakeCaseKeys = (obj, skipKeys = defaultSkipKeys, skipObjectKeys = default
   return obj;
 };
 
+function truncateObject(obj, currentDepth = 1, lengthTrigger = 20) {
+  if (typeof obj !== "object" || obj === null) {
+    return obj;
+  }
+  if (Array.isArray(obj)) {
+    if (obj.length > lengthTrigger && currentDepth <= 0) {
+      return `[Truncated - ${obj.length} length array]`;
+    }
+    return obj.map((item) => truncateObject(item, currentDepth - 1, lengthTrigger));
+  }
+  const keys = Object.keys(obj);
+  if (keys.length > lengthTrigger && currentDepth <= 0) {
+    return `{Truncated - ${keys.length} properties obj}`;
+  }
+  return keys.reduce(
+    (acc, key) => {
+      acc[key] = truncateObject(obj[key], currentDepth - 1, lengthTrigger);
+      return acc;
+    },
+    {}
+  );
+}
+
 function isOriginValid(event, allowedOrigins = [], isDev = ["development", "test"].includes("production")) {
   if (isDev) {
     return true;
@@ -2780,27 +2817,72 @@ function isOriginValid(event, allowedOrigins = [], isDev = ["development", "test
 
 const MAX_RETRIES = 5;
 const BASE_DELAY = 1e3;
+let refreshPromise = null;
+async function refreshToken() {
+  if (refreshPromise) return refreshPromise;
+  console.info("Refreshing access token...");
+  refreshPromise = (async () => {
+    try {
+      return await highLevelApi.refreshAccessToken().then(
+        (accessTokenResponse) => highLevelApi.getEnv().then((env) => {
+          setEnv(env);
+          return accessTokenResponse.access_token;
+        })
+      );
+    } catch (error) {
+      console.error("Failed to refresh token:", error);
+      throw error;
+    } finally {
+      refreshPromise = null;
+    }
+  })();
+  return refreshPromise;
+}
 function paramsSerializer(params) {
   const searchParams = new URLSearchParams();
-  for (const key in params) {
-    if (Array.isArray(params[key])) {
-      params[key].forEach((val) => searchParams.append(key, val));
+  function addParam(key, value) {
+    if (value === void 0 || value === null) {
+      return;
+    }
+    if (Array.isArray(value)) {
+      value.forEach((val) => addParam(key, val));
+    } else if (typeof value === "object" && !Array.isArray(value)) {
+      for (const subKey in value) {
+        addParam(`${key}[${subKey}]`, value[subKey]);
+      }
     } else {
-      searchParams.append(key, params[key]);
+      searchParams.append(key, value);
     }
   }
+  for (const key in params) {
+    addParam(key, params[key]);
+  }
   return searchParams.toString();
 }
 async function fetchWithRetry(url, options, remainingRetries = MAX_RETRIES) {
   try {
     const response = await fetch(url, options);
     if (!response.ok) {
-      if (response.status >= 500 && response.status < 600 && remainingRetries > 0) {
+      if (response.status === 401) {
+        const newToken = await refreshToken();
+        options.headers = options.headers || {};
+        options.headers.Authorization = `Bearer ${newToken}`;
+        return fetchWithRetry(url, options, remainingRetries);
+      } else if (response.status >= 500 && response.status < 600 && remainingRetries > 0) {
         const delay = BASE_DELAY * Math.pow(2, MAX_RETRIES - remainingRetries);
         await new Promise((resolve) => setTimeout(resolve, delay));
         return fetchWithRetry(url, options, remainingRetries - 1);
+      } else {
+        const errorData = await response.json();
+        const error = new Error(
+          `HTTP error! status: ${response.status}, message: ${errorData.message || response.statusText}`
+        );
+        error.status = response.status;
+        throw error;
       }
-      throw new Error(`HTTP error! status: ${response.status}`);
+    }
+    if (response.status === 204 || response.status === 205) {
+      return;
     }
     return response.json();
   } catch (error) {
@@ -2891,13 +2973,26 @@ function createHttpClient(origin, token) {
   };
 }
 
+function normalizeNetworkFilterParams(params) {
+  if (!params) return {};
+  return Object.entries(params).reduce(
+    (acc, [key, value]) => {
+      acc[key] = key.endsWith("__range") && Array.isArray(value) ? value.join(",") : value;
+      return acc;
+    },
+    {}
+  );
+}
+
 let env;
 let http;
-const logInfo = (msg, ...rest) => console.info(`[online handlers]: ${msg}`, ...rest);
-const check = () => {
+function check() {
   if (!env) throw new Error("Missing env");
   if (!http) throw new Error("Missing http");
-};
+}
+function pickNonNullish(data) {
+  return pickBy(data ?? {}, (v) => v !== void 0 && v !== null);
+}
 const setEnv = (e) => {
   env = e;
   http = createHttpClient(
@@ -2907,21 +3002,58 @@ const setEnv = (e) => {
 };
 const onlineRestApiHandlers = {
   get_canvases: async (params) => {
-    logInfo("online handler get_canvases called with:", params);
     check();
-    const { api_base_url, ...restParams } = params;
-    const res = await http.get("/canvases", { params: { ...restParams, instance_id: env.pitcher.instance.id } });
+    const { api_base_url, filters = {}, ...restParams } = params;
+    const res = await http.get("/canvases", {
+      params: {
+        instance_id: env.pitcher.instance.id,
+        ...normalizeNetworkFilterParams(filters),
+        ...pickNonNullish(restParams)
+      }
+    });
     return res;
   },
   get_canvas: async (params) => {
-    logInfo("online handler get_canvas called with:", params);
     check();
     const { id, ...restParams } = params;
     const res = await http.get(`/canvases/${params.id}`, { params: restParams });
     return res;
+  },
+  create_canvas: async (params) => {
+    check();
+    const res = await http.post("/canvases", { ...params, instance_id: env.pitcher.instance.id });
+    return res;
+  },
+  update_canvas: async (params) => {
+    check();
+    const { id, ...restParams } = params;
+    const res = await http.patch(`/canvases/${params.id}`, restParams);
+    return res;
+  },
+  delete_canvas: async (params) => {
+    check();
+    const res = await http.delete(`/canvases/${params.id}`);
+    return res;
+  },
+  share_canvas: async (params) => {
+    check();
+    let link;
+    try {
+      link = await http.get(`/shared-links/canvas/${params.id}`);
+    } catch (e) {
+      if (e?.status === 404) {
+        link = await http.post("/shared-links", {
+          canvas_id: params.id
+        });
+      } else {
+        throw e;
+      }
+    }
+    return link;
   }
 };
 
+const TRUNCATE_LENGTH_TRIGGER = 10;
 function updateOnlineHandlersEnv(env) {
   env && setEnv(env);
 }
@@ -2965,7 +3097,7 @@ class LowLevelApi extends EventEmitter {
     this.emit("event", event);
   }
   request(type, body = null) {
-    const fetchMode = this.options.fetchMode ?? "prefer-online";
+    const fetchMode = this.options.fetchMode ?? "postmessage";
     return new Promise((resolve, reject) => {
       const id = v4();
       const callback = (res) => {
@@ -2976,10 +3108,12 @@ class LowLevelApi extends EventEmitter {
           );
           if (type === "get_env") updateOnlineHandlersEnv(res.response.body);
         } else if (res.response.status === "error") {
-          this.options.errorLogger?.({
-            message: `Pitcher JS API call failure: ${res.request.type}`,
-            js_api_response: JSON.stringify(res)
-          });
+          if (this.options.errorLogger) {
+            this.options.errorLogger({
+              message: `Pitcher JS API call failure: ${res.request.type}`,
+              js_api_response: JSON.stringify(truncateObject(res, 3, TRUNCATE_LENGTH_TRIGGER))
+            });
+          }
           reject(this.options.casing === "camel" ? camelCaseKeys(res.response.body) : res.response.body);
         } else {
           throw new Error("unsupported response status");
@@ -3040,15 +3174,105 @@ function createHighLevelApi(options) {
   return {
     API,
     ...modules,
+    /**
+     * Subscribe to a given event type by its key.
+     *
+     * @param {string} type - The event type to subscribe to.
+     * @param {(payload: PitcherEvent) => void} callback - The callback function to handle the event.
+     * @returns A Promise resolving to a cleanup function to unsubscribe from the event.     * @example
+     *
+     * @example
+     * const unsubscribeFromSectionListUpdate = usePitcherApi().on('entered_fullscreen', (event: object) => {
+     *   // handle event
+     * })
+     * // later
+     * unsubscribeFromSectionListUpdate()
+     */
     on: (type, callback) => eventEmitter.on(type, callback),
+    /**
+     * Unsubscribe from a given event type by its key and the attached callback reference.
+     * @param {string} type - The event type to unsubscribe from.
+     * @param {(payload: PitcherEvent) => void} callback - The callback function reference to remove.
+     *
+     * @example
+     * const callback = (event: object) => {
+     *   // handle event
+     * }
+     * usePitcherApi().on('entered_fullscreen', callback)
+     * // later
+     * usePitcherApi().off('entered_fullscreen', callback)
+     */
     off: (type, callback) => eventEmitter.off(type, callback),
+    /**
+     * Make the entire CatalogIQ fullscreen.
+     *
+     * @example
+     * usePitcherApi().enterFullscreen()
+     */
     enterFullscreen: () => API.request("enter_fullscreen"),
+    /**
+     * Exit fullscreen mode.
+     *
+     * @example
+     * usePitcherApi().exitFullscreen()
+     */
     exitFullscreen: () => API.request("exit_fullscreen"),
+    /**
+     * Return is CatalogIQ in fullscreen.
+     *
+     * @example
+     * usePitcherApi().isFullscreen()
+     */
+    isFullscreen: () => API.request("is_fullscreen"),
+    /**
+     * Log out the current user.
+     *
+     * @example
+     * usePitcherApi().logout()
+     */
     logout: () => API.request("logout"),
+    /**
+     * Quit the current instance and go to the instance selection screen.
+     *
+     * @example
+     * usePitcherApi().quitInstance()
+     */
     quitInstance: () => API.request("quit_instance"),
+    /**
+     * Get the request types.
+     *
+     * @returns {Promise<any>}
+     */
     getRequestTypes: () => API.request("get_request_types"),
+    /**
+     * Broadcast an event to CatalogIQ.
+     * @param {PitcherEvent} event - The event to broadcast.
+     *
+     * @example
+     * usePitcherApi()
+     *   .broadcast({
+     *     type: "canvas_updated",
+     *     body: { context: { myContextProperty: 'test' } },
+     *   })
+     *   .then(function (result) {
+     *     useUi().toast({
+     *       message: "Canvas Populated.",
+     *       type: "info",
+     *     })
+     *   })
+     */
     broadcast: (event) => API.request("broadcast", event),
+    /**
+     * Subscribe to updates.
+     *
+     * @returns {Promise<void>}
+     */
     subscribe: () => API.request("subscribe"),
+    /**
+     * Unsubscribe from updates.
+     *
+     * @returns {Promise<void>}
+     */
     unsubscribe: () => API.request("unsubscribe")
   };
 }
@@ -3062,17 +3286,20 @@ const UI_MESSAGE = "UI_MESSAGE";
 const UI_API_METHOD_TYPES = {
   UI_BROADCAST: "ui_broadcast",
   UI_SELECT_CONTENT: "ui_select_content",
+  UI_SELECT_CANVASES: "ui_select_canvases",
   UI_OPEN: "ui_open",
   UI_EMBEDDABLE_READY: "ui_embeddable_ready",
   UI_TOAST: "ui_toast",
   UI_CAPTURE_APP_ERROR: "ui_capture_app_error",
   UI_UPDATE_CANVAS: "ui_update_canvas",
+  UI_OPEN_CANVAS_OVERLAY: "ui_open_canvas_overlay",
   UI_UPDATE_LOCATION: "ui_update_location",
   UI_PRESELECT_SFDC_MEETING_ID: "ui_preselect_sfdc_meeting_id",
   UI_SET_POSTCALL_STYLE: "ui_set_postcall_style",
   UI_ENABLE_POSTCALL_SUBMIT: "ui_enable_postcall_submit",
   UI_DISABLE_POSTCALL_SUBMIT: "ui_disable_postcall_submit",
   UI_COMPLETE_POSTCALL: "ui_complete_postcall",
+  UI_STOP_MEETING: "ui_stop_meeting",
   UI_CANVAS_NAVIGATE_NEXT_PAGE: "ui_canvas_navigate_next_page",
   UI_CANVAS_NAVIGATE_PREVIOUS_PAGE: "ui_canvas_navigate_previous_page",
   UI_CANVAS_NAVIGATE_PAGE: "ui_canvas_navigate_page",
@@ -3100,7 +3327,7 @@ async function ui_select_content(payload = {}) {
   const response = await pr.send(window.parent, UI_API_METHOD_TYPES.UI_SELECT_CONTENT, payload);
   return response.data;
 }
-async function select_content(payload = {}) {
+async function selectContent$1(payload = {}) {
   const pr = await usePostRobot();
   const response = await pr.send(window.parent, UI_API_METHOD_TYPES.UI_SELECT_CONTENT, payload);
   return response.data;
@@ -3109,73 +3336,130 @@ async function open(payload) {
   const pr = await usePostRobot();
   await pr.send(window.parent, UI_API_METHOD_TYPES.UI_OPEN, payload);
 }
-async function toast(payload) {
+async function toast$1(payload) {
   const pr = await usePostRobot();
   await pr.send(window.parent, UI_API_METHOD_TYPES.UI_TOAST, payload);
 }
-async function preselect_sfdc_meeting_id(payload) {
+async function preselectSfdcMeetingId(payload) {
   const pr = await usePostRobot();
   const response = await pr.send(window.parent, UI_API_METHOD_TYPES.UI_PRESELECT_SFDC_MEETING_ID, payload);
   return response.data;
 }
 
-async function embeddable_ready$1() {
+const contentUi = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+	__proto__: null,
+	open,
+	preselectSfdcMeetingId,
+	selectContent: selectContent$1,
+	toast: toast$1,
+	ui_select_content
+}, Symbol.toStringTag, { value: 'Module' }));
+
+async function embeddableReady$1() {
   const pr = await usePostRobot();
   await pr.send(window.parent, UI_API_METHOD_TYPES.UI_EMBEDDABLE_READY);
 }
 
-async function update_location(payload) {
+const loadingUi = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+	__proto__: null,
+	embeddableReady: embeddableReady$1
+}, Symbol.toStringTag, { value: 'Module' }));
+
+async function updateLocation(payload) {
   const pr = await usePostRobot();
   return pr.send(window.top, UI_API_METHOD_TYPES.UI_UPDATE_LOCATION, payload);
 }
 
-async function capture_app_error(payload) {
+const locationUi = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+	__proto__: null,
+	updateLocation
+}, Symbol.toStringTag, { value: 'Module' }));
+
+async function captureAppError(payload) {
   const pr = await usePostRobot();
   pr.send(window.parent, UI_API_METHOD_TYPES.UI_CAPTURE_APP_ERROR, payload);
 }
 
-async function update_canvas(payload) {
+const appErrorsUi = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+	__proto__: null,
+	captureAppError
+}, Symbol.toStringTag, { value: 'Module' }));
+
+async function updateCanvas$1(payload) {
   const pr = await usePostRobot();
   return pr.send(window.parent, UI_API_METHOD_TYPES.UI_UPDATE_CANVAS, payload).then((response) => response.data);
 }
-async function app_loaded() {
+async function appLoaded() {
   window.parent.postMessage({ type: UI_API_METHOD_TYPES.UI_APP_LOADED, body: {} }, "*");
 }
-async function app_resize(payload) {
+async function appResize(payload) {
   window.parent.postMessage({ type: UI_API_METHOD_TYPES.UI_APP_RESIZE, body: payload }, "*");
 }
-async function canvas_navigate_next_page() {
+async function canvasNavigateNextPage() {
   const pr = await usePostRobot();
   pr.send(window.parent, UI_API_METHOD_TYPES.UI_CANVAS_NAVIGATE_NEXT_PAGE);
 }
-async function canvas_navigate_previous_page() {
+async function canvasNavigatePreviousPage() {
   const pr = await usePostRobot();
   pr.send(window.parent, UI_API_METHOD_TYPES.UI_CANVAS_NAVIGATE_PREVIOUS_PAGE);
 }
-async function canvas_navigate_page(payload) {
+async function canvasNavigatePage(payload) {
   const pr = await usePostRobot();
   pr.send(window.parent, UI_API_METHOD_TYPES.UI_CANVAS_NAVIGATE_PAGE, payload);
 }
+async function openCanvasOverlay$1(payload) {
+  const pr = await usePostRobot();
+  await pr.send(window.parent, UI_API_METHOD_TYPES.UI_OPEN_CANVAS_OVERLAY, payload);
+}
+async function selectCanvases$1(payload = {}) {
+  const pr = await usePostRobot();
+  const response = await pr.send(window.parent, UI_API_METHOD_TYPES.UI_SELECT_CANVASES, payload);
+  return response.data;
+}
 
-async function complete_postcall(payload) {
+const canvasUi = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+	__proto__: null,
+	appLoaded,
+	appResize,
+	canvasNavigateNextPage,
+	canvasNavigatePage,
+	canvasNavigatePreviousPage,
+	openCanvasOverlay: openCanvasOverlay$1,
+	selectCanvases: selectCanvases$1,
+	updateCanvas: updateCanvas$1
+}, Symbol.toStringTag, { value: 'Module' }));
+
+async function completePostcall(payload) {
   const pr = await usePostRobot();
   pr.send(window.parent, UI_API_METHOD_TYPES.UI_COMPLETE_POSTCALL, payload);
 }
-async function enable_postcall_submit() {
+async function stopMeeting() {
+  const pr = await usePostRobot();
+  pr.send(window.parent, UI_API_METHOD_TYPES.UI_STOP_MEETING);
+}
+async function enablePostcallSubmit() {
   const pr = await usePostRobot();
   pr.send(window.parent, UI_API_METHOD_TYPES.UI_ENABLE_POSTCALL_SUBMIT);
 }
-async function disable_postcall_submit() {
+async function disablePostcallSubmit() {
   const pr = await usePostRobot();
   pr.send(window.parent, UI_API_METHOD_TYPES.UI_DISABLE_POSTCALL_SUBMIT);
 }
-async function set_postcall_style(payload) {
+async function setPostcallStyle(payload) {
   const pr = await usePostRobot();
   pr.send(window.parent, UI_API_METHOD_TYPES.UI_SET_POSTCALL_STYLE, payload);
 }
 
-async function on_native(type, handler) {
-  console.log("attaching native handler for type", type);
+const postCallUi = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+	__proto__: null,
+	completePostcall,
+	disablePostcallSubmit,
+	enablePostcallSubmit,
+	setPostcallStyle,
+	stopMeeting
+}, Symbol.toStringTag, { value: 'Module' }));
+
+async function onNative(type, handler) {
   const messageListener = (event) => {
     if (event.data.type === type) {
       handler(event.data.body);
@@ -3184,65 +3468,51 @@ async function on_native(type, handler) {
   window.addEventListener("message", messageListener);
   return () => window.removeEventListener("message", messageListener);
 }
-async function on_post_robot(type, handler) {
+async function onPostRobot(type, handler) {
   const pr = await usePostRobot();
   const listener = pr.on(type, (e) => handler(e.data));
   return listener.cancel;
 }
 function on$2(type, handler) {
   if (UI_NATIVE_MESSAGE_TYPES.includes(type)) {
-    return on_native(type, handler);
+    return onNative(type, handler);
   }
-  return on_post_robot(type, handler);
+  return onPostRobot(type, handler);
 }
-function on_meeting_canceled(handler) {
+function onMeetingCanceled(handler) {
   return on$2(UI_MESSAGE_TYPES.UI_MEETING_CANCELED, handler);
 }
-function on_canvas_updated(handler) {
+function onCanvasUpdated(handler) {
   return on$2(UI_MESSAGE_TYPES.UI_CANVAS_UPDATED, handler);
 }
-function on_section_list_updated(handler) {
+function onSectionListUpdated(handler) {
   return on$2(UI_MESSAGE_TYPES.UI_SECTION_LIST_UPDATED, handler);
 }
-function on_app_set_data(handler) {
+function onAppSetData(handler) {
   return on$2(UI_MESSAGE_TYPES.UI_APP_SET_DATA, handler);
 }
-function on_app_update_data(handler) {
+function onAppUpdateData(handler) {
   return on$2(UI_MESSAGE_TYPES.UI_APP_UPDATE_DATA, handler);
 }
-async function ui_broadcast(payload) {
+async function uiBroadcast(payload) {
   const pr = await usePostRobot();
   pr.send(window.parent, UI_API_METHOD_TYPES.UI_BROADCAST, payload);
 }
-
-const ui = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	app_loaded,
-	app_resize,
-	canvas_navigate_next_page,
-	canvas_navigate_page,
-	canvas_navigate_previous_page,
-	capture_app_error,
-	complete_postcall,
-	disable_postcall_submit,
-	embeddable_ready: embeddable_ready$1,
-	enable_postcall_submit,
-	on: on$2,
-	on_app_set_data,
-	on_app_update_data,
-	on_canvas_updated,
-	on_meeting_canceled,
-	on_section_list_updated,
-	open,
-	preselect_sfdc_meeting_id,
-	select_content,
-	set_postcall_style,
-	toast,
-	ui_broadcast,
-	ui_select_content,
-	update_canvas,
-	update_location
-}, Symbol.toStringTag, { value: 'Module' }));
+const ui = {
+  on: on$2,
+  onMeetingCanceled,
+  onCanvasUpdated,
+  onSectionListUpdated,
+  onAppSetData,
+  onAppUpdateData,
+  uiBroadcast,
+  ...contentUi,
+  ...loadingUi,
+  ...locationUi,
+  ...appErrorsUi,
+  ...canvasUi,
+  ...postCallUi
+};
 
 const ADMIN_MESSAGE = "ADMIN_MESSAGE";
 const ADMIN_MESSAGE_TYPES = {
@@ -3254,12 +3524,18 @@ const ADMIN_API_TYPES = {
 };
 const ADMIN_API_METHOD_TYPES = {
   CREATE_CANVAS: "admin_create_canvas",
-  GET_ENV: "admin_get_env",
+  GET_APP_CONFIG: "admin_get_app_config",
   GET_CANVAS: "admin_get_canvas",
   GET_CANVASES: "admin_get_canvases",
-  UPDATE_CANVAS: "admin_update_canvas",
+  OPEN_CANVAS_OVERLAY: "admin_open_canvas_overlay",
+  GET_ENV: "admin_get_env",
+  GET_FILE: "admin_get_file",
+  GET_FILES: "admin_get_files",
   GET_INSTANCE_METADATA_TEMPLATES: "admin_get_instance_metadata_templates",
-  GET_APP_CONFIG: "admin_get_app_config"
+  TOAST: "admin_toast",
+  UPDATE_CANVAS: "admin_update_canvas",
+  SELECT_CONTENT: "admin_select_content",
+  SELECT_CANVASES: "admin_select_canvases"
 };
 
 async function getEnv$1() {
@@ -3268,6 +3544,11 @@ async function getEnv$1() {
   return response.data;
 }
 
+const envAdmin = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+	__proto__: null,
+	getEnv: getEnv$1
+}, Symbol.toStringTag, { value: 'Module' }));
+
 async function createCanvas(payload) {
   const pr = await usePostRobot();
   const response = await pr.send(window.parent, ADMIN_API_METHOD_TYPES.CREATE_CANVAS, payload);
@@ -3288,6 +3569,25 @@ async function updateCanvas(payload) {
   const r = await pr.send(window.parent, ADMIN_API_METHOD_TYPES.UPDATE_CANVAS, payload);
   return r.data;
 }
+async function openCanvasOverlay(payload) {
+  const pr = await usePostRobot();
+  await pr.send(window.parent, ADMIN_API_METHOD_TYPES.OPEN_CANVAS_OVERLAY, payload);
+}
+async function selectCanvases(payload = {}) {
+  const pr = await usePostRobot();
+  const response = await pr.send(window.parent, ADMIN_API_METHOD_TYPES.SELECT_CANVASES, payload);
+  return response.data;
+}
+
+const canvasAdmin = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+	__proto__: null,
+	createCanvas,
+	getCanvas,
+	getCanvases,
+	openCanvasOverlay,
+	selectCanvases,
+	updateCanvas
+}, Symbol.toStringTag, { value: 'Module' }));
 
 async function getInstanceMetadataTemplates(payload) {
   const pr = await usePostRobot();
@@ -3295,23 +3595,58 @@ async function getInstanceMetadataTemplates(payload) {
   return response.data;
 }
 
-async function on$1(type, handler) {
+const metadataTemplatesAdmin = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+	__proto__: null,
+	getInstanceMetadataTemplates
+}, Symbol.toStringTag, { value: 'Module' }));
+
+async function getAppConfig(payload) {
   const pr = await usePostRobot();
-  const listener = pr.on(type, (e) => handler(e.data));
-  return listener.cancel;
+  const response = await pr.send(window.parent, ADMIN_API_METHOD_TYPES.GET_APP_CONFIG, payload);
+  return response.data;
+}
+async function getFile(payload) {
+  const pr = await usePostRobot();
+  const response = await pr.send(window.parent, ADMIN_API_METHOD_TYPES.GET_FILE, payload);
+  return response.data;
+}
+async function getFiles(payload) {
+  const pr = await usePostRobot();
+  const response = await pr.send(window.parent, ADMIN_API_METHOD_TYPES.GET_FILES, payload);
+  return response.data;
+}
+async function selectContent(payload) {
+  const pr = await usePostRobot();
+  const response = await pr.send(window.parent, ADMIN_API_METHOD_TYPES.SELECT_CONTENT, payload);
+  return response.data;
 }
 
-const admin = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+const filesAdmin = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
 	__proto__: null,
-	createCanvas,
-	getCanvas,
-	getCanvases,
-	getEnv: getEnv$1,
-	getInstanceMetadataTemplates,
-	on: on$1,
-	updateCanvas
+	getAppConfig,
+	getFile,
+	getFiles,
+	selectContent
 }, Symbol.toStringTag, { value: 'Module' }));
 
+async function on$1(type, handler) {
+  const pr = await usePostRobot();
+  const listener = pr.on(type, (e) => handler(e.data));
+  return listener.cancel;
+}
+async function toast(payload) {
+  const pr = await usePostRobot();
+  await pr.send(window.parent, ADMIN_API_METHOD_TYPES.TOAST, payload);
+}
+const admin = {
+  on: on$1,
+  toast,
+  ...envAdmin,
+  ...canvasAdmin,
+  ...metadataTemplatesAdmin,
+  ...filesAdmin
+};
+
 const DSR_MESSAGE = "DSR_MESSAGE";
 const DSR_MESSAGE_TYPES = {
   ENV_CHANGED: "dsr_env_changed"
@@ -3331,61 +3666,59 @@ async function getEnv() {
   return response.data;
 }
 
-async function embeddable_ready() {
+const envDsr = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+	__proto__: null,
+	getEnv
+}, Symbol.toStringTag, { value: 'Module' }));
+
+async function embeddableReady() {
   const pr = await usePostRobot();
   await pr.send(window.parent, DSR_API_METHOD_TYPES.DSR_EMBEDDABLE_READY);
 }
 
+const loadingDsr = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
+	__proto__: null,
+	embeddableReady
+}, Symbol.toStringTag, { value: 'Module' }));
+
 async function on(type, handler) {
   const pr = await usePostRobot();
   const listener = pr.on(type, (e) => handler(e.data));
   return listener.cancel;
 }
-
-const dsr = /*#__PURE__*/Object.freeze(/*#__PURE__*/Object.defineProperty({
-	__proto__: null,
-	embeddable_ready,
-	getEnv,
-	on
-}, Symbol.toStringTag, { value: 'Module' }));
+const dsr = {
+  on,
+  ...envDsr,
+  ...loadingDsr
+};
 
 let highLevelApi;
+let prevOptions;
 function usePitcherApi(options) {
-  if (!highLevelApi) highLevelApi = createHighLevelApi(options);
+  if (!highLevelApi || !isEqual(options, prevOptions)) {
+    highLevelApi = createHighLevelApi(options);
+    prevOptions = options;
+  }
   return highLevelApi;
 }
-const uiApi = Object.entries(
-  ui
-).reduce(
-  (acc, [key, value]) => {
-    acc[key] = value;
-    acc[snakeCase(key)] = value;
-    return acc;
-  },
-  {}
-);
+function enhanceWithSnakeCase(api) {
+  Object.entries(api).forEach(([key, value]) => {
+    const newKey = snakeCase(key);
+    if (newKey && !api[newKey]) {
+      api[newKey] = value;
+    }
+  });
+  return api;
+}
+const uiApi = enhanceWithSnakeCase(ui);
+const adminApi = enhanceWithSnakeCase(admin);
+const dsrApi = enhanceWithSnakeCase(dsr);
 function useUi() {
   return uiApi;
 }
-const adminApi = Object.entries(admin).reduce(
-  (acc, [key, value]) => {
-    acc[key] = value;
-    acc[snakeCase(key)] = value;
-    return acc;
-  },
-  {}
-);
 function useAdmin() {
   return adminApi;
 }
-const dsrApi = Object.entries(dsr).reduce(
-  (acc, [key, value]) => {
-    acc[key] = value;
-    acc[snakeCase(key)] = value;
-    return acc;
-  },
-  {}
-);
 function useDsr() {
   return dsrApi;
 }
@@ -3394,7 +3727,7 @@ function getAvailableApis() {
   const location = window.parent.jsApiLocation;
   return location === "ui" ? ["ui", "impact"] : [location ?? "impact"];
 }
-function useApi() {
+function useApi(options) {
   if (typeof window === "undefined") throw new Error("useApi: window is not defined");
   const location = window.parent.jsApiLocation;
   switch (location) {
@@ -3405,7 +3738,7 @@ function useApi() {
     case "dsr":
       return useDsr();
     case "impact":
-      return usePitcherApi();
+      return usePitcherApi(options);
     default:
       throw new Error(`Unknown api for location: ${location}`);
   }