@openfin/workspace 3.0.0 → 4.4.0

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/search.d.ts

@@ -0,0 +1,17 @@
+import { searchTopic as homeSearchTopic } from '@common/api/home';
+import type { CLISearchResultWithTemplate } from '@client/shapes';
+import type { Action as BaseAction, SearchProviderInfo, SearchProviderResponse, SearchTopicClient } from '@search/shapes';
+export interface Action extends BaseAction {
+    isHidden: boolean;
+    dispatch: () => any;
+}
+export interface SearchItem {
+    providerInfo: SearchProviderInfo;
+    result: CLISearchResultWithTemplate<any, any, Action>;
+    actions: Action[];
+    key: string;
+}
+export declare type Topic = typeof homeSearchTopic;
+export declare function waitForSearchRegistration(): Promise<void>;
+export declare function getTopic(topic: Topic): Promise<SearchTopicClient>;
+export declare function mapSearchResponsesToItems(topic: Topic, responses: SearchProviderResponse[]): SearchItem[];

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

@@ -0,0 +1,72 @@
+/// <reference types="openfin-adapter/fin" />
+import { App, StorefrontFooter, StorefrontLandingPage, StorefrontNavigationItemAppGrid, StorefrontNavigationSection, StorefrontProviderInfo } from '@client/shapes';
+export interface StorefrontProviderInfoWithIdentity extends StorefrontProviderInfo {
+    platformIdentity: OpenFin.Identity;
+}
+export interface LaunchStorefrontAppRequest {
+    app: App;
+    platformIdentity?: OpenFin.Identity;
+}
+export interface StorefrontProviderIdentity {
+    /**
+     * The ID of the Storefront Provider.
+     */
+    id: string;
+    /**
+     * The platform identity that registered the Storefront Provider.
+     */
+    platformIdentity: OpenFin.Identity;
+}
+export interface LaunchStorefrontProviderAppRequest extends StorefrontProviderIdentity {
+    app: App;
+}
+/**
+ * Launch a Storefront app.
+ * @param platformIdentity the identity of the platform that provided the app.
+ */
+export declare const launchStorefrontApp: (req: LaunchStorefrontProviderAppRequest) => Promise<void>;
+/**
+ * Get a list of applications for Storefront.
+ * @param platformIdentity the identity of the platform to get the apps from.
+ * @returns the list of Storefront apps for the platform.
+ */
+export declare const getStorefrontApps: (identity: StorefrontProviderIdentity) => Promise<App[]>;
+/**
+ * Get a list of all providers that have registered with the Storefront API.
+ */
+export declare const getStorefrontProviders: () => Promise<StorefrontProviderInfoWithIdentity[]>;
+export declare const showStorefront: () => Promise<any>;
+/**
+ * Get the platform's landing page for Storefront.
+ * @param platformIdentity the identity of the platform to get the landing page of.
+ * @returns the platform's landing page.
+ */
+export declare const getStorefrontLandingPage: (identity: StorefrontProviderIdentity) => Promise<StorefrontLandingPage | undefined>;
+/**
+ * Get the platform's footer for Storefront.
+ * @param platformIdentity the identity of the platform to get the footer of.
+ * @returns the platform's footer.
+ */
+export declare const getStorefrontFooter: (identity: StorefrontProviderIdentity) => Promise<StorefrontFooter>;
+/**
+ * Get the platform's navigation for Storefront.
+ * @param platformIdentity the identity of the platform to get the navigation of.
+ * @returns the platform's navigation.
+ */
+export declare const getStorefrontNavigation: (identity: StorefrontProviderIdentity) => Promise<[StorefrontNavigationSection?, StorefrontNavigationSection?]>;
+/**
+ * A helper method that gets a Storefront navigation item by ID.
+ * @param navigationItemId the id of the Storefront navigation item.
+ * @param platformIdentity the platform identity.
+ * @returns the navigation item with the ID.
+ */
+export declare const getStorefrontNavigationItemAppGrid: (navigationItemId: string, identity: StorefrontProviderIdentity) => Promise<StorefrontNavigationItemAppGrid | undefined>;
+/**
+ * A function to dispatch hiding the Storefront of current OF identity
+ * @returns action to hide Storefront
+ */
+export declare const hideStorefront: () => Promise<void>;
+/**
+ * Create the Storefront main window.
+ */
+export declare function createStorefrontWindow(): Promise<any>;

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/env.d.ts

@@ -0,0 +1,30 @@
+export declare enum Env {
+    Local = "local",
+    Dev = "dev",
+    Staging = "staging",
+    Prod = "prod"
+}
+export declare const isFin: boolean;
+export declare const isJest: boolean;
+export declare const isWindowDefined: boolean;
+export declare const isDocumentDefined: boolean;
+export declare const isWindowDefinedWithIndexDB: boolean;
+export declare const finUUID: string;
+export declare const finName: string;
+export declare const finEntityType: "" | import("openfin-adapter/src/shapes/EntityType").EntityType;
+export declare const env: Env;
+export declare const isEnvLocal: boolean;
+export declare const isEnvDev: boolean;
+export declare const isEnvStaging: boolean;
+export declare const isEnvProd: boolean;
+export declare const isLibrary: boolean;
+export declare const workspaceProviderFinsLink: string;
+export declare const workspaceProviderFallbackUrl: string;
+export declare const workspaceAppsUrl: string;
+export declare const workspaceStorefrontFooterUrl: string;
+export declare const workspaceStorefrontLandingPageUrl: string;
+export declare const workspaceStorefrontNavigationUrl: string;
+export declare const workspaceShareUrl: string;
+export declare const workspaceCdnUrl: string;
+export declare const workspaceCdnEnvUrl: string;
+export declare const workspaceRuntimeVersion: string;

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

@@ -0,0 +1,52 @@
+/// <reference types="openfin-adapter/fin" />
+export declare type LayoutComponentStateExtended = OpenFin.LayoutComponent['componentState'] & {
+    name: string;
+    uuid: string;
+};
+export declare type LayoutComponentExtended = Omit<OpenFin.LayoutComponent, 'componentState'> & {
+    componentState: LayoutComponentStateExtended;
+};
+export declare type LayoutStack = {
+    type: 'stack';
+    content: OpenFin.LayoutContent;
+};
+export declare type LayoutContentItemExtended = OpenFin.LayoutRow | OpenFin.LayoutColumn | LayoutComponentExtended | LayoutStack;
+export declare type LayoutContentExtended = LayoutContentItemExtended[];
+export declare type LayoutSettingsExtended = OpenFin.LayoutOptions['settings'] & {
+    reorderEnabled?: boolean;
+};
+export declare type LayoutExtended = {
+    settings?: LayoutSettingsExtended;
+    content: LayoutContentExtended;
+};
+export declare enum LayoutDOMEventType {
+    TabCreated = "tab-created",
+    ContainerCreated = "container-created",
+    ContainerResized = "container-resized"
+}
+export interface LayoutDOMEvent {
+    type: LayoutDOMEventType;
+    detail: {
+        containerSelector: string;
+        tabSelector: string;
+    };
+    isInitialized: boolean;
+}
+export declare type LayoutDOMEventListener = (ev: LayoutDOMEvent) => void;
+/**
+ * Deep clones a layout and removes view names.
+ * @param layout The Layout to be cloned
+ * @returns A copy of the layout with names removed
+ */
+export declare const cloneLayoutAndRemoveNames: (layout: any) => any;
+export declare const mapContentComponentState: (content: OpenFin.LayoutContent | LayoutContentExtended) => LayoutComponentStateExtended[];
+export declare const getLayoutWithSingleView: (title: string, url: string) => Promise<any>;
+export declare const isLayoutTabActive: (tabSelector: string) => boolean;
+export declare const containerId = "layout_container";
+export declare const getViewComponents: () => LayoutContentExtended;
+export declare const removeLayoutView: (name: string) => Promise<void>;
+export declare const addLayoutEventListener: (event: LayoutDOMEventType, listener: LayoutDOMEventListener) => void;
+/**
+ * Initialize the layout for the current OF window.
+ */
+export declare const initLayout: () => Promise<void>;

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

@@ -0,0 +1,8 @@
+declare enum LocalStorageKey {
+    LastLaunchedWorkspaceId = "activeWorkspaceId",
+    LastFocusedBrowserWindow = "lastFocusedBrowserWindow",
+    MachineName = "machineName",
+    NewTabPageLayout = "NewTabPageLayout",
+    NewTabPageSort = "NewTabPageSort"
+}
+export default LocalStorageKey;

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

@@ -0,0 +1,26 @@
+import { LogLocal } from './shapes';
+/**
+ * Responsible of capturing log information locally and centrally alongside the logs of other windows/views.
+ *
+ * **Warning: if you don't specify a name then it will still log out your messages but it becomes harder to distinguish where the log entry came from**
+ *
+ * Basic usage example:
+ *
+ * ```ts
+ * import logger from '../utils/logger';
+ *   const log = logger("My Component");
+ *
+ *   log.info("Initialised.");
+ * ```
+ * More information can be found [here](https://github.com/openfin/browser/blob/main/docs/Logging.md)
+ * @param name  Specify a name for this logger that will be the prefix of all log messages.
+ * @param logLocal  Specify an object to say what loglevel should be logged to the local window console e.g. { info: true }.
+ */
+export default function logger(name?: string, logLocal?: LogLocal): {
+    trace: (message: string, ...args: any[]) => void;
+    debug: (message: string, ...args: any[]) => void;
+    info: (message: string, ...args: any[]) => void;
+    warn: (message: string, ...args: any[]) => void;
+    error: (message: string, error?: any, ...args: any[]) => void;
+    fatal: (message: string, error?: any, ...args: any[]) => void;
+};

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

@@ -0,0 +1,35 @@
+import { LogEntry, LogOptions } from './shapes';
+declare class LogInterface {
+    private worker;
+    private name;
+    private requestResponseHandler;
+    private errorListeners;
+    constructor();
+    getLogs(fromId?: number): Promise<LogEntry[]>;
+    trace(message: string, sourceName?: string, args?: any[]): void;
+    debug(message: string, sourceName?: string, args?: any[]): void;
+    info(message: string, sourceName?: string, args?: any[]): void;
+    warn(message: string, sourceName?: string, args?: any[]): void;
+    error(message: string, error?: any, sourceName?: string, args?: any[]): void;
+    fatal(message: string, error?: any, sourceName?: string, args?: any[]): void;
+    configure(options: LogOptions): void;
+    onLogError(listener: (error: Error) => void): void;
+    removeListener(listener: (...args: unknown[]) => void): void;
+    private log;
+    private listener;
+}
+/**
+ * Responsible for managing the way logging behaves and retrieving logs. Additionally exposes logging functions but logger should be used for logging.
+ *
+ * Basic usage example:
+ *
+ * ```ts
+ * import logManager from '../utils/log-manager';
+ *
+ * const logs = await logManager.getLogs();
+ *
+ * ```
+ * More information can be found [here](https://github.com/openfin/browser/blob/main/docs/Logging.md)
+ */
+declare let instance: LogInterface | undefined;
+export default instance;

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

@@ -0,0 +1,27 @@
+export declare type LogLevel = 'trace' | 'debug' | 'info' | 'warn' | 'error' | 'fatal';
+export interface LogOptions {
+    instanceId?: string;
+    auditLimit?: number;
+    auditLevel?: LogLevel;
+    logLevel?: LogLevel;
+}
+export declare type LogLocal = {
+    [key in LogLevel]?: boolean;
+};
+export interface LogEntry {
+    id?: number;
+    level: LogLevel;
+    name: string;
+    source?: string;
+    message: string;
+    error?: string;
+    ts?: number;
+    data?: any[];
+}
+export interface GetLogOptions {
+    from?: number;
+    responseId: number;
+}
+export declare const LogColors: {
+    [key in LogLevel]: string;
+};

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

@@ -0,0 +1,33 @@
+/// <reference types="openfin-adapter/fin" />
+export declare type SnapshotDetailsExtended = OpenFin.Snapshot['snapshotDetails'] & {
+    machineId: string;
+    machineName?: string;
+};
+export declare type SnapshotExtended = {
+    snapshotDetails: SnapshotDetailsExtended;
+    windows: OpenFin.WindowOptions[];
+};
+export declare type ApplySnapshotOptionsExtended = OpenFin.ApplySnapshotOptions & {
+    attachToExistingWindow: boolean;
+};
+/**
+ * Set a friendly name of the current machine.
+ * @param name the friendly name.
+ */
+export declare function setMachineName(name: string): void;
+/**
+ * Get the machine's friendly name.
+ * @returns the machine's friendly name.
+ */
+export declare function getMachineName(): string;
+/**
+ * Get the current machine ID.
+ * @returns the machine ID.
+ */
+export declare function getMachineId(): Promise<string>;
+/**
+ * Get a snapshot with extra snapshot details.
+ * @param snapshot the snapshot to extend.
+ * @returns the snapshot with more snapshot details.
+ */
+export declare function getSnapshotExtended(snapshot?: OpenFin.Snapshot): Promise<SnapshotExtended>;

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

@@ -0,0 +1,2 @@
+declare const injectAPI: (namespace: string, api: any) => void;
+export default injectAPI;

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

@@ -0,0 +1,146 @@
+/// <reference types="openfin-adapter/fin" />
+import type { Fin } from 'openfin-adapter';
+import type { _Window } from 'openfin-adapter/src/api/window';
+import { ApplicationUUID } from './application';
+export declare type WindowFin = Fin<'window'>;
+export declare enum WindowName {
+    Home = "openfin-home",
+    Dock = "openfin-dock",
+    Storefront = "openfin-storefront",
+    HomeInternal = "openfin-home-internal",
+    BrowserMenu = "openfin-browser-menu",
+    BrowserIndicator = "openfin-browser-indicator",
+    BrowserWindow = "internal-generated-window"
+}
+export declare enum WindowEvent {
+    Shown = "shown",
+    BoundsChanged = "bounds-changed",
+    LayoutReady = "layout-ready",
+    EndUserBoundsChanging = "end-user-bounds-changing",
+    Blurred = "blurred",
+    CloseRequested = "close-requested",
+    Focused = "focused",
+    ShowRequested = "show-requested",
+    ViewCrashed = "view-crashed",
+    ViewAttached = "view-attached",
+    ViewDetached = "view-detached",
+    ViewPageTitleUpdated = "view-page-title-updated",
+    ViewDestroyed = "view-destroyed"
+}
+export interface WindowIdentity {
+    uuid: ApplicationUUID | string;
+    name: WindowName | string;
+}
+interface Point {
+    left: number;
+    top: number;
+}
+interface Size {
+    height: number;
+    width: number;
+}
+/**
+ * Gets the center point of a window given its bounds
+ * @param bounds OpenFin bounds - left, top, height, width
+ * @returns coords representing the center - left, top
+ */
+export declare const getCenterFromBounds: (bounds: OpenFin.WindowBounds) => Point;
+/**
+ * Gets the top and left coords of a window given its size and center point
+ * @param center point representing the desired center coords
+ * @param size height and width of the window
+ * @returns coords representing the left, top of window given the center point
+ */
+export declare const getBoundsFromCenter: (center: Point, size: Size) => Point;
+/**
+ * Get a wrapped OpenFin window.
+ *
+ * This method can only be used in an OF env.
+ * If used outside of OF, such as in a pre-rendering context, will throw a clear and traceable error.
+ *
+ * @param identity the window identity.
+ * @returns the wrapped OpenFin window identity.
+ */
+export declare function getOFWindow(identity: WindowIdentity): _Window;
+/**
+ * The OpenFin identity for the current window.
+ */
+export declare const currentOFIdentity: WindowIdentity;
+/**
+ * Get the current OpenFin window.
+ */
+export declare function getCurrentOFWindow(): _Window;
+/**
+ * The OpenFin identity for Home.
+ */
+export declare const homeOFIdentity: WindowIdentity;
+export declare const dockOFIdentity: WindowIdentity;
+export declare const StorefrontOFIdentity: WindowIdentity;
+export declare const providerOFIdentity: WindowIdentity;
+/**
+ * Get the Home OpenFin window.
+ */
+export declare function getHomeOFWindow(): _Window;
+export declare function getDockOFWindow(): _Window;
+/**
+ * Helper for max and restoring a window.
+ * @param identity the identity of the window to maximize or restore.
+ */
+export declare function maxOrRestore(identity: WindowIdentity): Promise<void>;
+/**
+ * Helper for showing a window.
+ * This method ensures the window is shown, brought to front and focused.
+ * @param identity the identity of the window to show.
+ */
+export declare function showAndFocus(identity: WindowIdentity): Promise<void>;
+/**
+ * Helper for hiding a window.
+ * This method ensures the window is hidden and blurred.
+ * @param identity the identity of the window to hide.
+ */
+export declare function hideAndBlur(identity: WindowIdentity): Promise<void>;
+/**
+ * Helper for showing / hiding a window.
+ * This method calls showAndFocus / hideAndBlur
+ * @param identity the identity of the window to hide.
+ */
+export declare function toggleVisibility(identity: WindowIdentity): Promise<void>;
+export declare const toggleDock: () => Promise<void>;
+export declare const showAndFocusDock: () => Promise<void>;
+export declare function isAnimatingSize(): boolean;
+/**
+ * Resizes a window to width and height saved in the store
+ * if they differ from current window size.
+ */
+export declare function restoreWindowSize(): Promise<void>;
+export declare function animateSize(width: number, height: number): Promise<void>;
+/**
+ * Returns true if the window name is that of a browser window.
+ * @param name the window name.
+ * @returns true if the name is that of a browser window's.
+ */
+export declare const isBrowserWindow: (name: string) => boolean;
+/**
+ * Force document body size. Called when resizing or on scaling changes.
+ */
+export declare function forceBodySize(): void;
+/**
+ * Gets all currently open browser windows.
+ */
+export declare function getBrowserWindows(): Promise<_Window[]>;
+/**
+ * Closes all currently open Browser windows.
+ */
+export declare function closeBrowserWindows(): Promise<void>;
+/**
+ * Returns true if the OpenFin window for the provided identity is running.
+ * */
+export declare const isWindowRunning: (identity: WindowIdentity) => Promise<boolean>;
+/**
+ * Check if Storefront window is running.
+ * @returns true if the Storefront window is running.
+ */
+export declare const isStorefrontWindowRunning: () => Promise<boolean>;
+export declare const isHomeWindowRunning: () => Promise<boolean>;
+export declare const showAndFocusStorefront: () => Promise<void>;
+export {};

package/index.d.ts

@@ -1,6 +1 @@
-import * as StorefrontAPI from './storefront';
-export * from './common';
-/**
- * Namespace for Storefront integrations.
- */
-export declare const Storefront: typeof StorefrontAPI;
+export * from './client-api/src';