@interopio/desktop 6.8.2 → 6.9.0-rc.1

package/changelog.md

@@ -1,5 +1,3 @@
-6.8.2
-- chore: Update ChannelContext's data type
 6.8.1
 - fix: ignore peerID when invocation target has instance
 6.8.0

package/desktop.d.ts

@@ -224,6 +224,11 @@ export declare namespace IOConnectDesktop {
          * Cookies API.
          */
         cookies: IOConnectDesktop.Cookies.API;
+
+        /**
+         * Interception API.
+         */
+        interception: IOConnectDesktop.Interception.API;
     }
 
     /**
@@ -5961,13 +5966,13 @@ export declare namespace IOConnectDesktop {
              * Pinned tab windows don't have a "Close"  button preventing the user from closing them. Available only for tab windows in web groups.
              * @since io.Connect Desktop 9.5
              */
-            pin(): Promise<void>;
+            pin(): Promise<IOConnectWindow>;
 
             /**
              * Unpins the tab of the current window. The previously pinned tab reverts to a normal tab window containing a "Close" button. Available only for tab windows in web groups.
              * @since io.Connect Desktop 9.5
              */
-            unpin(): Promise<void>;
+            unpin(): Promise<IOConnectWindow>;
 
             /**
              * Executes code in the context of the io.Connect Window.
@@ -6433,6 +6438,18 @@ export declare namespace IOConnectDesktop {
              */
             addIntentListener(intent: string | AddIntentListenerRequest, handler: (context: IntentContext) => any): { unsubscribe: UnsubscribeFunction };
 
+            /**
+             * Notifies when a handler for the an Intent is added.
+             * @param callback Callback function for handling the event.
+             */
+            onHandlerAdded(callback: (handler: IOConnectDesktop.Intents.ResolverIntentHandler) => void, intentName: string): UnsubscribeFunction;
+
+            /**
+             * Notifies when a handler for the an Intent is removed.
+             * @param callback Callback function for handling the event.
+             */
+            onHandlerRemoved(callback: (handler: IOConnectDesktop.Intents.ResolverIntentHandler)=> void, intentName: string): UnsubscribeFunction;
+
             /**
              * Registers an Intent handler. If your app is already registered as an Intent handler through its configuration,
              * use this method to supply a handler for the specified Intent. Otherwise, you can use it to register your app as an Intent handler
@@ -7382,6 +7399,18 @@ export declare namespace IOConnectDesktop {
              * Settings for invoking an Interop method when the notification action is clicked.
              */
             interop?: InteropActionSettings;
+
+            /**
+             * Unique ID for the notification action. This ID can be used in the `displayPath` property of another notification action to determine the position of the latter within the notification action menu.
+             */
+            displayId: string;
+
+            /**
+             * List of `displayId` values or titles of other notification actions describing the path within the notification action menu where the current notification action will be placed (e.g., `[ "main-action-id", "My Nested Action" ]`).
+             * The display ID takes precedence over the title when the framework searches for the respective item. If the provided display ID or title doesn't exist, an empty notification action will be created
+             * (the action will have a dropdown menu that will contain other actions, but when the user clicks on the action itself, nothing will happen).
+             */
+            displayPath: string[];
         }
 
         /**
@@ -7877,4 +7906,129 @@ export declare namespace IOConnectDesktop {
             value: string;
         }
     }
+
+    /**
+     * @intro
+     * The Interception API enables apps to register interception handlers with which to modify the low-level platform operations.
+     * Interception handlers can be executed before and/or after the default implementations of the platform operations,
+     * and the execution of the default implementation for a platform operation can be prevented entirely.
+     * This allows for finer control over the platform operations.
+     * It's possible to register only a single interception handler per platform operation within an API domain.
+     *
+     * For an app to be able to register interception handlers, interception must be enabled
+     * in the system configuration of **io.Connect Desktop** and the name of the app must be specified in the list of apps allowed to register interception handlers.
+     *
+     * *Available since io.Connect Desktop 9.6.*
+     */
+    export namespace Interception {
+        /**
+         * Interception API.
+         */
+        export interface API {
+            /**
+             * Registers an interception handler. It's possible to register only a single interception handler per platform operation within an API domain.
+             * @param config Object containing the interception handler to register and settings describing the platform operations to intercept.
+             */
+            register(config: InterceptionRegistrationConfig): Promise<void>;
+            /**
+             * Unregisters all interception handlers for the specified platform operations.
+             * @param config Object specifying the platform operations which to stop intercepting.
+             */
+            unregister(config: InterceptionUnregistrationConfig): Promise<void>;
+        }
+
+        /**
+         * Settings for registering an interception handler for the targeted platform operations.
+         */
+        export interface InterceptionRegistrationConfig {
+            /**
+             * Method implementation to be registered as a handler for the specified platform operations.
+             * It's possible to register only a single interception handler per platform operation within an API domain.
+             * @param message Object describing the intercepted platform operation.
+             */
+            handler: (message: InterceptionMessage) => Promise<InterceptionResponse | void>;
+            /**
+             * List of objects each describing a platform operation to intercept.
+             */
+            interceptions: Interception[];
+        }
+
+        /**
+         * Settings for unregistering the interception handlers for the targeted platform operations.
+         */
+        export interface InterceptionUnregistrationConfig {
+            /**
+             * List of objects each describing a platform operation which to stop intercepting.
+             */
+            interceptions: Interception[];
+        }
+
+        /**
+         * Describes an intercepted platform operation.
+         */
+        export interface InterceptionMessage {
+            /**
+             * The io.Connect API domain in which the platform operation has been intercepted.
+             */
+            domain: string;
+            /**
+             * The io.Connect platform operation that has been intercepted.
+             */
+            operation: string;
+            /**
+             * ID of the app that has invoked the platform operation. Can be used for tracking purposes.
+             */
+            callerId: string;
+            /**
+             * Specifies whether the platform operation has been intercepted before or after its execution.
+             */
+            phase: "before" | "after";
+            /**
+             * Arguments with which the intercepted platform operation was invoked.
+             */
+            operationArgs?: any[];
+        }
+
+        /**
+         * Describes the response returned by an interception handler.
+         * If the platform operation has been intercepted before the execution of its default implementation and the interception handler returns `undefined` or an empty object,
+         * the platform will proceed with the execution of the default operation implementation.
+         * If the platform operation has been intercepted after the execution of its default implementation and the interception handler returns `undefined` or an empty object,
+         * the platform will return the already calculated result.
+         */
+        export interface InterceptionResponse {
+            /**
+             * Arguments with which to proceed the execution of the intercepted platform operation.
+             * This property is taken into account only when the platform operation is intercepted before the execution of its default implementation.
+             */
+            operationArgs?: any[];
+            /**
+             * Result from the platform operation. Use this property to return a result from your interception handler
+             * when the platform operation has been intercepted after the execution of its default implementation.
+             * If the platform operation has been intercepted before the execution of its default implementation and this property is set,
+             * the execution of the default implementation will be prevented and the platform will return the specified result.
+             */
+            operationResult?: any;
+        }
+
+        /**
+         * Describes a platform operation to intercept and provides settings for its interception.
+         */
+        export interface Interception {
+            /**
+             * io.Connect API domain of the platform operation.
+             */
+            domain: string | "all";
+            /**
+             * Name of the io.Connect platform operation within the specified io.Connect API domain.
+             * Set to `"all"` to intercept all operations within the domain.
+             */
+            operation: string | "all";
+            /**
+             * Specifies whether to intercept the platform operation before or after the execution of its default implementation.
+             * Set to `"all"` to intercept the platform operation both before and after the execution of its default implementation.
+             */
+            phase?: "before" | "after" | "all";
+        }
+    }
 }