@openfin/workspace 22.2.18 → 22.3.1

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: ResponseModalConfig["windowOptions"], parentWindowIdentity?: OpenFin.Identity, centerOnMonitor?: boolean) => Promise<OpenFin.Bounds>;
+export declare const getResponseModalBounds: (modalOptions: ResponseModalConfig['windowOptions'], parentWindowIdentity?: OpenFin.Identity, centerOnMonitor?: boolean) => Promise<OpenFin.Bounds>;
 export declare function getResponseModalBoundsAndCenterParentIfModalOffScreen(modalOptions: ResponseModalConfig['windowOptions'], parentWindowIdentity?: OpenFin.Identity, centerOnMonitor?: boolean): Promise<OpenFin.Bounds>;
 /**
  * Adjusts the given bounds to be within the closest monitor's available bounds if they are offscreen.

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

@@ -1,4 +1,4 @@
-export declare const createNamespacedLocalStorage: <TKey extends string>(namespace: string) => Pick<Storage, "setItem" | "getItem" | "removeItem">;
+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 | null;
+export declare const getItem: (key: string) => string;
 export declare const removeItem: (key: string) => void;

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

@@ -1,3 +1,3 @@
 import type OpenFin from '@openfin/core';
 import { PageTabContextMenuItemTemplate } from '../../../client-api-platform/src/shapes';
-export declare const getPageTabMenuTemplate: (pageId: string, winIdentity: OpenFin.Identity) => Promise<PageTabContextMenuItemTemplate[]>;
+export declare const getPageTabMenuTemplate: (pageId: string, winIdentity: OpenFin.Identity, isEnterprise: boolean) => Promise<PageTabContextMenuItemTemplate[]>;

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

@@ -0,0 +1,7 @@
+/**
+ * Pick specific keys from an object.
+ * lodash.pick is deprecated and says to use destructuring instead, but that has one key flaw, it adds undefined properties to the result if the key is not present in the object.
+ * ie `const { a, b } = obj; return {a,b};` will result in `{ a: undefined, b: undefined }` if `a` or `b` are not present in `obj`.
+ * pick({}, ['a', 'b']) will result in `{}` if `a` or `b` are not present in the object.
+ */
+export declare function pick<T extends object, K extends keyof T>(obj: T, keys: K[]): Pick<T, K>;

package/common/src/utils/promise-with-resolvers.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Polyfill for `Promise.withResolvers` which is not available in this typescript version.
+ */
+export declare function withResolvers<T>(): PromiseWithResolvers<T>;
+export type PromiseWithResolvers<T> = {
+    promise: Promise<T>;
+    resolve: (value: T | PromiseLike<T>) => void;
+    reject: (reason?: any) => void;
+};

package/common/src/utils/shared-emitter.d.ts

@@ -5,12 +5,12 @@ export default function makeSharedEmitter<EventMap extends {
     [key: string | number]: any[];
 }>(id: string): {
     emit: <EventKey extends keyof EventMap>(event: EventKey, ...payload: EventMap[EventKey]) => Promise<void>;
-    addListener: <EventKey extends keyof EventMap>(event: EventKey, listener: (...payload: EventMap[EventKey]) => void) => void;
+    addListener: <EventKey_1 extends keyof EventMap>(event: EventKey_1, listener: (...payload: EventMap[EventKey_1]) => void) => void;
     /**
      * Creates a listener for a particular UUID instead of ApplicationUUID.Workspace.
      * @param uuid The UUID of the application to subscribe to.
      */
-    addListenerWithUUID: (uuid: string) => <EventKey extends keyof EventMap>(event: EventKey, listener: (...payload: EventMap[EventKey]) => void) => void;
-    removeListener: <EventKey extends keyof EventMap>(event: EventKey, listener: (...payload: EventMap[EventKey]) => void) => void;
-    once: <EventKey extends keyof EventMap>(event: EventKey, listener: (...payload: EventMap[EventKey]) => void) => void;
+    addListenerWithUUID: (uuid: string) => <EventKey_1 extends keyof EventMap>(event: EventKey_1, listener: (...payload: EventMap[EventKey_1]) => void) => void;
+    removeListener: <EventKey_2 extends keyof EventMap>(event: EventKey_2, listener: (...payload: EventMap[EventKey_2]) => void) => void;
+    once: <EventKey_3 extends keyof EventMap>(event: EventKey_3, listener: (...payload: EventMap[EventKey_3]) => void) => void;
 };

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

@@ -33,3 +33,26 @@ export type Awaitable<T> = Awaited<T> | Promise<Awaited<T>>;
 export type RemoveFunctions<T> = Pick<T, {
     [K in keyof T]: T[K] extends Function ? never : K;
 }[keyof T]>;
+type MissingKeys<T, U> = Exclude<keyof T, U>;
+/**
+ * A utility function that checks if the provided keys are valid for the given type T.
+ * The key thing it does is to ensure that all keys in T are present in the array, typescript can check for extra keys but not missing keys.
+ * While it is a function, it is really just a type check. The function is needed to encapsulate the type logic.
+ * It will throw a type error if any of the keys are not present in T.
+ *
+ * @example
+ * ```ts
+ * type Foo = {
+ *     bar: string;
+ *     qux?: string;
+ * };
+ *
+ * const fooChecker = makeKeyChecker<Foo>();
+ * const allFooKeys = fooChecker(['bar', 'qux']); // Valid
+ * fooChecker(['bar']); // Error: Missing keys: qux
+ * fooChecker(['qux']); // Error: Missing keys: bar
+ * fooChecker(['bar', 'qux', 'baz']); // 'baz' is not assignable to type keyof Foo;
+ * ```
+ */
+export declare const makeKeyChecker: <T extends object>() => <const K extends (keyof T)[]>(arr: K & (Exclude<keyof T, K[number]> extends never ? unknown : `Error: Missing keys: ${string & Exclude<keyof T, K[number]>}`)) => K;
+export {};

package/common/src/utils/workspace-modals.d.ts

@@ -28,4 +28,4 @@ export declare const showUpdateVersionModal: ({ identity, title, description }:
     identity: OpenFin.Identity;
     title: string;
     description: string;
-}) => Promise<ModalResponseEvent["data"]>;
+}) => Promise<ModalResponseEvent['data']>;

package/{common/src/utils/enterprise-dock.d.ts → dock3/src/api/constants.d.ts}

@@ -1,3 +1,5 @@
 export declare const DOCK_COMPANION_HEIGHT = 56;
 export declare const DOCK_COMPANION_WIDTH = 728;
 export declare const DOCK_COMPANION_TOP = 150;
+export declare const DOCK3_WINDOW_NAME = "dock3";
+export declare const getDock3ChannelName: (uuid?: string) => string;

package/dock3/src/api/idb.d.ts

@@ -0,0 +1,3 @@
+import { Dock3Config } from '../../../client-api-platform/src/shapes';
+export declare function getDock3ProviderConfig(): Promise<Dock3Config | undefined>;
+export declare function saveDock3ProviderConfig(config: Dock3Config): Promise<void>;

package/dock3/src/api/index.d.ts

@@ -0,0 +1,14 @@
+import { Dock3Config, DockAllowedWindowOptions } from '../../../dock3/src/shapes';
+import { Dock3ConstructorOverride, Dock3Provider } from './provider';
+export type DockInitOptions = {
+    config: Dock3Config;
+    override: Dock3ConstructorOverride;
+    windowOptions?: DockAllowedWindowOptions;
+};
+/**
+ *
+ * @param config Dock3 configuration object
+ * @param override Constructor override to customize the Dock3Provider
+ * @returns instance of Dock3Provider
+ */
+export declare function init(options: DockInitOptions): Promise<Dock3Provider>;

package/dock3/src/api/launch.d.ts

@@ -0,0 +1,3 @@
+import type { CompanionDockConfig } from '../shapes/enterprise';
+import type { Dock3Config, DockAllowedWindowOptions } from '../shapes/shapes';
+export declare function launchDock(dockName: string, baseUrl: string, config: CompanionDockConfig | Dock3Config, additionalOptions?: DockAllowedWindowOptions): Promise<void>;

package/dock3/src/api/protocol.d.ts

@@ -0,0 +1,73 @@
+import type { OpenFin } from '@openfin/core';
+import { BaseCustomDropdownItem } from '../../../client-api/src/shapes';
+import { BookmarkDockEntryPayload, DockEntry, LaunchDockEntryPayload } from '../../../client-api-platform/src/shapes';
+import { Dock3Config, DockCompanionButton } from '../../../dock3/src/shapes';
+type ChannelActionMap = {
+    [action: string]: (...args: any[]) => any;
+};
+type TypedChannelClient<ProviderActions extends ChannelActionMap, ClientActions extends ChannelActionMap> = Omit<OpenFin.ChannelClient, 'dispatch' | 'register'> & {
+    dispatch: <T extends keyof ProviderActions>(action: T, payload: Parameters<ProviderActions[T]>[0]) => Promise<Awaited<ReturnType<ProviderActions[T]>>>;
+    register: <T extends keyof ClientActions>(action: T, handler: (payload: Parameters<ClientActions[T]>[0], id: OpenFin.ProviderIdentity | OpenFin.ClientIdentity) => Promise<Awaited<ReturnType<ClientActions[T]>>>) => boolean;
+};
+type TypedChannelProvider<ProviderActions extends ChannelActionMap, ClientActions extends ChannelActionMap> = Omit<OpenFin.ChannelProvider, 'dispatch' | 'register'> & {
+    dispatch: <T extends keyof ClientActions>(to: OpenFin.ClientIdentity, action: T, payload: Parameters<ClientActions[T]>[0]) => Promise<Awaited<ReturnType<ClientActions[T]>>>;
+    register: <T extends keyof ProviderActions>(action: T, handler: (payload: Parameters<ProviderActions[T]>[0], id: OpenFin.ProviderIdentity | OpenFin.ClientIdentity) => Promise<Awaited<ReturnType<ProviderActions[T]>>>) => boolean;
+};
+/**
+ * @internal
+ */
+export type Dock3ChannelProviderChannelActions = {
+    'launch-entry': (payload: LaunchDockEntryPayload) => void;
+    'ready': () => void;
+    'save-config': (payload: {
+        config: Dock3Config;
+    }) => Promise<void>;
+    'bookmark-content-menu-entry': (payload: BookmarkDockEntryPayload) => Promise<void>;
+};
+/**
+ * @internal
+ */
+export type Dock3ChannelClientChannelActions = {
+    'handle-dock-config-updated': (payload: Dock3Config) => void;
+};
+/**
+ * @internal
+ */
+export type Dock3ChannelProvider = TypedChannelProvider<Dock3ChannelProviderChannelActions, Dock3ChannelClientChannelActions>;
+/**
+ * @internal
+ */
+export type Dock3ChannelClient = TypedChannelClient<Dock3ChannelProviderChannelActions, Dock3ChannelClientChannelActions>;
+/**
+ * These are channel actions registered by the platform.
+ *
+ * @internal
+ */
+export type EnterpriseDockChannelProviderChannelActions = Dock3ChannelProviderChannelActions & {
+    'set-dock-favorites-order': (newFavorites: DockEntry[]) => void;
+    'set-default-dock-buttons-order': (newFavorites: DockCompanionButton[]) => void;
+    'get-dock-workspaces-context-menu': () => BaseCustomDropdownItem[];
+    'handle-dock-workspaces-menu-response': (payload: any) => void;
+    'remove-favorite-entry': (entry: DockEntry) => void;
+    'add-favorite-entry': (entry: DockEntry) => void;
+};
+/**
+ * These are channel actions registered by the client (enterprise dock)
+ * @internal
+ */
+export type EnterpriseDockChannelClientChannelActions = Dock3ChannelClientChannelActions & {
+    'update-favorite-entries': () => void;
+    'update-content-menu': () => void;
+    'navigate-content-menu': () => void;
+};
+/**
+ * Used by Enterprise Dock for communication with the platform.
+ * @internal
+ */
+export type EnterpriseDockChannelClient = TypedChannelClient<EnterpriseDockChannelProviderChannelActions, EnterpriseDockChannelClientChannelActions>;
+/**
+ * Used by the platform for communication with Enterprise Dock.
+ * @internal
+ */
+export type EnterpriseDockChannelProvider = TypedChannelProvider<EnterpriseDockChannelProviderChannelActions, EnterpriseDockChannelClientChannelActions>;
+export {};

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

@@ -0,0 +1,89 @@
+import type { OpenFin } from '@openfin/core';
+import { BookmarkDockEntryPayload, LaunchDockEntryPayload } from '../../../client-api-platform/src/index';
+import { Dock3Config } from '../../../dock3/src/shapes';
+import { Async, CamelCase } from '../../../dock3/src/utils';
+import { Dock3ChannelProvider, Dock3ChannelProviderChannelActions } from './protocol';
+type InternalDock3ChannelActions = 'ready';
+type Dock3ProviderAPI = {
+    [K in keyof Omit<Dock3ChannelProviderChannelActions, InternalDock3ChannelActions> as CamelCase<K>]: Async<Dock3ChannelProviderChannelActions[K]>;
+};
+type ExtendsProtocolProvider<T extends Dock3ProviderAPI> = T extends Dock3ProviderAPI ? T : never;
+export type EnsureProviderMatchesProtocol = ExtendsProtocolProvider<Dock3Provider>;
+export declare class Dock3Provider {
+    #private;
+    static getOverrideConstructor(...args: ConstructorParameters<typeof Dock3Provider>): new () => Dock3Provider;
+    static instance: Dock3Provider | null;
+    constructor(config: Dock3Config, channel: Dock3ChannelProvider);
+    launchEntry(payload: LaunchDockEntryPayload): Promise<void>;
+    /**
+     * Returns a promise that resolves when the Dock3Provider is ready.
+     * This is useful to ensure that the dock is fully initialized before performing any operations.
+     * The promise will resolve when the dock sends the 'ready' action.
+     */
+    get ready(): Promise<void>;
+    bookmarkContentMenuEntry(payload: BookmarkDockEntryPayload): Promise<void>;
+    /**
+     * Read-only access to the current configuration of the Dock3Provider.
+     */
+    get config(): Dock3Config;
+    /**
+     * Protected setter for the configuration of the Dock3Provider.
+     * This does not save the configuration in storage nor notify the dock about the change.
+     * Use `updateConfig` method to update the configuration and save it.
+     * This should only be used internally in a `saveConfig` override if `super.saveConfig` is not called.
+     */
+    protected set config(newConfig: Dock3Config);
+    /**
+     * Updates the configuration of the Dock3Provider.
+     * This method updates the configuration, notifies the dock about the change and saves the new configuration to storage (via `saveConfig`).
+     * @param newConfig The new configuration to be applied.
+     */
+    updateConfig(config: Dock3Config): Promise<void>;
+    /**
+     * Shuts down the Dock3Provider and closes the dock window.
+     * This method sends a shutdown message to the dock and then closes the window.
+     */
+    shutdown(): Promise<void>;
+    /**
+     * Called whenever the configuration is updated, this method saves the configuration to the storage.
+     * This should not be called directly, if you need to update the configuration, use `updateConfig` method instead.
+     */
+    saveConfig({ config }: {
+        config: Dock3Config;
+    }): Promise<void>;
+    private handleConfigChange;
+    /**
+     * Called on startup to load the current configuration of the Dock3Provider.
+     * If you've overridden the `saveConfig` method, this should load the configuration from your storage.
+     * By default it will load the configuration from local storage. This can  be overriden to prevent loading from local storage.
+     * @example Prevent loading from local storage:
+     * ```typescript
+     * class MyDock3Provider extends Dock3Provider {
+     *    async loadConfig(): Promise<Dock3Config> {
+     *       // Do not load from local storage, return the default config
+     *       return this.config;
+     *   }
+     *  }
+     * ```
+     * @example Load from a custom storage:
+     * ```typescript
+     * class MyDock3Provider extends Dock3Provider {
+     *   async loadConfig(): Promise<Dock3Config> {
+     *      // Load from a custom storage
+     *      const configFromStorage = await myCustomStorage.getDockConfig();
+     *      // Update local config to ensure it is used.
+     *      if (configFromStorage) {
+     *         this.config = configFromStorage;
+     *      }
+     *      return this.config;
+     *   }
+     * }
+     * ```
+     * @returns The current configuration of the Dock3Provider.
+     */
+    loadConfig(): Promise<Dock3Config>;
+    getWindowSync(): OpenFin.Window;
+    private registerChannelActions;
+}
+export type Dock3ConstructorOverride = (Base: new () => Dock3Provider) => new () => Dock3Provider;
+export {};

package/dock3/src/shapes/enterprise.d.ts

@@ -0,0 +1,22 @@
+import { Point } from '../../../common/src/utils/window';
+import { Dock3Button, Dock3Config } from './shapes';
+export type { EnterpriseDockChannelClient, EnterpriseDockChannelProvider } from '../api/protocol';
+/**
+ * @internal
+ */
+export type DockCompanionButton = Exclude<Dock3Button, 'store'> | 'bookmarks' | 'searchShortcut';
+/**
+ * @internal
+ */
+export type CompanionDockConfig = Omit<Dock3Config, 'defaultDockButtons'> & {
+    /**
+     * Companion dock window position
+     */
+    dockPosition?: Point;
+    /**
+     * Base URL for the companion dock
+     */
+    baseUrl?: string;
+    defaultDockButtons?: DockCompanionButton[];
+    windowType?: 'enterprise';
+};

package/dock3/src/shapes/index.d.ts

@@ -0,0 +1,2 @@
+export * from './shapes';
+export * from './enterprise';

package/dock3/src/shapes/shapes.d.ts

@@ -0,0 +1,63 @@
+import type { OpenFin } from '@openfin/core';
+import { WorkspaceButton } from '../../../client-api/src/dock';
+import { ContentMenuEntry, DockEntry, TaskbarIcon } from '../../../client-api-platform/src/shapes';
+export type { Dock3Provider, Dock3ConstructorOverride } from '../api/provider';
+export type Dock3Button = WorkspaceButton | 'contentMenu';
+/**
+ * Configuration for the Dock 3.0 provider.
+ */
+export interface Dock3Config {
+    title?: string;
+    /**
+     * icon URL for the dock provider.
+     */
+    icon?: string | TaskbarIcon;
+    /**
+     * Favorites to be displayed in the dock
+     */
+    favorites?: DockEntry[];
+    /**
+     * Content menu entries to be displayed in the dock
+     */
+    contentMenu?: ContentMenuEntry[];
+    /**
+     * The config for the default dock buttons
+     */
+    defaultDockButtons?: Dock3Button[];
+    /**
+     * The id of the target element for the content menu.
+     */
+    contentMenuTargetId?: string;
+    /**
+     * The config for the companion dock ui
+     */
+    uiConfig?: {
+        contentMenu?: {
+            enableBookmarking?: boolean;
+        };
+        /**
+         * By default drag handle is visible. Set this to true to hide the drag handle
+         */
+        hideDragHandle?: boolean;
+        /**
+         * By default provider icon is just a drag region. Set this to true to convert it to content menu dropdown button.
+         */
+        providerIconContentMenu?: boolean;
+        /**
+         * Configuration for the dock more menu component.
+         */
+        moreMenu?: {
+            quitPlatform?: {
+                /**
+                 * By default the quit button will contain platform title in its label. Set this to true to hide the platform title.
+                 */
+                hidePlatformTitle?: boolean;
+                /**
+                 * By default the quit button will show a quit confirmation dialog. Set this to true to skip the quit confirmation dialog.
+                 */
+                skipDialog?: boolean;
+            };
+        };
+    };
+}
+export type DockAllowedWindowOptions = Partial<Pick<OpenFin.PlatformWindowOptions, 'defaultCentered' | 'saveWindowState' | 'taskbarIconGroup' | 'defaultTop' | 'defaultLeft'>>;

package/dock3/src/utils.d.ts

@@ -0,0 +1,2 @@
+export type CamelCase<T extends string> = T extends `${infer Head}-${infer Tail}` ? `${Head}${Capitalize<CamelCase<Tail>>}` : T;
+export type Async<T extends (...args: any[]) => any> = T extends (...args: infer P) => infer R ? (...args: P) => Promise<Awaited<R>> : never;

package/externals.report.json

@@ -58,6 +58,12 @@
         }
     ],
     "dexie": [
+        {
+            "type": "root-implicit",
+            "version": "^4.0.11",
+            "packageName": "dock3/package.json",
+            "issuer": "dock3/src/api/idb.ts"
+        },
         {
             "type": "explicit",
             "version": "^4.0.11",