@interopio/workspaces-api 4.1.1-beta.0 → 4.1.2

package/dist/workspaces.umd.js

@@ -916,6 +916,9 @@
 	const isWindowInSwimlaneResultDecoder = object({
 	    inWorkspace: boolean()
 	});
+	const frameVisibilityResultDecoder = object({
+	    isVisible: boolean()
+	});
 	const iconDecoder = object({
 	    base64Image: nonEmptyStringDecoder
 	});
@@ -1027,6 +1030,7 @@
 	        width: optional(nonNegativeNumberDecoder),
 	        height: optional(nonNegativeNumberDecoder)
 	    })),
+	    isVisible: optional(boolean()),
 	    frameId: optional(nonEmptyStringDecoder)
 	});
 	const loadingStrategyDecoder = oneOf(constant("direct"), constant("delayed"), constant("lazy"));
@@ -1525,6 +1529,9 @@
 	const workspacePinOptionsDecoder = optional(object({
 	    icon: optional(nonEmptyStringDecoder)
 	}));
+	const frameShowConfigDecoder = optional(object({
+	    activate: optional(boolean())
+	}));
 	const shortcutConfigDecoder = object({
 	    shortcut: nonEmptyStringDecoder,
 	    frameId: nonEmptyStringDecoder
@@ -1557,6 +1564,43 @@
 	const frameClosingResultDecoder = object({
 	    prevent: boolean()
 	});
+	const changeFrameVisibilityConfigDecoder = object({
+	    frameId: nonEmptyStringDecoder,
+	    activate: optional(boolean()),
+	    isVisible: boolean()
+	});
+	const sizeDecoder = object({
+	    width: positiveNumberDecoder,
+	    height: positiveNumberDecoder
+	});
+	const frameDialogOptionsDecoder = object({
+	    mode: optional(oneOf(constant("Global"), constant("WindowContainer"))),
+	    type: string(),
+	    size: optional(sizeDecoder),
+	    message: nonEmptyStringDecoder,
+	    messageTitle: optional(nonEmptyStringDecoder),
+	    movable: optional(boolean()),
+	    transparent: optional(boolean()),
+	    title: nonEmptyStringDecoder,
+	    context: optional(anyJson()),
+	    affirmativeButtonName: optional(nonEmptyStringDecoder),
+	    showAffirmativeButton: optional(boolean()),
+	    cancelButtonName: optional(nonEmptyStringDecoder),
+	    showCancelButton: optional(boolean()),
+	    negativeButtonName: optional(nonEmptyStringDecoder),
+	    showNegativeButton: optional(boolean()),
+	    defaultAction: optional(oneOf(constant("affirmative"), constant("negative"), constant("cancel"))),
+	    timerDuration: optional(positiveNumberDecoder),
+	    showTimer: optional(boolean()),
+	    inputMaxLength: optional(positiveNumberDecoder),
+	    inputPattern: optional(nonEmptyStringDecoder),
+	    inputPatternErrorMessage: optional(nonEmptyStringDecoder),
+	    inputPlaceholder: optional(string())
+	});
+	const showFrameDialogConfigDecoder = object({
+	    frameId: nonEmptyStringDecoder,
+	    options: frameDialogOptionsDecoder
+	});
 
 	const webPlatformMethodName = "T42.Web.Platform.Control";
 	const webPlatformWspStreamName = "T42.Web.Platform.WSP.Stream";
@@ -1636,7 +1680,10 @@
 	    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 }
+	    subscribeToFrameClosing: { name: "subscribeToFrameClosing", argsDecoder: simpleItemConfigDecoder, resultDecoder: voidResultDecoder },
+	    changeFrameVisibility: { name: "changeFrameVisibility", argsDecoder: changeFrameVisibilityConfigDecoder, resultDecoder: voidResultDecoder },
+	    getFrameVisibility: { name: "getFrameVisibility", argsDecoder: simpleItemConfigDecoder, resultDecoder: frameVisibilityResultDecoder },
+	    showFrameDialog: { name: "showFrameDialog", argsDecoder: showFrameDialogConfigDecoder, resultDecoder: anyJson() }
 	};
 
 	class PromiseWrapper {
@@ -3497,6 +3544,13 @@
 	        const frameId = this.id;
 	        return getData$1(this).controller.getTaskbarIcon(frameId);
 	    }
+	    isVisible() {
+	        if (!isDesktop()) {
+	            throw new Error("frame.isVisible() is not supported in IO Connect Browser");
+	        }
+	        const frameId = this.id;
+	        return getData$1(this).controller.getFrameVisibility(frameId);
+	    }
 	    async minimize() {
 	        if (!isDesktop()) {
 	            throw new Error("State operations are not supported in IO Connect Browser");
@@ -3553,6 +3607,26 @@
 	        }
 	        return getData$1(this).controller.initFrame(this.id, config);
 	    }
+	    async show(config) {
+	        if (!isDesktop()) {
+	            throw new Error("The show operation is not supported in IO Connect Browser");
+	        }
+	        const validatedConfig = frameShowConfigDecoder.runWithException(config);
+	        return getData$1(this).controller.showFrame(this.id, validatedConfig);
+	    }
+	    async hide() {
+	        if (!isDesktop()) {
+	            throw new Error("The hide operation is not supported in IO Connect Browser");
+	        }
+	        return getData$1(this).controller.hideFrame(this.id);
+	    }
+	    async showDialog(options) {
+	        if (!isDesktop()) {
+	            throw new Error("The showModal operation is not supported in IO Connect Browser");
+	        }
+	        frameDialogOptionsDecoder.runWithException(options);
+	        return getData$1(this).controller.showFrameDialog(this.id, options);
+	    }
 	    async onClosing(callback) {
 	        if (!isDesktop()) {
 	            throw new Error("Frame closing operations are not supported in io.Connect Browser");
@@ -4478,6 +4552,21 @@
 	        await this.isOperationSupported(OPERATIONS.setLoadingStrategy.name);
 	        return this.bridge.send(OPERATIONS.setLoadingStrategy.name, { itemId: workspaceId, strategy });
 	    }
+	    async showFrame(frameId, config) {
+	        const payload = { frameId, isVisible: true, ...config };
+	        return this.bridge.send(OPERATIONS.changeFrameVisibility.name, payload);
+	    }
+	    async hideFrame(frameId) {
+	        return this.bridge.send(OPERATIONS.changeFrameVisibility.name, { frameId, isVisible: false });
+	    }
+	    async getFrameVisibility(frameId) {
+	        const result = await this.bridge.send(OPERATIONS.getFrameVisibility.name, { itemId: frameId });
+	        return result.isVisible;
+	    }
+	    async showFrameDialog(frameId, options) {
+	        const result = await this.bridge.send(OPERATIONS.showFrameDialog.name, { frameId, options });
+	        return result;
+	    }
 	    async isOperationSupported(operation) {
 	        if (isDesktop()) {
 	            return { isSupported: true };
@@ -4835,6 +4924,18 @@
 	    registerFrameOnClosing(frameId, callback) {
 	        return this.closingController.registerFrameOnClosing(frameId, callback);
 	    }
+	    async showFrame(frameId, config) {
+	        return this.base.showFrame(frameId, config);
+	    }
+	    async hideFrame(frameId) {
+	        return this.base.hideFrame(frameId);
+	    }
+	    async getFrameVisibility(frameId) {
+	        return this.base.getFrameVisibility(frameId);
+	    }
+	    async showFrameDialog(frameId, options) {
+	        return this.base.showFrameDialog(frameId, options);
+	    }
 	    async handleCoreLocalSubscription(config, levelId) {
 	        await this.bridge.createCoreEventSubscription();
 	        config.scopeId = config.scopeId || levelId;
@@ -5139,7 +5240,7 @@
 	    }
 	}
 
-	var version = "4.1.1-beta.0";
+	var version = "4.1.2";
 
 	const composeAPI = (glue, ioc) => {
 	    const controller = ioc.controller;