@openfin/workspace-platform 22.5.25 → 23.0.1-alpha.75ce533e

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

@@ -35,6 +35,8 @@ export declare enum WorkspacePlatformChannelAction {
     GetLastFocusedBrowserWindow = "getLastFocusedBrowserWindow",
     GetPageByViewIdentity = "getPageByViewIdentity",
     GetThemes = "getThemes",
+    GetGeneratedPalettes = "getGeneratedPalettes",
+    GetThemePaletteSheet = "getThemePaletteSheet",
     GetSelectedScheme = "getSelectedScheme",
     SetSelectedScheme = "setSelectedScheme",
     OpenGlobalContextMenuInternal = "openGlobalContextMenuInternal",
@@ -67,31 +69,34 @@ export declare enum WorkspacePlatformChannelAction {
     CopyPage = "copyPage",
     HandlePageChanges = "handlePageChanges",
     MarkUnsavedPagesAsSavedInternal = "markUnsavedPagesAsSavedInternal",
-    TrackRemovedTabInternal = "trackRemovedTabInternal",
-    RestoreRemovedTabInternal = "restoreRemovedTabInternal",
-    TrackVisitedSiteInternal = "trackVisitedSiteInternal",
-    GetRecentlyVisitedSitesInternal = "getRecentlyVisitedSitesInternal",
-    GetFrequentlyVisitedSitesInternal = "getFrequentlyVisitedSitesInternal",
-    SearchSitesInternal = "searchSitesInternal",
-    GetSearchProvidersInternal = "getSearchProvidersInternal",
-    GetCuratedContentInternal = "getCuratedContentInternal",
-    HandleRequestNavigationInternal = "handleRequestNavigationInternal",
-    RefreshBookmarksInternal = "refreshBookmarksInternal",
-    LaunchBookmarkInternal = "launchBookmarkInternal",
-    GetNotificationsConfig = "getNotificationsConfig",
-    UpdateDockFavoritesInternal = "updateDockFavoritesInternal",
-    UpdateContentMenuInternal = "updateContentMenuInternal",
-    LaunchDockEntryInternal = "launchDockEntryInternal",
-    SetDockFavoritesOrderInternal = "setDockFavoritesOrderInternal",
-    NavigateContentMenuInternal = "navigateContentMenuInternal",
-    SetDefaultDockButtonsOrderInternal = "setDefaultDockButtonsOrderInternal",
-    GetDockWorkspacesContextMenuInternal = "getDockWorkspacesContextMenuInternal",
-    HandleDockWorkspacesMenuResponseInternal = "handleDockWorkspacesMenuResponseInternal",
-    RemoveDockFavoriteInternal = "removeDockFavoriteInternal",
-    AddDockFavoriteInternal = "addDockFavoriteInternal",
-    FocusAndExpandSearchInternal = "focusAndExpandSearchInternal",
-    SendUpdateVersionModalResponseInternal = "sendUpdateVersionModalResponseInternal",
-    ShowUpdateVersionModalInternal = "showUpdateVersionModalInternal"
+    TrackRemovedTabInternal = "trackRemovedTabInternal",// Enterprise
+    RestoreRemovedTabInternal = "restoreRemovedTabInternal",// Enterprise
+    TrackVisitedSiteInternal = "trackVisitedSiteInternal",// Enterprise
+    GetRecentlyVisitedSitesInternal = "getRecentlyVisitedSitesInternal",// Enterprise
+    GetFrequentlyVisitedSitesInternal = "getFrequentlyVisitedSitesInternal",// Enterprise
+    SearchSitesInternal = "searchSitesInternal",// Enterprise
+    GetSearchProvidersInternal = "getSearchProvidersInternal",// Enterprise
+    GetCuratedContentInternal = "getCuratedContentInternal",// Enterprise
+    HandleRequestNavigationInternal = "handleRequestNavigationInternal",// Enterprise
+    RefreshBookmarksInternal = "refreshBookmarksInternal",// Enterprise
+    LaunchBookmarkInternal = "launchBookmarkInternal",// Enterprise
+    GetNotificationsConfig = "getNotificationsConfig",// Deprecated
+    UpdateDockFavoritesInternal = "updateDockFavoritesInternal",// Enterprise
+    UpdateContentMenuInternal = "updateContentMenuInternal",// Enterprise
+    LaunchDockEntryInternal = "launchDockEntryInternal",// Enterprise
+    SetDockFavoritesOrderInternal = "setDockFavoritesOrderInternal",// Enterprise
+    NavigateContentMenuInternal = "navigateContentMenuInternal",// Enterprise
+    SetDefaultDockButtonsOrderInternal = "setDefaultDockButtonsOrderInternal",// Enterprise
+    GetDockWorkspacesContextMenuInternal = "getDockWorkspacesContextMenuInternal",// Enterprise
+    HandleDockWorkspacesMenuResponseInternal = "handleDockWorkspacesMenuResponseInternal",// Enterprise
+    RefreshDockCollectionMenuInternal = "refreshDockCollectionMenuInternal",// Enterprise
+    LaunchCollectionInternal = "launchCollectionInternal",//Enterprise
+    RemoveDockFavoriteInternal = "removeDockFavoriteInternal",// Enterprise
+    AddDockFavoriteInternal = "addDockFavoriteInternal",// Enterprise
+    FocusAndExpandSearchInternal = "focusAndExpandSearchInternal",// Enterprise
+    SendUpdateVersionModalResponseInternal = "sendUpdateVersionModalResponseInternal",// Enterprise
+    ShowUpdateVersionModalInternal = "showUpdateVersionModalInternal",// Enterprise
+    GetNotificationIndicatorColorsInternal = "getNotificationIndicatorColorsInternal"
 }
 export type PlatFormSupportedFeatures = boolean | {
     isWorkspacePlatform: boolean;

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

@@ -19,8 +19,8 @@ export declare const launchProvider: () => Promise<void>;
  */
 export declare const getChannelClientAndLaunchProvider: () => Promise<WorkspaceComponentChannelClient>;
 /**
- * Launches the Workspace provider if it is not running.
+ * Gets the theme data from the Platform provider, then launches the Workspace provider if it is not running, and then dispatches the theme data to the Workspace provider.
  * Then gets a Channel Client that is connected to the Workspace Provider.
  * @returns the Channel Client that is connected to the Workspace Provider.
  */
-export declare const getClientAPIChannelClientAndLaunchProvider: () => Promise<WorkspaceAPIClientChannelClient>;
+export declare const getChannelClientAndInitializeWorkspaceProvider: () => Promise<WorkspaceAPIClientChannelClient>;

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

@@ -98,7 +98,7 @@ export interface ProviderUpdateEventPayload {
  *
  * This allows for different providers to be registered with the same id.
  */
-export declare const getUniqueProviderIdentifier: ({ platformIdentity, id }: Pick<ProviderInfoInternal, 'platformIdentity' | 'id'>) => string;
+export declare const getUniqueProviderIdentifier: ({ platformIdentity, id }: Pick<ProviderInfoInternal, "platformIdentity" | "id">) => string;
 /**
  * Get a list of all providers that have registered with the provider API.
  */

package/common/src/api/shapes/notifications.d.ts

@@ -1,5 +1,6 @@
 /**
  * Options for using privately hosted notification service.
+ * @deprecated Custom manifest is now part of the platform manifest and is automatically resolved by the notifications API. Do not use this type as it will be ignored.
  */
 export type NotificationsCustomManifestOptions = {
     /**

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

@@ -30,29 +30,29 @@ export declare const launchStorefrontApp: (req: LaunchStorefrontProviderAppReque
  * @param identity of the platform to get the apps from.
  * @returns the list of Storefront apps for the platform.
  */
-export declare const getStorefrontApps: (provider: ProviderInfoInternal<'storefront'>) => Promise<App[]>;
+export declare const getStorefrontApps: (provider: ProviderInfoInternal<"storefront">) => Promise<App[]>;
 /**
  * Get the platform's landing page for Storefront.
  * @param identity of the platform to get the landing page of.
  * @returns the platform's landing page.
  */
-export declare const getStorefrontLandingPage: (provider: ProviderInfoInternal<'storefront'>) => Promise<StorefrontLandingPage | undefined>;
+export declare const getStorefrontLandingPage: (provider: ProviderInfoInternal<"storefront">) => Promise<StorefrontLandingPage | undefined>;
 /**
  * Get the platform's footer for Storefront.
  * @param identity of the platform to get the footer of.
  * @returns the platform's footer.
  */
-export declare const getStorefrontFooter: (provider: ProviderInfoInternal<'storefront'>) => Promise<StorefrontFooter>;
+export declare const getStorefrontFooter: (provider: ProviderInfoInternal<"storefront">) => Promise<StorefrontFooter>;
 /**
  * Get the platform's navigation for Storefront.
  * @param identity of the platform to get the navigation of.
  * @returns the platform's navigation.
  */
-export declare const getStorefrontNavigation: (provider: ProviderInfoInternal<'storefront'>) => Promise<[StorefrontNavigationSection?, StorefrontNavigationSection?]>;
+export declare const getStorefrontNavigation: (provider: ProviderInfoInternal<"storefront">) => Promise<[StorefrontNavigationSection?, StorefrontNavigationSection?]>;
 /**
  * A helper method that gets a Storefront navigation item by ID.
  * @param navigationItemId the id of the Storefront navigation item.
  * @param identity of the platform.
  * @returns the navigation item with the ID.
  */
-export declare const getStorefrontNavigationItemAppGrid: (navigationItemId: string, provider: ProviderInfoInternal<'storefront'>) => Promise<StorefrontNavigationItemAppGrid | undefined>;
+export declare const getStorefrontNavigationItemAppGrid: (navigationItemId: string, provider: ProviderInfoInternal<"storefront">) => Promise<StorefrontNavigationItemAppGrid | undefined>;

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

@@ -1,8 +1,13 @@
 import type { DefaultTheme } from 'styled-components';
 import type OpenFin from '@openfin/core';
-import { type ColorSchemeType, type ThemeSet } from '@openfin/ui-library';
-import { Palette } from '@openfin/ui-library/dist/theme';
+import type { ColorSchemeType, ThemeSet } from '@openfin/ui-library';
 import { ColorSchemeOptionType } from '../../../client-api-platform/src/shapes';
+import type { generateTheme } from '@openfin/theme-engine';
+export declare const ColorScheme: {
+    light: string;
+    dark: string;
+    system: string;
+};
 export type WorkspaceComponentSetSelectedSchemePayload = {
     newScheme: ColorSchemeOptionType;
     identity: OpenFin.Identity;
@@ -35,6 +40,13 @@ export interface NotificationIndicatorColorsSetLightScheme {
     dark?: NotificationIndicatorColorsSet;
     light: NotificationIndicatorColorsSet;
 }
+export type NotificationIndicatorColors = Record<string, Omit<NotificationIndicatorColorsSet, 'foreground'> & {
+    foreground: string;
+}>;
+export type NotificationIndicatorColorsParsed = {
+    dark: NotificationIndicatorColors;
+    light: NotificationIndicatorColors;
+};
 export type NotificationIndicatorColorsWithScheme = Record<string, NotificationIndicatorColorsSetDarkScheme | NotificationIndicatorColorsSetLightScheme>;
 export interface BaseThemeOptions {
     label: string;
@@ -65,7 +77,7 @@ export type CustomThemeOptions = BaseThemeOptions & {
      * };
      * ```
      */
-    notificationIndicatorColors?: Record<string, NotificationIndicatorColorsSet>;
+    notificationIndicatorColors?: NotificationIndicatorColors;
 };
 export type CustomThemeOptionsWithScheme = BaseThemeOptions & {
     /**
@@ -121,10 +133,23 @@ export type CustomThemeOptionsWithScheme = BaseThemeOptions & {
      */
     notificationIndicatorColors?: NotificationIndicatorColorsWithScheme;
 };
-export type CustomThemes = (CustomThemeOptions | CustomThemeOptionsWithScheme)[];
+export type ThemeOptions = BaseThemeOptions & {
+    seed: Parameters<typeof generateTheme>[0];
+    overrides?: Parameters<typeof generateTheme>[1];
+    default?: Exclude<ColorSchemeOptionType, 'system'>;
+} & {
+    notificationIndicatorColors?: NotificationIndicatorColorsWithScheme | NotificationIndicatorColors;
+};
+type GenerateThemeReturn = ReturnType<typeof generateTheme>;
+export type GeneratedPalettes = Pick<GenerateThemeReturn, 'dark' | 'light'>;
+export type LegacyPalettes = CustomThemeOptions | CustomThemeOptionsWithScheme;
+export type GenerateThemeParams = Parameters<typeof generateTheme>;
+export type CustomTheme = CustomThemeOptions | CustomThemeOptionsWithScheme | ThemeOptions;
+export type CustomThemes = CustomTheme[];
 export interface PreloadedThemeData {
-    themes: CustomThemes;
+    themes: CustomThemes | GeneratedPalettes;
     selectedScheme: ColorSchemeOptionType;
+    themePaletteSheet?: string;
 }
 export interface DefaultPaletteSet {
     brandPrimary: string;
@@ -265,16 +290,14 @@ export declare const OpenFinDarkTheme: {
     borderNeutral: "#C0C1C2";
 };
 export declare const DefaultOpenFinTheme: CustomThemes;
-export declare const getComputedPaletteSets: (customTheme: CustomThemeOptions | CustomThemeOptionsWithScheme) => WorkspaceThemeSet;
-/**
- * Transforms input {@link CustomThemes} to {@link ComputedThemes} used by Workspace Platform / Notifications Platform.
- *
- * @param customThemes array of themes to transform
- * @param storedScheme sets the default scheme if provided
- * @returns array of {@link ComputedThemes | computed themes}
- */
-export declare const computeThemes: (customThemes: CustomThemes, storedScheme?: ColorSchemeOptionType) => ComputedThemes;
-export declare const getComputedPlatformTheme: (platformIdentity: OpenFin.Identity) => Promise<ComputedTheme>;
+export declare const parseNotificationIndicatorColors: (customTheme: CustomTheme) => NotificationIndicatorColorsParsed;
+export declare const constructThemePaletteSheet: (themes: GeneratedPalettes) => string;
+export declare const getComputedPlatformTheme: (platformIdentity: OpenFin.Identity) => Promise<{
+    theme: CustomThemes | GeneratedPalettes;
+    defaultScheme: ColorSchemeOptionType;
+    themePaletteSheet: string;
+}>;
 export declare const setSelectedScheme: (ctx: ColorSchemeOptionType) => Promise<void>;
-export declare const getComputedScheme: (identity?: OpenFin.Identity) => Promise<Exclude<ColorSchemeType, 'system'>>;
-export declare const getComputedBackgroundColor: (paletteKey: keyof typeof Palette, defaultColor?: string) => Promise<string>;
+export declare const getComputedScheme: (identity?: OpenFin.Identity) => Promise<Exclude<ColorSchemeType, "system">>;
+export declare const getComputedBackgroundColor: (platformIdentity: OpenFin.Identity) => Promise<string>;
+export {};

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

@@ -23,3 +23,10 @@ export type ApplicationInfoExtended = OpenFin.ApplicationInfo & {
 };
 export declare const getCurrentOFApplication: () => OpenFin.Application;
 export declare const getWorkspaceOFApplication: () => OpenFin.Application;
+/**
+ * Gets the application manifest, caching the result after the first call.
+ * The manifest never changes during the application lifecycle, so this avoids redundant async calls.
+ * Uses promise-based caching to prevent race conditions when multiple calls occur before the first completes.
+ * @returns A Promise resolving to the application manifest
+ */
+export declare const getCachedManifest: () => Promise<OpenFin.Manifest>;

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

@@ -1,6 +1,6 @@
 import type OpenFin from '@openfin/core';
 import { EnterpriseMainContextMenuItemData, EnterpriseMainContextMenuItemTemplate, OpenGlobalContextMenuPayload } from '../../../client-api-platform/src/shapes';
-export declare const getEnterpriseContextMenuTemplate: ({ identity, selectedViews }: {
+export declare const getEnterpriseContextMenuTemplate: ({ identity }: {
     identity: OpenFin.Identity;
     selectedViews: OpenFin.Identity[];
 }) => Promise<EnterpriseMainContextMenuItemTemplate[]>;

package/common/src/utils/find-in-page/findInPageChannel.d.ts

@@ -0,0 +1,37 @@
+export type FindInPageChannelMessagePayload = {
+    type: 'close';
+} | {
+    type: 'find-text-changed';
+    value: string;
+} | {
+    type: 'focus-input';
+} | {
+    type: 'hide-from-search-menu';
+} | {
+    type: 'next-result';
+} | {
+    type: 'previous-result';
+} | {
+    type: 'show';
+} | {
+    type: 'update-state';
+    currentResultIndex?: number | null;
+    totalResults?: number | null;
+    value?: string | null;
+} | {
+    type: 'view-ready';
+} | {
+    type: 'window-ready';
+};
+/**
+ * Closes the find in page channel
+ */
+export declare const closeFindInPageChannel: (channel: BroadcastChannel) => void;
+/**
+ * Creates a new find in page channel
+ */
+export declare const createFindInPageChannel: (windowName?: string) => Promise<BroadcastChannel>;
+/**
+ * Sends a message via the find in page channel
+ */
+export declare const sendFindInPageMessage: (channel: BroadcastChannel, message: FindInPageChannelMessagePayload) => void;

package/common/src/utils/find-in-page/showFindInPageHandler.d.ts

@@ -0,0 +1,2 @@
+import type OpenFin from '@openfin/core';
+export declare const showFindInPageInTargetWindow: (windowIdentity: OpenFin.Identity) => Promise<void>;

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

@@ -74,6 +74,13 @@ export declare const manageDesktopSignals: () => {
         type: WP.GlobalContextMenuOptionType;
     };
 };
+export declare const findInPage: () => {
+    type: MenuItemType;
+    label: string;
+    data: {
+        type: WP.GlobalContextMenuOptionType;
+    };
+};
 export declare const renameWorkspace: () => {
     type: MenuItemType;
     label: string;
@@ -93,7 +100,7 @@ export declare const downloads: () => {
 export declare const appearance: () => {
     label: string;
 };
-export declare const getSavedWorkspaceContextMenuOptions: (activeWorkspace: Workspace, savedWorkspaces: Pick<Workspace, 'workspaceId' | 'title'>[], contextMenuOptionType: GlobalContextMenuOptionType) => {
+export declare const getSavedWorkspaceContextMenuOptions: (activeWorkspace: Workspace, savedWorkspaces: Pick<Workspace, "workspaceId" | "title">[], contextMenuOptionType: GlobalContextMenuOptionType) => {
     label: string;
     type: MenuItemType;
     enabled: boolean;

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

@@ -1,7 +1,5 @@
-/// <reference types="lodash" />
 import type OpenFin from '@openfin/core';
 import { WindowIdentity } from '../../../common/src/utils/window';
-import { AttachedPageInternal } from '../../../common/src/api/pages/shapes';
 import { AttachedPage, PageLayout } from '../../../client-api-platform/src/shapes';
 export type LayoutDOMEventType = 
 /**
@@ -12,12 +10,22 @@ export type LayoutDOMEventType =
  * Fired when a tab is created in a container. (Emmitted by core)
  */
  | 'tab-created'
+/**
+ * Fired when a new container/stack is created. (Emitted by Golden Layout)
+ */
+ | 'container-created'
 /**
  * Fired when the layout container is ready to be used. (Emitted by us)
  */
- | 'container-resized' | 'tab-closed';
+ | 'container-resized'
+/**
+ * Fired when a view item container is resized (e.g., via separator drag). (Emitted by us)
+ */
+ | 'view-container-resized' | 'tab-closed';
 export type LayoutDOMEvent = {
     type: Extract<LayoutDOMEventType, 'container-resized'>;
+} | {
+    type: Extract<LayoutDOMEventType, 'view-container-resized'>;
 } | {
     type: Extract<LayoutDOMEventType, 'tab-created' | 'tab-closed'>;
     detail: {
@@ -31,12 +39,21 @@ export type LayoutDOMEvent = {
     };
     isInitialized: boolean;
     target: HTMLElement;
+} | {
+    type: Extract<LayoutDOMEventType, 'container-created'>;
+    detail?: {
+        containerSelector?: string;
+        [key: string]: any;
+    };
+    target?: HTMLElement;
+    originalElement?: HTMLElement;
 } | {
     type: Extract<LayoutDOMEventType, 'tabs-list-resized'>;
 };
 export type LayoutDOMEventListener = (ev: LayoutDOMEvent) => void;
 export declare const VIEW_NAME_PREFIX: "internal-generated-view-";
-export declare const getFirstActiveViewFromLayout: (identity: OpenFin.LayoutIdentity) => Promise<OpenFin.Identity>;
+export declare const getViewNameFromTabId: (tabId: string) => string;
+export declare const getFirstActiveViewFromLayout: (identity: OpenFin.LayoutIdentity) => OpenFin.Identity | undefined;
 /**
  * Recursively clones a layout object, calling a passed callback on each `componentState` in the tree.
  * @param node Either the layout object itself, or one of the items in its tree.
@@ -44,6 +61,13 @@ export declare const getFirstActiveViewFromLayout: (identity: OpenFin.LayoutIden
  * @returns A mapped copy of the layout
  */
 export declare const mapLayoutViewComponents: (node: any, callback: (arg0: any) => any) => any;
+/**
+ * Recursively clones a layout object, calling a passed async callback on each `componentState` in the tree.
+ * @param node Either the layout object itself, or one of the items in its tree.
+ * @param callback Async callback to be called on each component's `componentState`
+ * @returns A Promise resolving to a mapped copy of the layout
+ */
+export declare const mapLayoutViewComponentsAsync: (node: any, callback: (arg0: any) => Promise<any>) => Promise<any>;
 /**
  * Copies the componentState and generates a name if it's not there
  * @param componentState view's componentState in the layout object, corresponds to View options
@@ -63,9 +87,9 @@ export declare const generateViewNameAndIdentifierNameIfNotExists: <T extends {
 /**
  * Deep clones a layout and converts view options (add names if necessary, apply defaults).
  * @param layout The Layout to be cloned
- * @returns A copy of the layout with view options converted
+ * @returns A Promise resolving to a copy of the layout with view options converted
  */
-export declare const cloneLayoutAndConvertViewOptions: (layout: PageLayout, initViewOptions?: Partial<OpenFin.ViewOptions>) => any;
+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.
@@ -79,13 +103,20 @@ export declare const cloneLayoutAndRemoveNames: (layout: PageLayout) => any;
  * @returns A copy of the layout with generated names removed
  */
 export declare const cloneLayoutAndRemoveGeneratedNames: (layout: PageLayout) => any;
-export declare const mapContentComponentState: (content: OpenFin.LayoutContent) => OpenFin.LayoutComponent['componentState'][];
+export declare const mapContentComponentState: (content: OpenFin.LayoutContent) => OpenFin.LayoutComponent["componentState"][];
 export declare const getLayoutWithSingleView: (title: string, url: string, winIdentity?: OpenFin.Identity) => Promise<any>;
 export declare const layoutNameInitializedMap: Map<string, boolean>;
 export declare const isLayoutTabActive: (tabSelector: string) => boolean;
 export declare const containerId = "layout_container";
 export declare const viewTabslistSelectors = ".lm_tabs";
 export declare const addLayoutEventListener: (event: LayoutDOMEventType, listener: LayoutDOMEventListener) => void;
+export declare const removeLayoutEventListener: (event: LayoutDOMEventType, listener: LayoutDOMEventListener) => void;
+/**
+ * Cleans up ResizeObservers and event listeners for a specific layout.
+ * Should be called when a layout is destroyed to prevent memory leaks.
+ * @param layoutName The layoutName/layoutContainerKey to cleanup
+ */
+export declare const cleanupLayoutObservers: (layoutName: string) => void;
 /**
  * Initialize the layout for the current OF window.
  */
@@ -120,9 +151,6 @@ export declare const findViewInLayout: (node: any, viewId: OpenFin.Identity) =>
  */
 export declare const countViews: (node: OpenFin.LayoutContent) => number;
 export declare const getLayoutConfig: (layoutContainerKey: string) => Promise<any>;
-export declare const updateTabStateBasedOnViewCount: (page: AttachedPageInternal, viewCount: number) => Promise<void>;
-export declare const updatePageForViewCount: (activePage: AttachedPageInternal | undefined) => Promise<void>;
-export declare const debouncedUpdatePageForViewCount: import("lodash").DebouncedFunc<(activePage: AttachedPageInternal | undefined) => Promise<void>>;
 export declare const findPageForView: (viewName: string, browserWindowIdentity?: WindowIdentity) => Promise<AttachedPage | undefined>;
 /**
  * Only show the view tab icon when not on the landing page

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

@@ -0,0 +1,131 @@
+/**
+ * Logger Utility for OpenFin Workspace Monorepo
+ *
+ * Provides structured, contextual logging with consistent formatting
+ * across all workspaces and modules.
+ */
+export interface LogData {
+    [key: string]: any;
+}
+export interface Logger {
+    debug: (method: string, message: string, data?: LogData | (() => LogData)) => void;
+    info: (method: string, message: string, data?: LogData | (() => LogData)) => void;
+    warn: (method: string, message: string, data?: LogData | (() => LogData)) => void;
+    error: (method: string, message: string, data?: LogData | (() => LogData)) => void;
+}
+/**
+ * Configuration for the logger
+ */
+export interface LoggerConfig {
+    /** Include timestamp in logs (default: true) */
+    includeTimestamp?: boolean;
+    /** Custom prefix for logs */
+    customPrefix?: string;
+    /**
+     * Stringify log data before passing to console (default: true).
+     * When true, objects are serialized as JSON strings for safer logging.
+     * When false, raw objects are passed to console, allowing expandable/inspectable
+     * objects in browser dev tools.
+     *
+     * @example
+     * To disable safe stringify for local development, you can:
+     * 1. Set this option per-logger: createLogger('MyContext', { stringifyData: false })
+     * 2. Or call setGlobalStringifyEnabled(false) once at app startup
+     */
+    stringifyData?: boolean;
+}
+/**
+ * Enable or disable safe stringify globally for all loggers.
+ * Useful for local development when you want expandable objects in browser dev tools.
+ *
+ * This overrides the build-time LOG_STRINGIFY setting at runtime.
+ * Individual logger config (stringifyData option) takes precedence over this setting.
+ *
+ * @param enabled - Whether to stringify log data
+ *
+ * @example
+ * ```typescript
+ * // Override build-time setting at runtime:
+ * import { setGlobalStringifyEnabled } from 'common/src/utils/logger';
+ *
+ * // Disable stringify to get expandable objects in console
+ * setGlobalStringifyEnabled(false);
+ * ```
+ */
+export declare const setGlobalStringifyEnabled: (enabled: boolean) => void;
+/**
+ * Get the current global stringify setting.
+ */
+export declare const getGlobalStringifyEnabled: () => boolean;
+/**
+ * Create a structured logger for a specific context
+ *
+ * @param context - The context identifier (workspace, module, or component name)
+ * @param config - Optional configuration for the logger
+ * @returns Enhanced logger instance
+ *
+ * @example
+ * ```typescript
+ * const logger = createLogger('browser.TabList');
+ *
+ * logger.info('addTab', 'Adding new tab', { pageId: '123' });
+ * logger.error('addTab', 'Failed to add tab', { error: err.message });
+ * ```
+ */
+export declare const createLogger: (context: string, config?: LoggerConfig) => Logger;
+/**
+ * Create a logger with performance monitoring capabilities
+ * Useful for tracking execution times and performance metrics
+ */
+export declare const createPerformanceLogger: (context: string, config?: LoggerConfig) => {
+    /**
+     * Start a performance timer
+     */
+    startTimer: (timerId: string, method: string, message: string, data?: LogData) => void;
+    /**
+     * Clear a specific timer without logging
+     */
+    clearTimer: (timerId: string) => void;
+    /**
+     * End a performance timer and log the duration
+     */
+    endTimer: (timerId: string, method: string, message: string, data?: LogData) => void;
+    debug: (method: string, message: string, data?: LogData | (() => LogData)) => void;
+    info: (method: string, message: string, data?: LogData | (() => LogData)) => void;
+    warn: (method: string, message: string, data?: LogData | (() => LogData)) => void;
+    error: (method: string, message: string, data?: LogData | (() => LogData)) => void;
+};
+export type EnhancedLogger = ReturnType<typeof createPerformanceLogger>;
+/**
+ * Middleware function for wrapping async operations with logging
+ */
+export declare const withLogging: <T extends any[], R>(logger: Logger, method: string, operation: (...args: T) => Promise<R> | R) => (...args: T) => Promise<R>;
+/**
+ * Legacy logger instance for backwards compatibility.
+ * Use `createLogger` for new code to get structured, contextual logging.
+ *
+ * @deprecated Use createLogger() instead for new code
+ */
+export declare const log: {
+    /**
+     * Calls console.debug with provided parameters and stringifies JS objects prior to logging.
+     * Only logs when LOG_DEBUG is enabled.
+     */
+    debug: (...args: unknown[]) => void;
+    /**
+     * Calls console.info with provided parameters and stringifies JS objects prior to logging
+     */
+    info: (...args: unknown[]) => void;
+    /**
+     * Calls console.warn with provided parameters and stringifies JS objects prior to logging
+     */
+    warn: (...args: unknown[]) => void;
+    /**
+     * Calls console.error with provided parameters and stringifies JS objects prior to logging
+     */
+    error: (...args: unknown[]) => void;
+    /**
+     * Calls console.trace with provided parameters and stringifies JS objects prior to logging
+     */
+    trace: (...args: unknown[]) => void;
+};

package/common/src/utils/menu-window-provider.d.ts

@@ -2,9 +2,13 @@ import type OpenFin from '@openfin/core';
 import { ResponseModalContent } from '../../../common/src/utils/menu-config';
 import type { OptionalExceptFor } from '../../../common/src/utils/types';
 type MenuEventTypes = {
-    response: [ModalResponseEvent];
-    ready: [OpenFin.Identity];
-    update: [string, Partial<OpenFin.Bounds>, string];
+    'response': [ModalResponseEvent];
+    'ready': [OpenFin.Identity];
+    'update': [string, Partial<OpenFin.Bounds>, string];
+    'modal-opened': [string];
+    'modal-closed': [string];
+    'search-menu-opening': [string];
+    'search-menu-closed': [string];
 };
 export interface ModalResponseEvent {
     data: {
@@ -17,12 +21,12 @@ export interface ModalResponseEvent {
 }
 export declare const menuEvents: {
     emit: <EventKey extends keyof MenuEventTypes>(event: EventKey, ...payload: MenuEventTypes[EventKey]) => Promise<void>;
-    addListener: <EventKey_1 extends keyof MenuEventTypes>(event: EventKey_1, listener: (...payload: MenuEventTypes[EventKey_1]) => void) => void;
-    addListenerWithUUID: (uuid: string) => <EventKey_1 extends keyof MenuEventTypes>(event: EventKey_1, listener: (...payload: MenuEventTypes[EventKey_1]) => void) => void;
-    removeListener: <EventKey_2 extends keyof MenuEventTypes>(event: EventKey_2, listener: (...payload: MenuEventTypes[EventKey_2]) => void) => void;
-    once: <EventKey_3 extends keyof MenuEventTypes>(event: EventKey_3, listener: (...payload: MenuEventTypes[EventKey_3]) => void) => void;
+    addListener: <EventKey extends keyof MenuEventTypes>(event: EventKey, listener: (...payload: MenuEventTypes[EventKey]) => void) => void;
+    addListenerWithUUID: (uuid: string) => <EventKey extends keyof MenuEventTypes>(event: EventKey, listener: (...payload: MenuEventTypes[EventKey]) => void) => void;
+    removeListener: <EventKey extends keyof MenuEventTypes>(event: EventKey, listener: (...payload: MenuEventTypes[EventKey]) => void) => void;
+    once: <EventKey extends keyof MenuEventTypes>(event: EventKey, listener: (...payload: MenuEventTypes[EventKey]) => void) => void;
 };
-export declare const emitMenuResponse: (data: ModalResponseEvent['data']) => Promise<void>;
+export declare const emitMenuResponse: (data: ModalResponseEvent["data"]) => Promise<void>;
 type WindowOptionsWithBounds = OptionalExceptFor<OpenFin.WindowOptions, 'name' | 'url'> & {
     top: number;
     left: number;
@@ -49,6 +53,6 @@ export declare function createMenuPosition(windowOptions: OptionalExceptFor<Open
 }>;
 export declare function showChildWindow({ options, parameters }: ShowChildOptions): Promise<OpenFin.Window>;
 export declare const waitForModalResponse: ({ options, content, parameters }: ResponseModalOptions) => Promise<{
-    data: ModalResponseEvent['data'];
+    data: ModalResponseEvent["data"];
 }>;
 export {};

package/common/src/utils/merge-deep.d.ts

@@ -1,5 +1,6 @@
 /**
  * Deep merge a set of source objects into a single target object.
+ * Arrays are concatenated rather than overwritten.
  * @param target the target object to merge sources into.
  * @param sources the source objects to merge into the target. (FIFO)
  */

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

@@ -16,7 +16,7 @@ export declare const getCenterOfParentWindowMonitor: (parentWindowIdentity?: Ope
  * @param centerOnMonitor whether the modal should be centered on the monitor
  * @returns the bounds for where the modal is to be displayed
  */
-export declare const getResponseModalBounds: (modalOptions: Pick<ResponseModalConfig['windowOptions'], 'defaultWidth' | 'defaultHeight'>, parentWindowIdentity?: OpenFin.Identity, centerOnMonitor?: boolean) => Promise<OpenFin.Bounds>;
+export declare const getResponseModalBounds: (modalOptions: Pick<ResponseModalConfig["windowOptions"], "defaultWidth" | "defaultHeight">, parentWindowIdentity?: OpenFin.Identity, centerOnMonitor?: boolean) => Promise<OpenFin.Bounds>;
 export declare function getResponseModalBoundsAndCenterParentIfModalOffScreen(modalOptions: Parameters<typeof getResponseModalBounds>[0], parentWindowIdentity?: OpenFin.Identity, centerOnMonitor?: boolean, relativeBounds?: boolean): Promise<OpenFin.Bounds>;
 /**
  * Adjusts the given bounds to be within the closest monitor's available bounds if they are offscreen.

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

@@ -1,4 +1,5 @@
-export declare const createNamespacedLocalStorage: <TKey extends string>(namespace: string) => Pick<Storage, 'setItem' | 'getItem' | 'removeItem'>;
-export declare const setItem: (key: string, value: string) => void;
-export declare const getItem: (key: string) => string;
-export declare const removeItem: (key: string) => void;
+import LocalStorageKey from './local-storage-key';
+export declare const setItem: (key: LocalStorageKey, value: string) => void;
+export declare const getItem: (key: LocalStorageKey) => string;
+export declare const removeItem: (key: LocalStorageKey) => void;
+export declare const createNamespacedLocalStorage: <TKey extends string>(namespace: string) => Pick<Storage, "setItem" | "getItem" | "removeItem">;