@openfin/workspace-platform 1.0.0 → 4.4.0

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

@@ -0,0 +1,47 @@
+/// <reference types="openfin-adapter/fin" />
+/**
+ * All of the remote procedures that can be called in the
+ * a Workspace Platform's address space.
+ *
+ * When adding a new channel action make sure to add a function that's name matches
+ * the value of the enum for the remote procedure in the Workspace Platform overrides.
+ * All of the registered channel action handlers can be found here in the platform's overrides:
+ * @see link: [Provider Protocol Handlers](https://github.com/openfin/workspace/client-api-platform/src/init/override-callback.ts)
+ */
+export declare enum ChannelAction {
+    LaunchApp = "launchApp",
+    SavePage = "savePage",
+    GetSavedPage = "getSavedPage",
+    CreateSavedPage = "createSavedPage",
+    UpdateSavedPage = "updateSavedPage",
+    DeleteSavedPage = "deleteSavedPage",
+    GetSavedPages = "getSavedPages",
+    CreateSavedPageInternal = "createSavedPageInternal",
+    UpdateSavedPageInternal = "updateSavedPageInternal",
+    DeleteSavedPageInternal = "deleteSavedPageInternal",
+    SharePage = "sharePage",
+    LaunchPage = "launchPage",
+    UpdatePageForWindow = "updatePageForWindow",
+    AttachPagesToWindow = "attachPagesToWindow",
+    DetachPagesFromWindow = "detachPagesFromWindow",
+    ReorderPagesForWindow = "reorderPagesForWindow",
+    SetActivePageForWindow = "setActivePageForWindow",
+    GetOpenPages = "getOpenPages",
+    GetActivePageIdForWindow = "getActivePageIdForWindow",
+    GetPagesForWindow = "getPagesForWindow",
+    GetPageForWindow = "getPageForWindow",
+    GetSavedPageMetadata = "getSavedPageMetadata",
+    GetUniquePageTitle = "getUniquePageTitle",
+    GetLastFocusedBrowserWindow = "getLastFocusedBrowserWindow"
+}
+/**
+ * Get a channel client for a specific Workspace platform.
+ *
+ * The channel client can execute remote procedures on the platform via its `dispatch` function.
+ * A call to the `dispatch` function will block until the channel action has concluded execution
+ * in the Workspace platform's address space.
+ * For a list of supported procedures, see the `ChannelAction` enum.
+ *
+ * @returns the channel client for the Workspace platform.
+ */
+export declare const getChannelClient: (identity: OpenFin.Identity) => Promise<import("openfin-adapter").ChannelClient>;

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

@@ -0,0 +1,10 @@
+import { Page } from '@common/api/pages/shapes';
+import type { CreateSavedPageRequest, UpdateSavedPageRequest } from '../shapes';
+export declare const getStorageApi: (identity: any) => {
+    createPage: (req: CreateSavedPageRequest) => Promise<any>;
+    deletePage: (id: string) => Promise<any>;
+    updatePage: (req: UpdateSavedPageRequest) => Promise<any>;
+    getPage: (id: string) => Promise<any>;
+    getPages: (query?: string) => Promise<Page[]>;
+    savePage: (page: Page) => Promise<any>;
+};

package/client-api-platform/src/api/workspace-module.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="openfin-adapter/fin" />
+import type { WorkspacePlatformModule } from '../shapes';
+export declare const getWorkspacePlatformModule: (identity: OpenFin.Identity) => WorkspacePlatformModule;

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

@@ -0,0 +1,6 @@
+/// <reference types="openfin-adapter/fin" />
+import type { WorkspacePlatformInitConfig, WorkspacePlatformModule } from './shapes';
+export * from './shapes';
+export declare const init: (options: WorkspacePlatformInitConfig) => Promise<void>;
+export declare const wrapSync: (identity: OpenFin.Identity) => WorkspacePlatformModule;
+export declare const getCurrentSync: () => WorkspacePlatformModule;

package/client-api-platform/src/init/browser-window-focus.d.ts

@@ -0,0 +1,19 @@
+/// <reference types="openfin-adapter/fin" />
+/**
+ * Get the last focused browser window.
+ * @returns the last focused browser window.
+ */
+export declare function getLastFocusedBrowserWindow(): Promise<OpenFin.Identity>;
+/**
+ * Set the OpenFin identity of the last focused browser window.
+ */
+export declare function setLastFocusedBrowserWindow(identity?: OpenFin.Identity): void;
+/**
+ * Listen for a browser window to be focused.
+ * When a browser window is focused, store it in local storage as the last focused browser window.
+ */
+export declare function listenForBrowserWindowFocus(): Promise<void>;
+/**
+ * Stop listening for a browser window to be focused.
+ */
+export declare function removeBrowserWindowFocusListener(): Promise<void>;

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

@@ -0,0 +1 @@
+export default function registerViewCleanUp(): void;

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

@@ -0,0 +1,5 @@
+import { BrowserInitConfig } from '../shapes';
+/**
+ * Initializing the Workspace Platform.
+ */
+export default function init(options: BrowserInitConfig): Promise<void>;

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

@@ -0,0 +1,3 @@
+/// <reference types="openfin-adapter/fin" />
+import type { BrowserInitConfig } from '@client-platform/shapes';
+export declare const getOverrideCallback: (initOptions: BrowserInitConfig) => OpenFin.OverrideCallback<OpenFin.PlatformProvider>;

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

@@ -0,0 +1,39 @@
+/// <reference types="openfin-adapter/fin" />
+export declare function overrideViewOptions(options: Partial<OpenFin.ViewOptions>): void;
+export declare const filterSnapshotWindows: (win: OpenFin.WindowOptions) => boolean;
+/**
+ * fitToMonitor()
+ * Function to determine if window size is too large
+ * for available rectangle area.
+ *
+ * - Checks monitor data for available rectangle coords
+ * - Defines max width/height for current monitor
+ * - Defines default width/height if property is not set
+ * - Updates options object default width/height if they exceed max values
+ *
+ * Ticket: WRK-1084
+ *
+ * @param options - Object passed into createWindow -> contains height and width
+ * @returns unprocessed or processed options object
+ */
+export declare const fitToMonitor: (options: any) => Promise<any>;
+declare type LegacyWindowOptions = Omit<OpenFin.PlatformWindowCreationOptions, 'workspacePlatform'> & {
+    pages?: OpenFin.Page[];
+    workstacks?: OpenFin.Page[];
+};
+export declare const initWorkspacePlatformOptions: (options: LegacyWindowOptions | OpenFin.PlatformWindowCreationOptions) => OpenFin.PlatformWindowCreationOptions;
+/**
+ * hasLayout()
+ * Function to force layout settings
+ * - Check if layout property exists if so process data, else return as is
+ * - Define behavior settings
+ * - Force dimension options
+ * - Validate icon
+ *
+ * Ticket: WRK-???
+ *
+ * @param options - options used to handle layout settings
+ * @returns processed or unprocesseed options
+ */
+export declare const applyBrowserDefaults: (options: OpenFin.PlatformWindowCreationOptions) => OpenFin.PlatformWindowCreationOptions;
+export {};

package/{src/shapes.ts → client-api-platform/src/shapes.d.ts}

@@ -1,40 +1,30 @@
+/// <reference types="openfin-adapter/fin" />
 import type { InteropBroker } from 'openfin-adapter/src/api/interop';
-
 import type { App } from '../../client-api/src/shapes';
 import type { AttachedPage, Page, PageWithUpdatableRuntimeAttribs } from '../../common/src/api/pages/shapes';
-
 export type { App, Image, AppIntent } from '../../client-api/src/shapes';
 export { AppManifestType } from '../../client-api/src/shapes';
-
 export interface CreateSavedPageRequest {
     page: Page;
 }
-
 export interface UpdateSavedPageRequest {
     /** The ID of the page to update. */
     pageId: string;
-
     /** The updated page. */
     page: Page;
 }
-
 export interface ReorderPagesRequest {
     /** The ordered ids of the attached pages. */
     pageIds: string[];
 }
-
 export interface UpdateOpenPageRequest {
     /** The ID of the page to update. */
     pageId: string;
-
     /** The updated page. */
     page: Partial<PageWithUpdatableRuntimeAttribs>;
 }
-
 export type { Page, PageLayout, PageLayoutDetails } from '../../common/src/api/pages/shapes';
-
-export type BrowserCreateWindowRequestInternal = BrowserCreateWindowRequest & OpenFin.WindowCreationOptions;
-
+export declare type BrowserCreateWindowRequestInternal = BrowserCreateWindowRequest & OpenFin.WindowCreationOptions;
 export interface BrowserCreateWindowRequest extends Omit<OpenFin.PlatformWindowCreationOptions, 'workspacePlatform'> {
     workspacePlatform: {
         pages: Page[];
@@ -44,7 +34,6 @@ export interface BrowserCreateWindowRequest extends Omit<OpenFin.PlatformWindowC
         newPageUrl?: string;
     };
 }
-
 export interface BrowserWindowModule {
     identity: OpenFin.Identity;
     openfinWindow: OpenFin.Window;
@@ -53,9 +42,7 @@ export interface BrowserWindowModule {
      * Return all the pages that are attached to a browser window.
      */
     getPages(): Promise<AttachedPage[]>;
-
     setActivePage(id: string): Promise<void>;
-
     /**
      * Attach a page to a browser window.
      * If a page with same id or title is attached to an existing browser window, an error will be thrown.
@@ -67,7 +54,6 @@ export interface BrowserWindowModule {
     updatePage(req: UpdateOpenPageRequest): Promise<void>;
     reorderPages(req: ReorderPagesRequest): Promise<void>;
 }
-
 export interface BrowserWindowFactory {
     /**
      * Synchronously returns a Browser Window object that represents an existing window
@@ -84,26 +70,22 @@ export interface BrowserWindowFactory {
      *
      */
     getAllWindows(): Promise<BrowserWindowModule[]>;
-    // Overrideable execution APIs - WILL BE PART OF OVERRIDECALLBACK - TOP LEVEL, NOT NESTED
     /**
      * Create a new browser window.
      *
      * @param options the browser window creation options
      */
     createWindow: (options: BrowserCreateWindowRequest) => Promise<BrowserWindowModule>;
-
     /**
      * Get a unique title for a page.
      * @param title a prefix for the title.
      */
     getUniquePageTitle(title?: string): Promise<string>;
-
     /**
      * Get the identity of the last focused Browser window.
      */
     getLastFocusedWindow(): Promise<OpenFin.Identity>;
 }
-
 export interface WorkspacePlatformStorage {
     getPages(): Promise<Page[]>;
     getPage(id: string): Promise<Page>;
@@ -112,12 +94,10 @@ export interface WorkspacePlatformStorage {
     deletePage(id: string): Promise<void>;
     savePage(page: Page): Promise<void>;
 }
-
 export interface LaunchAppPayload {
     target?: OpenFin.EntityInfo;
     app: App;
 }
-
 export interface WorkspacePlatformModule extends OpenFin.Platform {
     /**
      * Launch a browser snapshot that contains windows with pages.
@@ -125,28 +105,21 @@ export interface WorkspacePlatformModule extends OpenFin.Platform {
      * @param snapshot the browser snapshot to launch or a url or filepath to retrieve a JSON snapshot.
      */
     applySnapshot(snapshot: BrowserSnapshot | string): Promise<OpenFin.Platform>;
-
     getSnapshot(): Promise<BrowserSnapshot>;
-
     launchApp: (payload: LaunchAppPayload) => Promise<void>;
-
     Browser: BrowserWindowFactory;
-
     Storage: WorkspacePlatformStorage;
 }
-
 export interface BrowserSnapshot {
     windows: BrowserCreateWindowRequestInternal[];
 }
 export interface WorkspacePlatformProvider extends OpenFin.PlatformProvider {
-    // Storage Overrides
     getSavedPages(query?: string): Promise<Page[]>;
     getSavedPage(id: string): Promise<Page>;
     createSavedPage(req: CreateSavedPageRequest): Promise<void>;
     updateSavedPage(req: UpdateSavedPageRequest): Promise<void>;
     deleteSavedPage(id: string): Promise<void>;
 }
-
 export interface WorkspacePlatformInitConfig {
     browser: BrowserInitConfig;
     licenseKey: string;

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

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

package/common/src/api/pages/attached.d.ts

@@ -0,0 +1,101 @@
+/// <reference types="openfin-adapter/fin" />
+import type { AttachedPage, AttachPagesToWindowPayload, DetachPagesFromWindowPayload, ReorderPagesForWindowPayload, SetActivePageForWindowPayload, UpdatePageForWindowPayload } from './shapes';
+/**
+ * All of the remote procedures that can be called in the
+ * platform window's address space regarding attached pages.
+ */
+export declare enum ChannelAction {
+    GetPages = "get-pages",
+    GetActivePageForWindow = "get-active-page-for-window",
+    AttachPagesToWindow = "attach-pages-to-window",
+    DetachPagesFromWindow = "detach-pages-from-window",
+    SetActivePageForWindow = "set-active-page-for-window",
+    RenamePage = "rename-page",
+    ReorderPagesForWindow = "reorder-pages-for-window",
+    UpdatePageForWindow = "update-page-for-window",
+    UpdatePagesWindowOptions = "update-pages-window-options",
+    IsDetachingPages = "is-detaching-pages",
+    IsActivePageChanging = "is-active-page-changing"
+}
+export declare enum EventType {
+    AttachedPagesToWindow = "attached-pages-to-window",
+    DetachedPagesFromWindow = "detached-pages-from-window"
+}
+export declare const getWindowChannelId: (identity: OpenFin.Identity) => string;
+export declare const getEventEmitter: (identity: OpenFin.Identity) => {
+    emit: (event: string | number, ...payload: any[]) => Promise<void>;
+    addListener: (event: string | number, listener: import("@common/utils/shared-emitter").Listener) => void;
+    removeListener: (event: string | number, listener: import("@common/utils/shared-emitter").Listener) => void;
+    once: (event: string | number, listener: import("@common/utils/shared-emitter").Listener) => void;
+};
+/**
+ * Get the pages attached to a window.
+ * @param identity the identity of the window to get the attached pages of.
+ * @returns the pages attached to the window.
+ */
+export declare const getPages: (identity: OpenFin.Identity) => Promise<AttachedPage[]>;
+/**
+ * Get the active attached page for the specified window.
+ * @param identity the window identity to get the active attached page of.
+ * @returns the active attached page for the window.
+ */
+export declare const getActivePageForWindow: (identity: OpenFin.Identity) => Promise<AttachedPage>;
+/**
+ * Set the active attached page for the specified window.
+ * @param identity the window identity to set the active attached page of.
+ */
+export declare const setActivePageForWindow: (payload: SetActivePageForWindowPayload) => Promise<void>;
+/**
+ * Attach a page to an open window.
+ * If the page is already attached to a window, an error will be thrown.
+ *
+ * @param payload the attach pages to window payload.
+ */
+export declare const attachPagesToWindow: (payload: AttachPagesToWindowPayload) => Promise<void>;
+/**
+ * Detach pages from the window they are currently attached to.
+ * A detached page will not have its views cleaned up.
+ *
+ * @param payload the detach pages from window payload.
+ */
+export declare const detachPagesFromWindow: (payload: DetachPagesFromWindowPayload) => Promise<void>;
+export interface RenamePagePayload {
+    /** The OF window identity the page is attached to. */
+    identity: OpenFin.Identity;
+    /** The id of the page to change the name of. */
+    pageId: string;
+    /** The new title of the page. */
+    newTitle: string;
+}
+/**
+ * Rename an attached page.
+ * The page must be attached to the specified window.
+ *
+ * @param page the page to rename.
+ */
+export declare const renamePage: (payload: RenamePagePayload) => Promise<void>;
+/**
+ * Reorder pages attached to an open window.
+ * @param payload the reorder pages for window payload.
+ */
+export declare const reorderPagesForWindow: (payload: ReorderPagesForWindowPayload) => Promise<void>;
+/**
+ * Update a page attached to a window.
+ * @param payload the update page for window payload.
+ */
+export declare const updatePageForWindow: (payload: UpdatePageForWindowPayload) => Promise<void>;
+/**
+ * Forces a window to save its attached page state to window options.
+ * @param identity the identity of the window to save the pages of in window options.
+ */
+export declare const updatePagesWindowOptions: (identity: OpenFin.Identity) => Promise<void>;
+/**
+ * Check if the window identity is currently detaching pages.
+ * @param identity the OF window identity to check.
+ */
+export declare const isDetachingPages: (identity: OpenFin.Identity) => Promise<boolean>;
+/**
+ * Check if the window identity is in the middle of changing active pages.
+ * @param identity the OF window identity to check.
+ */
+export declare const isActivePageChanging: (identity: OpenFin.Identity) => Promise<boolean>;

package/common/src/api/pages/idb.d.ts

@@ -0,0 +1,12 @@
+import type { Page } from '@common/api/pages/shapes';
+export declare const store: import("idb-keyval").UseStore;
+export declare function getPage(id: string): Promise<Page>;
+export declare function getPageList(filter?: string): Promise<Page[]>;
+export declare function createPage({ page }: {
+    page: any;
+}): Promise<void>;
+export declare function deletePage(id: string): Promise<void>;
+export declare function updatePage({ pageId, page }: {
+    pageId: any;
+    page: any;
+}): Promise<boolean>;

package/common/src/api/pages/index.d.ts

@@ -0,0 +1,16 @@
+import { LayoutExtended } from '@common/utils/layout';
+import type { AttachedPage, Page, PageLayout, PageWithUpdatableRuntimeAttribs } from './shapes';
+export declare function getLegacyPages(): Promise<Page[]>;
+export declare function cleanPage(page: AttachedPage): Page;
+/**
+ * Get a page layout.
+ * @param layout the layout to add details to.
+ * @returns the layout with extra details.
+ */
+export declare const getPageLayout: (layout: any) => Promise<PageLayout>;
+/**
+ * Generates a Page object which represents a page.
+ * @param title the title for the page.
+ * @param layout the layout for the page.
+ */
+export declare const makePage: (title: string, layout: LayoutExtended) => Promise<PageWithUpdatableRuntimeAttribs>;

package/common/src/api/pages/legacy.d.ts

@@ -0,0 +1,16 @@
+import type { AttachedPage, PageLayout } from '@common/api/pages/shapes';
+interface Workstack {
+    id: string;
+    name: string;
+    isReadOnly: boolean;
+    layout: PageLayout;
+    isActive: boolean;
+}
+export declare function convertWorkstackToAttachedPage(workstack: Workstack & AttachedPage): AttachedPage;
+/**
+ * Attempts to fix any misconfigurations in a list of attached pages.
+ * @param pages the pages to fix.
+ * @returns the fixed pages.
+ */
+export declare const fixAttachedPages: (pages: AttachedPage[]) => AttachedPage[];
+export {};

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

@@ -0,0 +1,77 @@
+/// <reference types="openfin-adapter/fin" />
+import type { LayoutExtended } from '../../utils/layout';
+export interface PageLayoutDetails {
+    /** The id of the machine that created the page. */
+    machineId: string;
+    /** The name of the machine that created the page. */
+    machineName?: string;
+}
+export declare type PageLayout = LayoutExtended & {
+    layoutDetails?: PageLayoutDetails;
+};
+export interface Page {
+    /** A UI friendly title for the page. */
+    title: string;
+    /** The unique ID of the page. */
+    pageId: string;
+    /** An optional UI friendly description of the page. */
+    description?: string;
+    /** A optional UI friendly tooltip for the page. */
+    tooltip?: string;
+    /** True if the page is read only. In this state, the page is locked and cannot be unlocked. */
+    isReadOnly?: boolean;
+    /** The layout of the page. */
+    layout: PageLayout;
+}
+declare type AttachedPageMetadata = {
+    /** The window the page is currently attached to. */
+    parentIdentity?: OpenFin.Identity;
+    /** True if the page is the currently active page for its parent window. */
+    isActive?: boolean;
+    /** True if the page has unsaved changes. */
+    hasUnsavedChanges?: boolean;
+};
+export declare type AttachedPage = Page & AttachedPageMetadata;
+export declare type PageWithUpdatableRuntimeAttribs = Page & Pick<AttachedPage, 'hasUnsavedChanges'>;
+export interface DetachPagesFromWindowPayload {
+    /** The OF window identity to detach the pages from. */
+    identity: OpenFin.Identity;
+    /** The ids of the pages to detach. */
+    pageIds: string[];
+}
+export interface SetActivePageForWindowPayload {
+    /** The OF window identity to set the active page of. */
+    identity: OpenFin.Identity;
+    /**
+     * The id of the page to set as active.
+     * The page must be attached to the target window.
+     */
+    pageId: string;
+}
+export interface ReorderPagesForWindowPayload {
+    /** The OF window identity the pages to change the order of. */
+    identity: OpenFin.Identity;
+    /** The ordered ids of the attached pages. */
+    pageIds: string[];
+}
+export interface UpdatePageForWindowPayload {
+    /** The OF window identity the pages to change the order of. */
+    identity: OpenFin.Identity;
+    /** The id of the attached page to update. */
+    pageId: string;
+    /** The partial updated state of the page. */
+    page: Partial<PageWithUpdatableRuntimeAttribs>;
+}
+export interface AttachPagesToWindowPayload {
+    /** The OF window identity to attach the pages to. */
+    identity: OpenFin.Identity;
+    /** The pages to attach. */
+    pages: PageWithUpdatableRuntimeAttribs[];
+}
+export interface GetSavedPageMetadataPayload {
+    /** The OF window identity to attach the pages to. */
+    identity: OpenFin.Identity;
+    /** The id of the page to get the save state of. */
+    pageId: string;
+}
+export {};

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

@@ -0,0 +1,63 @@
+/// <reference types="openfin-adapter/fin" />
+/** The name of the channel for the centralized workspace protocol. */
+export declare const channelName = "__of_workspace_protocol__";
+/**
+ * All of the remote procedures that can be called in the
+ * Workspace Provider's address space.
+ *
+ * When adding a new channel action make sure to register a
+ * handler for the remote procedure in the Workspace Provider.
+ * All of the registered channel action handlers can be found here:
+ * @see link: [Provider Protocol Handlers](https://github.com/openfin/workspace/provider/src/api/protocol.ts)
+ */
+export declare enum ChannelAction {
+    RegisterStorefrontProvider = "register-storefront-provider",
+    DeregisterStorefrontProvider = "deregister-storefront-provider",
+    GetStorefrontProviders = "get-storefront-providers",
+    HideStorefront = "hide-storefront",
+    GetStorefrontProviderApps = "get-storefront-provider-apps",
+    GetStorefrontProviderLandingPage = "get-storefront-provider-landing-page",
+    GetStorefrontProviderFooter = "get-storefront-provider-footer",
+    GetStorefrontProviderNavigation = "get-storefront-provider-navigation",
+    LaunchStorefrontProviderApp = "launch-storefront-provider-app",
+    ShowStorefront = "show-storefront",
+    CreateStorefrontWindow = "create-storefront-window",
+    ShowHome = "show-home",
+    HideHome = "hide-home",
+    AssignHomeSearchContext = "assign-home-search-context",
+    GetLegacyPages = "get-legacy-pages",
+    GetLegacyWorkspaces = "get-legacy-workspaces"
+}
+export interface ChannelClient extends OpenFin.ChannelClient {
+    dispatch: (action: ChannelAction, payload: any) => Promise<any>;
+}
+/**
+ * Get a channel client for the centralized Workspace protocol.
+ *
+ * The channel client is automatically connected to the Workspace Provider,
+ * in which acts as a centralized location for executing Workspace API logic.
+ *
+ * The channel client can execute remote procedures on the provider via its `dispatch` function.
+ * A call to the `dispatch` function will block until the channel action has concluded execution
+ * in the Workspace Provider's address space.
+ * For a list of supported procedures, see the `ChannelAction` enum.
+ *
+ * @returns the channel client for the centralized workspace protocol.
+ */
+export declare const getChannelClient: () => Promise<ChannelClient>;
+/**
+ * Returns true if the current application was launched via a library (such as the Client APIs).
+ * Otherwise, returns false.
+ */
+export declare const isLaunchedViaLib: () => Promise<boolean>;
+/**
+ * Launches the Workspace Provider.
+ * If the Workspace Provider is already running, does nothing.
+ */
+export declare const launchProvider: () => Promise<void>;
+/**
+ * Launches the Workspace provider if it is not running.
+ * 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 getChannelClientAndLaunchProvider: () => Promise<ChannelClient>;

package/common/src/api/workspaces/index.d.ts

@@ -0,0 +1,7 @@
+/// <reference types="openfin-adapter/fin" />
+export interface Workspace {
+    workspaceId: string;
+    title: string;
+    snapshot: OpenFin.Snapshot;
+}
+export declare const getLegacyWorkspaces: () => Promise<Workspace[]>;

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

@@ -0,0 +1,38 @@
+/// <reference types="openfin-adapter/fin" />
+export declare enum ApplicationUUID {
+    /**
+     * The UUID of workspace.
+     * Home is a part of this application.
+     */
+    Workspace = "openfin-browser"
+}
+export interface ApplicationEvent {
+    viewIdentity?: OpenFin.Identity;
+    name?: string;
+    uuid?: string;
+}
+export declare type ApplicationListener = (ev: ApplicationEvent) => void;
+export declare enum ApplicationEventType {
+    RunRequested = "run-requested",
+    WindowOptionsChanged = "window-options-changed",
+    WindowClosed = "window-closed",
+    WindowCreated = "window-created"
+}
+export declare enum LaunchModeType {
+    FinProtocol = "fin-protocol"
+}
+export declare type ApplicationInfoExtended = OpenFin.ApplicationInfo & {
+    initialOptions: OpenFin.ApplicationInfo['initialOptions'] & {
+        userAppConfigArgs: any;
+    };
+};
+export declare const currentOFAppIdentity: {
+    uuid: string;
+    name: string;
+};
+export declare const workspaceOFAppIdentity: {
+    name: ApplicationUUID;
+    uuid: ApplicationUUID;
+};
+export declare const getCurrentOFApplication: () => import("openfin-adapter").Application;
+export declare const getWorkspaceOFApplication: () => import("openfin-adapter").Application;

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

@@ -0,0 +1,8 @@
+/**
+ * Make a function that connects to a channel.
+ * If already connected to the channel, will return the channel connection.
+ * If disconnected from the channel, will automatically reconnect.
+ * @param channelName the name of the channel to connect to.
+ * @returns the function to connect to the channel.
+ */
+export default function makeGetChannelClient(channelName: string): () => Promise<import("openfin-adapter").ChannelClient>;

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

@@ -0,0 +1,16 @@
+declare const makeDebouncedFunc: <T extends (...args: any[]) => Promise<any>>(func: T, debounceTimeout?: number) => T;
+/**
+ * Debounce a specified function.
+ *
+ * When the debounced function is called, the underlying wrapped function
+ * will be called.
+ *
+ * If the function is called again while the promise returned by the wrapped
+ * function is still resolving, the call will be blocked until the promise has
+ * resolved.
+ *
+ * Once the promise has been resolved, the wrapped function will be called again
+ * after a specified debounce timeout.
+ *
+ */
+export default makeDebouncedFunc;