@interopio/workspaces-api 3.5.6 → 3.5.7

package/dist/workspaces.umd.js

@@ -916,6 +916,13 @@
 	const isWindowInSwimlaneResultDecoder = object({
 	    inWorkspace: boolean()
 	});
+	const iconDecoder = object({
+	    base64Image: nonEmptyStringDecoder
+	});
+	const setIconArgumentsDecoder = object({
+	    icon: iconDecoder,
+	    frameId: nonEmptyStringDecoder
+	});
 	const allParentDecoder = oneOf(constant("workspace"), constant("row"), constant("column"), constant("group"));
 	const subParentDecoder = oneOf(constant("row"), constant("column"), constant("group"));
 	const frameStateDecoder = oneOf(constant("maximized"), constant("minimized"), constant("normal"));
@@ -1345,6 +1352,14 @@
 	const simpleItemConfigDecoder = object({
 	    itemId: nonEmptyStringDecoder
 	});
+	const closeOptionsDecoder = object({
+	    allowPrevent: optional(boolean()),
+	    showDialog: optional(boolean()),
+	});
+	const closeItemConfigDecoder = object({
+	    itemId: nonEmptyStringDecoder,
+	    closeOptions: optional(closeOptionsDecoder)
+	});
 	const frameSnapshotConfigDecoder = object({
 	    itemId: nonEmptyStringDecoder,
 	    excludeIds: optional(boolean())
@@ -1518,6 +1533,9 @@
 	    shortcut: nonEmptyStringDecoder,
 	    frameId: nonEmptyStringDecoder
 	});
+	const frameClosingDataDecoder = object({
+	    frameId: nonEmptyStringDecoder,
+	});
 	const setMaximizationBoundaryAPIConfigDecoder = object({
 	    enabled: boolean()
 	});
@@ -1536,6 +1554,9 @@
 	    itemId: nonEmptyStringDecoder,
 	    strategy: loadingStrategyDecoder
 	});
+	const frameClosingResultDecoder = object({
+	    prevent: boolean()
+	});
 
 	const webPlatformMethodName = "T42.Web.Platform.Control";
 	const webPlatformWspStreamName = "T42.Web.Platform.WSP.Stream";
@@ -1557,6 +1578,7 @@
 	};
 	const CLIENT_OPERATIONS = {
 	    shortcutClicked: { name: "shortcutClicked", argsDecoder: shortcutClickedDataDecoder, resultDecoder: voidResultDecoder },
+	    frameClosing: { name: "frameClosing", argsDecoder: frameClosingDataDecoder, resultDecoder: frameClosingResultDecoder },
 	};
 	const OPERATIONS = {
 	    ping: { name: "ping", resultDecoder: pingResultDecoder },
@@ -1578,7 +1600,7 @@
 	    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 },
+	    closeItem: { name: "closeItem", argsDecoder: closeItemConfigDecoder, resultDecoder: voidResultDecoder },
 	    resizeItem: { name: "resizeItem", argsDecoder: resizeItemConfigDecoder, resultDecoder: voidResultDecoder },
 	    setMaximizationBoundary: { name: "setMaximizationBoundary", argsDecoder: setMaximizationBoundaryConfigDecoder, resultDecoder: voidResultDecoder },
 	    changeFrameState: { name: "changeFrameState", argsDecoder: frameStateConfigDecoder, resultDecoder: voidResultDecoder },
@@ -1610,7 +1632,10 @@
 	    getPlatformFrameId: { name: "getPlatformFrameId", resultDecoder: getPlatformFrameIdResultDecoder },
 	    operationCheck: { name: "operationCheck", argsDecoder: operationCheckConfigDecoder, resultDecoder: operationCheckResultDecoder },
 	    setWindowDragMode: { name: "setWindowDragMode", argsDecoder: setWindowDragModeDecoder, resultDecoder: voidResultDecoder },
-	    setLoadingStrategy: { name: "setLoadingStrategy", argsDecoder: setLoadingStrategyDecoder, resultDecoder: voidResultDecoder }
+	    setLoadingStrategy: { name: "setLoadingStrategy", argsDecoder: setLoadingStrategyDecoder, resultDecoder: voidResultDecoder },
+	    getTaskbarIcon: { name: "getTaskbarIcon", resultDecoder: iconDecoder },
+	    setTaskbarIcon: { name: "setTaskbarIcon", argsDecoder: setIconArgumentsDecoder, resultDecoder: voidResultDecoder },
+	    subscribeToFrameClosing: { name: "subscribeToFrameClosing", argsDecoder: simpleItemConfigDecoder, resultDecoder: voidResultDecoder }
 	};
 
 	class PromiseWrapper {
@@ -1768,6 +1793,35 @@
 	        };
 	        return this.transport.onInternalMethodInvoked("control", wrappedCallback);
 	    }
+	    onOperationWithResponse(callback) {
+	        const wrappedCallback = async (payload, caller) => {
+	            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}`);
+	                }
+	            }
+	            const result = await callback(payload, caller);
+	            if (operationDefinition.resultDecoder) {
+	                try {
+	                    operationDefinition.resultDecoder.runWithException(result);
+	                }
+	                catch (error) {
+	                    throw new Error(`Unexpected internal outgoing result validation error: ${error.message}, for input: ${JSON.stringify(error.input)}, for operation ${operationName}`);
+	                }
+	            }
+	            return result;
+	        };
+	        return this.transport.onInternalMethodInvoked("control", wrappedCallback);
+	    }
 	    checkScopeMatch(scope, receivedIds) {
 	        if (scope.type === "global") {
 	            return true;
@@ -1981,7 +2035,7 @@
 	    registerMethod(key) {
 	        const method = INCOMING_METHODS[key];
 	        return this.agm.register(method.name, (args, caller) => {
-	            this.registry.execute(key, args, caller);
+	            return Promise.all(this.registry.execute(key, args, caller));
 	        });
 	    }
 	}
@@ -3434,6 +3488,21 @@
 	        const myId = getData$1(this).summary.id;
 	        return getData$1(this).controller.getFrameState(myId);
 	    }
+	    setIcon(icon) {
+	        if (!isDesktop()) {
+	            throw new Error("frame.setIcon() is not supported in IO Connect Browser");
+	        }
+	        iconDecoder.runWithException(icon);
+	        const frameId = this.id;
+	        return getData$1(this).controller.setTaskbarIcon(icon, frameId);
+	    }
+	    getIcon() {
+	        if (!isDesktop()) {
+	            throw new Error("frame.getIcon() is not supported in IO Connect Browser");
+	        }
+	        const frameId = this.id;
+	        return getData$1(this).controller.getTaskbarIcon(frameId);
+	    }
 	    async minimize() {
 	        if (!isDesktop()) {
 	            throw new Error("State operations are not supported in IO Connect Browser");
@@ -3455,9 +3524,10 @@
 	        const myId = getData$1(this).summary.id;
 	        return getData$1(this).controller.changeFrameState(myId, "normal");
 	    }
-	    close() {
+	    close(options) {
+	        const validatedOptions = optional(closeOptionsDecoder).runWithException(options);
 	        const myId = getData$1(this).summary.id;
-	        return getData$1(this).controller.closeItem(myId);
+	        return getData$1(this).controller.closeFrame(myId, validatedOptions);
 	    }
 	    snapshot() {
 	        const myId = getData$1(this).summary.id;
@@ -3489,6 +3559,20 @@
 	        }
 	        return getData$1(this).controller.initFrame(this.id, config);
 	    }
+	    async onClosing(callback) {
+	        if (!isDesktop()) {
+	            throw new Error("Frame closing operations are not supported in io.Connect Browser");
+	        }
+	        checkThrowCallback(callback);
+	        const wrappedCallback = async () => {
+	            let shouldPrevent = false;
+	            const preventClose = () => shouldPrevent = true;
+	            await callback({ prevent: preventClose });
+	            return { prevent: shouldPrevent };
+	        };
+	        const unsubscribe = await getData$1(this).controller.registerFrameOnClosing(this.id, wrappedCallback);
+	        return unsubscribe;
+	    }
 	    async onClosed(callback) {
 	        checkThrowCallback(callback);
 	        const myId = getData$1(this).summary.id;
@@ -4174,6 +4258,12 @@
 	        }
 	        await this.bridge.send(OPERATIONS.bundleItem.name, { type, itemId });
 	    }
+	    async getTaskbarIcon(frameId) {
+	        return await this.bridge.send(OPERATIONS.getTaskbarIcon.name, { frameId });
+	    }
+	    async setTaskbarIcon(icon, frameId) {
+	        await this.bridge.send(OPERATIONS.setTaskbarIcon.name, { icon, frameId });
+	    }
 	    getWorkspaceContext(workspaceId) {
 	        const contextName = `___workspace___${workspaceId}`;
 	        return this.contexts.get(contextName);
@@ -4202,6 +4292,9 @@
 	    async closeItem(itemId) {
 	        await this.bridge.send(OPERATIONS.closeItem.name, { itemId });
 	    }
+	    async closeFrame(itemId, closeOptions) {
+	        await this.bridge.send(OPERATIONS.closeItem.name, { itemId, closeOptions });
+	    }
 	    async resizeItem(itemId, config) {
 	        await this.bridge.send(OPERATIONS.resizeItem.name, Object.assign({}, { itemId }, config));
 	    }
@@ -4400,10 +4493,18 @@
 	    bridge;
 	    base;
 	    shortcutsController;
-	    constructor(bridge, base, shortcutsController) {
+	    closingController;
+	    constructor(bridge, base, shortcutsController, closingController) {
 	        this.bridge = bridge;
 	        this.base = base;
 	        this.shortcutsController = shortcutsController;
+	        this.closingController = closingController;
+	    }
+	    setTaskbarIcon(icon, frameId) {
+	        return this.base.setTaskbarIcon(icon, frameId);
+	    }
+	    getTaskbarIcon(frameId) {
+	        return this.base.getTaskbarIcon(frameId);
 	    }
 	    checkIsWindowLoaded(windowId) {
 	        return this.base.checkIsWindowLoaded(windowId);
@@ -4606,6 +4707,9 @@
 	    async closeItem(itemId) {
 	        return await this.base.closeItem(itemId);
 	    }
+	    async closeFrame(itemId, closeOptions) {
+	        return await this.base.closeFrame(itemId, closeOptions);
+	    }
 	    async resizeItem(itemId, config) {
 	        return await this.base.resizeItem(itemId, config);
 	    }
@@ -4709,6 +4813,9 @@
 	    setLoadingStrategy(workspaceId, strategy) {
 	        return this.base.setLoadingStrategy(workspaceId, strategy);
 	    }
+	    registerFrameOnClosing(frameId, callback) {
+	        return this.closingController.registerFrameOnClosing(frameId, callback);
+	    }
 	    async handleCoreLocalSubscription(config, levelId) {
 	        await this.bridge.createCoreEventSubscription();
 	        config.scopeId = config.scopeId || levelId;
@@ -4782,7 +4889,7 @@
 	    _shortcuts = CallbackFactory();
 	    constructor(bridge) {
 	        this.bridge = bridge;
-	        this.bridge.onOperation((payload, caller) => {
+	        this.bridge.onOperation((payload) => {
 	            if (payload.operation === CLIENT_OPERATIONS.shortcutClicked.name) {
 	                const data = payload.data;
 	                this._shortcuts.execute(`${data.frameId}-${data.shortcut}`);
@@ -4799,6 +4906,34 @@
 	    }
 	}
 
+	class ClosingController {
+	    bridge;
+	    registry = CallbackFactory();
+	    constructor(bridge) {
+	        this.bridge = bridge;
+	        this.subscribeToFrameClosing();
+	    }
+	    async registerFrameOnClosing(frameId, callback) {
+	        await this.bridge.send(OPERATIONS.subscribeToFrameClosing.name, { itemId: frameId });
+	        return this.registry.add(frameId, callback);
+	    }
+	    subscribeToFrameClosing() {
+	        this.bridge.onOperationWithResponse(async (payload) => {
+	            if (payload.operation !== CLIENT_OPERATIONS.frameClosing.name) {
+	                return;
+	            }
+	            const data = payload.data;
+	            const frameClosingResult = await Promise.all(this.registry.execute(data.frameId));
+	            return this.aggregateFrameClosingResult(frameClosingResult);
+	        });
+	    }
+	    aggregateFrameClosingResult(results) {
+	        return {
+	            prevent: results.some((result) => result?.prevent)
+	        };
+	    }
+	}
+
 	class IoC {
 	    agm;
 	    windows;
@@ -4811,6 +4946,7 @@
 	    _parentBaseInstance;
 	    _baseController;
 	    _shortcutsController;
+	    _closingController;
 	    constructor(agm, windows, layouts, contexts) {
 	        this.agm = agm;
 	        this.windows = windows;
@@ -4825,7 +4961,7 @@
 	    }
 	    get controller() {
 	        if (!this._controllerInstance) {
-	            this._controllerInstance = new MainController(this.bridge, this.baseController, this.shortcutsController);
+	            this._controllerInstance = new MainController(this.bridge, this.baseController, this.shortcutsController, this.closingController);
 	        }
 	        return this._controllerInstance;
 	    }
@@ -4835,6 +4971,12 @@
 	        }
 	        return this._shortcutsController;
 	    }
+	    get closingController() {
+	        if (!this._closingController) {
+	            this._closingController = new ClosingController(this.bridge);
+	        }
+	        return this._closingController;
+	    }
 	    get bridge() {
 	        if (!this._bridgeInstance) {
 	            this._bridgeInstance = new Bridge(this.transport, CallbackFactory());
@@ -4968,7 +5110,7 @@
 	    }
 	}
 
-	var version = "3.5.6";
+	var version = "3.5.7";
 
 	const composeAPI = (glue, ioc) => {
 	    const controller = ioc.controller;