@interopio/workspaces-api 3.2.2 → 3.2.3

package/src/communication/interop-transport.ts

@@ -1,175 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { ClientOperations, IncomingMethodTypes, INCOMING_METHODS, OUTGOING_METHODS, webPlatformMethodName, webPlatformWspStreamName } from "./constants";
-import { promisePlus } from "../shared/promisePlus";
-import { WorkspaceEventType } from "../types/subscription";
-import { InteropAPI, Subscription, InvocationResult, Instance } from "../types/glue";
-import { CallbackRegistry } from "callback-registry";
-
-export class InteropTransport {
-
-    private readonly defaultTransportTimeout: number = 30000;
-    private coreEventMethodInitiated = false;
-    private corePlatformSubPromise: Promise<Subscription>;
-
-    constructor(private readonly agm: InteropAPI,
-        private readonly registry: CallbackRegistry) { }
-
-    public async initiate(actualWindowId: string): Promise<void> {
-
-        const desktopGlobal = (window as any).glue42gd || (window as any).iodesktop;
-
-        if (desktopGlobal) {
-            await Promise.all(
-                Object.values(OUTGOING_METHODS).map((method) => {
-                    return this.verifyMethodLive(method.name);
-                })
-            );
-
-            await Promise.all(
-                Object.keys(INCOMING_METHODS).map((method: IncomingMethodTypes) => {
-                    return this.registerMethod(method);
-                })
-            );
-
-            return;
-        }
-
-        const browserGlobal = (window as any).glue42core || (window as any).iobrowser;
-
-        const systemId = browserGlobal.communicationId;
-
-        await Promise.all([
-            this.verifyMethodLive(webPlatformMethodName, systemId),
-            this.verifyMethodLive(webPlatformWspStreamName, systemId)
-        ]);
-
-        await this.transmitControl("frameHello", { windowId: actualWindowId });
-    }
-
-    public coreSubscriptionReady(eventCallback: (args?: any) => void): Promise<Subscription> {
-        if (!this.coreEventMethodInitiated) {
-            this.subscribePlatform(eventCallback);
-        }
-        return this.corePlatformSubPromise;
-    }
-
-    public subscribePlatform(eventCallback: (args?: any) => void): void {
-        this.coreEventMethodInitiated = true;
-
-        const browserGlobal = (window as any).glue42core || (window as any).iobrowser;
-
-        const systemId = browserGlobal.communicationId;
-
-        this.corePlatformSubPromise = this.agm.subscribe(webPlatformWspStreamName, systemId ? { target: { instance: systemId } } : undefined);
-
-        this.corePlatformSubPromise
-            .then((sub) => {
-                sub.onData((data) => eventCallback(data.data));
-            });
-    }
-
-    public async subscribe(streamName: string, streamBranch: string, streamType: WorkspaceEventType): Promise<Subscription> {
-
-        const subscriptionArgs = {
-            branch: streamBranch,
-            type: streamType
-        };
-
-        let subscription: Subscription;
-
-        try {
-            subscription = await this.agm.subscribe(streamName, { arguments: subscriptionArgs });
-        } catch (error) {
-            const message = `Internal subscription error! Error details: stream - ${streamName}, branch: ${streamBranch}. Internal message: ${error.message}`;
-            throw new Error(message);
-        }
-
-        return subscription;
-    }
-
-    public async transmitControl(operation: string, operationArguments: any): Promise<any> {
-
-        const desktopGlobal = (window as any).glue42gd || (window as any).iodesktop;
-        const browserGlobal = (window as any).glue42core || (window as any).iobrowser;
-        
-        const invocationArguments = desktopGlobal ? { operation, operationArguments } : { operation, domain: "workspaces", data: operationArguments };
-        const methodName = desktopGlobal ? OUTGOING_METHODS.control.name : webPlatformMethodName;
-
-        const platformTarget = desktopGlobal ? undefined : browserGlobal.communicationId;
-
-        let invocationResult: InvocationResult<any>;
-        const baseErrorMessage = `Internal Workspaces Communication Error. Attempted operation: ${JSON.stringify(invocationArguments)}. `;
-
-        // using the 0 index of the errors and values collections, because we expect only one server and
-        // this is to safeguard in case in future we decide to deprecate the default returned/message properties in favor of using only collections
-        try {
-            invocationResult = await this.agm.invoke(methodName, invocationArguments, platformTarget ? { instance: platformTarget } : "best", { methodResponseTimeoutMs: this.defaultTransportTimeout });
-
-            if (!invocationResult) {
-                throw new Error("Received unsupported result from GD - empty result");
-            }
-
-            if (!Array.isArray(invocationResult.all_return_values) || invocationResult.all_return_values.length === 0) {
-                throw new Error("Received unsupported result from GD - empty values collection");
-            }
-
-        } catch (error) {
-            if (error && error.all_errors && error.all_errors.length) {
-                // IMPORTANT: Do NOT change the `Inner message:` string, because it is used by other programs to extract the inner message of a communication error
-                const invocationErrorMessage = error.all_errors[0].message;
-                throw new Error(`${baseErrorMessage} -> Inner message: ${invocationErrorMessage}`);
-
-            }
-            // IMPORTANT: Do NOT change the `Inner message:` string, because it is used by other programs to extract the inner message of a communication error
-            throw new Error(`${baseErrorMessage} -> Inner message: ${error.message}`);
-        }
-
-        return invocationResult.all_return_values[0].returned;
-    }
-
-    public onInternalMethodInvoked(key: IncomingMethodTypes, callback: (operation: ClientOperations, caller: Instance) => void) {
-        return this.registry.add(key, callback);
-    }
-
-    private verifyMethodLive(name: string, systemId?: string): Promise<void> {
-        return promisePlus(() => {
-            return new Promise((resolve) => {
-                const hasMethod = this.agm.methods().some((method) => {
-                    const nameMatch = method.name === name;
-    
-                    const serverMatch = systemId ?
-                        method.getServers().some((server) => server.instance === systemId) :
-                        true;
-    
-                    return nameMatch && serverMatch;
-                });
-
-                if (hasMethod) {
-                    resolve();
-                    return;
-                }
-
-                const unSub = this.agm.serverMethodAdded((data) => {
-                    const method = data.method;
-                    const server = data.server;
-    
-                    const serverMatch = systemId ?
-                        server.instance === systemId :
-                        true;
-    
-                    if (method.name === name && serverMatch) {
-                        unSub();
-                        resolve();
-                    }
-                });
-            });
-        }, 15000, "Timeout waiting for the Workspaces communication channels");
-    }
-
-    private registerMethod(key: IncomingMethodTypes) {
-        const method = INCOMING_METHODS[key];
-        return this.agm.register(method.name, (args, caller) => {
-            this.registry.execute(key, args, caller);
-        });
-    }
-}

package/src/controllers/base.ts

@@ -1,487 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { Workspace } from "../models/workspace";
-import { WorkspaceSnapshotResult, WorkspaceCreateConfigProtocol, FrameSummaryResult, AddItemResult, WorkspaceSummariesResult, WorkspaceSummaryResult, SimpleWindowOperationSuccessResult, FrameSnapshotResult, WorkspaceStreamData, GetPlatformFrameIdResult, OperationCheckResult } from "../types/protocol";
-import { OPERATIONS } from "../communication/constants";
-import { FrameCreateConfig, WorkspaceIoCCreateConfig, WindowCreateConfig, ParentCreateConfig } from "../types/ioc";
-import { IoC } from "../shared/ioc";
-import { Bridge } from "../communication/bridge";
-import { GDWindow, WindowsAPI, ContextsAPI, LayoutsAPI } from "../types/glue";
-import { IOConnectWorkspaces } from "../../workspaces";
-import { Frame } from "../models/frame";
-import { RefreshChildrenConfig } from "../types/privateData";
-import { AllParentTypes, Child, ContainerLockConfig, SubParentTypes } from "../types/builders";
-import { PrivateDataManager } from "../shared/privateDataManager";
-import { Window } from "../models/window";
-import { UnsubscribeFunction } from "callback-registry";
-
-export class BaseController {
-
-    constructor(
-        private readonly ioc: IoC,
-        private readonly windows: WindowsAPI,
-        private readonly contexts: ContextsAPI,
-        private readonly layouts: LayoutsAPI,
-    ) { }
-
-    private get bridge(): Bridge {
-        return this.ioc.bridge;
-    }
-
-    private get privateDataManager(): PrivateDataManager {
-        return this.ioc.privateDataManager;
-    }
-
-    public checkIsWindowLoaded(windowId: string): boolean {
-        return (!!windowId) && this.windows.list().some((win) => win.id === windowId);
-    }
-
-    public async createWorkspace(createConfig: WorkspaceCreateConfigProtocol): Promise<Workspace> {
-        const snapshot = await this.bridge.send<WorkspaceSnapshotResult>(OPERATIONS.createWorkspace.name, createConfig);
-
-        const frameConfig: FrameCreateConfig = {
-            summary: snapshot.frameSummary
-        };
-        const frame = this.ioc.getModel<"frame">("frame", frameConfig);
-
-        const workspaceConfig: WorkspaceIoCCreateConfig = { frame, snapshot };
-
-        return this.ioc.getModel<"workspace">("workspace", workspaceConfig);
-    }
-
-    public async createEmptyFrame(definition: IOConnectWorkspaces.EmptyFrameDefinition): Promise<Frame> {
-        const frameSummary = await this.bridge.send<FrameSummaryResult>(OPERATIONS.createFrame.name, definition);
-        const frameConfig: FrameCreateConfig = {
-            summary: frameSummary
-        };
-
-        return this.ioc.getModel<"frame">("frame", frameConfig);
-    }
-
-    public async initFrame(frameId: string, config: IOConnectWorkspaces.FrameInitializationConfig): Promise<void> {
-        await this.bridge.send<void>(OPERATIONS.initFrame.name, { frameId, ...config });
-    }
-
-    public async restoreWorkspace(name: string, options: IOConnectWorkspaces.RestoreWorkspaceConfig): Promise<Workspace> {
-        const snapshot = await this.bridge.send<WorkspaceSnapshotResult>(OPERATIONS.openWorkspace.name, { name, restoreOptions: options });
-
-        const frameSummary = await this.bridge.send<FrameSummaryResult>(OPERATIONS.getFrameSummary.name, { itemId: snapshot.config.frameId });
-
-        const frameConfig: FrameCreateConfig = {
-            summary: frameSummary
-        };
-        const frame = this.ioc.getModel<"frame">("frame", frameConfig);
-
-        const workspaceConfig: WorkspaceIoCCreateConfig = { frame, snapshot };
-
-        return this.ioc.getModel<"workspace">("workspace", workspaceConfig);
-    }
-
-    public async add(type: "container" | "window", parentId: string, parentType: "row" | "column" | "group" | "workspace", definition: IOConnectWorkspaces.WorkspaceWindowDefinition | IOConnectWorkspaces.BoxDefinition): Promise<AddItemResult> {
-        let operationName: string;
-        const operationArgs = { definition, parentId, parentType };
-
-        if (type === "window") {
-            operationName = OPERATIONS.addWindow.name;
-        } else if (type === "container") {
-            operationName = OPERATIONS.addContainer.name;
-        } else {
-            throw new Error(`Unrecognized add type: ${type}`);
-        }
-
-        return await this.bridge.send<AddItemResult>(operationName, operationArgs);
-    }
-
-    public async getFrame(windowId: string): Promise<Frame> {
-        const frameSummary = await this.bridge.send<FrameSummaryResult>(OPERATIONS.getFrameSummary.name, { itemId: windowId });
-
-        const frameConfig: FrameCreateConfig = {
-            summary: frameSummary
-        };
-        return this.ioc.getModel<"frame">("frame", frameConfig);
-
-    }
-
-    public getFrames(allFrameSummaries: FrameSummaryResult[], predicate?: (frame: Frame) => boolean): Frame[] {
-
-        return allFrameSummaries.reduce<Frame[]>((frames, frameSummary) => {
-
-            const frameConfig: FrameCreateConfig = {
-                summary: frameSummary
-            };
-            const frameToCheck = this.ioc.getModel<"frame">("frame", frameConfig);
-
-            if (!predicate || predicate(frameToCheck)) {
-                frames.push(frameToCheck);
-            }
-
-            return frames;
-        }, []);
-    }
-
-    public getAllWorkspaceSummaries(...bridgeResults: WorkspaceSummariesResult[]): IOConnectWorkspaces.WorkspaceSummary[] {
-
-        const allSummaries = bridgeResults.reduce<WorkspaceSummaryResult[]>((summaries, summaryResult) => {
-            summaries.push(...summaryResult.summaries);
-            return summaries;
-        }, []);
-
-        return allSummaries.map<IOConnectWorkspaces.WorkspaceSummary>((summary) => {
-
-            return Object.assign(
-                {},
-                { id: summary.id, width: summary.config.widthInPx, height: summary.config.heightInPx },
-                summary.config
-            );
-        });
-    }
-
-    public handleOnSaved(callback: (layout: IOConnectWorkspaces.WorkspaceLayout) => void): UnsubscribeFunction {
-        const wrappedCallback = (layout: IOConnectWorkspaces.WorkspaceLayout): void => {
-            if (layout.type !== "Workspace") {
-                return;
-            }
-
-            callback(layout);
-        };
-
-        const addedUnSub: UnsubscribeFunction = this.layouts.onAdded(wrappedCallback);
-        const changedUnSub: UnsubscribeFunction = this.layouts.onChanged(wrappedCallback);
-
-        return (): void => {
-            addedUnSub();
-            changedUnSub();
-        };
-    }
-
-    public handleOnRemoved(callback: (layout: IOConnectWorkspaces.WorkspaceLayout) => void): UnsubscribeFunction {
-        const wrappedCallback = (layout: IOConnectWorkspaces.WorkspaceLayout): void => {
-            if (layout.type !== "Workspace") {
-                return;
-            }
-
-            callback(layout);
-        };
-
-        return this.layouts.onRemoved(wrappedCallback);
-    }
-
-    public async importLayouts(layouts: IOConnectWorkspaces.WorkspaceLayout[], mode: "replace" | "merge"): Promise<void> {
-        await this.layouts.import(layouts, mode);
-    }
-
-    public async transformStreamPayloadToWorkspace(payload: WorkspaceStreamData): Promise<Workspace> {
-        const frameConfig: FrameCreateConfig = {
-            summary: payload.frameSummary
-        };
-        const frame = this.ioc.getModel<"frame">("frame", frameConfig);
-
-        const snapshot = payload.workspaceSnapshot || (await this.bridge.send<WorkspaceSnapshotResult>(OPERATIONS.getWorkspaceSnapshot.name, { itemId: payload.workspaceSummary.id }));
-
-        const workspaceConfig: WorkspaceIoCCreateConfig = { frame, snapshot };
-
-        const workspace = this.ioc.getModel<"workspace">("workspace", workspaceConfig);
-
-        return workspace;
-    }
-
-    public async fetchWorkspace(itemId: string): Promise<Workspace> {
-
-        const snapshot = await this.bridge.send<WorkspaceSnapshotResult>(OPERATIONS.getWorkspaceSnapshot.name, { itemId });
-
-        const frameConfig: FrameCreateConfig = {
-            summary: snapshot.frameSummary
-        };
-
-        const frame = this.ioc.getModel<"frame">("frame", frameConfig);
-
-        const workspaceConfig: WorkspaceIoCCreateConfig = { frame, snapshot };
-
-        return this.ioc.getModel<"workspace">("workspace", workspaceConfig);
-
-    }
-
-    public async bundleWorkspaceTo(type: "row" | "column", workspaceId: string): Promise<void> {
-        await this.bridge.send(OPERATIONS.bundleWorkspace.name, { type, workspaceId });
-    }
-
-    public async bundleItemTo(type: "row" | "column", itemId: string): Promise<void> {
-        const isSupported = await this.isOperationSupported(OPERATIONS.bundleItem.name);
-
-        if (!isSupported) {
-            throw new Error(`Operation ${OPERATIONS.bundleItem.name} is not supported. Ensure that you are running the latest version of all packages`);
-        }
-
-        await this.bridge.send(OPERATIONS.bundleItem.name, { type, itemId });
-    }
-
-    public getWorkspaceContext(workspaceId: string): Promise<any> {
-        const contextName = `___workspace___${workspaceId}`;
-        return this.contexts.get(contextName);
-    }
-
-    public setWorkspaceContext(workspaceId: string, data: any): Promise<void> {
-        const contextName = `___workspace___${workspaceId}`;
-        return this.contexts.set(contextName, data);
-    }
-
-    public updateWorkspaceContext(workspaceId: string, data: any): Promise<void> {
-        const contextName = `___workspace___${workspaceId}`;
-        return this.contexts.update(contextName, data);
-    }
-
-    public subscribeWorkspaceContextUpdated(workspaceId: string, callback: (data: any) => void): Promise<UnsubscribeFunction> {
-        const contextName = `___workspace___${workspaceId}`;
-        return this.contexts.subscribe(contextName, callback);
-    }
-
-    public async restoreItem(itemId: string): Promise<void> {
-        await this.bridge.send(OPERATIONS.restoreItem.name, { itemId });
-    }
-
-    public async maximizeItem(itemId: string): Promise<void> {
-        await this.bridge.send(OPERATIONS.maximizeItem.name, { itemId });
-    }
-
-    public async focusItem(itemId: string): Promise<void> {
-        await this.bridge.send(OPERATIONS.focusItem.name, { itemId });
-    }
-
-    public async closeItem(itemId: string): Promise<void> {
-        await this.bridge.send(OPERATIONS.closeItem.name, { itemId });
-    }
-
-    public async resizeItem(itemId: string, config: IOConnectWorkspaces.ResizeConfig): Promise<void> {
-        await this.bridge.send(OPERATIONS.resizeItem.name, Object.assign({}, { itemId }, config));
-    }
-
-    public async setMaximizationBoundary(itemId: string, config: IOConnectWorkspaces.SetMaximizationBoundaryConfig): Promise<void> {
-        await this.bridge.send(OPERATIONS.setMaximizationBoundary.name, Object.assign({}, { itemId }, config));
-    }
-
-    public async showWorkspaceLoadingAnimation(workspaceId: string): Promise<void> {
-        await this.bridge.send(OPERATIONS.showLoadingAnimation.name, { itemId: workspaceId, type: "workspace" });
-    }
-
-    public async hideWorkspaceLoadingAnimation(workspaceId: string): Promise<void> {
-        await this.bridge.send(OPERATIONS.hideLoadingAnimation.name, { itemId: workspaceId, type: "workspace" });
-    }
-
-    public async moveFrame(itemId: string, config: IOConnectWorkspaces.MoveConfig): Promise<void> {
-        await this.bridge.send(OPERATIONS.moveFrame.name, Object.assign({}, { itemId }, config));
-    }
-
-    public getGDWindow(itemId: string): GDWindow {
-        return this.windows.list().find((gdWindow) => gdWindow.id === itemId);
-    }
-
-    public async forceLoadWindow(itemId: string): Promise<string> {
-        const controlResult = await this.bridge.send<SimpleWindowOperationSuccessResult>(OPERATIONS.forceLoadWindow.name, { itemId });
-
-        return controlResult.windowId;
-    }
-
-    public async ejectWindow(itemId: string): Promise<SimpleWindowOperationSuccessResult> {
-        return await this.bridge.send<SimpleWindowOperationSuccessResult>(OPERATIONS.ejectWindow.name, { itemId });
-    }
-
-    public async moveWindowTo(itemId: string, newParentId: string): Promise<void> {
-        await this.bridge.send(OPERATIONS.moveWindowTo.name, { itemId, containerId: newParentId });
-    }
-
-    public async getSnapshot(itemId: string, type: "workspace" | "frame"): Promise<WorkspaceSnapshotResult | FrameSnapshotResult> {
-        let result: WorkspaceSnapshotResult | FrameSnapshotResult;
-
-        if (type === "workspace") {
-            result = await this.bridge.send<WorkspaceSnapshotResult>(OPERATIONS.getWorkspaceSnapshot.name, { itemId });
-        } else if (type === "frame") {
-            result = await this.bridge.send<FrameSnapshotResult>(OPERATIONS.getFrameSnapshot.name, { itemId });
-        }
-
-        return result;
-    }
-
-    public async setItemTitle(itemId: string, title: string): Promise<void> {
-        await this.bridge.send(OPERATIONS.setItemTitle.name, { itemId, title });
-    }
-
-    public refreshChildren(config: RefreshChildrenConfig): Child[] {
-        const { parent, children, existingChildren, workspace } = config;
-        if (parent instanceof Window || (parent as IOConnectWorkspaces.WorkspaceWindow).type === "window") {
-            return;
-        }
-
-        const newChildren = children.map((newChildSnapshot) => {
-            let childToAdd = existingChildren.find((child) => {
-                return child.type === "window" ? child.elementId === newChildSnapshot.id : child.id === newChildSnapshot.id;
-            });
-
-            if (childToAdd) {
-                this.privateDataManager.remapChild(childToAdd, {
-                    parent: parent as AllParentTypes,
-                    children: [],
-                    config: newChildSnapshot.config
-                });
-            } else {
-                let createConfig: WindowCreateConfig | ParentCreateConfig;
-                if (newChildSnapshot.type === "window") {
-                    createConfig = {
-                        id: newChildSnapshot.id,
-                        parent: parent as AllParentTypes,
-                        frame: workspace.frame,
-                        workspace,
-                        config: newChildSnapshot.config,
-                    } as WindowCreateConfig;
-                } else {
-                    createConfig = {
-                        id: newChildSnapshot.id,
-                        parent: parent as AllParentTypes,
-                        frame: workspace.frame,
-                        workspace,
-                        config: newChildSnapshot.config,
-                        children: []
-                    } as ParentCreateConfig;
-                }
-
-                childToAdd = this.ioc.getModel<"child">(newChildSnapshot.type, createConfig);
-            }
-
-            if (newChildSnapshot.type !== "window") {
-                this.refreshChildren({
-                    workspace, existingChildren,
-                    children: newChildSnapshot.children,
-                    parent: childToAdd
-                });
-            }
-
-            return childToAdd;
-        });
-
-        if (parent instanceof Workspace) {
-            return newChildren;
-        } else {
-            this.privateDataManager.remapChild(parent as SubParentTypes, { children: newChildren });
-            return newChildren;
-        }
-    }
-
-    public iterateFindChild(children: Child[], predicate: (child: Child) => boolean): Child {
-        let foundChild = children.find((child) => predicate(child));
-
-        if (foundChild) {
-            return foundChild;
-        }
-
-        children.some((child) => {
-            if (child instanceof Window) {
-                return false;
-            }
-
-            foundChild = this.iterateFindChild((child as SubParentTypes).children, predicate);
-
-            if (foundChild) {
-                return true;
-            }
-        });
-
-        return foundChild;
-    }
-
-    public iterateFilterChildren(children: Child[], predicate: (child: Child) => boolean): Child[] {
-        const foundChildren = children.filter((child) => predicate(child));
-
-        const grandChildren = children.reduce<Child[]>((innerFound, child) => {
-            if (child instanceof Window) {
-                return innerFound;
-            }
-
-            innerFound.push(...this.iterateFilterChildren((child as SubParentTypes).children, predicate));
-
-            return innerFound;
-        }, []);
-
-        foundChildren.push(...grandChildren);
-
-        return foundChildren;
-    }
-
-    public notifyWindowAdded(windowId: string): Promise<void> {
-        return new Promise((resolve) => {
-
-            const alreadyPresent: boolean = this.windows.list().some((win) => win.id === windowId);
-
-            if (alreadyPresent) {
-                return resolve();
-            }
-
-            const unsubscribe: UnsubscribeFunction = this.windows.onWindowAdded((win) => {
-
-                if (win.id !== windowId) {
-                    return;
-                }
-
-                if (unsubscribe) {
-                    unsubscribe();
-                }
-
-                resolve();
-            });
-        });
-    }
-
-    public async hibernateWorkspace(workspaceId: string): Promise<void> {
-        await this.bridge.send<void>(OPERATIONS.hibernateWorkspace.name, { workspaceId });
-    }
-
-    public async resumeWorkspace(workspaceId: string): Promise<void> {
-        await this.bridge.send<void>(OPERATIONS.resumeWorkspace.name, { workspaceId });
-    }
-
-    public async lockWorkspace(workspaceId: string, config?: IOConnectWorkspaces.WorkspaceLockConfig): Promise<void> {
-        await this.bridge.send<void>(OPERATIONS.lockWorkspace.name, { workspaceId, config });
-    }
-
-    public async lockWindow(windowPlacementId: string, config?: IOConnectWorkspaces.WorkspaceWindowLockConfig): Promise<void> {
-        await this.bridge.send<void>(OPERATIONS.lockWindow.name, { windowPlacementId, config });
-    }
-
-    public async lockContainer(itemId: string, type: SubParentTypes["type"], config?: ContainerLockConfig): Promise<void> {
-        await this.bridge.send<void>(OPERATIONS.lockContainer.name, { itemId, type, config });
-    }
-
-    public async pinWorkspace(workspaceId: string, icon?: string): Promise<void> {
-        await this.bridge.send<void>(OPERATIONS.pinWorkspace.name, { workspaceId, icon });
-    }
-
-    public async unpinWorkspace(workspaceId: string): Promise<void> {
-        await this.bridge.send<void>(OPERATIONS.unpinWorkspace.name, { workspaceId });
-    }
-
-    public async getWorkspaceIcon(workspaceId: string): Promise<string> {
-        const result = await this.bridge.send<{ icon: string }>(OPERATIONS.getWorkspaceIcon.name, { workspaceId });
-        return result.icon;
-    }
-
-    public setWorkspaceIcon(workspaceId: string, icon: string): Promise<void> {
-        return this.bridge.send<void>(OPERATIONS.setWorkspaceIcon.name, { workspaceId, icon });
-    }
-
-    public async getPlatformFrameId(): Promise<GetPlatformFrameIdResult> {
-        try {
-            const result = await this.bridge.send<GetPlatformFrameIdResult>(OPERATIONS.getPlatformFrameId.name, {});
-
-            return result;
-        } catch (error) {
-            return {}
-        }
-    }
-
-    public async isOperationSupported(operation: string): Promise<OperationCheckResult> {
-        const desktopGlobal = (window as any).glue42gd || (window as any).iodesktop;
-
-        if (desktopGlobal) {
-            // operation check is not supported in Glue42Desktop
-            return { isSupported: true };
-        }
-        return await this.bridge.send<OperationCheckResult>(OPERATIONS.operationCheck.name, { operation });
-    }
-}