@openfin/workspace-platform 24.0.13 → 24.0.14

package/client-api-platform/src/api/app-directory.d.ts

@@ -7,7 +7,7 @@ import type { LaunchAppRequest, SearchSitesRequest, SearchSitesResponse, Site }
  * @param app the app directory entry.
  * @param opts launch options.
  */
-export declare function launchApp({ app, target }: LaunchAppRequest): Promise<void | OpenFin.Identity | OpenFin.View | OpenFin.Platform | OpenFin.Application>;
+export declare function launchApp({ app, target }: LaunchAppRequest): Promise<void | OpenFin.Identity | OpenFin.Application | OpenFin.View | OpenFin.Platform>;
 export declare const enterpriseAppDirectoryChannelClient: () => Promise<OpenFin.ChannelClient>;
 export declare function getResults(payload: {
     req: SearchSitesRequest;

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/channel-storage-proxy.test.d.ts

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

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/storage-proxies/local-storage-proxy.test.d.ts

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

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
@@ -97,7 +104,6 @@ export declare class ThemeStorageController {
      * @param scheme The default scheme specified in the palette
      */
     setThemeDefaultScheme(scheme: ColorSchemeOptionType): void;
-    setGeneratedPalettes(generatedPalettes: GeneratedPalettes): void;
     /**
      * 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

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

@@ -26,10 +26,15 @@ export declare const getActivePageIdForWindow: (identity: OpenFin.Identity) => P
  *
  * If the name is not unique, it will append a number to the end of the name.
  *
+ * When `BrowserInitConfig.allowDuplicatePageTitles` is `true`, this function
+ * short-circuits and returns the supplied name (or the default title) as-is,
+ * without appending a numeric suffix.
+ *
  * @param initialName The initial name to test
- * @returns string: a unique page name
+ * @param allowDuplicatePageTitles Whether duplicate page titles are permitted
+ * @returns string: a unique page name (or the input unchanged when duplicates are allowed)
  */
-export declare function getUniquePageTitle(initialName?: string): Promise<string>;
+export declare function getUniquePageTitle(initialName?: string, allowDuplicatePageTitles?: boolean): Promise<string>;
 export declare function handleSaveModalOnPageClose({ page }: HandleSaveModalOnPageClosePayload): Promise<SaveModalOnPageCloseResult>;
 /**
  * Default implementation of shouldPageClose. If enableBeforeUnload isn't set to true, always returns True (proceed with close).

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;
@@ -13,5 +13,9 @@ export declare const dispatchThemeToWorkspaceProvider: (themeData: {
 export declare const setSelectedScheme: (schemeType: ColorSchemeOptionType) => Promise<void>;
 export declare const getSelectedScheme: () => ColorSchemeOptionType | null | undefined;
 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/override-callback/browser-defaults.d.ts

@@ -4,4 +4,4 @@ import { BrowserInitConfig } from '../../../../client-api-platform/src/shapes';
 /**
  * Applies default options to the creation of browser windows.
  */
-export declare function applyBrowserDefaults(options: OpenFin.PlatformWindowCreationOptions, initOptions: Pick<BrowserInitConfig, 'defaultWindowOptions' | 'defaultPageOptions' | 'defaultViewOptions' | 'browserIconSize'> | undefined, themeData?: PreloadedThemeData): Promise<OpenFin.PlatformWindowCreationOptions>;
+export declare function applyBrowserDefaults(options: OpenFin.PlatformWindowCreationOptions, initOptions: Pick<BrowserInitConfig, 'defaultWindowOptions' | 'defaultPageOptions' | 'defaultViewOptions' | 'browserIconSize' | 'allowDuplicatePageTitles'> | undefined, themeData?: PreloadedThemeData): Promise<OpenFin.PlatformWindowCreationOptions>;

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

@@ -1,4 +1,4 @@
 import OpenFin from '@openfin/core';
 import type { AttachedPage, AttachedPageInternal } from '../../../../common/src/api/pages/shapes';
 import { BrowserInitConfig } from '../..';
-export declare const applyPageDefaults: (pages: AttachedPage[], initOptions?: Pick<BrowserInitConfig, "defaultPageOptions" | "defaultViewOptions" | "defaultWindowOptions">, overrideOptions?: OpenFin.PlatformWindowCreationOptions) => Promise<AttachedPageInternal[]>;
+export declare const applyPageDefaults: (pages: AttachedPage[], initOptions?: Pick<BrowserInitConfig, "defaultPageOptions" | "defaultViewOptions" | "defaultWindowOptions" | "allowDuplicatePageTitles">, overrideOptions?: OpenFin.PlatformWindowCreationOptions) => Promise<AttachedPageInternal[]>;

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

@@ -4,5 +4,12 @@ export declare function convertPanelViewOpts(panels: PanelConfig[], updatePageRe
     identity: OpenFin.Identity;
     pageId: string;
 }): Promise<ExtendedPanelConfig[]>;
-export declare function createPanelViewsForPages(pages: AttachedPage[]): Promise<void>;
+/**
+ * Creates panel views for all pages in parallel. Returns a promise that callers
+ * may optionally await. In the initial window creation path the return value is
+ * intentionally ignored (fire-and-forget) so panel creation doesn't block
+ * `super.createWindow`. In the `attachPagesToWindow` path the promise is awaited
+ * so views exist before the browser dispatches `attachPanelViews`.
+ */
+export declare function createPanelViewsForPages(pages: AttachedPage[]): Promise<PromiseSettledResult<unknown>[]> | undefined;
 export declare function createPanelViews(panels: PanelConfig[]): Promise<(void | OpenFin.View)[]>;

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>;
 export declare const isThemePreInitialised: () => boolean;
 /**
  * initTheming()

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

@@ -796,6 +796,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.
      */
@@ -2456,6 +2463,15 @@ export interface BrowserInitConfig {
      * https://developer.openfin.co/docs/javascript/stable/classes/OpenFin.InteropBroker.html
      */
     interopOverride?: OpenFin.OverrideCallback<OpenFin.InteropBroker, OpenFin.InteropBroker>;
+    /**
+     * When true, allows multiple pages to share the same title across browser
+     * windows. No numeric suffixes are appended and attach/add operations
+     * will not reject on title collision. `pageId` remains the unique
+     * identifier for all page operations.
+     *
+     * Defaults to `false` (current unique-title behavior preserved).
+     */
+    allowDuplicatePageTitles?: boolean;
 }
 interface WorkspaceMetadata {
     APIVersion: string;

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

@@ -291,7 +291,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: CustomThemes | GeneratedPalettes;
     defaultScheme: ColorSchemeOptionType;

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

@@ -91,12 +91,6 @@ export declare const generateViewNameAndIdentifierNameIfNotExists: <T extends {
  */
 export declare const cloneLayoutAndConvertViewOptions: (layout: PageLayout, initViewOptions?: Partial<OpenFin.ViewOptions>) => Promise<PageLayout>;
 export declare const cloneViewComponentWithoutName: (componentState: any) => any;
-/**
- * Deep clones a layout and removes view names.
- * @param layout The Layout to be cloned
- * @returns A copy of the layout with names removed
- */
-export declare const cloneLayoutAndRemoveNames: (layout: PageLayout) => any;
 /**
  * Deep clones a layout and removes generated view names.
  * @param layout The Layout to be cloned

package/externals.report.json

@@ -46,18 +46,18 @@
         }
     ],
     "dexie": [
-        {
-            "type": "root-implicit",
-            "version": "^4.0.11",
-            "packageName": "dock3/package.json",
-            "issuer": "dock3/src/api/idb.ts"
-        },
         {
             "type": "explicit",
             "version": "^4.0.11",
             "packageName": "client-api-platform/package.json",
             "issuer": "client-api-platform/src/api/dock/idb.ts"
         },
+        {
+            "type": "root-implicit",
+            "version": "^4.0.11",
+            "packageName": "dock3/package.json",
+            "issuer": "dock3/src/api/idb.ts"
+        },
         {
             "type": "explicit",
             "version": "^4.0.11",