@openfin/workspace-platform 5.3.1 → 5.6.3

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

@@ -1,12 +1,15 @@
 /// <reference types="openfin-adapter/fin" />
 import type { InteropBroker } from 'openfin-adapter/src/api/interop';
+import { NamedIdentity } from 'openfin-adapter/src/identity';
 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.
  */
@@ -30,6 +33,28 @@ export interface ReorderPagesRequest {
     /** An array of page ids that specify the order of the pages attached to the window. */
     pageIds: string[];
 }
+/**
+ * Request for opening a logo context menu in Browser.
+ */
+export interface OpenGlobalContextMenuRequest {
+    /** Screen x-coordinate where context menu should be shown. */
+    x: number;
+    /** Screen y-coordinate where context menu should be shown. */
+    y: number;
+    /** Miscelaneous options necessary for implementing custom logic in the provider override. */
+    customData?: any;
+}
+/**
+ * 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[];
+    /** 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;
+};
 /**
  * Request to update the attributes of a page in which is attached to a running browser window.
  */
@@ -39,6 +64,50 @@ export interface UpdateAttachedPageRequest {
     /** The updated page. */
     page: Partial<PageWithUpdatableRuntimeAttribs>;
 }
+export declare enum BrowserButtonType {
+    ShowHideTabs = "ShowHideTabs",
+    ColorLinking = "ColorLinking",
+    PresetLayouts = "PresetLayouts",
+    SavePage = "SavePage",
+    Minimise = "Minimise",
+    Maximise = "Maximise",
+    Close = "Close",
+    Custom = "Custom"
+}
+/**
+ * The shape of the payload sent by a custom button click to a custom action handler
+ */
+export interface CustomButtonActionPayload {
+    callerType: CustomActionCallerType.CustomButton;
+    windowIdentity: OpenFin.Identity;
+    customData: any;
+    x: number;
+    y: number;
+}
+export interface CustomBrowserButtonConfig {
+    type: BrowserButtonType.Custom;
+    tooltip: string;
+    disabled?: boolean;
+    iconUrl: string;
+    action: CustomActionSpecifier;
+}
+export interface PreDefinedButtonConfig {
+    type: BrowserButtonType;
+    tooltip?: string;
+    iconUrl?: string;
+    iconProps?: IconProps;
+}
+declare type ShowHideTabsConfig = {
+    type: BrowserButtonType.ShowHideTabs;
+};
+export declare type IconTrayButton = ShowHideTabsConfig | CustomBrowserButtonConfig | PreDefinedButtonConfig;
+export interface IconTrayOptions {
+    buttons: IconTrayButton[];
+}
+export declare type WindowStateButton = CustomBrowserButtonConfig | PreDefinedButtonConfig;
+export interface WindowStateButtonOptions {
+    buttons: WindowStateButton[];
+}
 /**
  * Request for creating a browser window.
  */
@@ -61,6 +130,14 @@ export interface BrowserCreateWindowRequest extends Omit<OpenFin.PlatformWindowC
          * If you do not provide a newPageUrl, then the new Page plus button will not be shown and you cannot create a new empty Page or Window.
          */
         newPageUrl?: string;
+        iconTrayOptions?: IconTrayOptions;
+        windowStateButtonOptions?: WindowStateButtonOptions;
+        /**
+         * Remove the Page UI and only allow a single page in the browser window.
+         * Must be set to true for this behavior.  If this is not set to false,
+         * then an empty `pages` option will be populated with a single page.
+         */
+        disableMultiplePages?: boolean;
     };
 }
 /**
@@ -110,7 +187,7 @@ export interface BrowserWindowModule {
      */
     getPages(): Promise<AttachedPage[]>;
     /**
-     * Set the active page for the browser window.
+     * Set the active page for the browser window.  If `multiplePagesDisabled` is `true` an error will be thrown.
      *
      * ```ts
      * import * as WorkspacePlatform from '@openfin/workspace-platform';
@@ -125,7 +202,7 @@ export interface BrowserWindowModule {
     setActivePage(id: string): Promise<void>;
     /**
      * Attach a page to a browser window.
-     * If a page with same id or title is attached to an existing browser window, an error will be thrown.
+     * If `multiplePagesDisabled` is `true` or a page with same id or title is attached to an existing browser window, an error will be thrown.
      *
      * ```ts
      * import * as WorkspacePlatform from '@openfin/workspace-platform';
@@ -156,6 +233,10 @@ export interface BrowserWindowModule {
      * // assume a browser window already exists
      * const windows = await workspacePlatform.Browser.getAllWindows();
      * await windows[0].addPage(page);
+     * // focus window
+     * await windows[0].openfinWindow.focus();
+     * // restore window if minimized
+     * await windows[0].openfinWindow.restore();
      * ```
      * @param page the attach page to a browser window.
      */
@@ -215,7 +296,7 @@ export interface BrowserWindowModule {
      */
     updatePage(req: UpdateAttachedPageRequest): Promise<void>;
     /**
-     * Reorder pages attached to the browser window.
+     * Reorder pages attached to the browser window.  If `multiplePagesDisabled` is `true` an error will be thrown.
      *
      * ```ts
      * import * as WorkspacePlatform from '@openfin/workspace-platform';
@@ -570,14 +651,83 @@ export interface WorkspacePlatformProvider extends OpenFin.PlatformProvider {
      * @param id of the id of the page to delete.
      */
     deleteSavedPage(id: string): Promise<void>;
+    /**
+     * Implementation for showing a global 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
+     */
+    openGlobalContextMenu(req: OpenGlobalContextMenuPayload, callerIdentity: any): any;
+}
+export declare enum CustomActionCallerType {
+    CustomButton = "CustomButton",
+    ContextMenu = "ContextMenu",
+    API = "API"
+}
+export interface CustomActionPayload {
+    callerType: CustomActionCallerType;
+    [x: string]: any;
+}
+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;
+}
+export interface CustomActionsMap {
+    [x: string]: (payload: CustomActionPayload) => any;
 }
 /**
  * Configuration for initializing a Workspace platform.
  */
 export interface WorkspacePlatformInitConfig {
+    customActions?: CustomActionsMap;
     /** Config for overriding browser options and behavior. */
     browser?: BrowserInitConfig;
-    /** Custom Themes object */
+    /** Custom Themes object
+     *
+     * ```ts
+     * import * as WorkspacePlatform from '@openfin/workspace-platform';
+     *
+     * // This is the palette used to create the OpenFin dark theme
+     * const customPalette: WorkspacePlatform.CustomPaletteSet = {
+     *   brandPrimary: '#504CFF',
+     *   brandSecondary: '#383A40',
+     *   backgroundPrimary: '#000',
+     *   background1: '#111214',
+     *   background2: '#1E1F23',
+     *   background3: '#24262B',
+     *   background4: '#2F3136',
+     *   background5: '#383A40',
+     *   background6: '#53565F',
+     *   statusSuccess: '#35C759',
+     *   statusWarning: '#C93400',
+     *   statusCritical: '#000',
+     *   statusActive: '#0879C4',
+     *   inputBackground: '#53565F',
+     *   inputColor: '#FFFFFF',
+     *   inputPlaceholder: '#C9CBD2',
+     *   inputDisabled: '#7D808A',
+     *   inputFocused: '#C9CBD2',
+     *   textDefault: '#FFFFFF',
+     *   textHelp: '#C9CBD2',
+     *   textInactive: '#7D808A',
+     * };
+     *
+     * const customTheme: WorkspacePlatform.CustomThemes = [{
+     *   label: "My Custom Theme",
+     *   palette: customPalette
+     * }];
+     *
+     * await WorkspacePlatform.init({
+     *   browser: { overrideCallback },
+     *   theme: customThemes
+     * });
+     */
     theme?: CustomThemes;
 }
 /**

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

@@ -0,0 +1,14 @@
+/// <reference types="openfin-adapter/fin" />
+export declare const getWindowChannelId: (identity: OpenFin.Identity) => string;
+export declare const getChannelClient: (identity: OpenFin.Identity) => Promise<import("openfin-adapter").ChannelClient>;
+/**
+ * If the browser window is reloaded too quickly, runtime will
+ * respond that the channel provider has already been created.
+ * Hence, we retry a couple of times to make sure this does not occur.
+ * (Should only happen in local development)
+ */
+export declare const createChannel: () => Promise<import("openfin-adapter").ChannelProvider>;
+export declare enum ChannelAction {
+    CloseBrowserWindow = "close-browser-window",
+    QuitPlatform = "quit-platform"
+}

package/common/src/api/pages/attached.d.ts

@@ -21,7 +21,6 @@ export declare enum EventType {
     AttachedPagesToWindow = "attached-pages-to-window",
     DetachedPagesFromWindow = "detached-pages-from-window"
 }
-export declare const getWindowChannelId: (identity: OpenFin.Identity) => string;
 export declare const getEventEmitter: (identity: OpenFin.Identity) => {
     emit: (event: string | number, ...payload: any[]) => Promise<void>;
     addListener: (event: string | number, listener: import("@common/utils/shared-emitter").Listener) => void;

package/common/src/api/pages/legacy.d.ts

@@ -6,7 +6,7 @@ interface Workstack {
     layout: PageLayout;
     isActive: boolean;
 }
-export declare function convertWorkstackToAttachedPage(workstack: Workstack & AttachedPage): AttachedPage;
+export declare function convertWorkstackToAttachedPage({ id, name, ...rest }: Workstack & AttachedPage): AttachedPage;
 /**
  * Attempts to fix any misconfigurations in a list of attached pages.
  * @param pages the pages to fix.

package/common/src/api/pages/shapes.d.ts

@@ -20,8 +20,17 @@ export interface Page {
     tooltip?: string;
     /** True if the page is read only. In this state, the page is locked and cannot be unlocked. */
     isReadOnly?: boolean;
+    /** Icon that appears on a page tab if there are unsaved changes (dirty state). If 'undefined', default icon will appear. */
+    unsavedIconUrl?: string;
+    /** Icon that appears on a page tab if there are no unsaved changes. If 'undefined', default icon will appear. */
+    iconUrl?: string;
     /** The layout of the page. */
     layout: PageLayout;
+    /** Used to manipulate behaviour of a close button on a page tab. If `undefined`, then close button is visible and actionable. */
+    closeButton?: {
+        hidden?: boolean;
+        disabled?: boolean;
+    };
 }
 declare type AttachedPageMetadata = {
     /** The window the page is currently attached to. */

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

@@ -0,0 +1,12 @@
+/// <reference types="openfin-adapter/fin" />
+import { _Window } from 'openfin-adapter/src/api/window';
+export declare enum MenuItemType {
+    Label = "normal",
+    Separator = "separator",
+    Submenu = "submenu",
+    Checkbox = "checkbox"
+}
+export declare type ShowContextMenuResponse = OpenFin.MenuResult & {
+    data: string;
+};
+export default function showContextMenu(opts: OpenFin.ShowPopupMenuOptions, win?: _Window): Promise<ShowContextMenuResponse>;

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

@@ -0,0 +1,18 @@
+/// <reference types="openfin-adapter/fin" />
+interface InternalWindowOptions extends OpenFin.PlatformWindowCreationOptions {
+    workspacePlatform: OpenFin.WindowOptions['workspacePlatform'] & {
+        _internalAutoShow: boolean;
+    };
+}
+/**
+ * Apply options to a window's options that will disallow the Core from auto showing the window.
+ * Instead, a script within the window itself must handle showing the window if deferred auto showing is enabled.
+ * When it comes time to show the window, the script can auto show if deferred by simply calling the `autoShowIfDeferred` function.
+ * @param opts the window options to apply deferred auto show to.
+ */
+export declare function applyDeferAutoShowOptions(opts: OpenFin.PlatformWindowCreationOptions): InternalWindowOptions;
+/**
+ * Will show the current window if deferred auto show is enabled.
+ */
+export declare function autoShowIfDeferred(): Promise<void>;
+export {};

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

@@ -12,19 +12,18 @@ export declare const isWindowDefinedWithIndexDB: boolean;
 export declare const finUUID: string;
 export declare const finName: string;
 export declare const finEntityType: "" | import("openfin-adapter/src/shapes/EntityType").EntityType;
-export declare const env: Env;
 export declare const isEnvLocal: boolean;
 export declare const isEnvDev: boolean;
 export declare const isEnvStaging: boolean;
 export declare const isEnvProd: boolean;
-export declare const isLibrary: boolean;
 export declare const workspaceProviderFinsLink: string;
 export declare const workspaceProviderFallbackUrl: string;
-export declare const workspaceAppsUrl: string;
-export declare const workspaceStorefrontFooterUrl: string;
-export declare const workspaceStorefrontLandingPageUrl: string;
-export declare const workspaceStorefrontNavigationUrl: string;
-export declare const workspaceShareUrl: 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

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

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

@@ -0,0 +1,11 @@
+/// <reference types="openfin-adapter/fin" />
+import { NamedIdentity } from 'openfin-adapter/src/identity';
+interface LandingPageUrls {
+    newPageUrl: string | false;
+    newTabUrl: string | false;
+}
+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 {};

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

@@ -1,4 +1,5 @@
 /// <reference types="openfin-adapter/fin" />
+import { NamedIdentity } from 'openfin-adapter/src/identity';
 export declare type LayoutComponentStateExtended = OpenFin.LayoutComponent['componentState'] & {
     name: string;
     uuid: string;
@@ -40,7 +41,7 @@ export declare type LayoutDOMEventListener = (ev: LayoutDOMEvent) => void;
  */
 export declare const cloneLayoutAndRemoveNames: (layout: any) => any;
 export declare const mapContentComponentState: (content: OpenFin.LayoutContent | LayoutContentExtended) => LayoutComponentStateExtended[];
-export declare const getLayoutWithSingleView: (title: string, url: string) => Promise<any>;
+export declare const getLayoutWithSingleView: (title: string, url: string, winIdentity?: NamedIdentity) => Promise<any>;
 export declare const isLayoutTabActive: (tabSelector: string) => boolean;
 export declare const containerId = "layout_container";
 export declare const getViewComponents: () => LayoutContentExtended;

package/common/src/utils/merge-deep.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Deep merge a set of source objects into a single target object.
+ * @param target the target object to merge sources into.
+ * @param sources the source objects to merge into the target. (FIFO)
+ */
+export declare function mergeDeep(target: any, ...sources: any[]): any;

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

@@ -1,5 +1,3 @@
 export declare const capitalize: (s: string) => string;
-export declare const titleize: (s: string) => string;
 export declare const pascalize: (s: string) => string;
-export declare const slugify: (s: string) => string;
 export declare const isStringMatchesQuery: (title: string, query?: string) => boolean;

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

@@ -31,6 +31,9 @@ export interface WindowIdentity {
     uuid: ApplicationUUID | string;
     name: WindowName | string;
 }
+export interface WindowCreationOptionsExtended extends OpenFin.PlatformWindowCreationOptions {
+    backgroundThrottling?: boolean;
+}
 interface Point {
     left: number;
     top: number;
@@ -144,4 +147,5 @@ export declare const isStorefrontWindowRunning: () => Promise<boolean>;
 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 {};