@openfin/workspace-platform 17.0.3 → 17.0.4

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

@@ -111,6 +111,7 @@ export declare enum ButtonStyle {
     Secondary = "secondary",
     TextOnly = "textOnly"
 }
+export type SplitButtonStyle = Extract<ButtonStyle, ButtonStyle.Primary | ButtonStyle.Secondary>;
 export type PlainContainerTemplateFragment = ContainerTemplateFragment<'Container'>;
 export type ButtonTemplateFragment = ContainerTemplateFragment<'Button'> & FragmentAction & {
     /**
@@ -120,9 +121,9 @@ export type ButtonTemplateFragment = ContainerTemplateFragment<'Button'> & Fragm
 };
 export type SplitButtonFragment = ContainerTemplateFragment<'SplitButton'> & {
     /**
-     * The type of button that determines styling.
+     * Determines the styling of the split button.
      */
-    buttonType: 'primary' | 'secondary';
+    buttonStyle: SplitButtonStyle;
     /**
      * Data key of the template fragment.
      *
@@ -132,7 +133,7 @@ export type SplitButtonFragment = ContainerTemplateFragment<'SplitButton'> & {
      * ```ts
      * const myTemplateLayout = {
      *    type: FragmentTypes.SplitButton,
-     *    buttonType: 'primary',
+     *    buttonStyle: ButtonStyle.Primary,
      *    dataKey: 'splitButton1',
      * }
      *

package/client-api-platform/src/init/browser-window-focus.d.ts

@@ -4,10 +4,6 @@ import type OpenFin from '@openfin/core';
  * @returns the last focused browser window.
  */
 export declare function getLastFocusedBrowserWindow(): Promise<OpenFin.Identity | undefined>;
-/**
- * Set the OpenFin identity of the last focused browser window.
- */
-export declare function setLastFocusedBrowserWindow(identity?: OpenFin.Identity): Promise<void>;
 /**
  * Listen for a browser window to be focused.
  * When a browser window is focused, store it in local storage as the last focused browser window.

package/client-api-platform/src/init/{browser-defaults.d.ts → override-callback/browser-defaults.d.ts}

@@ -1,6 +1,6 @@
 import type OpenFin from '@openfin/core';
-import type { CustomThemeOptions, CustomThemeOptionsWithScheme } from '../../../common/src/api/theming';
-import { BrowserInitConfig } from '../../../client-api-platform/src/shapes';
+import type { CustomThemeOptions, CustomThemeOptionsWithScheme } from '../../../../common/src/api/theming';
+import { BrowserInitConfig } from '../../../../client-api-platform/src/shapes';
 /**
  * Applies default options to the creation of browser windows.
  */

package/client-api-platform/src/init/{dialogs.d.ts → override-callback/dialogs.d.ts}

@@ -1,3 +1,3 @@
 import type OpenFin from '@openfin/core';
-import { ShowQuitPlatformDialogRequest } from '..';
+import { ShowQuitPlatformDialogRequest } from '../../../../client-api-platform/src/shapes';
 export declare const showQuitPlatformDialogInternal: (req: ShowQuitPlatformDialogRequest, identity: OpenFin.ProviderIdentity | OpenFin.ClientIdentity) => Promise<void>;

package/client-api-platform/src/init/{override-callback.d.ts → override-callback/index.d.ts}

@@ -1,3 +1,3 @@
 import type OpenFin from '@openfin/core';
-import { BrowserInitConfig, WorkspacePlatformOverrideCallback, WorkspacePlatformProvider } from '../../../client-api-platform/src/shapes';
+import { BrowserInitConfig, WorkspacePlatformOverrideCallback, WorkspacePlatformProvider } from '../../../../client-api-platform/src/shapes';
 export declare const getOverrideCallback: (browserInitOptions: BrowserInitConfig | null, overrideCallback?: WorkspacePlatformOverrideCallback) => OpenFin.OverrideCallback<WorkspacePlatformProvider>;

package/client-api-platform/src/init/override-callback/index.test.d.ts

@@ -0,0 +1 @@
+import '@common/test/fin-mocks';

package/client-api-platform/src/init/override-callback/mock-snapshots.d.ts

@@ -0,0 +1,234 @@
+export declare const mockSnapshotWithInternalData1: {
+    windows: {
+        layout: {
+            content: {
+                type: string;
+                content: ({
+                    type: string;
+                    content: {
+                        type: string;
+                        componentName: string;
+                        componentState: {
+                            _internalWorkspaceData: {
+                                viewIdentifier: string;
+                                browserNavigationButtons: {
+                                    back: boolean;
+                                    forward: boolean;
+                                    reload: boolean;
+                                };
+                            };
+                        };
+                    }[];
+                } | {
+                    type: string;
+                    content: ({
+                        type: string;
+                        content: {
+                            type: string;
+                            content: {
+                                type: string;
+                                componentName: string;
+                                componentState: {
+                                    _internalWorkspaceData: {
+                                        viewIdentifier: string;
+                                        browserNavigationButtons: {
+                                            back: boolean;
+                                            forward: boolean;
+                                            reload: boolean;
+                                        };
+                                    };
+                                };
+                            }[];
+                        }[];
+                    } | {
+                        type: string;
+                        content: {
+                            type: string;
+                            componentName: string;
+                            componentState: {
+                                _internalWorkspaceData: {
+                                    viewIdentifier: string;
+                                    browserNavigationButtons: {
+                                        reload: boolean;
+                                    };
+                                };
+                            };
+                        }[];
+                    })[];
+                })[];
+            }[];
+        };
+    }[];
+};
+export declare const mockSnapshotWithWorkspacePlatform1: {
+    windows: {
+        layout: {
+            content: {
+                type: string;
+                content: ({
+                    type: string;
+                    content: {
+                        type: string;
+                        componentName: string;
+                        componentState: {
+                            _internalWorkspaceData: {
+                                viewIdentifier: string;
+                            };
+                            workspacePlatform: {
+                                browserNavigationButtons: {
+                                    back: boolean;
+                                    forward: boolean;
+                                    reload: boolean;
+                                };
+                            };
+                        };
+                    }[];
+                } | {
+                    type: string;
+                    content: ({
+                        type: string;
+                        content: {
+                            type: string;
+                            content: {
+                                type: string;
+                                componentName: string;
+                                componentState: {
+                                    _internalWorkspaceData: {
+                                        viewIdentifier: string;
+                                    };
+                                    workspacePlatform: {
+                                        browserNavigationButtons: {
+                                            back: boolean;
+                                            forward: boolean;
+                                            reload: boolean;
+                                        };
+                                    };
+                                };
+                            }[];
+                        }[];
+                    } | {
+                        type: string;
+                        content: {
+                            type: string;
+                            componentName: string;
+                            componentState: {
+                                _internalWorkspaceData: {
+                                    viewIdentifier: string;
+                                };
+                                workspacePlatform: {
+                                    browserNavigationButtons: {
+                                        reload: boolean;
+                                    };
+                                };
+                            };
+                        }[];
+                    })[];
+                })[];
+            }[];
+        };
+    }[];
+};
+export declare const mockSnapshotWithInternalData2: {
+    windows: {
+        workspacePlatform: {
+            pages: {
+                layout: {
+                    content: {
+                        type: string;
+                        content: ({
+                            type: string;
+                            content: {
+                                type: string;
+                                content: {
+                                    type: string;
+                                    componentName: string;
+                                    componentState: {
+                                        _internalWorkspaceData: {
+                                            viewIdentifier: string;
+                                            browserNavigationButtons: {
+                                                back: boolean;
+                                                forward: boolean;
+                                                reload: boolean;
+                                            };
+                                        };
+                                    };
+                                }[];
+                            }[];
+                        } | {
+                            type: string;
+                            content: {
+                                type: string;
+                                content: {
+                                    type: string;
+                                    componentName: string;
+                                    componentState: {
+                                        _internalWorkspaceData: {
+                                            viewIdentifier: string;
+                                            browserNavigationButtons: {
+                                                reload: boolean;
+                                            };
+                                        };
+                                    };
+                                }[];
+                            }[];
+                        })[];
+                    }[];
+                };
+            }[];
+        };
+    }[];
+};
+export declare const mockSnapshotWithWorkspacePlatform2: {
+    windows: {
+        workspacePlatform: {
+            pages: {
+                layout: {
+                    content: {
+                        type: string;
+                        content: ({
+                            type: string;
+                            content: {
+                                type: string;
+                                content: {
+                                    type: string;
+                                    componentName: string;
+                                    componentState: {
+                                        _internalWorkspaceData: {
+                                            viewIdentifier: string;
+                                        };
+                                        workspacePlatform: {
+                                            browserNavigationButtons: {
+                                                back: boolean;
+                                                forward: boolean;
+                                                reload: boolean;
+                                            };
+                                        };
+                                    };
+                                }[];
+                            }[];
+                        } | {
+                            type: string;
+                            content: {
+                                type: string;
+                                content: {
+                                    type: string;
+                                    componentName: string;
+                                    componentState: {
+                                        _internalWorkspaceData: {
+                                            viewIdentifier: string;
+                                        };
+                                        workspacePlatform: {
+                                            browserNavigationButtons: {
+                                                reload: boolean;
+                                            };
+                                        };
+                                    };
+                                }[];
+                            }[];
+                        })[];
+                    }[];
+                };
+            }[];
+        };
+    }[];
+};

package/client-api-platform/src/init/{page-defaults.d.ts → override-callback/page-defaults.d.ts}

@@ -1,3 +1,3 @@
-import type { AttachedPage } from '../../../common/src/api/pages/shapes';
-import type { BrowserInitConfig } from '..';
+import type { AttachedPage } from '../../../../common/src/api/pages/shapes';
+import type { BrowserInitConfig } from '../..';
 export declare const applyPageDefaults: (pages: AttachedPage[], defaultPageOptions?: BrowserInitConfig['defaultPageOptions']) => Promise<AttachedPage[]>;

package/client-api-platform/src/init/override-callback/snapshot.d.ts

@@ -0,0 +1,3 @@
+import type OpenFin from '@openfin/core';
+export declare const parseInternalWorkspaceDataOnWindows: <T extends OpenFin.Snapshot>(snapshot: T) => T;
+export declare const parseWorkspacePlatformOnWindows: <T extends OpenFin.Snapshot>(snapshot: T) => T;

package/client-api-platform/src/init/override-callback/view-options.d.ts

@@ -0,0 +1,12 @@
+import type OpenFin from '@openfin/core';
+import { BrowserCreateViewRequest, BrowserViewState, BrowserWorkspacePlatformViewOptions } from '../../../../client-api-platform/src/shapes';
+export declare function overrideViewOptions(options: Partial<OpenFin.ViewOptions>, initOptions: Partial<OpenFin.ViewOptions>): any;
+export declare function preserveInteropIfManifestConflict(opts: Partial<OpenFin.ViewOptions>, fetchManifest: ({ manifestUrl }: {
+    manifestUrl: string;
+}, callerIdentity: OpenFin.Identity) => any, callerIdentity: OpenFin.Identity): Promise<any>;
+type ViewStateBase = Pick<BrowserViewState, '_internalWorkspaceData' | 'workspacePlatform'>;
+export declare const mapInternalWorkspaceDataToWorkspacePlatform: <T extends ViewStateBase>(viewState: T) => T;
+export declare const mapWorkspacePlatformToInternalWorkspaceData: <T extends ViewStateBase>(viewState: T) => T;
+export declare const setHotkeysIfNavigationButtonsEnabled: (options: BrowserCreateViewRequest) => Promise<BrowserCreateViewRequest>;
+export declare const registerHotkeyListenersIfEnabled: (viewIdentity: OpenFin.Identity, buttonOptions?: BrowserWorkspacePlatformViewOptions['browserNavigationButtons']) => void;
+export {};

package/client-api-platform/src/init/utils.d.ts

@@ -1,10 +1,6 @@
 import type OpenFin from '@openfin/core';
 import type { Page } from '../../../common/src/api/pages/shapes';
 import type { BrowserSnapshot } from '..';
-export declare function overrideViewOptions(options: Partial<OpenFin.ViewOptions>, initOptions: OpenFin.ViewOptions): any;
-export declare function preserveInteropIfManifestConflict(opts: Partial<OpenFin.ViewOptions>, fetchManifest: ({ manifestUrl }: {
-    manifestUrl: string;
-}, callerIdentity: OpenFin.Identity) => any, callerIdentity: OpenFin.Identity): Promise<any>;
 export declare const filterSnapshotWindows: (win: OpenFin.WindowOptions) => boolean;
 /**
  * fitToMonitor()
@@ -37,4 +33,5 @@ export type WindowType = 'browser' | 'platform' | 'classic' | 'mixed';
  * @returns - Whether the snapshot has browser windows.
  */
 export declare function checkHasBrowserWindows(snapshot: BrowserSnapshot): boolean;
+export declare const copyObject: <T>(obj: T) => T;
 export {};

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

@@ -486,6 +486,27 @@ export declare enum WindowType {
     Browser = "browser",
     Platform = "platform"
 }
+export interface BrowserWorkspacePlatformViewOptions {
+    browserNavigationButtons?: RequireAtLeastOne<{
+        back?: boolean;
+        forward?: boolean;
+        reload?: boolean;
+    }>;
+}
+type RequireAtLeastOne<T, Keys extends keyof T = keyof T> = Pick<T, Exclude<keyof T, Keys>> & {
+    [K in Keys]-?: Required<Pick<T, K>> & Partial<Pick<T, Exclude<Keys, K>>>;
+}[Keys];
+export interface BrowserCreateViewPayload {
+    opts: BrowserCreateViewRequest;
+    target?: OpenFin.CreateViewTarget;
+    targetView?: OpenFin.Identity;
+}
+export interface BrowserCreateViewRequest extends OpenFin.PlatformViewCreationOptions {
+    workspacePlatform?: BrowserWorkspacePlatformViewOptions;
+}
+export interface BrowserViewState extends OpenFin.ViewState {
+    workspacePlatform?: BrowserWorkspacePlatformViewOptions;
+}
 export interface BrowserWorkspacePlatformWindowOptions {
     /** For internal usage.  Defaults to 'browser' when Browser is enabled when the WorkspacePlatform is initialized.  In order to use
      * non-Browser layout windows ('platform' windows) in a Browser-enabled workspace platform, set windowType to `platform`. In that instance, the other properties
@@ -510,6 +531,46 @@ export interface BrowserWorkspacePlatformWindowOptions {
     newPageUrl?: string;
     toolbarOptions?: ToolbarOptions;
     windowStateButtonOptions?: WindowStateButtonOptions;
+    /**
+     * Use when you want to display navigation buttons in Browser toolbar. Disabled by default.
+     *
+     * @example
+     * ```
+     * import * as WP from "@openfin/workspace-platform";
+     *
+     * const platform = WP.getCurrentSync();
+     * const browserWin = platform.Browser.createWindow({
+     *   ...,
+     *   workspacePlatform: {
+     *     ...,
+     *     navigationButtons: {
+     *       enabled: true;
+     *     }
+     *   }
+     * });
+     * ```
+     *
+     * @example
+     * ```
+     * // With disabled default keyboard shortcuts
+     * const browserWin = platform.Browser.createWindow({
+     *   ...,
+     *   workspacePlatform: {
+     *     ...,
+     *     navigationButtons: {
+     *       enabled: true;
+     *       hotkeysDisabled: true;
+     *     }
+     *   }
+     * });
+     * ```
+     */
+    navigationButtons?: {
+        enabled: false;
+    } | {
+        enabled: true;
+        hotkeysDisabled?: boolean;
+    };
     /**
      * 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,
@@ -1189,6 +1250,49 @@ export interface WorkspacePlatformModule extends OpenFin.Platform {
      * Get a snapshot that contains browser windows with pages.
      */
     getSnapshot(): Promise<BrowserSnapshot>;
+    /**
+     * Preferred way of getting View options with Workspace Platform.
+     *
+     * @param viewIdentity
+     *
+     * @example
+     * ```
+     * import * as WP from "@openfin/workspace-platform";
+     *
+     * const platform = WP.getCurrentSync();
+     * const view = await platform.createView(options);
+     * const viewOptions = await platform.getViewSnapshot(view.identity);
+     *
+     * console.log(viewOptions.workspacePlatform);
+     * ```
+     */
+    getViewSnapshot(viewIdentity: OpenFin.Identity): Promise<BrowserViewState>;
+    /**
+     * Use when you need to create a View into Browser window. In addition to what regular platfom `createView` offers, here you can specify `workspacePlatform` options for settings related to Workspace Platform.
+     *
+     * For general details about this method, see docs for `@openfin/core`.
+     *
+     *
+     * @example
+     * ```
+     * import * as WP from "@openfin/workspace-platform";
+     *
+     * const platform = WP.getCurrentSync();
+     *
+     * platform.createView({
+     *   url: "https://url-to-your-app.com",
+     *   ...,
+     *   workspacePlatform: {
+     *     browserNavigationButtons: {
+     *       reload: false,
+     *       back: true,
+     *       forward: true
+     *     }
+     *   }
+     * });
+     * ```
+     */
+    createView(viewOptions: Partial<OpenFin.ViewOptions> | BrowserCreateViewRequest, target?: OpenFin.CreateViewTarget, targetView?: OpenFin.Identity): Promise<OpenFin.View>;
     /**
      * Launch an application.
      *
@@ -1388,6 +1492,13 @@ export interface WorkspacePlatformProvider extends OpenFin.PlatformProvider {
      * @param req the payload received by the provider
      */
     handleAnalytics(req: AnalyticsEvent[]): Promise<void>;
+    /**
+     * Override when you need to add custom functionality when creating a view.
+     *
+     * @param payload creatin options for the new view
+     * @param callerIdentity identity of the entity that called {@link WorkspacePlatformModule.createView}
+     */
+    createView(payload: BrowserCreateViewPayload, callerIdentity: OpenFin.Identity): Promise<OpenFin.View>;
     /**
      * Implementation for deciding whether a modal informing about loss of unsaved changes will be displayed when closing a page.
      * The default implementation returns `{ shouldShowModal: true }` if the page has unsaved changes (`hasUnsavedChanges` page property)
@@ -1743,7 +1854,7 @@ export interface BrowserInitConfig {
     /**
      * 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.
      */
-    defaultViewOptions?: OpenFin.ViewOptions;
+    defaultViewOptions?: Partial<OpenFin.ViewOptions>;
     /**
      * The platform title. UI friendly title for the platform in browser.
      */

package/common/src/api/protocol/workspace-platform.d.ts

@@ -6,7 +6,7 @@ import type OpenFin from '@openfin/core';
  * When adding a new channel action make sure to add a function that's name matches
  * the value of the enum for the remote procedure in the Workspace Platform overrides and the override-callback.
  * All of the registered channel action handlers can be found here in the platform's overrides:
- * @see link: [Provider Protocol Handlers](https://github.com/openfin/workspace/client-api-platform/src/init/override-callback.ts)
+ * @see link: [Provider Protocol Handlers](https://github.com/openfin/workspace/client-api-platform/src/init/override-callback/index.ts)
  */
 export declare enum WorkspacePlatformChannelAction {
     LaunchApp = "launchApp",
@@ -19,7 +19,6 @@ export declare enum WorkspacePlatformChannelAction {
     CreateSavedPageInternal = "createSavedPageInternal",
     UpdateSavedPageInternal = "updateSavedPageInternal",
     DeleteSavedPageInternal = "deleteSavedPageInternal",
-    SharePage = "sharePage",
     UpdatePageForWindow = "updatePageForWindow",
     AttachPagesToWindow = "attachPagesToWindow",
     DetachPagesFromWindow = "detachPagesFromWindow",

package/common/src/utils/modal-bounds.d.ts

@@ -7,7 +7,7 @@ import { ResponseModalConfig } from './menu-config';
  * @param modalOptions window options including height/width so that we can calculate the correct bounds
  * @param parentWindowIdentity the window to get the bounds from. If this is undefined, the primary monitor will be used
  * @param centerOnMonitor whether the modal should be centered on the monitor
- * @returns a point (top/left) as to where the window should be placed
+ * @returns the bounds for where the modal is to be displayed
  */
 export declare const getResponseModalBounds: (modalOptions: ResponseModalConfig['windowOptions'], parentWindowIdentity?: OpenFin.Identity, centerOnMonitor?: boolean) => Promise<OpenFin.Bounds>;
 /**

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

@@ -11,7 +11,6 @@ export declare enum PageRoute {
     Browser = "/browser/",
     BrowserPopupMenu = "/browser/popup-menu/",
     Provider = "/provider/",
-    BrowserPopupMenuSharePage = "/browser/popup-menu/share-page/",
     BrowserPopupMenuSaveModal = "/browser/popup-menu/save-modal/",
     BrowserPopupMenuLayouts = "/browser/popup-menu/layouts/layouts/",
     BrowserPopupMenuColorLinking = "/browser/popup-menu/color-linking/color-linking/",

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

@@ -3,9 +3,8 @@ export type SnapshotDetailsExtended = OpenFin.Snapshot['snapshotDetails'] & {
     machineId: string;
     machineName?: string;
 };
-export type SnapshotExtended = {
+export type SnapshotExtended = OpenFin.Snapshot & {
     snapshotDetails: SnapshotDetailsExtended;
-    windows: OpenFin.WindowOptions[];
 };
 export type ApplySnapshotOptionsExtended = OpenFin.ApplySnapshotOptions & {
     attachToExistingWindow: boolean;

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

@@ -157,4 +157,6 @@ export declare const getComponentWindowStatus: () => Promise<{
     storefrontRunning: boolean;
     homeRunning: boolean;
 }>;
+export declare const deserializeWindowBounds: (serialized: string) => OpenFin.WindowBounds | null;
+export declare const serializeWindowBounds: (bounds: OpenFin.WindowBounds) => string;
 export {};

package/common/src/utils/workspace-modals.d.ts

@@ -7,6 +7,7 @@ export declare const showDeleteWorkspaceModal: (windowIdentity: OpenFin.Identity
  *
  * @param windowIdentity Parent or Current OpenFin Window Identity
  * @param workspaceTitle The platform label
+ * @param shouldCenterOnMonitor Boolean - determines if modal window is centered on the monitor.
  * @returns Boolean - Affirmative or Negative response from user
  */
 export declare const showPlatformQuitModal: (windowIdentity: OpenFin.Identity, workspaceTitle: string, shouldCenterOnMonitor?: boolean) => Promise<boolean>;