@interopio/workspaces-api 3.2.2 → 3.2.3

package/src/builders/parentBuilder.ts

@@ -1,62 +0,0 @@
-import { BaseBuilder } from "./baseBuilder";
-import { ChildBuilder } from "../types/builders";
-import { IOConnectWorkspaces } from "../../workspaces";
-
-interface PrivateData {
-    definition: IOConnectWorkspaces.BoxDefinition;
-    base: BaseBuilder;
-    children: ChildBuilder[];
-}
-
-const privateData = new WeakMap<ParentBuilder, PrivateData>();
-
-export class ParentBuilder implements ParentBuilder {
-
-    constructor(
-        definition: IOConnectWorkspaces.BoxDefinition,
-        base: BaseBuilder
-    ) {
-        const children = base.wrapChildren(definition.children);
-
-        delete definition.children;
-
-        privateData.set(this, { base, children, definition });
-    }
-
-    public get type(): "column" | "row" | "group" {
-        return privateData.get(this).definition.type;
-    }
-
-    public addColumn(definition?: IOConnectWorkspaces.BoxDefinition): ParentBuilder {
-        const base = privateData.get(this).base;
-
-        return base.add("column", privateData.get(this).children, definition);
-    }
-
-    public addRow(definition?: IOConnectWorkspaces.BoxDefinition): ParentBuilder {
-        const base = privateData.get(this).base;
-
-        return base.add("row", privateData.get(this).children, definition);
-    }
-
-    public addGroup(definition?: IOConnectWorkspaces.BoxDefinition): ParentBuilder {
-        const base = privateData.get(this).base;
-
-        return base.add("group", privateData.get(this).children, definition);
-    }
-
-    public addWindow(definition: IOConnectWorkspaces.WorkspaceWindowDefinition): ParentBuilder {
-        const base = privateData.get(this).base;
-
-        base.addWindow(privateData.get(this).children, definition);
-
-        return this;
-    }
-
-    public serialize(): IOConnectWorkspaces.BoxDefinition {
-        const definition = privateData.get(this).definition;
-        definition.children = privateData.get(this).base.serializeChildren(privateData.get(this).children);
-        return definition;
-    }
-
-}

package/src/builders/workspaceBuilder.ts

@@ -1,102 +0,0 @@
-import { BaseBuilder } from "./baseBuilder";
-import { ChildBuilder } from "../types/builders";
-import { ParentBuilder } from "./parentBuilder";
-import { workspaceBuilderCreateConfigDecoder, nonNegativeNumberDecoder } from "../shared/decoders";
-import { IOConnectWorkspaces } from "../../workspaces";
-import { WorkspacesController } from "../types/controller";
-
-interface PrivateData {
-    definition: IOConnectWorkspaces.WorkspaceDefinition;
-    children: ChildBuilder[];
-    base: BaseBuilder;
-    controller: WorkspacesController;
-}
-
-const privateData = new WeakMap<WorkspaceBuilder, PrivateData>();
-
-export class WorkspaceBuilder implements WorkspaceBuilder {
-
-    constructor(
-        definition: IOConnectWorkspaces.WorkspaceDefinition,
-        base: BaseBuilder,
-        controller: WorkspacesController
-    ) {
-        const children = base.wrapChildren(definition.children);
-
-        delete definition.children;
-
-        privateData.set(this, { base, children, definition, controller });
-    }
-
-    public addColumn(definition?: IOConnectWorkspaces.BoxDefinition): ParentBuilder {
-        const children = privateData.get(this).children;
-
-        const areAllColumns = children.every((child) => child instanceof ParentBuilder && child.type === "column");
-
-        if (!areAllColumns) {
-            throw new Error("Cannot add a column to this workspace, because there are already children of another type");
-        }
-
-        const base = privateData.get(this).base;
-
-        return base.add("column", children, definition);
-    }
-
-    public addRow(definition?: IOConnectWorkspaces.BoxDefinition): ParentBuilder {
-        const children = privateData.get(this).children;
-
-        const areAllRows = children.every((child) => child instanceof ParentBuilder && child.type === "row");
-
-        if (!areAllRows) {
-            throw new Error("Cannot add a row to this workspace, because there are already children of another type");
-        }
-
-        const base = privateData.get(this).base;
-
-        return base.add("row", children, definition);
-    }
-
-    public addGroup(definition?: IOConnectWorkspaces.BoxDefinition): ParentBuilder {
-        const children = privateData.get(this).children;
-
-        if (children.length !== 0) {
-            throw new Error("Cannot add a group to this workspace, because there are already defined children.");
-        }
-
-        const base = privateData.get(this).base;
-
-        return base.add("group", children, definition);
-    }
-
-    public addWindow(definition: IOConnectWorkspaces.WorkspaceWindowDefinition): WorkspaceBuilder {
-        const children = privateData.get(this).children;
-
-        if (children.length !== 0) {
-            throw new Error("Cannot add a window to this workspace, because there are already defined children.");
-        }
-
-        const base = privateData.get(this).base;
-
-        base.addWindow(children, definition);
-
-        return this;
-    }
-
-    public getChildAt(index: number): ChildBuilder {
-        nonNegativeNumberDecoder.runWithException(index);
-        const data = privateData.get(this).children;
-
-        return data[index];
-    }
-
-    public async create(config?: IOConnectWorkspaces.WorkspaceCreateConfig): Promise<IOConnectWorkspaces.Workspace> {
-        const saveConfig = workspaceBuilderCreateConfigDecoder.runWithException(config);
-
-        const definition = privateData.get(this).definition;
-        definition.children = privateData.get(this).base.serializeChildren(privateData.get(this).children);
-
-        const controller = privateData.get(this).controller;
-
-        return controller.createWorkspace(definition, saveConfig);
-    }
-}

package/src/communication/bridge.ts

@@ -1,263 +0,0 @@
-import { CallbackRegistry, UnsubscribeFunction } from "callback-registry";
-import { SubscriptionConfig, ActiveSubscription, WorkspaceEventType, WorkspaceEventAction, WorkspacePayload, WorkspaceEventScope, PendingSubscription } from "../types/subscription";
-import { ClientOperations, CLIENT_OPERATIONS, STREAMS } from "./constants";
-import { OPERATIONS } from "./constants";
-import { eventTypeDecoder, streamRequestArgumentsDecoder, workspaceEventActionDecoder } from "../shared/decoders";
-import { IOConnectWorkspaces } from "../../workspaces";
-import { InteropTransport } from "./interop-transport";
-import { PromiseWrapper } from "../shared/promiseWrapper";
-import { Instance } from "../types/glue";
-
-export class Bridge {
-
-    private readonly activeSubscriptions: ActiveSubscription[] = [];
-    private readonly pendingSubScriptions: PendingSubscription[] = [];
-
-    constructor(
-        private readonly transport: InteropTransport,
-        private readonly registry: CallbackRegistry
-    ) { }
-
-    public async createCoreEventSubscription(): Promise<void> {
-        await this.transport.coreSubscriptionReady(this.handleCoreEvent.bind(this));
-    }
-
-    public handleCoreSubscription(config: SubscriptionConfig): UnsubscribeFunction {
-        const registryKey = `${config.eventType}-${config.action}`;
-        const scope = config.scope;
-        const scopeId = config.scopeId;
-
-        return this.registry.add(registryKey, (args) => {
-            const scopeConfig = {
-                type: scope,
-                id: scopeId
-            };
-
-            const receivedIds = {
-                frame: args.frameSummary?.id || args.windowSummary?.config.frameId,
-                workspace: args.workspaceSummary?.id || args.windowSummary?.config.workspaceId,
-                container: args.containerSummary?.itemId,
-                window: args.windowSummary?.itemId
-            };
-
-            const shouldInvokeCallback = this.checkScopeMatch(scopeConfig, receivedIds);
-
-            if (!shouldInvokeCallback) {
-                return;
-            }
-
-            config.callback(args);
-        });
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    public async send<T>(operationName: string, operationArgs?: any): Promise<T> {
-
-        const operationDefinition = Object.values(OPERATIONS).find((operation) => operation.name === operationName);
-
-        if (!operationDefinition) {
-            throw new Error(`Cannot find definition for operation name: ${operationName}`);
-        }
-
-        if (operationDefinition.argsDecoder) {
-            try {
-                operationDefinition.argsDecoder.runWithException(operationArgs);
-            } catch (error) {
-                throw new Error(`Unexpected internal outgoing validation error: ${error.message}, for input: ${JSON.stringify(error.input)}, for operation ${operationName}`);
-            }
-        }
-
-        try {
-            const operationResult = await this.transport.transmitControl(operationDefinition.name, operationArgs);
-
-            operationDefinition.resultDecoder.runWithException(operationResult);
-
-            return operationResult;
-        } catch (error) {
-            if (error.kind) {
-                throw new Error(`Unexpected internal incoming validation error: ${error.message}, for input: ${JSON.stringify(error.input)}, for operation ${operationName}`);
-            }
-            throw new Error(error.message);
-        }
-    }
-
-    public async subscribe(config: SubscriptionConfig): Promise<IOConnectWorkspaces.Unsubscribe> {
-        const pendingSub = this.getPendingSubscription(config);
-        if (pendingSub) {
-            await pendingSub.promise;
-        }
-
-        let activeSub = this.getActiveSubscription(config);
-        const registryKey = this.getRegistryKey(config);
-
-        if (!activeSub) {
-            const pendingPromise = new PromiseWrapper<void>();
-            const pendingSubscription = {
-                streamType: config.eventType,
-                level: config.scope,
-                levelId: config.scopeId,
-                promise: pendingPromise.promise
-            };
-            this.pendingSubScriptions.push(pendingSubscription);
-            try {
-                const stream = STREAMS[config.eventType];
-                const gdSub = await this.transport.subscribe(stream.name, this.getBranchKey(config), config.eventType);
-
-                gdSub.onData((streamData) => {
-                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-                    const data = streamData.data as { action: string; payload: any };
-
-                    // important to decode without exception, because we do not want to throw an exception here
-                    const requestedArgumentsResult = streamRequestArgumentsDecoder.run(streamData.requestArguments);
-                    const actionResult = workspaceEventActionDecoder.run(data.action);
-
-                    if (!requestedArgumentsResult.ok || !actionResult.ok) {
-                        return;
-                    }
-
-                    const streamType = requestedArgumentsResult.result.type;
-                    const branch = requestedArgumentsResult.result.branch;
-
-                    const keyToExecute = `${streamType}-${branch}-${actionResult.result}`;
-                    const validatedPayload = STREAMS[streamType].payloadDecoder.run(data.payload);
-                    if (!validatedPayload.ok) {
-                        return;
-                    }
-
-                    this.registry.execute(keyToExecute, validatedPayload.result);
-                });
-
-                activeSub = {
-                    streamType: config.eventType,
-                    level: config.scope,
-                    levelId: config.scopeId,
-                    callbacksCount: 0,
-                    gdSub
-                };
-
-                this.activeSubscriptions.push(activeSub);
-
-                pendingPromise.resolve();
-            } catch (error) {
-                pendingPromise.reject(error);
-
-                throw error;
-            } finally {
-                this.removePendingSubscription(pendingSubscription);
-            }
-
-        }
-
-        const unsubscribe = this.registry.add(registryKey, config.callback);
-
-        ++activeSub.callbacksCount;
-
-        return (): void => {
-            unsubscribe();
-            --activeSub.callbacksCount;
-
-            if (activeSub.callbacksCount === 0) {
-                activeSub.gdSub.close();
-                this.activeSubscriptions.splice(this.activeSubscriptions.indexOf(activeSub), 1);
-            }
-        };
-    }
-
-    public onOperation(callback: (operation: ClientOperations, caller: Instance) => void) {
-
-        const wrappedCallback = (payload: ClientOperations, caller: Instance) => {
-            const operationName = payload.operation;
-            const operationArgs = payload.data;
-            const operationDefinition = Object.values(CLIENT_OPERATIONS).find((operation) => operation.name === operationName);
-
-            if (!operationDefinition) {
-                throw new Error(`Cannot find definition for operation name: ${operationName}`);
-            }
-
-            if (operationDefinition.argsDecoder) {
-                try {
-                    operationDefinition.argsDecoder.runWithException(operationArgs);
-                } catch (error) {
-                    throw new Error(`Unexpected internal outgoing validation error: ${error.message}, for input: ${JSON.stringify(error.input)}, for operation ${operationName}`);
-                }
-            }
-
-            callback(payload, caller);
-        };
-
-        return this.transport.onInternalMethodInvoked("control", wrappedCallback);
-    }
-
-    private checkScopeMatch(scope: { type: WorkspaceEventScope; id?: string }, receivedIds: { frame: string; workspace: string; container: string; window: string }): boolean {
-
-        if (scope.type === "global") {
-            return true;
-        }
-
-        if (scope.type === "frame" && scope.id === receivedIds.frame) {
-            return true;
-        }
-
-        if (scope.type === "workspace" && scope.id === receivedIds.workspace) {
-            return true;
-        }
-
-        if (scope.type === "container" && scope.id === receivedIds.container) {
-            return true;
-        }
-
-        if (scope.type === "window" && scope.id === receivedIds.window) {
-            return true;
-        }
-
-        return false;
-    }
-
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    private handleCoreEvent(args: any): void {
-        const data = args.data;
-        try {
-            const verifiedAction: WorkspaceEventAction = workspaceEventActionDecoder.runWithException(data.action);
-            const verifiedType: WorkspaceEventType = eventTypeDecoder.runWithException(data.type);
-            const verifiedPayload: WorkspacePayload = STREAMS[verifiedType].payloadDecoder.runWithException(data.payload);
-
-            const registryKey = `${verifiedType}-${verifiedAction}`;
-
-            this.registry.execute(registryKey, verifiedPayload);
-        } catch (error) {
-            console.warn(`Cannot handle event with data ${JSON.stringify(data)}, because of validation error: ${error.message}`);
-        }
-    }
-
-    private getBranchKey(config: SubscriptionConfig): string {
-        return config.scope === "global" ? config.scope : `${config.scope}_${config.scopeId}`;
-    }
-
-    private getRegistryKey(config: SubscriptionConfig): string {
-        return `${config.eventType}-${this.getBranchKey(config)}-${config.action}`;
-    }
-
-    private getActiveSubscription(config: SubscriptionConfig): ActiveSubscription {
-        return this.activeSubscriptions
-            .find((activeSub) => activeSub.streamType === config.eventType &&
-                activeSub.level === config.scope &&
-                activeSub.levelId === config.scopeId
-            );
-    }
-
-    private getPendingSubscription(config: SubscriptionConfig): PendingSubscription {
-        return this.pendingSubScriptions
-            .find((activeSub) => activeSub.streamType === config.eventType &&
-                activeSub.level === config.scope &&
-                activeSub.levelId === config.scopeId
-            );
-    }
-
-    private removePendingSubscription(pendingSubscription: PendingSubscription): void {
-        const index = this.pendingSubScriptions.indexOf(pendingSubscription);
-
-        if (index >= 0) {
-            this.pendingSubScriptions.splice(index, 1);
-        }
-    }
-}

package/src/communication/constants.ts

@@ -1,202 +0,0 @@
-import {
-    isWindowInSwimlaneResultDecoder,
-    frameSummaryDecoder,
-    workspaceSnapshotResultDecoder,
-    frameSummariesResultDecoder,
-    workspaceCreateConfigDecoder,
-    getFrameSummaryConfigDecoder,
-    layoutSummariesDecoder,
-    openWorkspaceConfigDecoder,
-    workspaceSummariesResultDecoder,
-    voidResultDecoder,
-    exportedLayoutsResultDecoder,
-    workspaceLayoutDecoder,
-    deleteLayoutConfigDecoder,
-    simpleItemConfigDecoder,
-    resizeItemConfigDecoder,
-    moveFrameConfigDecoder,
-    frameSnapshotResultDecoder,
-    simpleWindowOperationSuccessResultDecoder,
-    setItemTitleConfigDecoder,
-    moveWindowConfigDecoder,
-    addWindowConfigDecoder,
-    addContainerConfigDecoder,
-    addItemResultDecoder,
-    bundleWorkspaceConfigDecoder,
-    workspaceStreamDataDecoder,
-    frameStreamDataDecoder,
-    containerStreamDataDecoder,
-    windowStreamDataDecoder,
-    workspaceLayoutSaveConfigDecoder,
-    pingResultDecoder,
-    frameStateConfigDecoder,
-    frameStateResultDecoder,
-    workspacesImportLayoutDecoder,
-    workspaceSelectorDecoder,
-    lockWorkspaceDecoder,
-    lockWindowDecoder,
-    lockContainerDecoder,
-    frameBoundsResultDecoder,
-    getWorkspaceIconResultDecoder,
-    pinWorkspaceDecoder,
-    setWorkspaceIconDecoder,
-    frameSummaryResultDecoder,
-    emptyFrameDefinitionDecoder,
-    frameInitProtocolConfigDecoder,
-    shortcutClickedDataDecoder,
-    shortcutConfigDecoder,
-    frameSnapshotConfigDecoder,
-    setMaximizationBoundaryConfigDecoder,
-    loadingAnimationConfigDecoder,
-    getPlatformFrameIdResultDecoder,
-    workspacesImportLayoutsDecoder,
-    bundleItemConfigDecoder,
-    operationCheckConfigDecoder,
-    operationCheckResultDecoder
-} from "../shared/decoders";
-import { ControlOperation, StreamOperation } from "../types/protocol";
-import { WorkspaceEventType } from "../types/subscription";
-
-type OperationsTypes = "isWindowInWorkspace" |
-    "createWorkspace" |
-    "getAllFramesSummaries" |
-    "getFrameSummary" |
-    "getAllWorkspacesSummaries" |
-    "getWorkspaceSnapshot" |
-    "getAllLayoutsSummaries" |
-    "openWorkspace" |
-    "deleteLayout" |
-    "saveLayout" |
-    "importLayout" |
-    "importLayouts" |
-    "exportAllLayouts" |
-    "restoreItem" |
-    "maximizeItem" |
-    "focusItem" |
-    "closeItem" |
-    "resizeItem" |
-    "setMaximizationBoundary" |
-    "moveFrame" |
-    "getFrameSnapshot" |
-    "forceLoadWindow" |
-    "ejectWindow" |
-    "setItemTitle" |
-    "moveWindowTo" |
-    "addWindow" |
-    "addContainer" |
-    "bundleWorkspace" |
-    "bundleItem" |
-    "ping" |
-    "changeFrameState" |
-    "getFrameState" |
-    "getFrameBounds" |
-    "hibernateWorkspace" |
-    "resumeWorkspace" |
-    "lockWorkspace" |
-    "lockWindow" |
-    "lockContainer" |
-    "pinWorkspace" |
-    "unpinWorkspace" |
-    "getWorkspaceIcon" |
-    "setWorkspaceIcon" |
-    "createFrame" |
-    "registerShortcut" |
-    "unregisterShortcut" |
-    "initFrame" |
-    "showLoadingAnimation" |
-    "hideLoadingAnimation" |
-    "getPlatformFrameId" |
-    "operationCheck";
-type OutgoingMethodTypes = "control" | "frameStream" | "workspaceStream" | "containerStream" | "windowStream";
-export type IncomingMethodTypes = "control";
-
-export const webPlatformMethodName = "T42.Web.Platform.Control";
-export const webPlatformWspStreamName = "T42.Web.Platform.WSP.Stream";
-
-export const OUTGOING_METHODS: { [key in OutgoingMethodTypes]: { name: string; isStream: boolean } } = {
-    control: { name: "T42.Workspaces.Control", isStream: false },
-    frameStream: { name: "T42.Workspaces.Stream.Frame", isStream: true },
-    workspaceStream: { name: "T42.Workspaces.Stream.Workspace", isStream: true },
-    containerStream: { name: "T42.Workspaces.Stream.Container", isStream: true },
-    windowStream: { name: "T42.Workspaces.Stream.Window", isStream: true }
-};
-
-export const INCOMING_METHODS: { [key in IncomingMethodTypes]: { name: string; isStream: boolean } } = {
-    control: { name: "T42.Workspaces.Client.Control", isStream: false },
-};
-
-export const STREAMS: { [key in WorkspaceEventType]: StreamOperation } = {
-    frame: { name: "T42.Workspaces.Stream.Frame", payloadDecoder: frameStreamDataDecoder },
-    workspace: { name: "T42.Workspaces.Stream.Workspace", payloadDecoder: workspaceStreamDataDecoder },
-    container: { name: "T42.Workspaces.Stream.Container", payloadDecoder: containerStreamDataDecoder },
-    window: { name: "T42.Workspaces.Stream.Window", payloadDecoder: windowStreamDataDecoder }
-};
-
-interface ShortcutClicked {
-    operation: "shortcutClicked",
-    data: {
-        shortcut: string;
-        frameId: string;
-    }
-}
-
-export type ClientOperations = ShortcutClicked;
-
-export type OnOperationsTypes = "shortcutClicked";
-
-export const CLIENT_OPERATIONS: { [key in OnOperationsTypes]: ControlOperation } = {
-    shortcutClicked: { name: "shortcutClicked", argsDecoder: shortcutClickedDataDecoder, resultDecoder: voidResultDecoder },
-};
-
-export const OPERATIONS: { [key in OperationsTypes]: ControlOperation } = {
-    ping: { name: "ping", resultDecoder: pingResultDecoder },
-    isWindowInWorkspace: { name: "isWindowInWorkspace", argsDecoder: simpleItemConfigDecoder, resultDecoder: isWindowInSwimlaneResultDecoder },
-    createWorkspace: { name: "createWorkspace", resultDecoder: workspaceSnapshotResultDecoder, argsDecoder: workspaceCreateConfigDecoder },
-    createFrame: { name: "createFrame", resultDecoder: frameSummaryResultDecoder, argsDecoder: emptyFrameDefinitionDecoder },
-    initFrame: { name: "initFrame", resultDecoder: voidResultDecoder, argsDecoder: frameInitProtocolConfigDecoder },
-    getAllFramesSummaries: { name: "getAllFramesSummaries", resultDecoder: frameSummariesResultDecoder },
-    getFrameSummary: { name: "getFrameSummary", resultDecoder: frameSummaryDecoder, argsDecoder: getFrameSummaryConfigDecoder },
-    getAllWorkspacesSummaries: { name: "getAllWorkspacesSummaries", resultDecoder: workspaceSummariesResultDecoder },
-    getWorkspaceSnapshot: { name: "getWorkspaceSnapshot", resultDecoder: workspaceSnapshotResultDecoder, argsDecoder: simpleItemConfigDecoder },
-    getAllLayoutsSummaries: { name: "getAllLayoutsSummaries", resultDecoder: layoutSummariesDecoder },
-    openWorkspace: { name: "openWorkspace", argsDecoder: openWorkspaceConfigDecoder, resultDecoder: workspaceSnapshotResultDecoder },
-    deleteLayout: { name: "deleteLayout", resultDecoder: voidResultDecoder, argsDecoder: deleteLayoutConfigDecoder },
-    saveLayout: { name: "saveLayout", resultDecoder: workspaceLayoutDecoder, argsDecoder: workspaceLayoutSaveConfigDecoder },
-    importLayout: { name: "importLayout", resultDecoder: voidResultDecoder, argsDecoder: workspacesImportLayoutDecoder },
-    importLayouts: { name: "importLayouts", resultDecoder: voidResultDecoder, argsDecoder: workspacesImportLayoutsDecoder },
-    exportAllLayouts: { name: "exportAllLayouts", resultDecoder: exportedLayoutsResultDecoder },
-    restoreItem: { name: "restoreItem", argsDecoder: simpleItemConfigDecoder, resultDecoder: voidResultDecoder },
-    maximizeItem: { name: "maximizeItem", argsDecoder: simpleItemConfigDecoder, resultDecoder: voidResultDecoder },
-    focusItem: { name: "focusItem", argsDecoder: simpleItemConfigDecoder, resultDecoder: voidResultDecoder },
-    closeItem: { name: "closeItem", argsDecoder: simpleItemConfigDecoder, resultDecoder: voidResultDecoder },
-    resizeItem: { name: "resizeItem", argsDecoder: resizeItemConfigDecoder, resultDecoder: voidResultDecoder },
-    setMaximizationBoundary: { name: "setMaximizationBoundary", argsDecoder: setMaximizationBoundaryConfigDecoder, resultDecoder: voidResultDecoder },
-    changeFrameState: { name: "changeFrameState", argsDecoder: frameStateConfigDecoder, resultDecoder: voidResultDecoder },
-    getFrameState: { name: "getFrameState", argsDecoder: simpleItemConfigDecoder, resultDecoder: frameStateResultDecoder },
-    getFrameBounds: { name: "getFrameBounds", argsDecoder: simpleItemConfigDecoder, resultDecoder: frameBoundsResultDecoder },
-    moveFrame: { name: "moveFrame", argsDecoder: moveFrameConfigDecoder, resultDecoder: voidResultDecoder },
-    getFrameSnapshot: { name: "getFrameSnapshot", argsDecoder: frameSnapshotConfigDecoder, resultDecoder: frameSnapshotResultDecoder },
-    forceLoadWindow: { name: "forceLoadWindow", argsDecoder: simpleItemConfigDecoder, resultDecoder: simpleWindowOperationSuccessResultDecoder },
-    ejectWindow: { name: "ejectWindow", argsDecoder: simpleItemConfigDecoder, resultDecoder: simpleWindowOperationSuccessResultDecoder },
-    setItemTitle: { name: "setItemTitle", argsDecoder: setItemTitleConfigDecoder, resultDecoder: voidResultDecoder },
-    moveWindowTo: { name: "moveWindowTo", argsDecoder: moveWindowConfigDecoder, resultDecoder: voidResultDecoder },
-    addWindow: { name: "addWindow", argsDecoder: addWindowConfigDecoder, resultDecoder: addItemResultDecoder },
-    addContainer: { name: "addContainer", argsDecoder: addContainerConfigDecoder, resultDecoder: addItemResultDecoder },
-    bundleWorkspace: { name: "bundleWorkspace", argsDecoder: bundleWorkspaceConfigDecoder, resultDecoder: voidResultDecoder },
-    bundleItem: { name: "bundleItem", argsDecoder: bundleItemConfigDecoder, resultDecoder: voidResultDecoder },
-    hibernateWorkspace: { name: "hibernateWorkspace", argsDecoder: workspaceSelectorDecoder, resultDecoder: voidResultDecoder },
-    resumeWorkspace: { name: "resumeWorkspace", argsDecoder: workspaceSelectorDecoder, resultDecoder: voidResultDecoder },
-    lockWorkspace: { name: "lockWorkspace", argsDecoder: lockWorkspaceDecoder, resultDecoder: voidResultDecoder },
-    lockWindow: { name: "lockWindow", argsDecoder: lockWindowDecoder, resultDecoder: voidResultDecoder },
-    lockContainer: { name: "lockContainer", argsDecoder: lockContainerDecoder, resultDecoder: voidResultDecoder },
-    pinWorkspace: { name: "pinWorkspace", argsDecoder: pinWorkspaceDecoder, resultDecoder: voidResultDecoder },
-    unpinWorkspace: { name: "unpinWorkspace", argsDecoder: workspaceSelectorDecoder, resultDecoder: voidResultDecoder },
-    getWorkspaceIcon: { name: "getWorkspaceIcon", argsDecoder: workspaceSelectorDecoder, resultDecoder: getWorkspaceIconResultDecoder },
-    setWorkspaceIcon: { name: "setWorkspaceIcon", argsDecoder: setWorkspaceIconDecoder, resultDecoder: voidResultDecoder },
-    registerShortcut: { name: "registerShortcut", argsDecoder: shortcutConfigDecoder, resultDecoder: voidResultDecoder },
-    unregisterShortcut: { name: "unregisterShortcut", argsDecoder: shortcutConfigDecoder, resultDecoder: voidResultDecoder },
-    showLoadingAnimation: { name: "showLoadingAnimation", argsDecoder: loadingAnimationConfigDecoder, resultDecoder: voidResultDecoder },
-    hideLoadingAnimation: { name: "hideLoadingAnimation", argsDecoder: loadingAnimationConfigDecoder, resultDecoder: voidResultDecoder },
-    getPlatformFrameId: { name: "getPlatformFrameId", resultDecoder: getPlatformFrameIdResultDecoder },
-    operationCheck: { name: "operationCheck", argsDecoder: operationCheckConfigDecoder, resultDecoder: operationCheckResultDecoder },
-};