@interopio/workspaces-api 3.5.5 → 3.5.7

package/changelog.md

@@ -1,3 +1,8 @@
+3.5.7
+feat: G4 e 8073 workspace frame on closing event prevention master
+feat: G4E-8009 Setting taskbar icon for workspace frame api
+3.5.6
+feat: ability to embed a loading strategy within a workspaces layout upon saving
 3.5.5
 feat: setup a workspace to open only once
 3.5.4

package/dist/workspaces.es.js

@@ -910,6 +910,13 @@ const windowDragModeDecoder = oneOf(constant("keepInside"), constant("autoEject"
 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"));
@@ -1164,7 +1171,8 @@ const workspaceConfigResultDecoder = object({
     widthInPx: optional(number()),
     heightInPx: optional(number()),
     isPinned: optional(boolean()),
-    windowDragMode: optional(windowDragModeDecoder)
+    windowDragMode: optional(windowDragModeDecoder),
+    loadingStrategy: optional(loadingStrategyDecoder)
 });
 const baseChildSnapshotConfigDecoder = object({
     frameId: nonEmptyStringDecoder,
@@ -1338,6 +1346,14 @@ const moveConfigDecoder = object({
 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())
@@ -1511,6 +1527,9 @@ const shortcutClickedDataDecoder = object({
     shortcut: nonEmptyStringDecoder,
     frameId: nonEmptyStringDecoder
 });
+const frameClosingDataDecoder = object({
+    frameId: nonEmptyStringDecoder,
+});
 const setMaximizationBoundaryAPIConfigDecoder = object({
     enabled: boolean()
 });
@@ -1525,6 +1544,13 @@ const setWindowDragModeDecoder = object({
     itemId: nonEmptyStringDecoder,
     dragMode: windowDragModeDecoder
 });
+const setLoadingStrategyDecoder = object({
+    itemId: nonEmptyStringDecoder,
+    strategy: loadingStrategyDecoder
+});
+const frameClosingResultDecoder = object({
+    prevent: boolean()
+});
 
 const webPlatformMethodName = "T42.Web.Platform.Control";
 const webPlatformWspStreamName = "T42.Web.Platform.WSP.Stream";
@@ -1546,6 +1572,7 @@ const STREAMS = {
 };
 const CLIENT_OPERATIONS = {
     shortcutClicked: { name: "shortcutClicked", argsDecoder: shortcutClickedDataDecoder, resultDecoder: voidResultDecoder },
+    frameClosing: { name: "frameClosing", argsDecoder: frameClosingDataDecoder, resultDecoder: frameClosingResultDecoder },
 };
 const OPERATIONS = {
     ping: { name: "ping", resultDecoder: pingResultDecoder },
@@ -1567,7 +1594,7 @@ const OPERATIONS = {
     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 },
@@ -1598,7 +1625,11 @@ const OPERATIONS = {
     hideLoadingAnimation: { name: "hideLoadingAnimation", argsDecoder: loadingAnimationConfigDecoder, resultDecoder: voidResultDecoder },
     getPlatformFrameId: { name: "getPlatformFrameId", resultDecoder: getPlatformFrameIdResultDecoder },
     operationCheck: { name: "operationCheck", argsDecoder: operationCheckConfigDecoder, resultDecoder: operationCheckResultDecoder },
-    setWindowDragMode: { name: "setWindowDragMode", argsDecoder: setWindowDragModeDecoder, resultDecoder: voidResultDecoder }
+    setWindowDragMode: { name: "setWindowDragMode", argsDecoder: setWindowDragModeDecoder, 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 {
@@ -1756,6 +1787,35 @@ class Bridge {
         };
         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;
@@ -1969,7 +2029,7 @@ class InteropTransport {
     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));
         });
     }
 }
@@ -2679,6 +2739,20 @@ class Workspace {
         }
         return getData$3(this).config.windowDragMode;
     }
+    get loadingStrategy() {
+        if (!isDesktop()) {
+            console.warn("The workspace.loadingStrategy property is not supported in IO Connect Browser");
+        }
+        return getData$3(this).config.loadingStrategy;
+    }
+    async setLoadingStrategy(strategy) {
+        if (!isDesktop()) {
+            throw new Error("Not supported in IO Connect Browser");
+        }
+        const controller = getData$3(this).controller;
+        await controller.setLoadingStrategy(this.id, strategy);
+        await this.refreshReference();
+    }
     async removeChild(predicate) {
         checkThrowCallback(predicate);
         const child = this.children.find(predicate);
@@ -3408,6 +3482,21 @@ class Frame {
         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");
@@ -3429,9 +3518,10 @@ class Frame {
         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;
@@ -3463,6 +3553,20 @@ class Frame {
         }
         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;
@@ -4148,6 +4252,12 @@ class BaseController {
         }
         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);
@@ -4176,6 +4286,9 @@ class BaseController {
     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));
     }
@@ -4358,6 +4471,10 @@ class BaseController {
             return {};
         }
     }
+    async setLoadingStrategy(workspaceId, strategy) {
+        await this.isOperationSupported(OPERATIONS.setLoadingStrategy.name);
+        return this.bridge.send(OPERATIONS.setLoadingStrategy.name, { itemId: workspaceId, strategy });
+    }
     async isOperationSupported(operation) {
         if (isDesktop()) {
             return { isSupported: true };
@@ -4370,10 +4487,18 @@ class MainController {
     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);
@@ -4576,6 +4701,9 @@ class MainController {
     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);
     }
@@ -4676,6 +4804,12 @@ class MainController {
     getPlatformFrameId() {
         return this.base.getPlatformFrameId();
     }
+    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;
@@ -4749,7 +4883,7 @@ class ShortcutsController {
     _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}`);
@@ -4766,6 +4900,34 @@ class ShortcutsController {
     }
 }
 
+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;
@@ -4778,6 +4940,7 @@ class IoC {
     _parentBaseInstance;
     _baseController;
     _shortcutsController;
+    _closingController;
     constructor(agm, windows, layouts, contexts) {
         this.agm = agm;
         this.windows = windows;
@@ -4792,7 +4955,7 @@ class IoC {
     }
     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;
     }
@@ -4802,6 +4965,12 @@ class IoC {
         }
         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());
@@ -4935,7 +5104,7 @@ class IoC {
     }
 }
 
-var version = "3.5.5";
+var version = "3.5.7";
 
 const composeAPI = (glue, ioc) => {
     const controller = ioc.controller;