@openfin/workspace-platform 45.2.1 → 45.2.3

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

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

package/client-api-platform/src/api/controllers/__tests__/workspace-storage-proxy-store.test.d.ts

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

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

@@ -0,0 +1,2 @@
+import { LanguageStorageController } from '../../../../client-api-platform/src/api/controllers/language-storage-controller';
+export declare const getLanguageStorageController: () => LanguageStorageController;

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

@@ -0,0 +1,25 @@
+import { WorkspaceStorageProxyStore } from '../../../../client-api-platform/src/api/controllers/workspace-storage-proxy-store';
+import { Locale } from '../../../../client-api-platform/src/shapes';
+/**
+ * Stores the configured and user-selected languages on the platform origin and
+ * mirrors the effective preference into the Workspace UI origin.
+ *
+ * Twin of `ThemeStorageController`: `SelectedLanguage` is the user's explicit choice
+ * (Language menu), `DefaultLanguage` is the platform's init-time configuration, and
+ * resolution is `Selected ?? Default ?? en-US`.
+ */
+export declare class LanguageStorageController {
+    private providerStorage;
+    private workspaceStorageProxyStore;
+    constructor(providerStorage: Pick<Storage, 'getItem' | 'setItem'>, workspaceStorageProxyStore?: WorkspaceStorageProxyStore);
+    setSelectedLanguage(locale: Locale): void;
+    setDefaultLanguage(locale: Locale): void;
+    getSelectedLanguage(): Locale | undefined;
+    getDefaultLanguage(): Locale;
+    getLanguage(): Locale;
+    /**
+     * Mirrors the language preference into Workspace UI storage so every UI document on
+     * that origin can read it before first paint and react to `storage` events.
+     */
+    synchronizeWorkspaceStorage: () => Promise<void>;
+}

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

@@ -1,3 +1,4 @@
+import { WorkspaceStorageProxyStore } from '../../../../client-api-platform/src/api/controllers/workspace-storage-proxy-store';
 import { StorageProxy } from '../../../../client-api-platform/src/api/utils';
 import { ColorSchemeOptionType, CustomPaletteSet } from '../../../../client-api-platform/src/shapes';
 /**
@@ -36,15 +37,13 @@ export declare const generateLegacyCSSVars: (palettes: LegacyPalettes, isWindows
     dark: string;
 };
 export declare class ThemeStorageController {
-    #private;
     private providerStorage;
+    private workspaceStorageProxyStore;
     private darkPaletteVars?;
     private lightPaletteVars?;
     private themePaletteSheet?;
-    private workspaceStorage?;
-    private storageFactory?;
     private isLegacySinglePaletteTheme;
-    constructor(providerStorage: Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>);
+    constructor(providerStorage: Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>, workspaceStorageProxyStore?: WorkspaceStorageProxyStore);
     /**
      * Sets the storage factory. This can only be done once, and will throw for subsequent calls.
      *

package/client-api-platform/src/api/controllers/workspace-storage-proxy-store.d.ts

@@ -0,0 +1,13 @@
+import { StorageProxy } from '../../../../client-api-platform/src/api/utils';
+/**
+ * Owns the storage proxy shared by platform features that need to synchronize
+ * state into the Workspace UI origin.
+ */
+export declare class WorkspaceStorageProxyStore {
+    private storageProxy?;
+    private storageFactory?;
+    setStorageFactory: (factory: () => StorageProxy) => void;
+    getOrCreateStorageProxy: () => Promise<StorageProxy>;
+    destroyStorageProxy: () => Promise<void>;
+}
+export declare const workspaceStorageProxyStore: WorkspaceStorageProxyStore;

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

@@ -1,3 +1,86 @@
+export declare const viewTabColors: {
+    backgroundColor: {
+        default: string;
+        hover: string;
+        active: string;
+        focus: string;
+    };
+    fontColor: {
+        default: string;
+        active: string;
+    };
+};
+/** `viewTab` stays on `workspacePlatform`; only its siblings move into `_internalWorkspaceData`. */
+export declare const mockSnapshotWithViewTab: {
+    windows: {
+        layout: {
+            content: {
+                type: string;
+                content: {
+                    type: string;
+                    componentName: string;
+                    componentState: {
+                        _internalWorkspaceData: {
+                            viewIdentifier: string;
+                        };
+                        workspacePlatform: {
+                            browserNavigationButtons: {
+                                reload: boolean;
+                            };
+                            viewTab: {
+                                backgroundColor: {
+                                    default: string;
+                                    hover: string;
+                                    active: string;
+                                    focus: string;
+                                };
+                                fontColor: {
+                                    default: string;
+                                    active: string;
+                                };
+                            };
+                        };
+                    };
+                }[];
+            }[];
+        };
+    }[];
+};
+export declare const mockSnapshotWithViewTabMapped: {
+    windows: {
+        layout: {
+            content: {
+                type: string;
+                content: {
+                    type: string;
+                    componentName: string;
+                    componentState: {
+                        _internalWorkspaceData: {
+                            viewIdentifier: string;
+                            browserNavigationButtons: {
+                                reload: boolean;
+                            };
+                        };
+                        workspacePlatform: {
+                            viewTab: {
+                                backgroundColor: {
+                                    default: string;
+                                    hover: string;
+                                    active: string;
+                                    focus: string;
+                                };
+                                fontColor: {
+                                    default: string;
+                                    active: string;
+                                };
+                            };
+                        };
+                    };
+                }[];
+            }[];
+        };
+    }[];
+};
 export declare const mockSnapshotWithInternalData1: {
     windows: {
         layout: {

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

@@ -1,10 +1,21 @@
 import type OpenFin from '@openfin/core';
 import { BrowserCreateViewRequest, BrowserViewState, BrowserWorkspacePlatformViewOptions } from '../../../../client-api-platform/src/shapes';
+/**
+ * Strips unusable `viewTab` colors instead of rejecting the request. A tab color is decoration, and this runs
+ * inside `createView`, so throwing here would abort view creation and leave the surrounding window
+ * half-built over a cosmetic typo. Discarded states fall back to their theme default in the stylesheet.
+ */
+export declare const sanitizeViewWorkspacePlatform: (opts: BrowserCreateViewRequest) => BrowserCreateViewRequest;
 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;
+/**
+ * Moves legacy workspace platform view options into `_internalWorkspaceData`, which Core round-trips through layout
+ * componentState. `viewTab` and newer options are exempt — Core now persists `workspacePlatform` on view options directly,
+ * so they stay put and the runtime becomes the single source of truth.
+ */
 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;

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

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

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

@@ -5,6 +5,7 @@ import type { AnalyticsEvent } from '../../common/src/utils/usage-register';
 import type { CustomActionSpecifier, CustomButtonConfig } from '../../common/src/api/action';
 import type { AddDefaultPagePayload, AttachedPage, BookmarkNode, CopyPagePayload, HandlePagesAndWindowClosePayload, HandlePagesAndWindowCloseResult, HandleSaveModalOnPageClosePayload, Page, PageLayoutsWithSelectedViews, PageWithUpdatableRuntimeAttribs, SaveModalOnPageCloseResult, SetActivePageForWindowPayload, ShouldPageClosePayload, ShouldPageCloseResult, ViewsPreventingUnloadPayload } from '../../common/src/api/pages/shapes';
 import type { NotificationsCustomManifestOptions } from '../../common/src/api/shapes/notifications';
+import type { ViewTabAppearanceOptions } from '../../common/src/api/shapes/view-tab';
 import type { CustomThemes, GeneratedPalettes } from '../../common/src/api/theming';
 import type { App, DockProviderConfigWithIdentity, StoreButtonConfig } from '../../client-api/src/shapes';
 import type { WorkflowIntegration } from '../../client-api/src/shapes/integrations';
@@ -15,6 +16,7 @@ export type { App, AppIntent, Image } from '../../client-api/src/shapes';
 export type { CustomActionSpecifier, CustomButtonConfig } from '../../common/src/api/action';
 export type { AttachedPage, Page, PagePinnedState, PageLayout, PageLayoutDetails, PageWithUpdatableRuntimeAttribs, PanelConfigHorizontal, PanelConfigVertical, PanelConfig, ExtendedPanelConfig, CopyPagePayload, HandleSaveModalOnPageClosePayload, SaveModalOnPageCloseResult, SetActivePageForWindowPayload, ShouldPageClosePayload, ShouldPageCloseResult, ViewsPreventingUnloadPayload } from '../../common/src/api/pages/shapes';
 export { PanelPosition } from '../../common/src/api/pages/shapes';
+export type { ThemedIcon, ViewTabAppearanceOptions, ViewTabColorRole, ViewTabControl, ViewTabControlPosition, ViewTabStateColorOptions } from '../../common/src/api/shapes/view-tab';
 export type { CustomThemes, CustomThemeOptions, ThemeOptions, CustomThemeOptionsWithScheme, CustomPaletteSet, BaseThemeOptions, ThemeExtension, WorkspaceThemeSet, NotificationIndicatorColorsSet, NotificationIndicatorColorsSetDarkScheme, NotificationIndicatorColorsSetLightScheme, NotificationIndicatorColorsWithScheme } from '../../common/src/api/theming';
 export type { AnalyticsEvent } from '../../common/src/utils/usage-register';
 export type { WorkflowIntegration } from '../../client-api/src/shapes/integrations';
@@ -232,7 +234,7 @@ export type ViewTabContextMenuTemplate = OpenFin.MenuItemTemplate<ViewTabMenuDat
 /**
  * UI elements within a view tab that can be navigated to via keyboard.
  */
-export type ViewTabElements = 'inactive-tab' | 'active-tab' | 'inactive-tab-close-button' | 'active-tab-close-button' | 'add-tab-button';
+export type ViewTabElements = 'inactive-tab' | 'active-tab' | 'inactive-tab-close-button' | 'active-tab-close-button' | 'inactive-tab-custom-control' | 'active-tab-custom-control' | 'add-tab-button';
 /**
  * Configuration options for view tab keyboard navigation behavior.
  */
@@ -242,7 +244,7 @@ export interface ViewTabOptions {
      * arrow keys when an element in the view is selected.
      * The order of the items in the array have no impact.
      * Note: these are not mutually exclusive and can overlap.
-     * Default (when undefined): ["inactive-tab","active-tab","active-tab-close-button","inactive-tab-close-button","add-tab-button"]
+     * Default (when undefined): ["inactive-tab","active-tab","active-tab-close-button","inactive-tab-close-button","active-tab-custom-control","inactive-tab-custom-control","add-tab-button"]
      */
     arrowNavigation?: ViewTabElements[];
     /**
@@ -369,6 +371,19 @@ export interface ViewTabCustomActionPayload {
     windowIdentity: OpenFin.Identity;
     selectedViews: OpenFin.Identity[];
 }
+export interface ViewTabControlActionPayload {
+    callerType: CustomActionCallerType.ViewTabControl;
+    /** Identity of the Browser window containing the view tab. */
+    windowIdentity: OpenFin.Identity;
+    /** Identity of the view represented by the tab. */
+    viewIdentity: OpenFin.Identity;
+    /** Any data necessary for the functioning of the specified custom action. */
+    customData?: any;
+    /** Client x-coordinate where the control was invoked. */
+    x: number;
+    /** Client y-coordinate where the control was invoked. */
+    y: number;
+}
 /**
  * Payload received by the openViewTabContextMenu provider override.
  */
@@ -608,12 +623,16 @@ export declare enum WindowType {
     Browser = "browser",
     Platform = "platform"
 }
+/** How view tab widths are calculated. `'uniform'` is today's equal-width behavior. */
+export type ViewTabWidthMode = 'uniform' | 'content';
 export interface BrowserWorkspacePlatformViewOptions {
     browserNavigationButtons?: RequireAtLeastOne<{
         back?: boolean;
         forward?: boolean;
         reload?: boolean;
     }>;
+    /** Per-view tab appearance options. */
+    viewTab?: ViewTabAppearanceOptions;
 }
 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>>>;
@@ -690,16 +709,36 @@ export interface BrowserWorkspacePlatformWindowOptions {
         minWidth?: string;
         maxWidth?: string;
     };
-    /** Specifies the min and max sizes for view tabs in a layout.
+    /**
+     * Specifies the min and max sizes for view tabs in a layout, and how those widths are calculated.
      * View tabs will expand to take all available space up to the specified maximum size.
      * Similarly, they will collapse down to the specified minimum size.
      * When there is not enough room to fit the tabs, the tabstrip will become scrollable.
      * Sizes can be specified as pixels (e.g. "100px") or as percentage of tab strip width (e.g. "20%").
-     * The default value for both min and max is "120px". To maintain usability, minimum values below 28px will be ignored and 28px will be used as the minimum.
+     * Defaults depend on the width mode: `'uniform'` uses "120px" for both bounds, while `'content'` sizes a
+     * tab to its own chrome and so applies no minimum and a "200px" maximum.
+     * To maintain usability, minimum values below 28px will be ignored and 28px will be used as the minimum.
+     *
+     * @example
+     * ```ts
+     * workspacePlatform: {
+     *   viewTabDimensions: {
+     *     widthMode: 'content',
+     *     minWidth: '50px',
+     *     maxWidth: '200px'
+     *   }
+     * }
+     * ```
      */
     viewTabDimensions?: {
         minWidth?: string;
         maxWidth?: string;
+        /**
+         * Controls how view tab widths are calculated.
+         * - `'uniform'` (default): current equal-width tab behavior.
+         * - `'content'`: tab width is driven by tab chrome (label, favicon, spinner, controls) within min/max bounds.
+         */
+        widthMode?: ViewTabWidthMode;
     };
     /**
      * Controls whether tab-search chevron buttons are shown for page tabs and view tabs.
@@ -1989,6 +2028,7 @@ export declare enum CustomActionCallerType {
     StoreCustomButton = "StoreCustomButton",
     CustomDropdownItem = "CustomDropdownItem",
     GlobalContextMenu = "GlobalContextMenu",
+    ViewTabControl = "ViewTabControl",
     ViewTabContextMenu = "ViewTabContextMenu",
     PageTabContextMenu = "PageTabContextMenu",
     SaveButtonContextMenu = "SaveButtonContextMenu",
@@ -1999,7 +2039,7 @@ export declare enum CustomActionCallerType {
  * When `callerType == CustomActionCallerType.API`, the payload is defined by the code directly invoking the action.*/
 export type CustomActionPayload = {
     callerType: CustomActionCallerType.API;
-} | CustomButtonActionPayload | StoreCustomButtonActionPayload | CustomDropdownItemActionPayload | GlobalContextMenuOptionActionPayload | ViewTabCustomActionPayload | PageTabContextMenuOptionActionPayload | OpenSaveContextMenuOptionActionPayload;
+} | CustomButtonActionPayload | StoreCustomButtonActionPayload | CustomDropdownItemActionPayload | GlobalContextMenuOptionActionPayload | ViewTabControlActionPayload | ViewTabCustomActionPayload | PageTabContextMenuOptionActionPayload | OpenSaveContextMenuOptionActionPayload;
 export interface GetCurrentWorkspaceOptions {
     skipSnapshotUpdate?: boolean;
 }

package/common/src/api/shapes/view-tab.d.ts

@@ -0,0 +1,86 @@
+import type { CustomButtonConfig } from '../../../../common/src/api/action';
+/**
+ * A CSS color value per view tab state. Any omitted state keeps its theme default, so a partial
+ * object overrides only the states it names.
+ *
+ * An empty string means inherit — that state is unset and falls back to its theme default. This is the only
+ * way to remove a color from a view that already has one: `updateOptions` merges, so omitting a state leaves
+ * its current color in place, and an empty `viewTab` object is treated as no change at all.
+ */
+export interface ViewTabStateColorOptions {
+    /** Color when the tab is inactive. */
+    default?: string;
+    /** Color when the tab is hovered (and not active). */
+    hover?: string;
+    /** Color when the tab is active. */
+    active?: string;
+    /** Color when the tab is active and its view is focused. */
+    focus?: string;
+}
+export type ViewTabControlPosition = {
+    /** Tab element used as the placement anchor. */
+    relativeTo: 'title' | 'favicon';
+    /** Side of the anchor on which the control is placed. */
+    placement: 'before' | 'after';
+};
+export type ThemedIcon = {
+    dark: string;
+    light: string;
+};
+export interface ViewTabControl extends Omit<CustomButtonConfig, 'iconUrl' | 'parentHover'> {
+    /** Icon URL, or URLs selected according to the current color scheme. */
+    iconUrl?: string | ThemedIcon;
+    /** Defaults to before the tab title. */
+    position?: ViewTabControlPosition;
+}
+export type ViewTabColorRole = 'backgroundColor' | 'fontColor';
+/**
+ * Per-view view-tab appearance settings, nested under `workspacePlatform.viewTab` on view options.
+ *
+ * @example
+ * ```ts
+ * import * as WorkspacePlatform from '@openfin/workspace-platform';
+ *
+ * const platform = WorkspacePlatform.getCurrentSync();
+ * await platform.Browser.createView({
+ *   url: 'https://example.com',
+ *   workspacePlatform: {
+ *     viewTab: {
+ *       backgroundColor: { default: '#1e3a5f', active: '#356aa3' },
+ *       fontColor: { default: '#c9d8ea', active: '#ffffff' }
+ *     }
+ *   }
+ * });
+ * ```
+ *
+ * @example
+ * Returning a view to its theme defaults, naming every state that should be unset:
+ * ```ts
+ * await view.updateOptions({
+ *   workspacePlatform: {
+ *     viewTab: {
+ *       backgroundColor: { default: '', hover: '', active: '', focus: '' },
+ *       fontColor: { default: '', hover: '', active: '', focus: '' }
+ *     }
+ *   }
+ * });
+ * ```
+ */
+export interface ViewTabAppearanceOptions {
+    /** Tab background color per state. */
+    backgroundColor?: ViewTabStateColorOptions;
+    /** Tab title text color per state. Does not affect the close or lock icons. */
+    fontColor?: ViewTabStateColorOptions;
+    /**
+     * Snapshot-safe controls rendered in this view's tab.
+     *
+     * Rendering requires the GoldenLayout 2 engine with scrolling tab overflow, which is how the
+     * Core UI Browser creates its layouts (`experimental.layoutEngine: 'v2'`, the Browser default).
+     * Windows that opt back in to the v1 engine render their tabs without custom controls, and this
+     * option is ignored rather than rejected.
+     *
+     * Controls render at a fixed size, so the right-most ones are clipped on tabs that are too
+     * narrow to fit them.
+     */
+    controls?: ViewTabControl[];
+}

package/common/src/test/logger-mock.d.ts

@@ -1,5 +1,15 @@
 export declare const mockLogger: {
     debug: jest.Mock<any, any, any>;
+    info: jest.Mock<any, any, any>;
     warn: jest.Mock<any, any, any>;
     error: jest.Mock<any, any, any>;
 };
+export declare const mockPerformanceLogger: {
+    debug: jest.Mock<any, any, any>;
+    info: jest.Mock<any, any, any>;
+    warn: jest.Mock<any, any, any>;
+    error: jest.Mock<any, any, any>;
+    startTimer: jest.Mock<any, any, any>;
+    endTimer: jest.Mock<any, any, any>;
+    clearTimer: jest.Mock<any, any, any>;
+};

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

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

package/common/src/utils/view-options.d.ts

@@ -0,0 +1,20 @@
+import type OpenFin from '@openfin/core';
+export type ViewOptionsConsumer = 'appearance' | 'controls' | 'shared';
+/**
+ * Reads view options for the custom view-tab feature, optionally instrumented in debug builds.
+ *
+ * Collection is active only when the build-time `LOG_DEBUG` constant is true — set via
+ * `OF__WORKSPACE_LOG_DEBUG=true` at build time (including PR preview builds where that env is enabled).
+ * Tests may also enable collection with `globalThis.LOG_DEBUG = true` when the build constant is undefined.
+ * Production builds call `view.getOptions()` directly with no marks or logs.
+ *
+ * Baseline comparison before de-duplication should primarily use IPC / measure count: expect two `getOptions`
+ * calls and two Performance Timeline entries per view (appearance + controls). The de-duplicated path emits one
+ * entry with the `shared` consumer. Per-call baseline durations are secondary because two reads can overlap.
+ *
+ * Inspect entries in DevTools by filtering measures named `of-workspace-view-tab-get-options-*`. The Performance
+ * Timeline duration is authoritative; structured logs are the human-readable companion.
+ *
+ * Each debug invocation calls `view.getOptions()` exactly once — no caching or de-duplication on this branch.
+ */
+export declare const getViewOptions: (view: OpenFin.View, consumer: ViewOptionsConsumer) => Promise<OpenFin.ViewOptions>;

package/common/src/utils/view-tab-appearance.d.ts

@@ -0,0 +1,51 @@
+import type OpenFin from '@openfin/core';
+import type { ViewTabAppearanceOptions, ViewTabColorRole } from '../../../common/src/api/shapes/view-tab';
+export declare const VIEW_TAB_STATES: readonly ["default", "hover", "active", "focus"];
+export type ViewTabState = (typeof VIEW_TAB_STATES)[number];
+/** A color that was discarded during sanitization, for the caller to log. */
+export interface RejectedViewTabColor {
+    role: ViewTabColorRole;
+    /** Absent when the whole role was malformed rather than one of its states. */
+    state?: ViewTabState;
+    value: unknown;
+}
+/**
+ * Drops every state whose value is not a supported CSS color, returning what survived alongside what was
+ * discarded. Tab color is decoration, so a malformed value degrades that state to its theme default instead
+ * of failing the operation that carried it.
+ *
+ * Only the two color roles are validated. Every other `viewTab` option — `controls`, and whatever follows it
+ * — is carried through untouched, so a bad color cannot take an unrelated tab option down with it. Appearance
+ * is omitted only when nothing at all is left, which keeps a wholly-invalid object out of persistence.
+ */
+export declare const sanitizeViewTabAppearance: (viewTab: unknown) => {
+    appearance?: ViewTabAppearanceOptions;
+    rejected: RejectedViewTabColor[];
+};
+/** Formats a rejected color for a log line, e.g. `viewTab.fontColor.default "##EDE8D0"`. */
+export declare const describeRejectedViewTabColor: ({ role, state, value }: RejectedViewTabColor) => string;
+type ViewOptionsWithWorkspacePlatform = {
+    workspacePlatform?: {
+        viewTab?: ViewTabAppearanceOptions;
+    };
+};
+/**
+ * True when this `view-options-changed` diff touched `workspacePlatform.viewTab`, so that unrelated view
+ * option changes do not repaint tabs.
+ *
+ * `oldVal` is checked as well as `newVal` because clearing `viewTab` drops it from `newVal` entirely —
+ * that case only shows up on the old side, and it still needs a repaint.
+ */
+export declare const hasViewTabDiff: (diff: unknown) => boolean;
+export declare const getViewTabAppearanceFromViewOptions: (options: ViewOptionsWithWorkspacePlatform) => ViewTabAppearanceOptions | undefined;
+/**
+ * Reads view tab appearance from the view. Core persists `workspacePlatform` on view options across create,
+ * `updateOptions`, snapshot, and `getOptions`, so `getOptions` is the single source of truth.
+ */
+export declare const getViewTabAppearanceFromView: (view: OpenFin.View) => Promise<ViewTabAppearanceOptions | undefined>;
+/**
+ * Writes the per-state custom properties for a single tab element. Values are set inline so that sibling tabs
+ * in the same tab strip are unaffected.
+ */
+export declare const applyViewTabAppearance: (tab: HTMLElement, appearance?: ViewTabAppearanceOptions) => void;
+export {};

package/externals.report.json

@@ -13,14 +13,6 @@
             "issuer": "common/src/utils/layout.ts"
         }
     ],
-    "lodash.clonedeep": [
-        {
-            "type": "explicit",
-            "version": "4.5.0",
-            "packageName": "common/package.json",
-            "issuer": "common/src/utils/layout.ts"
-        }
-    ],
     "react-i18next": [
         {
             "type": "explicit",
@@ -45,19 +37,27 @@
             "issuer": "common/src/api/i18next.ts"
         }
     ],
-    "dexie": [
+    "lodash.clonedeep": [
         {
             "type": "explicit",
-            "version": "^4.0.11",
+            "version": "4.5.0",
             "packageName": "common/package.json",
-            "issuer": "common/src/api/pages/idb.ts"
-        },
+            "issuer": "common/src/utils/layout.ts"
+        }
+    ],
+    "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": "common/package.json",
+            "issuer": "common/src/api/pages/idb.ts"
+        },
         {
             "type": "explicit",
             "version": "^4.0.11",