@interopio/workspaces-api 3.2.1 → 3.2.3

package/src/controllers/main.ts

@@ -1,541 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Bridge } from "../communication/bridge";
-import { IsWindowInSwimlaneResult, WorkspaceCreateConfigProtocol, WorkspaceSnapshotResult, FrameSummariesResult, WorkspaceSummariesResult, LayoutSummariesResult, ExportedLayoutsResult, FrameSnapshotResult, AddItemResult, WindowStreamData, FrameStateResult, FrameBoundsResult, WorkspaceStreamData } from "../types/protocol";
-import { OPERATIONS } from "../communication/constants";
-import { SubscriptionConfig, WorkspaceEventType, WorkspaceEventAction } from "../types/subscription";
-import { Workspace } from "../models/workspace";
-import { Frame } from "../models/frame";
-import { Child, ContainerLockConfig, SubParentTypes } from "../types/builders";
-import { RefreshChildrenConfig } from "../types/privateData";
-import { IOConnectWorkspaces } from "../../workspaces";
-import { WorkspacesController } from "../types/controller";
-import { GDWindow } from "../types/glue";
-import { BaseController } from "./base";
-import { UnsubscribeFunction } from "callback-registry";
-import { ShortcutsController } from "./shortcuts";
-
-export class MainController implements WorkspacesController {
-
-    constructor(
-        private readonly bridge: Bridge,
-        private readonly base: BaseController,
-        private readonly shortcutsController: ShortcutsController
-    ) { }
-
-    public checkIsWindowLoaded(windowId: string): boolean {
-        return this.base.checkIsWindowLoaded(windowId);
-    }
-
-    public async checkIsInSwimlane(windowId: string): Promise<boolean> {
-
-        const controlResult = await this.bridge.send<IsWindowInSwimlaneResult>(OPERATIONS.isWindowInWorkspace.name, { itemId: windowId });
-
-        return controlResult.inWorkspace;
-    }
-
-    public async createWorkspace(definition: IOConnectWorkspaces.WorkspaceDefinition, saveConfig?: IOConnectWorkspaces.WorkspaceCreateConfig): Promise<Workspace> {
-        const createConfig: WorkspaceCreateConfigProtocol = Object.assign({}, definition, { saveConfig });
-
-        return await this.base.createWorkspace(createConfig);
-    }
-
-    public async createEmptyFrame(definition: IOConnectWorkspaces.EmptyFrameDefinition): Promise<Frame> {
-        return await this.base.createEmptyFrame(definition);
-    }
-
-    public async initFrame(frameId: string, config: IOConnectWorkspaces.FrameInitializationConfig): Promise<void> {
-        return this.base.initFrame(frameId, config);
-    }
-
-    public async restoreWorkspace(name: string, options?: IOConnectWorkspaces.RestoreWorkspaceConfig): Promise<Workspace> {
-        const allLayouts = await this.getLayoutSummaries();
-
-        const layoutExists = allLayouts.some((summary) => summary.name === name);
-
-        if (!layoutExists) {
-            throw new Error(`This layout: ${name} cannot be restored, because it doesn't exist.`);
-        }
-
-        if (options?.frameId) {
-            const allFrameSummaries = await this.bridge.send<FrameSummariesResult>(OPERATIONS.getAllFramesSummaries.name);
-
-            const foundMatchingFrame = allFrameSummaries.summaries.some((summary) => summary.id === options.frameId);
-
-            if (!foundMatchingFrame) {
-                throw new Error(`Cannot reuse the frame with id: ${options.frameId}, because there is no frame with that ID found`);
-            }
-        }
-
-        return await this.base.restoreWorkspace(name, options);
-    }
-
-    public async add(type: "container" | "window", parentId: string, parentType: "row" | "column" | "group" | "workspace", definition: IOConnectWorkspaces.WorkspaceWindowDefinition | IOConnectWorkspaces.BoxDefinition): Promise<AddItemResult> {
-        return await this.base.add(type, parentId, parentType, definition);
-    }
-
-    public processLocalSubscription(config: SubscriptionConfig, levelId: string): Promise<IOConnectWorkspaces.Unsubscribe> {
-        const desktopGlobal = (window as any).glue42gd || (window as any).iodesktop;
-
-        return desktopGlobal ?
-            this.handleEnterpriseLocalSubscription(config, levelId) :
-            this.handleCoreLocalSubscription(config, levelId);
-    }
-
-    public processGlobalSubscription(callback: (callbackData: unknown) => void | Promise<void>, eventType: WorkspaceEventType, action: WorkspaceEventAction): Promise<IOConnectWorkspaces.Unsubscribe> {
-        const desktopGlobal = (window as any).glue42gd || (window as any).iodesktop;
-
-        return desktopGlobal ?
-            this.handleEnterpriseGlobalSubscription(callback, eventType, action) :
-            this.handleCoreGlobalSubscription(callback, eventType, action);
-    }
-
-    public async getFrame(selector: { windowId?: string; predicate?: (frame: Frame) => boolean }): Promise<Frame> {
-
-        if (selector.windowId) {
-            return await this.base.getFrame(selector.windowId);
-        }
-
-        if (selector.predicate) {
-            return (await this.getFrames(selector.predicate))[0];
-        }
-
-        throw new Error(`The provided selector is not valid: ${JSON.stringify(selector)}`);
-    }
-
-    public async getFrames(predicate?: (frame: Frame) => boolean): Promise<Frame[]> {
-
-        const allFrameSummaries = await this.bridge.send<FrameSummariesResult>(OPERATIONS.getAllFramesSummaries.name);
-
-        return this.base.getFrames(allFrameSummaries.summaries, predicate);
-    }
-
-    public getWorkspaceById(workspaceId: string): Promise<Workspace> {
-        return this.base.fetchWorkspace(workspaceId);
-    }
-
-    public async getWorkspaceByWindowId(itemId: string): Promise<Workspace> {
-        const desktopGlobal = (window as any).glue42gd || (window as any).iodesktop;
-
-        if (!desktopGlobal) {
-            // workspace-ui-core doesn't accept an itemId for getWorkspaceSnapshot, but GD does and getWorkspaceSnapshot is significantly faster
-            return (await this.getWorkspaces((wsp) => !!wsp.getWindow((w) => w.id === itemId)))[0];
-        }
-        return this.base.fetchWorkspace(itemId);
-    }
-
-    public transformStreamPayloadToWorkspace(payload: WorkspaceStreamData): Promise<Workspace> {
-        return this.base.transformStreamPayloadToWorkspace(payload);
-    }
-
-    public async getWorkspace(predicate: (workspace: Workspace) => boolean): Promise<Workspace> {
-        let foundWorkspace: Workspace;
-
-        await this.iterateWorkspaces((wsp, end) => {
-            if (predicate(wsp)) {
-                foundWorkspace = wsp;
-                end();
-            }
-        });
-
-        return foundWorkspace;
-    }
-
-    public async getWorkspaces(predicate?: (workspace: Workspace) => boolean): Promise<Workspace[]> {
-        const matchingWorkspaces: Workspace[] = [] as Workspace[];
-
-        await this.iterateWorkspaces((wsp) => {
-            if (!predicate || predicate(wsp)) {
-                matchingWorkspaces.push(wsp);
-            }
-        });
-
-        return matchingWorkspaces;
-    }
-
-    public async getWorkspacesByFrameId(frameId: string): Promise<Workspace[]> {
-        const workspaceSummaries = await this.getAllWorkspaceSummaries();
-        const summariesForFrame = workspaceSummaries.filter((s) => s.frameId === frameId);
-
-        const workspacesForFrame = await Promise.all(summariesForFrame.map((summary) => {
-            return this.base.fetchWorkspace(summary.id);
-        }));
-
-        return workspacesForFrame;
-    }
-
-    public async getAllWorkspaceSummaries(): Promise<IOConnectWorkspaces.WorkspaceSummary[]> {
-
-        const allSummariesResult = await this.bridge.send<WorkspaceSummariesResult>(OPERATIONS.getAllWorkspacesSummaries.name, {});
-
-        return this.base.getAllWorkspaceSummaries(allSummariesResult);
-    }
-
-    public async getWindow(predicate: (swimlaneWindow: IOConnectWorkspaces.WorkspaceWindow) => boolean): Promise<IOConnectWorkspaces.WorkspaceWindow> {
-        let resultWindow: IOConnectWorkspaces.WorkspaceWindow;
-
-        await this.iterateWorkspaces((wsp, end) => {
-            const foundWindow = wsp.getWindow(predicate);
-
-            if (foundWindow) {
-                resultWindow = foundWindow;
-                end();
-            }
-        });
-
-        return resultWindow;
-    }
-
-    public async getParent(predicate: (parent: IOConnectWorkspaces.WorkspaceBox) => boolean): Promise<IOConnectWorkspaces.WorkspaceBox> {
-        let resultParent: IOConnectWorkspaces.WorkspaceBox;
-
-        await this.iterateWorkspaces((wsp, end) => {
-
-            const foundParent = wsp.getBox(predicate);
-
-            if (foundParent) {
-                resultParent = foundParent;
-                end();
-            }
-        });
-
-        return resultParent;
-    }
-
-    public async getLayoutSummaries(): Promise<IOConnectWorkspaces.WorkspaceLayoutSummary[]> {
-        const allLayouts = await this.bridge.send<LayoutSummariesResult>(OPERATIONS.getAllLayoutsSummaries.name);
-        return allLayouts.summaries;
-    }
-
-    public async deleteLayout(name: string): Promise<void> {
-        await this.bridge.send(OPERATIONS.deleteLayout.name, { name });
-    }
-
-    public async exportLayout(predicate?: (layout: IOConnectWorkspaces.WorkspaceLayout) => boolean): Promise<IOConnectWorkspaces.WorkspaceLayout[]> {
-        const allLayoutsResult = await this.bridge.send<ExportedLayoutsResult>(OPERATIONS.exportAllLayouts.name);
-        return allLayoutsResult.layouts.reduce<IOConnectWorkspaces.WorkspaceLayout[]>((matchingLayouts, layout) => {
-
-            if (!predicate || predicate(layout)) {
-                matchingLayouts.push(layout);
-            }
-
-            return matchingLayouts;
-        }, []);
-    }
-
-    public async saveLayout(config: IOConnectWorkspaces.WorkspaceLayoutSaveConfig): Promise<IOConnectWorkspaces.WorkspaceLayout> {
-        return await this.bridge.send(OPERATIONS.saveLayout.name, config);
-    }
-
-    public async importLayouts(layouts: IOConnectWorkspaces.WorkspaceLayout[], mode: "replace" | "merge"): Promise<void> {
-        const desktopGlobal = (window as any).glue42gd || (window as any).iodesktop;
-
-        if (desktopGlobal) {
-            try {
-                // ensuring backwards compatibility
-                await this.bridge.send(OPERATIONS.importLayouts.name, { layouts, mode });
-            } catch (error) {
-                // this is a soft-reversal to handle an import issue with GD
-                await Promise.all(layouts.map((layout) => this.bridge.send(OPERATIONS.importLayout.name, { layout, mode })));
-            }
-            return;
-        }
-
-        await this.base.importLayouts(layouts, mode);
-    }
-
-    public handleOnSaved(callback: (layout: IOConnectWorkspaces.WorkspaceLayout) => void): UnsubscribeFunction {
-        return this.base.handleOnSaved(callback);
-    }
-
-    public handleOnRemoved(callback: (layout: IOConnectWorkspaces.WorkspaceLayout) => void): UnsubscribeFunction {
-        return this.base.handleOnRemoved(callback);
-    }
-
-    public async bundleWorkspaceTo(type: "row" | "column", workspaceId: string): Promise<void> {
-        return await this.base.bundleWorkspaceTo(type, workspaceId);
-    }
-
-    public async bundleItemTo(type: "row" | "column", id: string): Promise<void> {
-        return await this.base.bundleItemTo(type, id);
-    }
-
-    public getWorkspaceContext(workspaceId: string): Promise<any> {
-        return this.base.getWorkspaceContext(workspaceId);
-    }
-
-    public setWorkspaceContext(workspaceId: string, data: any): Promise<void> {
-        return this.base.setWorkspaceContext(workspaceId, data);
-    }
-
-    public updateWorkspaceContext(workspaceId: string, data: any): Promise<void> {
-        return this.base.updateWorkspaceContext(workspaceId, data);
-    }
-
-    public subscribeWorkspaceContextUpdated(workspaceId: string, callback: (data: any) => void): Promise<import("callback-registry").UnsubscribeFunction> {
-        return this.base.subscribeWorkspaceContextUpdated(workspaceId, callback);
-    }
-
-    public async restoreItem(itemId: string): Promise<void> {
-        return await this.base.restoreItem(itemId);
-    }
-
-    public async maximizeItem(itemId: string): Promise<void> {
-        return await this.base.maximizeItem(itemId);
-    }
-
-    public async focusItem(itemId: string): Promise<void> {
-        return await this.base.focusItem(itemId);
-    }
-
-    public async changeFrameState(frameId: string, state: IOConnectWorkspaces.FrameState): Promise<void> {
-        await this.bridge.send<void>(OPERATIONS.changeFrameState.name, { frameId, requestedState: state });
-    }
-
-    public async getFrameBounds(frameId: string): Promise<IOConnectWorkspaces.FrameBounds> {
-        const frameResult = await this.bridge.send<FrameBoundsResult>(OPERATIONS.getFrameBounds.name, { itemId: frameId });
-        return frameResult.bounds;
-    }
-
-    public async getFrameState(frameId: string): Promise<IOConnectWorkspaces.FrameState> {
-        const frameResult = await this.bridge.send<FrameStateResult>(OPERATIONS.getFrameState.name, { itemId: frameId });
-        return frameResult.state;
-    }
-
-    public async closeItem(itemId: string): Promise<void> {
-        return await this.base.closeItem(itemId);
-    }
-
-    public async resizeItem(itemId: string, config: IOConnectWorkspaces.ResizeConfig): Promise<void> {
-        return await this.base.resizeItem(itemId, config);
-    }
-
-    public async setMaximizationBoundary(itemId: string, config: IOConnectWorkspaces.SetMaximizationBoundaryConfig): Promise<void> {
-        return await this.base.setMaximizationBoundary(itemId, config);
-    }
-
-    public async showWorkspaceLoadingAnimation(workspaceId: string): Promise<void> {
-        return await this.base.showWorkspaceLoadingAnimation(workspaceId);
-    }
-
-    public async hideWorkspaceLoadingAnimation(workspaceId: string): Promise<void> {
-        return await this.base.hideWorkspaceLoadingAnimation(workspaceId);
-    }
-
-    public async moveFrame(itemId: string, config: IOConnectWorkspaces.MoveConfig): Promise<void> {
-        return await this.base.moveFrame(itemId, config);
-    }
-
-    public getGDWindow(itemId: string): GDWindow {
-        return this.base.getGDWindow(itemId);
-    }
-
-    public async forceLoadWindow(itemId: string): Promise<string> {
-        const windowId = await this.base.forceLoadWindow(itemId);
-
-        await this.base.notifyWindowAdded(windowId);
-
-        return windowId;
-    }
-
-    public async ejectWindow(itemId: string): Promise<string> {
-        const windowId: string = (await this.base.ejectWindow(itemId)).windowId;
-
-        await this.base.notifyWindowAdded(windowId);
-
-        return windowId;
-    }
-
-    public async moveWindowTo(itemId: string, newParentId: string): Promise<void> {
-        return await this.base.moveWindowTo(itemId, newParentId);
-    }
-
-    public async getSnapshot(itemId: string, type: "workspace"): Promise<WorkspaceSnapshotResult>
-    public async getSnapshot(itemId: string, type: "frame"): Promise<FrameSnapshotResult>
-    public async getSnapshot(itemId: string, type: "workspace" | "frame"): Promise<WorkspaceSnapshotResult | FrameSnapshotResult> {
-        return await this.base.getSnapshot(itemId, type);
-    }
-
-    public async setItemTitle(itemId: string, title: string): Promise<void> {
-        return await this.base.setItemTitle(itemId, title);
-    }
-
-    public flatChildren(children: Child[]): Child[] {
-        return children.reduce<Child[]>((soFar, child) => {
-
-            soFar.push(child);
-
-            if (child.type !== "window") {
-                soFar.push(...this.flatChildren(child.children));
-            }
-
-            return soFar;
-        }, []);
-    }
-
-    public refreshChildren(config: RefreshChildrenConfig): Child[] {
-        return this.base.refreshChildren(config);
-    }
-
-    public iterateFindChild(children: Child[], predicate: (child: Child) => boolean): Child {
-        return this.base.iterateFindChild(children, predicate);
-    }
-
-    public iterateFilterChildren(children: Child[], predicate: (child: Child) => boolean): Child[] {
-        return this.base.iterateFilterChildren(children, predicate);
-    }
-
-    public hibernateWorkspace(workspaceId: string): Promise<void> {
-        return this.base.hibernateWorkspace(workspaceId);
-    }
-
-    public resumeWorkspace(workspaceId: string): Promise<void> {
-        return this.base.resumeWorkspace(workspaceId);
-    }
-
-    public lockWorkspace(workspaceId: string, config?: IOConnectWorkspaces.WorkspaceLockConfig): Promise<void> {
-        return this.base.lockWorkspace(workspaceId, config);
-    }
-
-    public lockWindow(windowPlacementId: string, config?: IOConnectWorkspaces.WorkspaceWindowLockConfig): Promise<void> {
-        return this.base.lockWindow(windowPlacementId, config);
-    }
-
-    public lockContainer(itemId: string, type: SubParentTypes["type"], config?: ContainerLockConfig): Promise<void> {
-        return this.base.lockContainer(itemId, type, config);
-    }
-
-    public pinWorkspace(workspaceId: string, icon?: string): Promise<void> {
-        return this.base.pinWorkspace(workspaceId, icon);
-    }
-
-    public unpinWorkspace(workspaceId: string): Promise<void> {
-        return this.base.unpinWorkspace(workspaceId);
-    }
-
-    public getWorkspaceIcon(workspaceId: string): Promise<string> {
-        return this.base.getWorkspaceIcon(workspaceId);
-    }
-
-    public setWorkspaceIcon(workspaceId: string, icon: string): Promise<void> {
-        return this.base.setWorkspaceIcon(workspaceId, icon);
-    }
-
-    public async getFrameConstraints(frameId: string): Promise<IOConnectWorkspaces.FrameConstraints> {
-        const frameSnapshot = await this.getSnapshot(frameId, "frame");
-
-        return {
-            minWidth: frameSnapshot.config.minWidth,
-            maxWidth: frameSnapshot.config.maxWidth,
-            minHeight: frameSnapshot.config.minHeight,
-            maxHeight: frameSnapshot.config.maxHeight,
-        };
-    }
-
-    public registerShortcut(shortcut: string, frameId: string, callback: () => void): Promise<UnsubscribeFunction> {
-        return this.shortcutsController.registerShortcut(shortcut, frameId, callback);
-    }
-
-    public getPlatformFrameId(): Promise<{id?: string}> {
-        return this.base.getPlatformFrameId();
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    private async handleCoreLocalSubscription(config: SubscriptionConfig, levelId: string): Promise<IOConnectWorkspaces.Unsubscribe> {
-        await this.bridge.createCoreEventSubscription();
-
-        config.scopeId = config.scopeId || levelId;
-
-        if (config.eventType === "window" && config.action === "loaded") {
-            const originalCB = config.callback;
-
-            const wrappedCB = async (callbackData: WindowStreamData): Promise<void> => {
-
-                await this.base.notifyWindowAdded(callbackData.windowSummary.config.windowId);
-
-                originalCB(callbackData);
-            };
-
-            config.callback = wrappedCB;
-        }
-
-        return this.bridge.handleCoreSubscription(config);
-    }
-
-    private handleEnterpriseLocalSubscription(config: SubscriptionConfig, levelId: string): Promise<IOConnectWorkspaces.Unsubscribe> {
-        config.scopeId = config.scopeId || levelId;
-
-        if (config.eventType === "window" && config.action === "loaded") {
-            const originalCB = config.callback;
-
-            const wrappedCB = async (callbackData: WindowStreamData): Promise<void> => {
-                await this.base.notifyWindowAdded(callbackData.windowSummary.config.windowId);
-                originalCB(callbackData);
-            };
-
-            config.callback = wrappedCB;
-        }
-
-        return this.bridge.subscribe(config);
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    private async handleCoreGlobalSubscription(callback: (callbackData: unknown) => void | Promise<void>, eventType: WorkspaceEventType, action: WorkspaceEventAction): Promise<IOConnectWorkspaces.Unsubscribe> {
-        await this.bridge.createCoreEventSubscription();
-
-        const config: SubscriptionConfig = {
-            eventType, callback, action,
-            scope: "global",
-        };
-
-        if (eventType === "window" && action === "loaded") {
-            const wrappedCB = async (callbackData: WindowStreamData): Promise<void> => {
-
-                await this.base.notifyWindowAdded(callbackData.windowSummary.config.windowId);
-
-                callback(callbackData);
-            };
-
-            config.callback = wrappedCB;
-        }
-
-        return this.bridge.handleCoreSubscription(config);
-    }
-
-    private handleEnterpriseGlobalSubscription(callback: (callbackData: unknown) => void | Promise<void>, eventType: WorkspaceEventType, action: WorkspaceEventAction): Promise<IOConnectWorkspaces.Unsubscribe> {
-        const config: SubscriptionConfig = {
-            eventType, callback, action,
-            scope: "global",
-        };
-
-        if (eventType === "window" && action === "loaded") {
-            const wrappedCB = async (callbackData: WindowStreamData): Promise<void> => {
-
-                await this.base.notifyWindowAdded(callbackData.windowSummary.config.windowId);
-
-                callback(callbackData);
-            };
-
-            config.callback = wrappedCB;
-        }
-
-        return this.bridge.subscribe(config);
-    }
-
-    private async iterateWorkspaces(callback: (workspace: Workspace, end: () => void) => void): Promise<void> {
-        let ended = false;
-
-        const end = (): void => { ended = true; };
-
-        const workspaceSummaries = await this.getAllWorkspaceSummaries();
-
-        for (const summary of workspaceSummaries) {
-            if (ended) {
-                return;
-            }
-
-            const wsp = await this.base.fetchWorkspace(summary.id);
-
-            callback(wsp, end);
-        }
-    }
-}

package/src/controllers/shortcuts.ts

@@ -1,28 +0,0 @@
-import { UnsubscribeFunction } from "callback-registry";
-import { Bridge } from "../communication/bridge";
-import { CLIENT_OPERATIONS, OPERATIONS } from "../communication/constants";
-import CallbackRegistry from "callback-registry";
-
-
-export class ShortcutsController {
-    private _shortcuts = CallbackRegistry();
-    constructor(
-        private readonly bridge: Bridge,
-    ) {
-        this.bridge.onOperation((payload, caller) => {
-            if (payload.operation === CLIENT_OPERATIONS.shortcutClicked.name) {
-                const data = payload.data;
-                this._shortcuts.execute(`${data.frameId}-${data.shortcut}`);
-            }
-        })
-    }
-
-    public async registerShortcut(shortcut: string, frameId: string, callback: () => void): Promise<UnsubscribeFunction> {
-        await this.bridge.send<void>(OPERATIONS.registerShortcut.name, { shortcut, frameId });
-        const un = this._shortcuts.add(`${frameId}-${shortcut}`, callback);
-        return () => {
-            un();
-            this.bridge.send<void>(OPERATIONS.unregisterShortcut.name, { shortcut, frameId });
-        }
-    }
-}

package/src/index.ts

@@ -1,23 +0,0 @@
-import { IoC } from "./shared/ioc";
-import { composeAPI } from "./main";
-import { WorkspacesFactoryFunction } from "../workspaces";
-
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const factoryFunction: WorkspacesFactoryFunction = async (io: any): Promise<void> => {
-
-    const ioc = new IoC(io.agm, io.windows, io.layouts, io.contexts);
-
-    const actualWindowId = io.interop.instance.windowId;
-
-    await ioc.initiate(actualWindowId);
-
-    io.workspaces = composeAPI(io, ioc);
-};
-
-// attach to window object
-if (typeof window !== "undefined") {
-    /* eslint-disable @typescript-eslint/no-explicit-any */
-    (window as any).IOWorkspaces = factoryFunction;
-}
-
-export default factoryFunction;