@openfin/workspace 23.2.17 → 23.2.19

package/client-api/src/notifications.d.ts

@@ -2,6 +2,11 @@ import * as Notifications from '@openfin/notifications';
 import type { NotificationsPlatform, NotificationsRegisterOptions } from './shapes/notifications';
 export * from '@openfin/notifications';
 export * from './shapes/notifications';
+/**
+ * Notifications Center <= 2.13 expects a legacy NotificationsThemeSet object.
+ * Versions >= 2.14 supports detailed theming.
+ */
+export declare const isLegacyNotifications: (version: string) => boolean;
 /**
  * @deprecated Use `register` with {@link NotificationsRegisterOptions | options?: NotificationsRegisterOptions} argument instead.
  */

package/client-api/src/notifications.test.d.ts

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

package/client-api-platform/src/api/controllers/storage-proxies/channel-storage-proxy.d.ts

@@ -0,0 +1,19 @@
+import { StorageProxy } from '../../../../../client-api-platform/src/api/utils';
+/**
+ * Channel Storage Proxy allows population of storage keys in a different origin, assuming that origin has set up
+ * a storage proxy on the specified URL.
+ *
+ * This is useful for writing to the localStorage of workspace when the provider is on a different origin.
+ */
+export declare class ChannelStorageProxy implements StorageProxy {
+    #private;
+    constructor(url: string);
+    get isDestroyed(): boolean;
+    /**
+     * Sets a key in the proxied storage partition.
+     * @param key Key to set
+     * @param value Value.
+     */
+    setItem(key: string, value: string): Promise<void>;
+    destroy(): Promise<void>;
+}

package/client-api-platform/src/api/controllers/storage-proxies/local-storage-proxy.d.ts

@@ -0,0 +1,12 @@
+import { StorageProxy } from '../../../../../client-api-platform/src/api/utils';
+/**
+ * LocalStorage backed StorageProxy, for use in same origin scenarios (i.e. when the provider and workspace UI are guaranteed
+ * to share a storage partition).
+ */
+export declare class LocalStorageProxy implements StorageProxy {
+    #private;
+    constructor(storage: Pick<Storage, 'setItem'>);
+    setItem(key: string, value: string): Promise<void>;
+    destroy(): Promise<void>;
+    get isDestroyed(): boolean;
+}

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

@@ -17,3 +17,20 @@ export declare const initialiseStoragePalettes: (customThemes: CustomThemes | un
     notificationIndicatorColors: NotificationIndicatorColorsParsed | null;
 };
 export declare const getThemeStorageController: () => ThemeStorageController;
+/**
+ * Resolves when the first theme sync completes. Use this to ensure that we do not launch UI such as browser until this has completed.
+ *
+ * @param allowFailure Whether to suppress rejections and continue anyway. Recommended for most use cases.
+ */
+export declare const waitForFirstThemeSync: (allowFailure?: boolean) => Promise<void>;
+/**
+ * Creates and initialises the Theme Storage Controller singleton.
+ *
+ * Triggers the first theme sync, but does not await it. To ensure dependent UI can guarantee the theme palette is synced,
+ * you can call `await waitForFirstThemeSync` (e.g. in the createWindow provider override).
+ *
+ * @param isEnterprise Whether in enterprise mode (allows using local storage proxy directly).
+ * @param baseUrl Base url of the hosted workspace UI.
+ * @param syncTimeout How long `waitForFirstThemeSync` should wait before rejecting.
+ */
+export declare const initialiseThemeController: (isEnterprise: boolean, baseUrl: string, syncTimeout: number) => void;

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

@@ -1,6 +1,9 @@
-import { GeneratedPalettes } from '../../../../common/src/api/theming';
 import { StorageProxy } from '../../../../client-api-platform/src/api/utils';
 import { ColorSchemeOptionType, CustomPaletteSet } from '../../../../client-api-platform/src/shapes';
+/**
+ * Converts a string => (string | number) dictionary into a set of css vars.
+ */
+export declare const getVars: (vars: Record<string, string | number>) => string;
 /**
  * Palette extensions can be used to add new variables to the palette set.
  *
@@ -23,38 +26,38 @@ export type Palettes = {
     light: string;
     dark: string;
 };
+/**
+ * Generates `--workspace-palette-*` CSS variable strings from a CustomPaletteSet.
+ * Used to produce legacy CSS vars for backwards compatibility with workspace apps
+ * that still consume the legacy theme system.
+ */
+export declare const generateLegacyCSSVars: (palettes: LegacyPalettes, isWindows: boolean) => {
+    light: string;
+    dark: string;
+};
 export declare class ThemeStorageController {
+    #private;
     private providerStorage;
     private darkPaletteVars?;
     private lightPaletteVars?;
     private themePaletteSheet?;
-    private generatedPalettes?;
     private workspaceStorage?;
-    private recreateFactory?;
+    private storageFactory?;
     private isLegacySinglePaletteTheme;
     constructor(providerStorage: Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>);
     /**
-     * Set the current Storage Proxy to enable Workspace Storage properties to be populated.
-     */
-    setWorkspaceStorageProxy: (proxy: StorageProxy) => void;
-    /**
-     * Set a factory to recreate the storage proxy if it was destroyed (e.g. when a new browser
-     * window is opened after the last one closed with preventQuitOnLastWindowClosed true).
-     * Called once at platform init; avoids createWindow needing URL/env dependencies.
+     * Sets the storage factory. This can only be done once, and will throw for subsequent calls.
+     *
+     * All storage writes will be pending until the factory is created.
+     * @param factory
      */
-    setRecreateFactory: (factory: () => Promise<StorageProxy>) => void;
+    setStorageFactory: (factory: () => StorageProxy) => void;
     /**
      * Close the storage proxy window and clear the reference. Called when the last browser window
      * closes so the platform can quit (storage proxy would otherwise keep the process alive).
-     * Clears the reference before awaiting destroy() to avoid a race with ensureWorkspaceStorageProxy.
+     * Clears the reference before awaiting destroy() to avoid a race with getOrCreateStorageProxy.
      */
     destroyWorkspaceStorageProxy: () => Promise<void>;
-    /**
-     * Ensure the workspace storage proxy exists, recreating via the factory set at init if it was
-     * previously destroyed. No-op if no factory was set (e.g. in tests). Call before using
-     * workspace storage (e.g. when creating a browser window).
-     */
-    ensureWorkspaceStorageProxy: () => Promise<void>;
     /**
      * Check if there's an explicit user preference stored in localStorage.
      * A user preference is indicated by the presence of a SelectedColorScheme key. Which is something assigned if you click on the Appearance dropdown.
@@ -63,11 +66,15 @@ export declare class ThemeStorageController {
     private hasUserPreference;
     /**
      * Synchronize the current palette and scheme with workspace's storage instance if
-     * storage based theming is enabled. Only syncs when user has explicitly selected a scheme.
+     * storage based theming is enabled.
      *
-     * Wrapped in try/catch so it does not throw
+     * Workspace storage is consumed by workspace apps still on the legacy theme system
+     * whose theme-loader does NOT set `data-scheme` on the document. To maintain
+     * backwards compatibility the sheet written here uses the legacy format: for an
+     * explicit light/dark scheme only that scheme's vars are placed inside `:root{}`,
+     * while "system" uses `@media (prefers-color-scheme)` queries with `:root`.
      */
-    trySynchronizeWorkspaceStorage: () => Promise<void>;
+    synchronizeWorkspaceStorage: () => 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
@@ -99,12 +106,17 @@ export declare class ThemeStorageController {
      * @param scheme The default scheme specified in the palette
      */
     setThemeDefaultScheme(scheme: ColorSchemeOptionType): void;
-    setGeneratedPalettes(generatedPalettes: GeneratedPalettes): void;
     /**
      * Returns the current scheme
      * @returns 'light' | 'system' | 'dark'
      */
     getScheme(): ColorSchemeOptionType;
+    /**
+     * Write the theme palette sheet to both in-memory state and providerStorage (namespaced localStorage)
+     * immediately. This ensures the theme is available for themeLoader on same-origin pages
+     * before the workspace storage proxy is ready.
+     */
+    setThemePaletteSheet(sheet: string): void;
     getThemePaletteSheet(): string | undefined;
     getThemePalette(): {
         light: string;

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

@@ -1,6 +1,6 @@
 import type OpenFin from '@openfin/core';
-import type { BaseThemeOptions, CustomTheme, GenerateThemeParams } from '../../../common/src/api/theming';
-import { ColorSchemeOptionType, ThemeApi } from '../../../client-api-platform/src/shapes';
+import type { GeneratedPalettes, NotificationIndicatorColorsParsed } from '../../../common/src/api/theming';
+import { ColorSchemeOptionType, LegacyNotificationsThemeSet, ThemeApi } from '../../../client-api-platform/src/shapes';
 export declare const getThemingApi: (identity: OpenFin.ApplicationIdentity) => ThemeApi;
 export declare const dispatchThemeToWorkspaceProvider: (themeData: {
     themePaletteSheet: string;
@@ -15,5 +15,9 @@ export declare const getSelectedScheme: () => ColorSchemeOptionType | null | und
 /** @internal */
 export declare const getIsLegacySinglePaletteTheme: () => boolean;
 export declare const getThemePaletteSheet: () => string | undefined;
-export declare const mapLegacyThemeToCustomTheme: (legacyTheme: CustomTheme) => GenerateThemeParams;
-export declare const mapLegacyBrandIcons: (legacyBrand: BaseThemeOptions["brand"]) => GenerateThemeParams[1];
+export { assignIfDefined, mapGeneratedPalettesToLegacyPalettes, mapLegacyBrandIcons, mapLegacyThemeToCustomTheme } from '../../../common/src/api/theme-migration';
+/**
+ * Builds a legacy NotificationsThemeSet from generated palettes and indicator colors.
+ * Used by the provider-side handler to serve old Notification Center versions (<=2.13).
+ */
+export declare const buildLegacyNotificationsTheme: (generatedPalettes: GeneratedPalettes, notificationIndicatorColors: NotificationIndicatorColorsParsed | null) => Promise<LegacyNotificationsThemeSet | null>;

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

@@ -2,11 +2,6 @@ export declare const listenForStoreClose: () => void;
 export type StorageProxy = {
     setItem: (data: string, value: string) => Promise<void>;
     destroy: () => Promise<void>;
+    isDestroyed: boolean;
 };
-export declare const createStorageProxy: (url: string, isEnterprise: boolean) => Promise<StorageProxy>;
-/**
- * Ensure the workspace storage proxy window exists. Recreates it if it was previously destroyed
- * (e.g. when the last browser window closed with preventQuitOnLastWindowClosed true and a new
- * browser window is now being created). Uses the factory registered at init; no-op in tests.
- */
-export declare const ensureWorkspaceStorageProxy: () => Promise<void>;
+export declare const getStorageFactory: (isEnterprise: boolean, baseUrl: string) => (() => StorageProxy);

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

@@ -1,5 +1,6 @@
 import OpenFin from '@openfin/core';
 import { WorkspacePlatformInitConfig } from '../../../client-api-platform/src/shapes';
+export declare const MAX_FIRST_THEME_SYNC_WAIT = 3000;
 /**
  * Initilaize a Workspace Platform.
  *

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

@@ -1,9 +1,10 @@
 import { GeneratedPalettes, NotificationIndicatorColorsParsed } from '../../../common/src/api/theming';
-import { CustomThemes } from '../shapes';
+import { CustomThemes, LegacyNotificationsThemeSet } from '../shapes';
 export declare const getThemes: () => CustomThemes | null;
 export declare const getGeneratedPalettes: () => GeneratedPalettes;
 export declare const getThemePaletteSheet: () => string;
 export declare const getNotificationIndicatorColorsInternal: () => NotificationIndicatorColorsParsed;
+export declare const getLegacyNotificationsThemeInternal: () => Promise<LegacyNotificationsThemeSet | null>;
 /**
  * initTheming()
  * @param customThemes array of theme objects

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

@@ -809,6 +809,13 @@ export interface BrowserWorkspacePlatformWindowOptions {
      * When true, disables the ability to close pages in the window. False by default.
      */
     preventPageClose?: boolean;
+    /**
+     * When true, disables the find in page feature for the window.
+     * The find in page view will not be created and no find in page logic will run.
+     * This option must be set at window creation time and cannot be changed dynamically.
+     * False by default.
+     */
+    disableFindInPage?: boolean;
     /**
      * Taskbar Icon for the Browser Window. If light and dark icon are defined, then the taskbar icon will change when the scheme changes.
      */
@@ -1818,6 +1825,33 @@ export interface ThemeApi {
      * @returns the notification indicator colors.
      */
     getNotificationIndicatorColorsInternal(): Promise<NotificationIndicatorColorsParsed | null>;
+    /**
+     * @internal
+     * Build a legacy NotificationsThemeSet from the current generated palettes.
+     * Used for backwards compatibility with older Notification Center versions
+     * that do not support detailed theming.
+     */
+    getLegacyNotificationsThemeInternal(): Promise<LegacyNotificationsThemeSet | null>;
+}
+/**
+ * @internal
+ * Legacy theme format expected by Notification Center <= 2.13.
+ * Each scheme contains a styled-components DefaultTheme-compatible object
+ * with optional embedded notification indicator colors.
+ */
+export interface LegacyNotificationsThemeSet {
+    light: Record<string, unknown> & {
+        notificationIndicatorColors?: Record<string, {
+            background: string;
+            foreground: string;
+        }>;
+    };
+    dark: Record<string, unknown> & {
+        notificationIndicatorColors?: Record<string, {
+            background: string;
+            foreground: string;
+        }>;
+    };
 }
 /**
  * Controller for a Workspace Platform.
@@ -2823,7 +2857,6 @@ export type WorkspacePlatformOverrideCallback = OpenFin.OverrideCallback<Workspa
 export type BrowserOverrideCallback = WorkspacePlatformOverrideCallback;
 /**
  * Content menu entry shape cloned and re-exported from UI Library.
- * @internal
  */
 export type ContentMenuEntry = {
     bookmarked?: boolean;
@@ -2851,7 +2884,6 @@ export type BookmarkDockEntryPayload = {
 };
 /**
  * Represents dock entry for favorites
- * @internal
  */
 export type DockEntry = {
     type: 'folder';

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

@@ -98,7 +98,9 @@ export declare enum WorkspacePlatformChannelAction {
     ShowUpdateVersionModalInternal = "showUpdateVersionModalInternal",// Enterprise
     GetNotificationIndicatorColorsInternal = "getNotificationIndicatorColorsInternal",// Custom Notification Indicators Colors
     /** @internal */
-    GetIsLegacySinglePaletteTheme = "getIsLegacySinglePaletteTheme"
+    GetIsLegacySinglePaletteTheme = "getIsLegacySinglePaletteTheme",
+    /** @internal */
+    GetLegacyNotificationsThemeInternal = "getLegacyNotificationsThemeInternal"
 }
 export type PlatFormSupportedFeatures = boolean | {
     isWorkspacePlatform: boolean;

package/common/src/api/theme-migration.d.ts

@@ -0,0 +1,46 @@
+import type { BaseThemeOptions, CustomPaletteSet, CustomTheme, CustomThemes, GeneratedPalettes, GenerateThemeParams } from './theming';
+export declare const assignIfDefined: (target: Record<string, unknown>, key: string, value: unknown) => void;
+/**
+ * Maps a legacy palette-based theme to theme-engine seed + overrides.
+ *
+ * Legacy themes use `palette` (single scheme) or `palettes` (light/dark) with
+ * explicit color values. This function translates those values into the dotted
+ * token paths that `generateTheme` expects.
+ *
+ * Mapping reference: https://www.figma.com/design/bUbUpAHJl8xGEtFbpYZ5z3/Theme?node-id=0-1&p=f&m=dev
+ */
+export declare const mapLegacyThemeToCustomTheme: (legacyTheme: CustomTheme) => GenerateThemeParams;
+/**
+ * Reverse of mapLegacyThemeToCustomTheme.
+ * Takes the resolved token maps from a generated theme and maps them back to the
+ * legacy CustomPaletteSet shape so that workspace apps still on the legacy theme
+ * system can consume them.
+ */
+export declare const mapGeneratedPalettesToLegacyPalettes: (generatedPalettes: GeneratedPalettes) => {
+    light: CustomPaletteSet;
+    dark: CustomPaletteSet;
+};
+export declare const mapLegacyBrandIcons: (legacyBrand: BaseThemeOptions["brand"]) => GenerateThemeParams[1];
+/**
+ * Converts legacy CustomThemes (from old workspace platforms v23.0.22 and earlier)
+ * into GeneratedPalettes with toCSS() methods and a ready-to-inject palette sheet.
+ *
+ * This is the backward-compatibility bridge: when a new workspace app (home, dock,
+ * storefront) discovers it's running against a legacy platform — detected by
+ * `getGeneratedPalettes()` throwing because the channel action doesn't exist —
+ * it calls `getThemes()` to retrieve the old-format themes and runs them through
+ * this function to produce the same output the new pipeline expects.
+ *
+ * The conversion mirrors `initialiseStoragePalettes` in client-api-platform but
+ * omits storage controller side-effects (setPalettes, setThemePaletteSheet) since
+ * those belong to the platform init path, not the workspace app consumption path.
+ *
+ * Theme shape discrimination:
+ * - `palette`: single palette applied to both schemes (legacy single-scheme theme)
+ * - `palettes`: explicit light/dark palettes (legacy dual-scheme theme)
+ * - `seed`: already a token-based theme (should not reach this path, but handled for safety)
+ */
+export declare const convertLegacyThemesToGeneratedPalettes: (themes: CustomThemes | null | undefined) => {
+    generatedPalettes: GeneratedPalettes;
+    themePaletteSheet: string;
+};

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

@@ -315,7 +315,21 @@ export declare const OpenFinDarkTheme: {
 };
 export declare const DefaultOpenFinTheme: CustomThemes;
 export declare const parseNotificationIndicatorColors: (customTheme: CustomTheme) => NotificationIndicatorColorsParsed;
-export declare const constructThemePaletteSheet: (themes: GeneratedPalettes) => string;
+/**
+ * Builds a CSS stylesheet that exposes theme tokens as custom properties.
+ *
+ * The sheet is written to provider storage and consumed by same-origin pages
+ * via an adopted stylesheet. It uses `data-scheme` selectors for dark/system
+ * switching, which the new theme-loader sets on the document element.
+ *
+ * @param legacyVars Optional `--workspace-palette-*` CSS variable strings to
+ *   merge alongside the new `--color-role-*` variables. When provided, apps on
+ *   the legacy theme system that read these variables will receive correct values.
+ */
+export declare const constructThemePaletteSheet: (themes: GeneratedPalettes, legacyVars?: {
+    light: string;
+    dark: string;
+}) => string;
 export declare const getComputedPlatformTheme: (platformIdentity: OpenFin.Identity) => Promise<{
     theme: GeneratedPalettes | CustomThemes;
     defaultScheme: ColorSchemeOptionType;

package/externals.report.json

@@ -2,7 +2,7 @@
     "@openfin/notifications": [
         {
             "type": "explicit",
-            "version": "2.14.1",
+            "version": "2.14.2",
             "packageName": "client-api/package.json",
             "issuer": "client-api/src/notifications.ts"
         }
@@ -43,37 +43,31 @@
             "issuer": "common/src/utils/layout.ts"
         }
     ],
-    "react-i18next": [
+    "lodash.clonedeep": [
         {
             "type": "root-implicit",
-            "version": "15.4.0",
+            "version": "4.5.0",
             "packageName": "common/package.json",
-            "issuer": "common/src/api/i18next.ts"
+            "issuer": "common/src/utils/layout.ts"
         }
     ],
-    "i18next": [
+    "react-i18next": [
         {
             "type": "root-implicit",
-            "version": "^23.7.16",
+            "version": "15.4.0",
             "packageName": "common/package.json",
             "issuer": "common/src/api/i18next.ts"
         }
     ],
-    "lodash.clonedeep": [
+    "i18next": [
         {
             "type": "root-implicit",
-            "version": "4.5.0",
+            "version": "^23.7.16",
             "packageName": "common/package.json",
-            "issuer": "common/src/utils/layout.ts"
+            "issuer": "common/src/api/i18next.ts"
         }
     ],
     "dexie": [
-        {
-            "type": "root-implicit",
-            "version": "^4.0.11",
-            "packageName": "common/package.json",
-            "issuer": "common/src/api/pages/idb.ts"
-        },
         {
             "type": "root-implicit",
             "version": "^4.0.11",
@@ -86,6 +80,12 @@
             "packageName": "client-api-platform/package.json",
             "issuer": "client-api-platform/src/api/dock/idb.ts"
         },
+        {
+            "type": "root-implicit",
+            "version": "^4.0.11",
+            "packageName": "common/package.json",
+            "issuer": "common/src/api/pages/idb.ts"
+        },
         {
             "type": "root-implicit",
             "version": "^4.0.11",