@openfin/workspace-platform 4.3.0 → 4.7.0

package/src/api/browser/index.ts

@@ -1,46 +0,0 @@
-import type { AttachedPage, Page } from '@common/api/pages/shapes';
-
-import type { BrowserCreateWindowRequest, BrowserWindowModule } from '../../shapes';
-import { ChannelAction, getChannelClient } from '../protocol';
-
-import { getBrowserModule } from './browser-module';
-
-export const getBrowserApi = (identity: OpenFin.Identity) => {
-    const platform = fin.Platform.wrapSync(identity);
-
-    const getOpenPages = async (): Promise<AttachedPage[]> => {
-        const client = await platform.getClient();
-        return client.dispatch(ChannelAction.GetOpenPages, undefined);
-    };
-
-    return {
-        wrapSync: (windowIdentity: OpenFin.Identity) => getBrowserModule(windowIdentity),
-        createWindow: async (options: BrowserCreateWindowRequest): Promise<BrowserWindowModule> => {
-            const win = await platform.createWindow(options as any); // TODO: remove typecast after container removes Page type
-            return getBrowserModule(win.identity);
-        },
-        getOpenPages,
-        getAllWindows: async (): Promise<BrowserWindowModule[]> => {
-            const CHILD_WINDOW_NAME_PREFIX = 'internal-generated-window-';
-            const childWindows = await fin.Application.wrapSync(identity).getChildWindows();
-            const browserWindows = childWindows.filter((win) => win.identity.name.includes(CHILD_WINDOW_NAME_PREFIX));
-            return browserWindows.map((bw) => getBrowserModule(bw.identity));
-        },
-
-        launchPage: async (page: Page): Promise<BrowserWindowModule> => {
-            const client = await platform.getClient();
-            await client.dispatch(ChannelAction.LaunchPage, { page, attachToExistingWindow: true });
-            const pages = await getOpenPages();
-            const launchedPage = pages.find((p) => p.pageId === page.pageId);
-            return getBrowserModule(launchedPage.parentIdentity);
-        },
-        getUniquePageTitle: async (title?: string) => {
-            const channel = await getChannelClient(identity);
-            return channel.dispatch(ChannelAction.GetUniquePageTitle, title);
-        },
-        getLastFocusedWindow: async () => {
-            const channel = await getChannelClient(identity);
-            return channel.dispatch(ChannelAction.GetLastFocusedBrowserWindow, undefined);
-        }
-    };
-};

package/src/api/pages/helper.ts

@@ -1,113 +0,0 @@
-import type { Fin } from 'openfin-adapter';
-
-import { getSnapshotExtended, SnapshotExtended } from '@common/utils/snapshot';
-import { getBrowserWindows } from '@common/utils/window';
-
-import { makePage } from '@common/api/pages';
-import * as attachedPageAPI from '@common/api/pages/attached';
-import { fixAttachedPages } from '@common/api/pages/legacy';
-import { AttachedPage, Page } from '@common/api/pages/shapes';
-
-import { initWorkspacePlatformOptions } from '@client-platform/init/utils';
-
-import { getOpenPages, getUniquePageTitle, setActivePageForWindow } from '.';
-
-declare const fin: Fin<'window'>;
-
-/**
- * Brings the page's parent window into focus.
- * The window will be brought to front, focused and restored.
- * @param page the page to focus.
- */
-const focusAndRestoreWindow = (identity: OpenFin.Identity) => {
-    const targetWin = fin.Window.wrapSync(identity);
-    return Promise.all([targetWin.bringToFront(), targetWin.restore(), targetWin.focus()]);
-};
-
-/**
- * Get a snapshot with pages.
- *
- * Makes sure that the layout of the page is up to date with the window's layout.
- *
- * @returns a snapshot with windows that contain pages.
- */
-export async function getSnapshotWithPages(superGetSnapshot?: () => Promise<SnapshotExtended>) {
-    const browserWins = await getBrowserWindows();
-    await Promise.all(browserWins.map(({ identity }) => attachedPageAPI.updatePagesWindowOptions(identity)));
-    return superGetSnapshot ? superGetSnapshot() : getSnapshotExtended();
-}
-
-/**
- * Launch a snapshot that contains windows with pages.
- *
- * If a page with the same ID is already launched in the platform,
- * focus and set it as the active page.
- *
- * If there is no page on the desktop with the same ID, launch
- * the new window with the page.
- *
- * @param snapshot the snapshot to launch.
- */
-export async function applySnapshotWithPages(
-    snapshot: OpenFin.Snapshot,
-    superApplySnapshot?: (superSnapshot: OpenFin.Snapshot) => Promise<void>
-): Promise<void> {
-    const allAttachedPages = await getOpenPages();
-
-    const monitorInfo = snapshot.snapshotDetails?.monitorInfo || (await fin.System.getMonitorInfo());
-    const allLaunchingWindows = (snapshot.windows || []).filter(({ layout }) => !!layout);
-
-    const attachedPageMap: Map<string, Page> = new Map();
-    allAttachedPages.forEach((w) => attachedPageMap.set(w.pageId, w));
-
-    const newWindowOptions: OpenFin.WindowOptions[] = [];
-    const launchingWindowsPromises = allLaunchingWindows.map(async (launchingWindow: OpenFin.WindowOptions) => {
-        const options = initWorkspacePlatformOptions(launchingWindow);
-        const pagesToLaunch: Page[] = [];
-        const launchingPages = fixAttachedPages(options?.workspacePlatform?.pages);
-        if (!launchingPages?.length) {
-            const title = await getUniquePageTitle();
-            pagesToLaunch.push(await makePage(title, options.layout));
-        }
-
-        let pageToActivate: AttachedPage;
-        launchingPages.forEach((launchingPage) => {
-            const attachedPage = attachedPageMap.get(launchingPage.pageId);
-            if (attachedPage) {
-                pageToActivate = attachedPage;
-                return;
-            }
-            pagesToLaunch.push(launchingPage);
-        });
-
-        if (pageToActivate) {
-            await Promise.all([
-                setActivePageForWindow({
-                    identity: pageToActivate.parentIdentity,
-                    pageId: pageToActivate.pageId
-                }),
-                focusAndRestoreWindow(pageToActivate.parentIdentity)
-            ]);
-        }
-
-        if (pagesToLaunch.length) {
-            newWindowOptions.push({
-                ...(options as OpenFin.WindowOptions),
-                workspacePlatform: { ...options.workspacePlatform, pages: pagesToLaunch as OpenFin.Page[] }
-            });
-        }
-    });
-    await Promise.all(launchingWindowsPromises);
-
-    if (!newWindowOptions.length) return;
-    const platform = fin.Platform.getCurrentSync();
-    const applySnapshot = superApplySnapshot || platform.applySnapshot.bind(platform);
-    return applySnapshot({
-        ...snapshot,
-        snapshotDetails: {
-            ...snapshot.snapshotDetails,
-            monitorInfo
-        },
-        windows: newWindowOptions
-    });
-}

package/src/api/pages/index.ts

@@ -1,164 +0,0 @@
-import { currentOFIdentity, getBrowserWindows } from '@common/utils/window';
-
-import * as attachedPageAPI from '@common/api/pages/attached';
-import type { AttachPagesToWindowPayload } from '@common/api/pages/shapes';
-
-import type { CreateSavedPageRequest, Page, UpdateSavedPageRequest } from '@client-platform/shapes';
-
-import { ChannelAction, getChannelClient } from '../protocol';
-
-/**
- * Get all open pages in which are attached to a window.
- * @returns the list of attached pages.
- */
-export const getOpenPages = async () => {
-    const browserWins = await getBrowserWindows();
-    const attachedPages = await Promise.all(
-        browserWins.map(async ({ identity }) => attachedPageAPI.getPages(identity))
-    );
-    return attachedPages.reduce((x, y) => x.concat(y), []);
-};
-
-const findAttachedPage = async (id: string) => {
-    const allRunningPages = await getOpenPages();
-    return allRunningPages.find((page) => page.pageId === id);
-};
-
-const createPageInStorage = async (req: CreateSavedPageRequest) => {
-    const client = await getChannelClient(currentOFIdentity);
-    return client.dispatch(ChannelAction.CreateSavedPage, req);
-};
-
-const getPagesInStorage = async (): Promise<Page[]> => {
-    const client = await getChannelClient(currentOFIdentity);
-    return client.dispatch(ChannelAction.GetSavedPages, undefined);
-};
-
-const getPageInStorage = async (id: string): Promise<Page> => {
-    const client = await getChannelClient(currentOFIdentity);
-    return client.dispatch(ChannelAction.GetSavedPage, id);
-};
-
-const deletePageInStorage = async (id: string) => {
-    const client = await getChannelClient(currentOFIdentity);
-    return client.dispatch(ChannelAction.DeleteSavedPage, id);
-};
-
-const updatePageInStorage = async (req) => {
-    const client = await getChannelClient(currentOFIdentity);
-    return client.dispatch(ChannelAction.UpdateSavedPage, req);
-};
-
-/**
- * Update attached page attributes to match a saved page.
- * Specifically, `pageId` and `title` must always match.
- */
-const updateAttachedPage = async (pageId: string, page: Page) => {
-    const attachedPage = await findAttachedPage(pageId);
-    if (attachedPage && (attachedPage.title !== page.title || pageId !== page.pageId)) {
-        await attachedPageAPI.updatePageForWindow({
-            identity: attachedPage.parentIdentity,
-            pageId: pageId,
-            page: {
-                pageId: page.pageId,
-                title: page.title
-            }
-        });
-    }
-    return attachedPage;
-};
-
-export const createSavedPageInternal = async ({ page }: CreateSavedPageRequest) => {
-    await updateAttachedPage(page.pageId, page);
-    await createPageInStorage({ page });
-};
-
-export const deleteSavedPageInternal = async (id: string) => {
-    const pageToDelete = await getPageInStorage(id);
-    if (!pageToDelete) return;
-    await deletePageInStorage(id);
-};
-
-export const updateSavedPageInternal = async ({ pageId, page }: UpdateSavedPageRequest) => {
-    await updateAttachedPage(pageId, page);
-    const isDatabaseUpdated = await updatePageInStorage({ pageId, page });
-    return isDatabaseUpdated;
-};
-
-export const savePage = async (page: Page) => {
-    const savedPage = await getPageInStorage(page.pageId);
-    if (savedPage) {
-        return updateSavedPageInternal({ pageId: page.pageId, page });
-    }
-    return createSavedPageInternal({ page });
-};
-
-export const attachPagesToWindow = async (payload: AttachPagesToWindowPayload) => {
-    await attachedPageAPI.attachPagesToWindow(payload);
-};
-
-export const updatePageForWindow = async (payload) => {
-    await attachedPageAPI.updatePageForWindow(payload);
-};
-
-export const detachPagesFromWindow = async (payload) => {
-    await attachedPageAPI.detachPagesFromWindow(payload);
-};
-
-export const setActivePageForWindow = async (payload) => {
-    await attachedPageAPI.setActivePageForWindow(payload);
-};
-
-export const getPagesForWindow = (identity: OpenFin.Identity) => attachedPageAPI.getPages(identity);
-
-export const getPageForWindow = async ({ identity, pageId }) => {
-    const pages = await getPagesForWindow(identity);
-    return pages.find((p) => p.pageId === pageId);
-};
-
-export const reorderPagesForWindow = async (payload) => {
-    await attachedPageAPI.reorderPagesForWindow(payload);
-};
-
-export const getActivePageIdForWindow = async (identity) => {
-    const { pageId } = await attachedPageAPI.getActivePageForWindow(identity);
-    return pageId;
-};
-
-const checkIsUnique = (val: string, arr: string[]): boolean => !arr.find((n) => n === val);
-
-/**
- * Helper function to maintain duplicate name format in fewer places
- * @param baseName Name to which we want to append
- * @param counter Number to append
- * @returns string: The name with the counter appended
- */
-const formatNameWithCounter = (baseName: string, counter: number): string => `${baseName} (${counter})`;
-
-/**
- * Checks if a given page name is unique
- * If not, add a progressive number to it
- * @param initialName The initial name to test
- * @returns string: a unique page name
- */
-export async function getUniquePageTitle(initialName = 'Untitled Page'): Promise<string> {
-    const [savedPages, openPages] = await Promise.all([getPagesInStorage(), getOpenPages()]);
-
-    // Names need to be unique across all running and saved pages
-    const allPageNames = [...savedPages, ...openPages].map(({ title }) => title);
-
-    if (!allPageNames.find((n) => n === initialName)) {
-        return initialName;
-    }
-
-    // Format is any number of digits, wrapped in parentheses and preceded by a space.
-    const stripNumberRegEx = / \(.+\)$/;
-
-    let counter = 1;
-    const baseName = initialName.replace(stripNumberRegEx, '');
-
-    while (!checkIsUnique(formatNameWithCounter(baseName, counter), allPageNames)) {
-        counter += 1;
-    }
-    return formatNameWithCounter(baseName, counter);
-}

package/src/api/protocol.ts

@@ -1,60 +0,0 @@
-/**
- * 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 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 const getChannelClient = async (identity: OpenFin.Identity) => {
-    const platform = fin.Platform.wrapSync(identity);
-    const client = await platform.getClient();
-    const errMsg = 'Target is not a Workspace Platform. Target must call WorkspacePlatform.init';
-    try {
-        const res = await client.dispatch('isWorkspacePlatform');
-        if (res === true) {
-            return client;
-        }
-        throw new Error(errMsg);
-    } catch (e) {
-        throw new Error(errMsg);
-    }
-};

package/src/api/storage.ts

@@ -1,32 +0,0 @@
-import { Page } from '@common/api/pages/shapes';
-
-import type { CreateSavedPageRequest, UpdateSavedPageRequest } from '../shapes';
-
-import { ChannelAction, getChannelClient } from './protocol';
-
-export const getStorageApi = (identity) => ({
-    createPage: async (req: CreateSavedPageRequest) => {
-        const client = await getChannelClient(identity);
-        return client.dispatch(ChannelAction.CreateSavedPageInternal, req);
-    },
-    deletePage: async (id: string) => {
-        const client = await getChannelClient(identity);
-        return client.dispatch(ChannelAction.DeleteSavedPageInternal, id);
-    },
-    updatePage: async (req: UpdateSavedPageRequest) => {
-        const client = await getChannelClient(identity);
-        return client.dispatch(ChannelAction.UpdateSavedPageInternal, req);
-    },
-    getPage: async (id: string) => {
-        const client = await getChannelClient(identity);
-        return client.dispatch(ChannelAction.GetSavedPage, id);
-    },
-    getPages: async (query?: string): Promise<Page[]> => {
-        const client = await getChannelClient(identity);
-        return client.dispatch(ChannelAction.GetSavedPages, query);
-    },
-    savePage: async (page: Page) => {
-        const client = await getChannelClient(identity);
-        return client.dispatch(ChannelAction.SavePage, page);
-    }
-});

package/src/api/workspace-module.ts

@@ -1,36 +0,0 @@
-import { finEntityType, finName, finUUID } from '@common/utils/env';
-
-import type { BrowserSnapshot, WorkspacePlatformModule } from '../shapes';
-import { LaunchAppPayload } from '..';
-
-import { getBrowserApi } from './browser';
-import { ChannelAction, getChannelClient } from './protocol';
-import { getStorageApi } from './storage';
-
-export const getWorkspacePlatformModule = (identity: OpenFin.Identity): WorkspacePlatformModule => {
-    const platform = fin.Platform.wrapSync(identity);
-
-    const platformModule = Object.assign(platform, {
-        applySnapshot: async (snapshot: BrowserSnapshot | string): Promise<OpenFin.Platform> => {
-            if (typeof snapshot !== 'string' && !snapshot?.windows) {
-                throw new Error('Not a valid browser snapshot');
-            }
-            return fin.Platform.wrapSync(identity).applySnapshot(snapshot);
-        },
-        getSnapshot: () =>
-            fin.Platform.wrapSync(identity)
-                .getSnapshot()
-                .then((snapshot) => snapshot as BrowserSnapshot),
-        launchApp: async (req: LaunchAppPayload): Promise<void> => {
-            if (!req.target) {
-                req.target = { uuid: finUUID, name: finName, entityType: finEntityType || 'unknown' };
-            }
-            const client = await getChannelClient(identity);
-            return client.dispatch(ChannelAction.LaunchApp, req);
-        },
-        Browser: getBrowserApi(identity),
-        Storage: getStorageApi(identity)
-    });
-
-    return platformModule;
-};

package/src/index.ts

@@ -1,35 +0,0 @@
-import { workspaceRuntimeVersion } from '@common/utils/env';
-
-import { getWorkspacePlatformModule } from './api/workspace-module';
-import initBrowser from './init';
-import type { WorkspacePlatformInitConfig, WorkspacePlatformModule } from './shapes';
-
-export * from './shapes';
-
-const validateRuntime = async (requiredVersions: number[]): Promise<boolean> => {
-    return new Promise<boolean>(async (resolve) => {
-        const runtimeVersion = await fin.System.getVersion();
-        const vbits = runtimeVersion.split('.').map((n) => parseInt(n));
-        const valid = requiredVersions.every((n, i) => {
-            return i < 3 ? vbits[i] === requiredVersions[i] : true;
-        });
-        resolve(valid);
-    });
-};
-
-// TODO - pass through options and do the thing
-export const init = async (options: WorkspacePlatformInitConfig) => {
-    const requiredVersions = workspaceRuntimeVersion.split('.').map((n) => parseInt(n));
-    const validRuntime = await validateRuntime(requiredVersions);
-    if (validRuntime) {
-        const browserOptions = options?.browser;
-        return initBrowser(browserOptions);
-    } else {
-        throw new Error(
-            `Runtime version is not supported.  ${requiredVersions[0]}.${requiredVersions[1]}.${requiredVersions[2]}.* is required`
-        );
-    }
-};
-
-export const wrapSync = (identity: OpenFin.Identity): WorkspacePlatformModule => getWorkspacePlatformModule(identity);
-export const getCurrentSync = (): WorkspacePlatformModule => wrapSync(fin.me.identity);

package/src/init/browser-window-focus.ts

@@ -1,59 +0,0 @@
-import LocalStorageKey from '@common/utils/local-storage-key';
-import logger from '@common/utils/logger';
-import { isBrowserWindow, isWindowRunning } from '@common/utils/window';
-
-const log = logger('api.platform-window-focus');
-
-function saveLastFocusedBrowserWindow(identity: OpenFin.Identity) {
-    if (typeof localStorage === 'undefined') return;
-    try {
-        const strLastFocused = JSON.stringify(identity);
-        localStorage.setItem(LocalStorageKey.LastFocusedBrowserWindow, strLastFocused);
-    } catch (err) {
-        log.error('failed to save last focused browser window: ', err);
-    }
-}
-
-/**
- * Get the last focused browser window.
- * @returns the last focused browser window.
- */
-export async function getLastFocusedBrowserWindow(): Promise<OpenFin.Identity> {
-    if (typeof localStorage === 'undefined') return;
-    try {
-        const strLastFocused = localStorage.getItem(LocalStorageKey.LastFocusedBrowserWindow);
-        const identity = JSON.parse(strLastFocused);
-        if (await isWindowRunning(identity)) {
-            return identity;
-        }
-    } catch (err) {
-        log.error('failed to get last focused browser window: ', err);
-    }
-    return undefined;
-}
-
-/**
- * Set the OpenFin identity of the last focused browser window.
- */
-export function setLastFocusedBrowserWindow(identity = fin.me.identity): void {
-    const isFocusedBrowserWindow = isBrowserWindow(identity.name);
-    if (!isFocusedBrowserWindow) return;
-    saveLastFocusedBrowserWindow(identity);
-}
-
-/**
- * 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 async function listenForBrowserWindowFocus(): Promise<void> {
-    const app = fin.Application.getCurrentSync();
-    await app.addListener('window-focused', setLastFocusedBrowserWindow);
-}
-
-/**
- * Stop listening for a browser window to be focused.
- */
-export async function removeBrowserWindowFocusListener(): Promise<void> {
-    const app = fin.Application.getCurrentSync();
-    await app.removeListener('window-focused', setLastFocusedBrowserWindow);
-}

package/src/init/cleanup.ts

@@ -1,87 +0,0 @@
-import { ApplicationEventType, getCurrentOFApplication } from '@common/utils/application';
-import makeDebouncedFunc from '@common/utils/debounce';
-import { mapContentComponentState } from '@common/utils/layout';
-import logger from '@common/utils/logger';
-import { getCurrentOFWindow, isBrowserWindow } from '@common/utils/window';
-
-import { getOpenPages } from '../api/pages';
-
-const log = logger('api.cleanup');
-
-/** Time to debounce scheduling of views cleanup. */
-const viewCleanupDebounce = 2500;
-
-/** Delay before views are destroyed. */
-const viewCleanupDelay = 5000;
-
-/** The map of views that are scheduled for cleanup. */
-const viewCleanupMap: Map<string, any> = new Map();
-
-/** Get a string that represents the view's identity. */
-const getViewId = (identity: OpenFin.Identity) => `${identity.uuid}-${identity.name}`;
-
-async function scheduleViewCleanup() {
-    log.debug('scheduling views to cleanup');
-
-    const attachedPages = await getOpenPages();
-
-    // A set of view ids that should not be cleaned up.
-    const viewsToPreserve: Set<string> = new Set();
-    attachedPages.forEach((page) => {
-        // Get all the views in the page layout content.
-        const viewStates = mapContentComponentState(page.layout.content);
-        viewStates.forEach((viewState) => {
-            if (viewState.name) {
-                const viewId = getViewId(viewState);
-
-                // This view is still attached to a page, and therefore must be preserved.
-                viewsToPreserve.add(viewId);
-                log.debug(`preserving view with id ${viewId}`);
-            }
-        });
-    });
-
-    const currentWin = getCurrentOFWindow();
-
-    // Views that are not attached to a browser window.
-    const inactiveViews = await currentWin.getCurrentViews();
-
-    inactiveViews.forEach(({ identity }) => {
-        const viewId = getViewId(identity);
-        if (viewsToPreserve.has(viewId) || viewCleanupMap.has(viewId)) return;
-
-        // Do not destroy view immediately. Destroying view immediately
-        // can cause issues when dragging and dropping pages between windows.
-        const timeoutId = setTimeout(() => {
-            log.debug(`destroying view with id ${viewId}`);
-            fin.View.wrapSync(identity).destroy();
-            viewCleanupMap.delete(viewId);
-        }, viewCleanupDelay);
-        log.debug(`scheduled cleanup of view with id ${viewId}`);
-        viewCleanupMap.set(viewId, timeoutId);
-    });
-
-    viewCleanupMap.forEach((v, k) => {
-        // If a view is no longer scheduled for cleanup, clear timeout.
-        if (viewsToPreserve.has(k)) {
-            clearTimeout(v);
-            viewCleanupMap.delete(k);
-            log.debug(`cancelled scheduled cleanup of view with id ${k}`);
-        }
-    });
-}
-
-const debouncedScheduleViewCleanup = makeDebouncedFunc(scheduleViewCleanup, viewCleanupDebounce);
-
-const handleWindowEvent = ({ name }) => {
-    if (isBrowserWindow(name)) {
-        debouncedScheduleViewCleanup();
-    }
-};
-
-export default function registerViewCleanUp() {
-    const app = getCurrentOFApplication();
-    app.addListener(ApplicationEventType.WindowOptionsChanged, debouncedScheduleViewCleanup);
-    app.addListener(ApplicationEventType.WindowClosed, handleWindowEvent);
-    app.addListener(ApplicationEventType.WindowCreated, handleWindowEvent);
-}

package/src/init/index.ts

@@ -1,42 +0,0 @@
-import { Env, env, isFin } from '@common/utils/env';
-import { currentOFIdentity, getCurrentOFWindow, hideAndBlur, WindowEvent } from '@common/utils/window';
-
-import { BrowserInitConfig } from '../shapes';
-
-import { listenForBrowserWindowFocus } from './browser-window-focus';
-import registerViewCleanUp from './cleanup';
-import { getOverrideCallback } from './override-callback';
-
-/**
- * Handle platform ready event.
- */
-async function handlePlatformReady() {
-    registerViewCleanUp();
-    listenForBrowserWindowFocus();
-
-    if (env !== Env.Local) {
-        const win = getCurrentOFWindow();
-        // Ensure that the provider window is always hidden in all envs except for local dev.
-        win.addListener(WindowEvent.ShowRequested, () => hideAndBlur(currentOFIdentity));
-    }
-}
-
-let initPromise: Promise<void>;
-
-/**
- * Initializing the Workspace Platform.
- */
-export default function init(options: BrowserInitConfig) {
-    if (!isFin) {
-        throw new Error('Cannot be used outside an OpenFin env.');
-    }
-    if (!initPromise) {
-        const platform = fin.Platform.getCurrentSync();
-        platform.once('platform-api-ready', () => handlePlatformReady());
-        initPromise = fin.Platform.init({
-            overrideCallback: getOverrideCallback(options),
-            interopOverride: options?.interopOverride
-        });
-    }
-    return initPromise;
-}