@interopio/workspaces-api 3.2.1 → 3.2.3

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 },
-};

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);
-        });
-    }
-}