@openfin/workspace-platform 5.6.2 → 6.0.0

package/client-api-platform/src/shapes.d.ts

@@ -1,15 +1,14 @@
 /// <reference types="openfin-adapter/fin" />
 import type { InteropBroker } from 'openfin-adapter/src/api/interop';
 import { NamedIdentity } from 'openfin-adapter/src/identity';
+import { IconProps } from '@openfin/ui-library';
 import type { AttachedPage, Page, PageWithUpdatableRuntimeAttribs } from '../../common/src/api/pages/shapes';
 import type { CustomThemes } from '../../common/src/api/theming';
 import type { App } from '../../client-api/src/shapes';
-import { MenuData } from './api/context-menu/browser-logo-handler';
 export type { CustomThemes } from '../../common/src/api/theming';
 export type { App, Image, AppIntent } from '../../client-api/src/shapes';
 export { AppManifestType } from '../../client-api/src/shapes';
 export type { AttachedPage, Page, PageWithUpdatableRuntimeAttribs, PageLayout, PageLayoutDetails } from '../../common/src/api/pages/shapes';
-import type { IconProps } from '@openfin/ui-library';
 /**
  * Request for creating a saved page in persistent storage.
  */
@@ -41,19 +40,150 @@ export interface OpenGlobalContextMenuRequest {
     x: number;
     /** Screen y-coordinate where context menu should be shown. */
     y: number;
-    /** Miscelaneous options necessary for implementing custom logic in the provider override. */
+    /** Miscellaneous options necessary for implementing custom logic in the provider override. */
     customData?: any;
 }
+/**Shape of the data property of a context menu template item */
+export interface ContextMenuItemData {
+    type: string;
+    action?: CustomActionSpecifier;
+}
+/**Types of global context menu options, including pre-defined ones.
+ * User-defined context menu items should use the value `Custom` */
+export declare enum GlobalContextMenuOptionType {
+    NewWindow = "NewWindow",
+    NewPage = "NewPage",
+    CloseWindow = "CloseWindow",
+    OpenStorefront = "OpenStorefront",
+    Quit = "Quit",
+    Custom = "Custom"
+}
+/**Types of page tab context menu options, including pre-defined ones.
+ * User-defined context menu items should use the value `Custom` */
+export declare enum PageTabContextMenuOptionType {
+    Close = "Close",
+    Duplicate = "Duplicate",
+    Rename = "Rename",
+    Save = "Save",
+    Custom = "Custom"
+}
+/**Shape of the data property of a global context menu template item */
+export interface GlobalContextMenuItemData extends ContextMenuItemData {
+    type: GlobalContextMenuOptionType;
+}
+/**Configuration of an option in the global context menu */
+export interface GlobalContextMenuItemTemplate extends OpenFin.MenuItemTemplate {
+    data: GlobalContextMenuItemData;
+}
+/**Shape of the data property of a page tab context menu template item */
+export interface PageTabContextMenuItemData extends ContextMenuItemData {
+    type: PageTabContextMenuOptionType;
+}
+/**Configuration of an option in the page tab context menu */
+export interface PageTabContextMenuItemTemplate extends OpenFin.MenuItemTemplate {
+    data: PageTabContextMenuItemData;
+}
+/**Payload received by a Custom Action that is invoked by a custom global context menu option */
+export interface GlobalContextMenuOptionActionPayload {
+    callerType: CustomActionCallerType.GlobalContextMenu;
+    /** Identity of the browser window where the context menu is invoked */
+    windowIdentity: OpenFin.Identity;
+    /** Any data necessary for the functioning of specified custom action*/
+    customData?: any;
+}
+/**Payload received by a Custom Action that is invoked by a custom page tab context menu option */
+export interface PageTabContextMenuOptionActionPayload {
+    callerType: CustomActionCallerType.PageTabContextMenu;
+    /** Identity of the browser window where the context menu is invoked */
+    windowIdentity: OpenFin.Identity;
+    /** Any data necessary for the functioning of specified custom action*/
+    customData?: any;
+    /** Id of the page on which the context menu is invoked */
+    pageId: string;
+}
 /**
  * Payload received by the openGlobalContextMenu provider override.
  */
 export declare type OpenGlobalContextMenuPayload = OpenGlobalContextMenuRequest & {
     /** Template defining the options to show in the context menu. */
-    template: OpenFin.MenuItemTemplate[];
+    template: GlobalContextMenuItemTemplate[];
+    /** Identity of the Browser window where context menu should be shown. */
+    identity: NamedIdentity;
+    /** Default function that handles stock context menu options. */
+    callback: (data: GlobalContextMenuItemData, payload: OpenGlobalContextMenuPayload) => any;
+};
+export interface ViewTabContextMenuTemplate extends OpenFin.MenuItemTemplate {
+    data: ViewTabMenuData;
+}
+/**
+ * Request for opening a view tab context menu in Browser.
+ */
+export interface OpenViewTabContextMenuRequest {
+    /** Screen x-coordinate where context menu should be shown. */
+    x: number;
+    /** Screen y-coordinate where context menu should be shown. */
+    y: number;
+    /** Miscellaneous options necessary for implementing custom logic in the provider override. */
+    customData?: any;
+    /** Template defining the options to show in the context menu. */
+    template: ViewTabContextMenuTemplate[];
+    selectedViews: OpenFin.Identity[];
+}
+/**
+ * Request for opening a page tab context menu in Browser.
+ */
+export interface OpenPageTabContextMenuRequest {
+    /** Screen x-coordinate where context menu should be shown. */
+    x: number;
+    /** Screen y-coordinate where context menu should be shown. */
+    y: number;
+    /** Miscellaneous options necessary for implementing custom logic in the provider override. */
+    customData?: any;
+    /** Id of the page on which the context menu is invoked */
+    pageId: string;
+}
+export declare enum ViewTabMenuOptionType {
+    NewView = "NewView",
+    DuplicateViews = "DuplicateView",
+    OpenWithDefaultBrowser = "OpenWithDefaultBrowser",
+    ReloadViews = "ReloadTab",
+    CloseViews = "CloseTab",
+    AddToChannel = "AddToChannel",
+    RemoveFromChannel = "RemoveFromChannel",
+    Custom = "Custom"
+}
+export interface ViewTabMenuData {
+    type: ViewTabMenuOptionType;
+    action?: CustomActionSpecifier;
+    option?: string;
+}
+export interface ViewTabCustomActionPayload {
+    callerType: CustomActionCallerType.ViewTabContextMenu;
+    /** Any data necessary for the functioning of specified custom action*/
+    customData: any;
+    /** Identity of the Browser window where context menu should be shown. */
+    windowIdentity: NamedIdentity;
+    selectedViews: OpenFin.Identity[];
+}
+/**
+ * Payload received by the openViewTabContextMenu provider override.
+ */
+export declare type OpenViewTabContextMenuPayload = OpenViewTabContextMenuRequest & {
     /** Identity of the Browser window where context menu should be shown. */
     identity: NamedIdentity;
     /** Default function that handles stock context menu options. */
-    callback: (data: MenuData) => any;
+    callback: (data: ViewTabMenuData, req: OpenViewTabContextMenuPayload) => any;
+};
+/**
+ * Payload received by the openViewTabContextMenu provider override.
+ */
+export declare type OpenPageTabContextMenuPayload = OpenPageTabContextMenuRequest & {
+    /** Identity of the Browser window where context menu should be shown. */
+    identity: NamedIdentity;
+    /** Template defining the options to show in the context menu. */
+    template: PageTabContextMenuItemTemplate[];
+    /** Default function that handles stock context menu options. */
+    callback: (data: PageTabContextMenuItemData, req: OpenPageTabContextMenuPayload) => any;
 };
 /**
  * Request to update the attributes of a page in which is attached to a running browser window.
@@ -64,6 +194,9 @@ export interface UpdateAttachedPageRequest {
     /** The updated page. */
     page: Partial<PageWithUpdatableRuntimeAttribs>;
 }
+/**
+ * Types of buttons on browser windows
+ */
 export declare enum BrowserButtonType {
     ShowHideTabs = "ShowHideTabs",
     ColorLinking = "ColorLinking",
@@ -78,32 +211,57 @@ export declare enum BrowserButtonType {
  * The shape of the payload sent by a custom button click to a custom action handler
  */
 export interface CustomButtonActionPayload {
+    /** Calling the CustomButton type */
     callerType: CustomActionCallerType.CustomButton;
+    /** Identity for the current window. */
     windowIdentity: OpenFin.Identity;
+    /** Any data necessary for the functioning of specified custom action*/
     customData: any;
+    /** Screen x-coordinate where custom button should be shown. */
     x: number;
+    /** Screen y-coordinate where custom button should be shown. */
     y: number;
 }
+/**
+ * Custom browser buttons
+ */
 export interface CustomBrowserButtonConfig {
+    /** Type of cutom browser button */
     type: BrowserButtonType.Custom;
+    /** Button name text when hovered over */
     tooltip: string;
+    /** Disable custom button true or false */
     disabled?: boolean;
+    /** icon URL for icon image */
     iconUrl: string;
+    /** Custom action once the button is clicked */
     action: CustomActionSpecifier;
 }
+/**
+ * Default Browser Button types
+ */
 export interface PreDefinedButtonConfig {
+    /** Type of default browser button */
     type: BrowserButtonType;
+    /** Button name text when hovered over */
     tooltip?: string;
+    /** icon URL for icon image */
     iconUrl?: string;
     iconProps?: IconProps;
 }
 declare type ShowHideTabsConfig = {
     type: BrowserButtonType.ShowHideTabs;
 };
+/**
+ *  Buttons on the left of WindowStateButtonOptions
+ */
 export declare type IconTrayButton = ShowHideTabsConfig | CustomBrowserButtonConfig | PreDefinedButtonConfig;
 export interface IconTrayOptions {
     buttons: IconTrayButton[];
 }
+/**
+ * Buttons to the top far right of Browser
+ */
 export declare type WindowStateButton = CustomBrowserButtonConfig | PreDefinedButtonConfig;
 export interface WindowStateButtonOptions {
     buttons: WindowStateButton[];
@@ -309,6 +467,66 @@ export interface BrowserWindowModule {
      * @param req the reorder pages request.
      */
     reorderPages(req: ReorderPagesRequest): Promise<void>;
+    /**
+     * Replace icon tray options with custom icon tray options
+     *
+     * ```ts
+     * import * as WorkspacePlatform from '@openfin/workspace-platform';
+     *
+     * // to set the array to our default buttons, pass in null
+     *
+     * const workspacePlatform = WorkspacePlatform.getCurrentSync();
+     * workspacePlatform.Browser.wrapSync(identity).replaceIconTrayOptions({buttons:[{
+     *      type: 'Custom',
+     *      tooltip: 'Custom Tooltip',
+     *      disabled: false,
+     *      iconUrl: 'https://www.openfin.co/favicon.ico',
+     *      action: {
+     *          id: 'sample-custom-action-name',
+     *          customData: {
+     *              message: 'Clicked on custom Icon Tray button'
+     *          }
+     *      }
+     *  }]})
+     *
+     *  const openFinWindow = fin.Window.wrapSync(identity);
+     *  // call getOptions() to view updated iconTrayOptions under workspacePlatform
+     *  await openFinWindow.getOptions()
+     * ```
+     * @param options new icon tray options.
+     */
+    replaceIconTrayOptions(options: IconTrayOptions): Promise<void>;
+    /**
+     * Replace window state button options with custom window state button options
+     *
+     * ```ts
+     * import * as WorkspacePlatform from '@openfin/workspace-platform';
+     *
+     * // to set the array to our default buttons, pass in null
+     *
+     * const workspacePlatform = WorkspacePlatform.getCurrentSync();
+     * workspacePlatform.Browser.wrapSync(identity).replaceWindowStateButtonOptions({buttons:[{
+     *     type: 'Custom',
+     *     tooltip: 'Custom tooltip',
+     *     disabled: false,
+     *     iconUrl: 'https://www.openfin.co/favicon.ico',
+     *     action: {
+     *         id: 'sample-custom-action-name',
+     *         customData: {
+     *             message: 'Clicked on custom window state button'
+     *         }
+     *     }
+     * }]})
+     *
+     *  const openFinWindow = fin.Window.wrapSync(identity);
+     *  // call getOptions() to view updated windowStateButtonOptions under workspacePlatform
+     *  await openFinWindow.getOptions()
+     * ```
+     * @param options new window state options.
+     */
+    replaceWindowStateButtonOptions(options: WindowStateButtonOptions): Promise<void>;
+    _openViewTabContextMenu(req: OpenViewTabContextMenuRequest): Promise<void>;
+    _openPageTabContextMenu(req: OpenPageTabContextMenuRequest): Promise<void>;
 }
 /**
  * Factory for wrapping browser windows and global operations.
@@ -375,7 +593,66 @@ export interface BrowserWindowFactory {
      *      workspacePlatform {
      *          pages: [page],
      *          title: 'My Window Title',
-     *          favicon: 'https://google.com/favicon.ico'
+     *          favicon: 'https://google.com/favicon.ico',
+     *          disableMultiplePages: true,  // disable page functonality for the window
+     *          iconTrayOptions: {  // configure the set of tray icons for the window
+     *              buttons: [
+     *                  {  // adding a custom tray icon for the window
+     *                      type: BrowserButtonType.Custom,
+     *                      tooltip: 'Sample Tray Icon',
+     *                      disabled: false,
+     *                      iconUrl: 'https://www.openfin.co/favicon.ico',
+     *                      action: {
+     *                          // This action needs to be registed in customActions property in the call WorkspacePlatform.init
+     *                          id: 'sample-trayicon-custom-action',
+     *                          customData: {
+     *                              message: 'Clicked on custom Icon Tray button'
+     *                          }
+     *                      }
+     *                  },
+     *                  {
+     *                      type: BrowserButtonType.ShowHideTabs
+     *                  },
+     *                  {
+     *                      type: BrowserButtonType.ColorLinking
+     *                  },
+     *                  {
+     *                      type: BrowserButtonType.PresetLayouts
+     *                  },
+     *                  {
+     *                      type: BrowserButtonType.SavePage
+     *                  }
+     *             ]
+     *          }
+     *          windowStateButtonOptions: { configure the set of icons for setting window states
+     *              buttons: [
+     *                   {   // adding a custom window state icon for the window
+     *                       id: 'windowState123',
+     *                       type: BrowserButtonType.Custom,
+     *                       tooltip: 'Sample Window State button',
+     *                       disabled: false,
+     *                       iconUrl: 'https://www.openfin.co/favicon.ico',
+     *                       action: {
+     *                          // This action needs to be registed in customActions property in the call WorkspacePlatform.init
+     *                           id: 'sample-window-state-custom-action',
+     *                           customData: {
+     *                               message: 'Clicked on custom Window State button'
+     *                           }
+     *                       }
+     *                   },
+     *                   {  // override tooltip and icon URL for standard Maximise button
+     *                      type: BrowserButtonType.Maximise,
+     *                      tooltip: overrideWindowStateIcons ? 'Studio Maximise' : undefined,
+     *                      iconUrl: overrideWindowStateIcons ? 'https://www.openfin.co/favicon.ico' : undefined
+     *                   },
+     *                   {
+     *                      type: BrowserButtonType.Minimise
+     *                   },
+     *                   {
+     *                      type: BrowserButtonType.Close
+     *                   }
+     *              ]
+     *          }
      *      }
      * };
      * const window = await workspacePlatform.Browser.createWindow(options);
@@ -657,29 +934,52 @@ export interface WorkspacePlatformProvider extends OpenFin.PlatformProvider {
      * @param req the payload received by the provider call
      * @param callerIdentity OF identity of the entity from which the request originated
      */
-    openGlobalContextMenu(req: OpenGlobalContextMenuPayload, callerIdentity: any): any;
+    openGlobalContextMenu(req: OpenGlobalContextMenuPayload, callerIdentity: OpenFin.Identity): any;
+    /**
+     * Implementation for showing a view tab context menu given a menu template,
+     * handler callback, and screen coordinates
+     * @param req the payload received by the provider call
+     * @param callerIdentity OF identity of the entity from which the request originated
+     */
+    openViewTabContextMenu(req: OpenViewTabContextMenuPayload, callerIdentity: OpenFin.Identity): any;
+    /**
+     * Implementation for showing a page tab context menu given a menu template,
+     * handler callback, and screen coordinates
+     * @param req the payload received by the provider call
+     * @param callerIdentity OF identity of the entity from which the request originated
+     */
+    openPageTabContextMenu(req: OpenPageTabContextMenuPayload, callerIdentity: OpenFin.Identity): any;
 }
+/**
+ * The origins from which a custom action can be invoked
+ */
 export declare enum CustomActionCallerType {
     CustomButton = "CustomButton",
-    ContextMenu = "ContextMenu",
+    GlobalContextMenu = "GlobalContextMenu",
+    ViewTabContextMenu = "ViewTabContextMenu",
+    PageTabContextMenu = "PageTabContextMenu",
     API = "API"
 }
-export interface CustomActionPayload {
-    callerType: CustomActionCallerType;
-    [x: string]: any;
-}
+/**The payload received by a Custom Action.
+ * The `callerType` property can be used to determine what data is available in the payload and cast accordingly.
+ * When `callerType == CustomActionCallerType.API`, the payload is defined by the code directly invoking the action.*/
+export declare type CustomActionPayload = {
+    callerType: CustomActionCallerType.API;
+} | CustomButtonActionPayload | GlobalContextMenuOptionActionPayload | ViewTabCustomActionPayload | PageTabContextMenuOptionActionPayload;
+/**
+ * Configures a custom action when the control is invoked
+ */
 export interface CustomActionSpecifier {
     /** Identifier of a custom action defined at platform initialization*/
     id: string;
     /** Any data necessary for the functioning of specified custom action*/
-    customData: any;
-}
-export interface InvokeCustomActionRequest {
-    actionId: string;
-    payload: CustomActionPayload;
+    customData?: any;
 }
+/**
+ * Defines custom action map where the key is the custom action ID and value is the action handler
+ */
 export interface CustomActionsMap {
-    [x: string]: (payload: CustomActionPayload) => any;
+    [actionId: string]: (payload: CustomActionPayload) => any;
 }
 /**
  * Configuration for initializing a Workspace platform.
@@ -743,16 +1043,75 @@ export interface WorkspacePlatformInitConfig {
  *    WorkspacePlatformProvider
  * ) => {
  *   class Override extends WorkspacePlatformProvider {
+ *       // ovrride default behavior of updateSavedPage
  *       updateSavedPage = async (req: UpdateSavedPageRequest): Promise<void> => {
  *           console.log(`saving page ${req.page.pageId}`);
  *           // calling custom function to the save page here
- *      };
+ *       };
+ *
+ *       // add a custom menu item in Global Context Menu
+ *       openGlobalContextMenu(req: WorkspacePlatform.OpenGlobalContextMenuPayload, callerIdentity: any) {
+ *            return super.openGlobalContextMenu(
+ *               {
+ *                   ...req,
+ *                   template: [
+ *                       ...req.template,
+ *                       {
+ *                           label: 'Sample custom global option',
+ *                           data: {
+ *                               type: GlobalContextMenuOptionType.Custom,
+ *                               action: {
+ *                                      // This action needs to be registed in customActions property in the call WorkspacePlatform.init
+ *                                   id: 'sample-custom-global-menu-action'
+ *                               }
+ *                           }
+ *                       }
+ *                   ]
+ *               },
+ *               callerIdentity
+ *           );
+ *       }
+ *
+ *       // add a custom menu item in View Tab Context Menu
+ *       openViewTabContextMenu = async (payload: OpenViewTabContextMenuPayload, callerIdentity) => {
+ *           return super.openViewTabContextMenu({
+ *               ...payload,
+ *               template: [
+ *                   {
+ *                       label: 'Sample View Tab Context Menu',
+ *                       data: {
+ *                           type: ViewTabMenuOptionType.Custom,
+ *                           action: {
+ *                                  // This action needs to be registed in customActions property in the call WorkspacePlatform.init
+ *                               id: 'sample-viewtab-action',
+ *                               customData: 'Custom View Tab Action'
+ *                           }
+ *                       }
+ *                   },
+ *                   ...payload.template
+ *               ]
+ *           }, callerIdentity);
+ *       };
+ *
+ *
  *   }
  *   return new Override();
  * };
  *
  * await WorkspacePlatform.init({
  *  browser: { overrideCallback },
+ *       customActions: {
+ *           'sample-custom-global-menu-action': (payload: CustomActionPayload) => {
+ *               alert('This custom action works ' + JSON.stringify(payload));
+ *               return 'someresponse';
+ *           },
+ *           'sample-viewtab-action': (payload: ViewTabCustomActionPayload) => {
+ *               alert('This custom action works ' + JSON.stringify(payload));
+ *               return 'someresponse';
+ *           }
+ *       }
+ *
+ *
  * });
  */
 export declare type BrowserOverrideCallback = OpenFin.OverrideCallback<WorkspacePlatformProvider>;
@@ -764,6 +1123,8 @@ export interface BrowserInitConfig {
      * Default options for creating a new browser window. Any option not included in WorkspacePlatform.getCurrentSync().Browser.createWindow(options) call will default to the value provided in this field.
      */
     defaultWindowOptions?: BrowserCreateWindowRequest;
+    /** Default options when creating a new page. If `iconUrl`, `unsavedIconUrl` or `closeButton` are not defined when creating a page, setting will default to `defaultPageOptions`. */
+    defaultPageOptions?: Pick<Page, 'iconUrl' | 'unsavedIconUrl' | 'closeButton'>;
     /**
      * The default options when creating a new browser window. Any option not included in WorkspacePlatform.getCurrentSync().Browser.createView(options) call will default to the value provided in this field.
      */

package/common/src/api/browser-protocol.d.ts

@@ -8,7 +8,16 @@ export declare const getChannelClient: (identity: OpenFin.Identity) => Promise<i
  * (Should only happen in local development)
  */
 export declare const createChannel: () => Promise<import("openfin-adapter").ChannelProvider>;
+export interface AddToChannelRequest {
+    newChannelId: string;
+    selectedViews: OpenFin.Identity[];
+}
 export declare enum ChannelAction {
     CloseBrowserWindow = "close-browser-window",
-    QuitPlatform = "quit-platform"
+    QuitPlatform = "quit-platform",
+    ClosePage = "close-page",
+    AddToChannel = "add-to-channel",
+    RemoveFromChannel = "remove-from-channel",
+    SavePage = "save-page",
+    DuplicatePage = "duplicate-page"
 }

package/common/src/utils/defer-show.d.ts

@@ -0,0 +1,46 @@
+/// <reference types="openfin-adapter/fin" />
+interface InternalWindowOptions extends OpenFin.PlatformWindowCreationOptions {
+    workspacePlatform: OpenFin.WindowOptions['workspacePlatform'] & {
+        _internalAutoShow: boolean;
+        _internalDeferShowEnabled: boolean;
+    };
+}
+/**
+ * This function prevents a created window from being auto shown by the Core.
+ * The Core will auto show the window before the window has a chance to register a listener to prevent it.
+ * With these options applied, the window must call `setCanShow(true)` when it is ready to be shown.
+ * If `autoShow` was originally true, the window will be show upon the first call to `setCanShow(true)`.
+ *
+ * By applying these options it is assumed that the window calls `registerDeferShow()` and `setCanShow(true)`.
+ *
+ * This function should be used in conjunction the `withDeferShow` platform middleware.
+ * `withDeferShow` will prevent the window from being shown before the window has launched and registered
+ * its show requested listener.
+ *
+ * @param opts the options to modify.
+ * @returns the modified options.
+ */
+export declare const applyDeferShowOptions: (opts: OpenFin.PlatformWindowCreationOptions) => InternalWindowOptions;
+/**
+ * This function is a middleware that can be applied to a platform's `createWindow` function.
+ * If the defer show API has been enabled in window options using the `applyDeferShowOptions` function
+ * the window will be prevented from showing.
+ * @param superCreateWindow the create window method to decorate.
+ * @returns the `createWindow` method wrapped with this middleware.
+ */
+export declare const withDeferShow: (superCreateWindow: (opts: OpenFin.PlatformWindowCreationOptions, callerIdentity: OpenFin.Identity) => Promise<OpenFin.Window>) => (opts: OpenFin.PlatformWindowCreationOptions, callerIdentity?: OpenFin.Identity) => Promise<import("openfin-adapter").Window>;
+/**
+ * Assert if the window is able to be shown or not.
+ * Upon calling `setCanShow(true)`, if the window was previously prevented
+ * from being shown, this function will show the window.
+ * @param bool true if the window should be able to be shown. (Default is false)
+ */
+export declare const setCanShow: (bool: boolean) => Promise<void>;
+/**
+ * Add a listener that defers showing the current window.
+ * To allow the window to be shown, `setCanShow(true)` must be called.
+ * Upon calling `setCanShow(true)`, if the window was previously prevented
+ * from being shown, it will show.
+ */
+export declare const registerDeferShow: () => Promise<void>;
+export {};

package/common/src/utils/env.d.ts

@@ -21,9 +21,3 @@ export declare const workspaceProviderFallbackUrl: string;
 export declare const workspaceCdnUrl: string;
 export declare const workspaceCdnEnvUrl: string;
 export declare const workspaceRuntimeVersion: string;
-/**
- * A promise that resolves when:
- *    - The window 'load' event is fired.
- *    - The window first paint occurs.
- */
-export declare const firstPaint: Promise<void>;

package/common/src/utils/global-context-menu.d.ts

@@ -1,2 +1,3 @@
 import { NamedIdentity } from 'openfin-adapter/src/identity';
-export declare const getGlobalContextMenuTemplate: (winIdentity: NamedIdentity) => Promise<any[]>;
+import { GlobalContextMenuItemTemplate } from '../../../client-api-platform/src/shapes';
+export declare const getGlobalContextMenuTemplate: (winIdentity: NamedIdentity) => Promise<GlobalContextMenuItemTemplate[]>;

package/common/src/utils/landing-page.d.ts

@@ -7,5 +7,5 @@ interface LandingPageUrls {
 export declare const getLandingPageUrls: (winIdentity?: NamedIdentity) => Promise<LandingPageUrls>;
 export declare const checkHasNewTabUrl: () => Promise<boolean>;
 export declare const getNewLandingTabViewOptions: (target: OpenFin.Identity) => Promise<OpenFin.PlatformViewCreationOptions>;
-export declare const makeNewLandingPage: (winIdentity?: NamedIdentity) => Promise<import("@client-platform/index").PageWithUpdatableRuntimeAttribs>;
+export declare const makeNewLandingPage: (winIdentity?: NamedIdentity) => Promise<import("client-api-platform").PageWithUpdatableRuntimeAttribs>;
 export {};

package/common/src/utils/page-tab-context-menu.d.ts

@@ -0,0 +1,2 @@
+import { PageTabContextMenuItemTemplate } from '../../../client-api-platform/src/shapes';
+export declare const getPageTabMenuTemplate: (saved: boolean) => PageTabContextMenuItemTemplate[];

package/common/src/utils/window.d.ts

@@ -25,7 +25,8 @@ export declare enum WindowEvent {
     ViewAttached = "view-attached",
     ViewDetached = "view-detached",
     ViewPageTitleUpdated = "view-page-title-updated",
-    ViewDestroyed = "view-destroyed"
+    ViewDestroyed = "view-destroyed",
+    OptionsChanged = "options-changed"
 }
 export interface WindowIdentity {
     uuid: ApplicationUUID | string;
@@ -148,4 +149,5 @@ export declare const isHomeWindowRunning: () => Promise<boolean>;
 export declare const showAndFocusStorefront: () => Promise<void>;
 export declare const centerWindowIfOffScreen: (windowIdentity?: WindowIdentity) => Promise<void>;
 export declare const getDisableMultiplePagesOption: (identity: WindowIdentity) => Promise<any>;
+export declare const getPlatformWindowTitle: (identity: WindowIdentity) => Promise<any>;
 export {};