@openfin/workspace-platform 20.3.5 → 20.3.7

package/client-api-platform/src/api/context-menu/index.d.ts

@@ -1,10 +1,20 @@
 import type OpenFin from '@openfin/core';
 import { ContextMenuType } from '../../../../common/src/utils/popup-window';
 import { InternalOpenGlobalContextMenuRequest, InternalOpenPageTabContextMenuRequest, OpenGlobalContextMenuPayload, OpenPageTabContextMenuPayload, OpenSaveButtonContextMenuPayload, OpenSaveButtonContextMenuRequest, OpenViewTabContextMenuPayload, OpenViewTabContextMenuRequest, WorkspacePlatformProvider } from '../../../../client-api-platform/src/shapes';
+/**
+ * Enum representing the possible anchor behaviors for positioning context menus.
+ * These are relative to an element/cursor position (as opposed to a corner of the context menu window).
+ *
+ * e.g. AnchorBehavior.BottomRight implies a context menu will expand aligned with the bottom and right edge of an element.
+ *
+ * @enum {number}
+ */
 export declare enum AnchorBehavior {
-    BottomLeft = 0,
-    BottomRight = 1,
-    Center = 2
+    TopLeft = 0,
+    TopRight = 1,
+    BottomLeft = 2,
+    BottomRight = 3,
+    Center = 4
 }
 type ContextMenuPayload = OpenGlobalContextMenuPayload | OpenViewTabContextMenuPayload | OpenPageTabContextMenuPayload | OpenSaveButtonContextMenuPayload;
 export declare const openCommonContextMenu: (payload: ContextMenuPayload, _callerIdentity: OpenFin.Identity, type?: ContextMenuType, anchorBehavior?: AnchorBehavior) => Promise<void>;

package/client-api-platform/src/api/controllers/__tests__/theme-storage-controller.test.d.ts

@@ -0,0 +1 @@
+export {};

package/client-api-platform/src/api/controllers/theme-storage-controller-store.d.ts

@@ -0,0 +1,4 @@
+import { ThemeStorageController } from '../../../../client-api-platform/src/api/controllers/theme-storage-controller';
+import { CustomThemes } from '../../../../client-api-platform/src/shapes';
+export declare const initialiseStoragePalettes: (customThemes: CustomThemes) => void;
+export declare const getThemeStorageController: () => ThemeStorageController;

package/client-api-platform/src/api/controllers/theme-storage-controller.d.ts

@@ -0,0 +1,51 @@
+import { StorageProxy } from '../../../../client-api-platform/src/api/utils';
+import { ColorSchemeOptionType, CustomPaletteSet } from '../../../../client-api-platform/src/shapes';
+/**
+ * Palette extensions can be used to add new variables to the palette set.
+ *
+ * This is particularly useful if a value uses a different palette constant depending on scheme.
+ */
+export declare const getPaletteExtensions: (palette: CustomPaletteSet, paletteScheme: 'light' | 'dark') => {
+    selectedTab: string;
+};
+export type Palettes = {
+    dark: CustomPaletteSet;
+    light: CustomPaletteSet;
+};
+export declare class ThemeStorageController {
+    private providerStorage;
+    private darkPaletteVars?;
+    private lightPaletteVars?;
+    private workspaceStorage?;
+    constructor(providerStorage: Pick<Storage, 'getItem' | 'setItem'>);
+    private getVarsByScheme;
+    /**
+     * Set the current Storage Proxy to enable Workspace Storage properties to be populated.
+     */
+    setWorkspaceStorageProxy: (proxy: StorageProxy) => void;
+    /**
+     * Synchronize the current palette and scheme with workspace's storage instance if
+     * storage based theming is enabled
+     */
+    trySynchronizeWorkspaceStorage: () => Promise<void>;
+    /**
+     * Set the current Palette to be used by workspace. This palette will be converted into
+     * css vars and combined into a single stylesheet. This stylesheet is exposed in localstorage
+     * to allow workspace UI elements to load the palette before their first paint.
+     * @param palettes Light and Dark Palette constants
+     */
+    setPalettes: ({ light, dark }: Palettes) => Promise<void>;
+    /**
+     * Set the current scheme of workspace. Specifically setting light or dark
+     * will ignore the OS scheme, whereas 'system' will always respect it.
+     *
+     * This will also update the CSS vars to either support media queries in System mode or force a palette.
+     * @param scheme 'light', 'dark' or 'system'.
+     */
+    setScheme(scheme: ColorSchemeOptionType): void;
+    /**
+     * Returns the current scheme
+     * @returns 'light' | 'system' | 'dark'
+     */
+    getScheme(): ColorSchemeOptionType;
+}

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

@@ -1 +1,6 @@
 export declare const listenForStoreClose: () => void;
+export type StorageProxy = {
+    setItem: (data: string, value: string) => Promise<void>;
+    destroy: () => Promise<void>;
+};
+export declare const createStorageProxy: (url: string) => Promise<StorageProxy>;

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

@@ -2,7 +2,6 @@ import type OpenFin from '@openfin/core';
 import { WindowName } from '../../../../common/src/utils/window';
 import type { PreloadedThemeData } from '../../../../common/src/api/theming';
 import { BrowserInitConfig } from '../../../../client-api-platform/src/shapes';
-export declare const ENTERPRISE_LANDING_PAGE_URL: string;
 export declare const searchMenuIdentityBase: {
     uuid: string;
     name: WindowName;

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

@@ -2,8 +2,8 @@ import { CustomThemes } from '../shapes';
 export declare const getThemes: () => CustomThemes;
 /**
  * initTheming()
- * Accepts an array of CustomThemes objects and stores it
  * @param customThemes array of theme objects
+ * Accepts an array of CustomThemes objects and stores it
  * @returns array of custom theme objects
  */
-export default function initTheming(customThemes: CustomThemes): void;
+export default function initTheming(customThemes: CustomThemes): Promise<void>;

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

@@ -2269,3 +2269,7 @@ export interface LaunchBookmarkPayload {
     sourceIdentity: OpenFin.Identity;
     sourceEvent: Pick<MouseEvent, 'ctrlKey' | 'metaKey' | 'shiftKey'>;
 }
+export type SearchProviderFilter = {
+    id: string;
+    title: string;
+};

package/common/src/api/__test__/default-palette.d.ts

@@ -0,0 +1,48 @@
+export declare const defaultDarkScheme: {
+    background1: string;
+    background2: string;
+    background3: string;
+    background4: string;
+    background5: string;
+    background6: string;
+    backgroundPrimary: string;
+    brandPrimary: string;
+    brandSecondary: string;
+    contentBackground1: string;
+    inputBackground: string;
+    inputColor: string;
+    inputDisabled: string;
+    inputFocused: string;
+    inputPlaceholder: string;
+    statusActive: string;
+    statusCritical: string;
+    statusSuccess: string;
+    statusWarning: string;
+    textDefault: string;
+    textHelp: string;
+    textInactive: string;
+};
+export declare const defaultLightScheme: {
+    background1: string;
+    background2: string;
+    background3: string;
+    background4: string;
+    background5: string;
+    background6: string;
+    backgroundPrimary: string;
+    brandPrimary: string;
+    brandSecondary: string;
+    contentBackground1: string;
+    inputBackground: string;
+    inputColor: string;
+    inputDisabled: string;
+    inputFocused: string;
+    inputPlaceholder: string;
+    statusActive: string;
+    statusCritical: string;
+    statusSuccess: string;
+    statusWarning: string;
+    textDefault: string;
+    textHelp: string;
+    textInactive: string;
+};

package/common/src/api/theming.d.ts

@@ -1,6 +1,6 @@
 import type { DefaultTheme } from 'styled-components';
 import type OpenFin from '@openfin/core';
-import { ColorSchemeType, ThemeSet } from '@openfin/ui-library';
+import { type ColorSchemeType, type ThemeSet } from '@openfin/ui-library';
 import { Palette } from '@openfin/ui-library';
 import { ColorSchemeOptionType } from '../../../client-api-platform/src/shapes';
 export type WorkspaceComponentSetSelectedSchemePayload = {

package/common/src/components/IndicatorContainer/helper.d.ts

@@ -0,0 +1,30 @@
+import type OpenFin from '@openfin/core';
+export declare enum ShowAtType {
+    Top = "top",
+    Below = "below"
+}
+export declare const getParentWindowBounds: (parentWindow: OpenFin.Window | false, parentWindowBounds?: OpenFin.WindowBounds) => Promise<OpenFin.WindowBounds>;
+export declare const isWindowMaximized: (parentWindow: OpenFin.Window | false) => Promise<boolean>;
+/**
+ * Generates the bounds for the indicator window based on the provided parameters.
+ * If isEnterprise is true indicator will show below, otherwise default will show at the top
+ * Indicator appears center of parent window
+ * If window is maximized, indicator will appear center of monitor bounds
+ *
+ *
+ * @param identity identity of browser window.
+ * @param myWidth width of the window.
+ * @param myHeight height of the window.
+ * @param showAt showAt The position to show the window relative to its parent.
+ * @param parentWindowBounds The bounds of the parent window.
+ * @returns the bounds of where the indicator will be placed.
+ */
+export declare function generateBounds(identity: OpenFin.Identity, myWidth: number, myHeight: number, showAt: ShowAtType, parentWindowBounds?: OpenFin.WindowBounds): Promise<{
+    left: number;
+    top: number;
+    width: number;
+    height: number;
+}>;
+declare function adjustWindowDimensions(identity: OpenFin.Identity, container: HTMLDivElement, showAt: ShowAtType, parentWindowBounds?: OpenFin.WindowBounds): Promise<void>;
+declare const debouncedAdjustWindowDimension: typeof adjustWindowDimensions;
+export default debouncedAdjustWindowDimension;

package/common/src/utils/browser-base-url.d.ts

@@ -17,6 +17,7 @@ export declare function getBrowserBaseUrl(returnUrlWithATrailingSlash?: boolean)
  * @returns The browser base url override if it exists, otherwise null
  */
 export declare function getEnterpriseBaseUrl(returnUrlWithATrailingSlash?: boolean): Promise<string>;
+export declare function getEnterpriseLandingUrl(): Promise<string>;
 /**
  * Get the enterprise browser or the workspace browser base url
  * @param isEnterprise - if true, we are in enterprise browser

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

@@ -19,4 +19,11 @@ export declare const DefaultSaveMenuBounds: {
     width: number;
     height: number;
 };
+export declare const getBoundsBasedOnAnchorBehavior: (bounds: OpenFin.Bounds, anchorBehavior: AnchorBehavior) => OpenFin.Bounds | {
+    bottom: number;
+    top: number;
+    left: number;
+    height: number;
+    width: number;
+};
 export declare const getPrintOption: () => Promise<ViewTabContextMenuTemplate | PageTabContextMenuItemTemplate>;

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

@@ -2,7 +2,6 @@ import type OpenFin from '@openfin/core';
 import { MenuItemType } from '../../../common/src/utils/context-menu';
 import * as WP from '../../../client-api-platform/src/index';
 import { GlobalContextMenuItemTemplate, GlobalContextMenuOptionType, Workspace } from '../../../client-api-platform/src/shapes';
-export declare const isOSWindows: () => Promise<boolean>;
 export declare const getCloseWindow: () => {
     type: MenuItemType;
     label: string;

package/common/src/utils/local-storage-key.d.ts

@@ -6,6 +6,7 @@ declare enum LocalStorageKey {
     NewTabPageSort = "NewTabPageSort",
     DockPosition = "DockPosition",
     SelectedColorScheme = "SelectedColorScheme",
+    ThemePaletteSheet = "ThemePaletteSheet",
     HasMovedStore = "HasMovedStore",
     PageDragState = "BrowserPageDragState"
 }

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

@@ -18,3 +18,38 @@ export declare const getCenterOfParentWindowMonitor: (parentWindowIdentity?: Ope
  */
 export declare const getResponseModalBounds: (modalOptions: ResponseModalConfig['windowOptions'], parentWindowIdentity?: OpenFin.Identity, centerOnMonitor?: boolean) => Promise<OpenFin.Bounds>;
 export declare function getResponseModalBoundsAndCenterParentIfModalOffScreen(modalOptions: ResponseModalConfig['windowOptions'], parentWindowIdentity?: OpenFin.Identity, centerOnMonitor?: boolean): Promise<OpenFin.Bounds>;
+/**
+ * Adjusts the given bounds to be within the closest monitor's available bounds if they are offscreen.
+ *
+ * @param {OpenFin.Bounds} bounds - The bounds to be adjusted.
+ * @returns {Promise<OpenFin.Bounds>} - The adjusted bounds that are within the closest monitor's available bounds.
+ */
+export declare function getClosestBoundsIfModalBoundsOffscreen(bounds: OpenFin.Bounds): Promise<OpenFin.Bounds>;
+/**
+ * Adjusts the given bounds if they are offscreen to be within the closest monitor's available bounds.
+ * Returns bounds relative to the parent window's bounds (as opposed to bounds relative to the monitor).
+ *
+ * @param {OpenFin.WindowBounds} parentWindowBounds - The bounds of the parent window.
+ * @param {OpenFin.Bounds} bounds - The bounds to be adjusted.
+ * @returns {Promise<OpenFin.Bounds>} - The adjusted bounds that are within the closest monitor's available bounds relative to the parent window's bounds.
+ */
+export declare const getClosestRelativeBoundsIfModalBoundsOffscreen: (parentWindowBounds: OpenFin.WindowBounds, bounds: OpenFin.Bounds) => Promise<OpenFin.Bounds>;
+/**
+ * Returns whether a window is maximized and the OS is Windows 10 or 11.
+ * Relates to: https://github.com/electron/electron/issues/4045
+ *
+ * @param window - The OpenFin window.
+ * @returns A promise that resolves to a boolean indicating whether a window is maximized and the OS is Windows 10 or 11.
+ */
+export declare const getIsWindowMaximizedOnWindows10Or11: (window: OpenFin.Window) => Promise<boolean>;
+/**
+ * Retrieves the current bounds of a window whether it's maximized or minimized.
+ * For maximized windows on Windows 10 and 11, it will return adjusted bounds to account for an Electron bug where a 7px
+ * shadow is included in the measurement of the window bounds.
+ *
+ * Relates to: https://github.com/electron/electron/issues/4045
+ *
+ * @param windowIdentity - The identity of the window.
+ * @returns A promise that resolves to the current window bounds.
+ */
+export declare const getCurrentBounds: (windowIdentity: OpenFin.Identity) => Promise<OpenFin.WindowBounds>;

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

@@ -0,0 +1,2 @@
+export declare const isOSWindows: () => Promise<boolean>;
+export declare const isWindows10Or11: () => Promise<boolean>;

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

@@ -68,6 +68,8 @@ export type SearchMenuChannelResponse = {
 } | {
     type: 'keyboard-event';
     keyboardEvent: BrowserSearchMenuKeyboardEvent;
+} | {
+    type: 'search-provider-changed';
 };
 export declare function showPopupWin<T extends keyof UserMenuParams>(parentWindow: OpenFin.Window, params: UserMenuParams[T], windowOpts: OpenFin.PopupOptions): Promise<OpenFin.PopupResult>;
 export {};

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

@@ -27,6 +27,7 @@ declare enum BrowserRoute {
     EnterpriseBrowser = "/enterprise/",
     EnterpriseContextMenu = "/context-menu/",
     EnterpriseBookmarkDialog = "/bookmark-dialog/",
+    EnterpriseStorageProxy = "/enterprise/storage-proxy",
     DropdownMenu = "/dropdown-menu/",
     EnterpriseDock = "/dock/"
 }
@@ -43,6 +44,7 @@ declare const PageRoute: {
     EnterpriseBrowser: BrowserRoute.EnterpriseBrowser;
     EnterpriseContextMenu: BrowserRoute.EnterpriseContextMenu;
     EnterpriseBookmarkDialog: BrowserRoute.EnterpriseBookmarkDialog;
+    EnterpriseStorageProxy: BrowserRoute.EnterpriseStorageProxy;
     DropdownMenu: BrowserRoute.DropdownMenu;
     EnterpriseDock: BrowserRoute.EnterpriseDock;
     Home: WorkspaceRoute.Home;

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

@@ -174,5 +174,5 @@ export declare const getWindowBounds: (window: OpenFin.Window) => Promise<OpenFi
  * @param monitor the monitor to check against
  */
 export declare function getPercentageOfBoundsInMonitor(bounds: OpenFin.Bounds, monitor: OpenFin.MonitorDetails): number;
-export declare function getMonitorWindowMaximizedOn(parentWindowBounds: OpenFin.WindowBounds): Promise<OpenFin.MonitorDetails>;
+export declare function getMonitorWindowMaximizedOn(parentWindowBounds: OpenFin.Bounds): Promise<OpenFin.MonitorDetails>;
 export {};