@interopio/desktop 6.6.0 → 6.7.0-next.0

package/desktop.d.ts

@@ -6059,9 +6059,9 @@ export declare namespace IOConnectDesktop {
             /**
              * Updates the context of the current or a specified Channel.
              * @param data Data object with which to update the Channel context.
-             * @param name The name of the Channel to update. If not provided, will update the current Channel.
+             * @param options The name of the Channel to update, or an object containing the name of the Channel to update and a flag indicating whether the published data is an FDC3 context. If no options are provided, the current Channel will be updated.
              */
-            publish(data: any, name?: string): Promise<void>;
+            publish(data: any, options?: string | PublishOptions): Promise<void>;
 
             /**
              * Sets a specified path within the Channel context to the provided value. If the path doesn't exist, it will be created.
@@ -6240,6 +6240,21 @@ export declare namespace IOConnectDesktop {
             data: any;
         }
 
+        /**
+         * Options for updating a Channel context with the `publish()` method.
+         */
+        export interface PublishOptions {
+            /**
+             * The name of the Channel to update. If not provided, the current Channel will be updated.
+             */
+            name?: string;
+
+            /**
+             * Flag indicating whether the published data is an FDC3 context. If so, it must contain a required `type` property.
+             */
+            fdc3?: boolean;
+        }
+
         /**
          * All restrictions applied to a window for publishing or subscribing to Channels.
          */
@@ -6404,6 +6419,11 @@ export declare namespace IOConnectDesktop {
              */
             getIntents(handler: IntentHandler): Promise<GetIntentsResult>;
 
+            /**
+             * Removes all saved Intent handlers for previously raised Intents.
+             */
+            clearSavedHandlers(): Promise<void>;
+
             /**
              * API for controlling the Intents Resolver UI app.
              */
@@ -6456,6 +6476,11 @@ export declare namespace IOConnectDesktop {
              */
             handlerFilter?: HandlerFilter;
 
+            /**
+             * Details about the app instance that opened the Intents Resolver UI.
+             */
+            caller?: ResolverCaller;
+
             /**
              * Retrieves the title for the search operation. Available only if the `filterHandlers()` method was used to open the Intents Resolver UI and the `title` property of the `HandlerFilter` object was set.
              */
@@ -6465,18 +6490,51 @@ export declare namespace IOConnectDesktop {
              * Notifies when a handler for the current Intent is added. Replays already existing handlers.
              * @param callback Callback function for handling the event.
              */
-            onHandlerAdded(callback: (handler: ResolverIntentHandler) => void): UnsubscribeFunction;
+            onHandlerAdded(callback: (handler: ResolverIntentHandler, intent: IntentInfo) => void): UnsubscribeFunction;
 
             /**
              * Notifies when a handler for the current Intent is removed.
              * @param callback Callback function for handling the event.
              */
-            onHandlerRemoved(callback: (removedHandler: ResolverIntentHandler) => void): UnsubscribeFunction;
+            onHandlerRemoved(callback: (removedHandler: ResolverIntentHandler, intent: IntentInfo) => void): UnsubscribeFunction;
 
             /**
              * Sends the chosen Intent handler to the app which raised the Intent.
              */
-            sendResponse(handler: ResolverIntentHandler): Promise<IOConnectDesktop.Interop.InvocationResult | undefined>;
+            sendResponse(handler: ResolverIntentHandler, options?: SendResolverResponseOptions): Promise<IOConnectDesktop.Interop.InvocationResult | undefined>;
+        }
+
+        /**
+         * Describes the app instance that opened the Intents Resolver UI.
+         */
+        export interface ResolverCaller {
+            /**
+             * ID of the Interop instance of the app that opened the Intents Resolver UI.
+             */
+            id: string;
+            /**
+             * Name of the app that opened the Intents Resolver UI.
+             */
+            applicationName?: string;
+            /**
+             * Title of the app that opened the Intents Resolver UI.
+             */
+            applicationTitle?: string;
+        }
+
+        /**
+         * Options for sending the chosen Intent handler to the app that raised the Intent.
+         */
+        export interface SendResolverResponseOptions {
+            /**
+             * If `true`, the chosen Intent handler will be saved as a handler for the raised Intent. If the handler is saved, the next time the same Intent is raised, the Intents Resolver UI won't open and the saved handler will be used automatically.
+             * @default false
+             */
+            saveHandler: boolean;
+            /**
+             * Use this property to supply the name of the Intent when the Intents Resolver UI is opened via the `filterHandlers()` method and you want to save the Intent handler for that Intent. If the Intents Resolver UI is opened via the `raise()` method, it isn't necessary to explicitly provide the Intent name here, as specifying an Intent name is mandatory when using the `raise()` method.
+             */
+            intent?: string;
         }
 
         /**
@@ -6488,6 +6546,11 @@ export declare namespace IOConnectDesktop {
              */
             applicationName: string;
 
+            /**
+             * Title of the Intent handler.
+             */
+            applicationTitle?: string;
+
             /**
              * Icon of the Intent handler app.
              */
@@ -6723,6 +6786,12 @@ export declare namespace IOConnectDesktop {
              * @default false
              */
             readonly waitUserResponseIndefinitely?: boolean;
+
+            /**
+             * If `true`, the previously saved Intent handler for this Intent (if any) will be cleared.
+             * @default false
+             */
+            readonly clearSavedHandler?: boolean;
         }
 
         /**

package/dist/desktop.browser.js

@@ -2933,7 +2933,7 @@
       }
   };
 
-  var version$1 = "6.3.4";
+  var version$1 = "6.4.0-next.0";
 
   function prepareConfig$1 (configuration, ext, glue42gd) {
       let nodeStartingContext;
@@ -17573,6 +17573,9 @@
               channels.handleRestrictionsChanged(restrictions, targetWindowId);
               return;
           }
+          if (command === "isFdc3DataWrappingSupported") {
+              return { isSupported: true };
+          }
           throw new Error(`unknown command ${command}`);
       });
       const result = await interop.invoke("T42.Channels.Announce", { swId: windowId, instance: interop.instance.instance });
@@ -17671,8 +17674,7 @@
           const contextName = this.createContextName(name);
           const contextData = await this.contexts.get(contextName);
           if (contextData[LATEST_FDC3_TYPE]) {
-              const { latest_fdc3_type, ...data } = contextData;
-              return data;
+              return this.getContextWithFdc3Data(contextData);
           }
           return contextData;
       }
@@ -17751,6 +17753,21 @@
           }
           return fdc3PropsArr[0].split("_").slice(1).join("_");
       }
+      getContextWithFdc3Data(channelContext) {
+          const { latest_fdc3_type, ...rest } = channelContext;
+          const parsedType = latest_fdc3_type.split("&").join(".");
+          const fdc3Context = { type: parsedType, ...rest.data[`fdc3_${latest_fdc3_type}`] };
+          delete rest.data[`fdc3_${latest_fdc3_type}`];
+          const context = {
+              name: channelContext.name,
+              meta: channelContext.meta,
+              data: {
+                  ...rest.data,
+                  fdc3: fdc3Context
+              }
+          };
+          return context;
+      }
   }
 
   class ChannelsImpl {
@@ -17780,17 +17797,7 @@
           }
           const id = Utils.generateId();
           this.pendingReplays[id] = true;
-          const callbackWithPermissionCheck = async (data, context, updaterId) => {
-              const restrictionByChannel = await this.getRestrictionsByChannel(context.name);
-              if (restrictionByChannel.read) {
-                  callback(data, context, updaterId);
-              }
-              else {
-                  this.onRestrictionsChanged(() => {
-                      callback(data, context, updaterId);
-                  }, id, context.name);
-              }
-          };
+          const wrappedCallback = this.getWrappedSubscribeCallback(callback, id);
           if (this.lastUpdate) {
               let lastUpdate = Object.assign({}, this.lastUpdate);
               setTimeout(async () => {
@@ -17798,12 +17805,12 @@
                       if (this.lastUpdate) {
                           lastUpdate = this.lastUpdate;
                       }
-                      callbackWithPermissionCheck(lastUpdate.context.data, lastUpdate.context, lastUpdate.updaterId);
+                      wrappedCallback(lastUpdate.context.data, lastUpdate.context, lastUpdate.updaterId);
                   }
                   delete this.pendingReplays[id];
               }, 0);
           }
-          const unsub = this.registry.add(this.subsKey, callbackWithPermissionCheck);
+          const unsub = this.registry.add(this.subsKey, wrappedCallback);
           return () => {
               this.pendingReplays[id] = false;
               this.pendingRestrictionCallbacks.delete(id);
@@ -17818,46 +17825,35 @@
               throw new Error("Please provide the callback as a function!");
           }
           const id = Utils.generateId();
-          const callbackWithPermissionCheck = async (data, context, updaterId) => {
-              const restrictionByChannel = await this.getRestrictionsByChannel(context.name);
-              if (restrictionByChannel.read) {
-                  callback(data, context, updaterId);
-              }
-              else {
-                  this.onRestrictionsChanged(() => {
-                      callback(data, context, updaterId);
-                  }, id, context.name);
-              }
-          };
-          const unsub = await this.shared.subscribeFor(name, callbackWithPermissionCheck);
+          const wrappedCallback = this.getWrappedSubscribeCallback(callback, id);
+          const unsub = await this.shared.subscribeFor(name, wrappedCallback);
           return () => {
               this.pendingRestrictionCallbacks.delete(id);
               unsub();
           };
       }
-      async publish(data, name) {
+      async publish(data, options) {
           if (typeof data !== "object") {
               throw new Error("Please provide the data as an object!");
           }
-          if (name) {
-              if (typeof name !== "string") {
-                  throw new Error("Please provide the name as a string!");
-              }
-              if (!this.shared.isChannel(name)) {
-                  return Promise.reject(new Error(`A channel with name: ${name} doesn't exist!`));
-              }
-              if (!(await this.getRestrictionsByChannel(name)).write) {
-                  throw new Error(`Window does not have permission to write to channel ${name}`);
-              }
-              return this.shared.updateData(name, data);
+          if (options) {
+              this.validatePublishOptions(options);
           }
-          if (!this.currentContext) {
+          if (typeof options === "object") {
+              return this.publishWithOptions(data, options);
+          }
+          const channelName = typeof options === "string" ? options : this.currentContext;
+          if (!channelName) {
               throw new Error("Not joined to any channel!");
           }
-          if (!(await this.getRestrictionsByChannel(this.currentContext)).write) {
+          if (!this.shared.isChannel(channelName)) {
+              return Promise.reject(new Error(`A channel with name: ${channelName} doesn't exist!`));
+          }
+          const canPublish = (await this.getRestrictionsByChannel(channelName)).write;
+          if (!canPublish) {
               throw new Error(`Window does not have permission to write to channel ${this.currentContext}`);
           }
-          return this.shared.updateData(this.currentContext, data);
+          return this.shared.updateData(channelName, data);
       }
       async setPaths(paths, name) {
           if (name) {
@@ -18161,6 +18157,82 @@
               throw new Error(`path property is not a valid string from the Path Value argument: ${JSON.stringify(path)}`);
           }
       }
+      validatePublishOptions(options) {
+          if ((typeof options !== "string" && typeof options !== "object") || Array.isArray(options)) {
+              throw new Error("Provide options as a string or an object");
+          }
+          if (typeof options === "object") {
+              this.validatePublishOptionsObject(options);
+              return;
+          }
+          if (options === "string" && !options.length) {
+              throw new Error("Provide options as a non-empty string");
+          }
+      }
+      validatePublishOptionsObject(options) {
+          if (typeof options !== "object" || Array.isArray(options)) {
+              throw new Error("Provide options as an object");
+          }
+          if (options.name && (typeof options.name !== "string" || !options.name.length)) {
+              throw new Error("Provide options.name as a non-empty string");
+          }
+          if (Object.keys(options).includes("fdc3") && typeof options.fdc3 !== "boolean") {
+              throw new Error("Provide options.fdc3 as a boolean");
+          }
+      }
+      async publishWithOptions(data, options) {
+          const channelName = options.name || this.currentContext;
+          if (!this.shared.isChannel(channelName)) {
+              throw new Error(`A channel with name: ${options.name} doesn't exist!`);
+          }
+          if (!channelName) {
+              throw new Error("Cannot publish to channel, because not joined to a channel!");
+          }
+          const canPublish = (await this.getRestrictionsByChannel(channelName)).write;
+          if (!canPublish) {
+              throw new Error(`Window does not have permission to write to channel ${this.currentContext}`);
+          }
+          if (!options.fdc3) {
+              return this.shared.updateData(channelName, data);
+          }
+          return this.publishFdc3Data(channelName, data);
+      }
+      async publishFdc3Data(channelName, data) {
+          var _a;
+          if (typeof data.type !== "string" || !((_a = data.type) === null || _a === void 0 ? void 0 : _a.length)) {
+              throw new Error("Expected a valid FDC3 Context with compulsory 'type' field");
+          }
+          const { type, ...rest } = data;
+          const parsedType = type.split(".").join("&");
+          const fdc3DataToPublish = { [`fdc3_${parsedType}`]: rest };
+          return this.shared.updateData(channelName, fdc3DataToPublish);
+      }
+      getWrappedSubscribeCallback(callback, id) {
+          const wrappedCallback = async (_, context, updaterId) => {
+              const restrictionByChannel = await this.getRestrictionsByChannel(context.name);
+              const channelData = this.getDataWithFdc3Encoding(context);
+              if (restrictionByChannel.read) {
+                  callback(channelData, context, updaterId);
+              }
+              else {
+                  this.onRestrictionsChanged(() => {
+                      callback(channelData, context, updaterId);
+                  }, id, context.name);
+              }
+          };
+          return wrappedCallback;
+      }
+      getDataWithFdc3Encoding(context) {
+          const { data, latest_fdc3_type } = context;
+          if (!latest_fdc3_type) {
+              return data;
+          }
+          const parsedType = latest_fdc3_type.split("&").join(".");
+          const latestTypePropName = `fdc3_${latest_fdc3_type}`;
+          const fdc3Data = { type: parsedType, ...data[latestTypePropName] };
+          const { [latestTypePropName]: latestFDC3Type, ...rest } = data;
+          return { ...rest, fdc3: fdc3Data };
+      }
   }
 
   function factory$4(contexts, agm, getWindows, logger) {
@@ -18284,7 +18356,7 @@
       };
   }
 
-  var version = "6.5.1";
+  var version = "6.6.0";
 
   var prepareConfig = (options) => {
       function getLibConfig(value, defaultMode, trueMode) {
@@ -19192,28 +19264,6 @@
       }
       return { isValid: true, ok: handler };
   };
-  const validateRaiseIntentsResolverResponse = (responseObj) => {
-      const invalidKey = Object.keys(responseObj).some((key) => key !== "intent" && key !== "handler");
-      if (invalidKey) {
-          return { isValid: false, error: "Response is not a valid object. Expected { intent: string, handler: IntentHandler }" };
-      }
-      if (typeof responseObj.intent !== "string") {
-          return { isValid: false, error: `Response object has invalid 'intent' key. Expected a string, got ${typeof responseObj.intent}` };
-      }
-      const { isValid, error } = validateIntentHandlerAsResponse(responseObj.handler);
-      return isValid
-          ? { isValid: true, ok: { intent: responseObj.intent, handler: responseObj.handler } }
-          : { isValid: false, error };
-  };
-  const validateFilterHandlersResolverResponse = (responseObj) => {
-      if (!responseObj.handler) {
-          return { isValid: false, error: "Response is not a valid object. Expected { handler: IntentHandler }" };
-      }
-      const { isValid, error } = validateIntentHandlerAsResponse(responseObj.handler);
-      return isValid
-          ? { isValid: true, ok: { handler: responseObj.handler } }
-          : { isValid: false, error };
-  };
   const validateIntentRequestTarget = (target) => {
       if (!target) {
           return;
@@ -19300,14 +19350,27 @@
           throw new Error(errorMsg);
       }
   };
-  const validateIntentsResolverResponse = (method, responseObj) => {
-      return method === "raise" ? validateRaiseIntentsResolverResponse(responseObj) : validateFilterHandlersResolverResponse(responseObj);
+  const validateResolverResponse = (responseObj) => {
+      var _a, _b;
+      if (typeof responseObj.intent !== "string") {
+          return { isValid: false, error: `Response object has invalid 'intent' key. Expected a string, got ${typeof responseObj.intent}` };
+      }
+      if (((_a = responseObj.userSettings) === null || _a === void 0 ? void 0 : _a.preserveChoice) && typeof ((_b = responseObj.userSettings) === null || _b === void 0 ? void 0 : _b.preserveChoice) !== "boolean") {
+          return { isValid: false, error: `Response object has invalid 'userSettings.preserveChoice' key. Expected a boolean, got ${typeof responseObj.userSettings.preserveChoice}` };
+      }
+      const { isValid, error } = validateIntentHandlerAsResponse(responseObj.handler);
+      return isValid
+          ? { isValid: true, ok: responseObj }
+          : { isValid, error };
   };
   const validateIntentRequest = (request) => {
       validateIntentRequestContext(request.context);
       validateIntentRequestTarget(request.target);
       validateIntentRequestTimeout(request.timeout);
       validateWaitUserResponseIndefinitely(request.waitUserResponseIndefinitely);
+      if (typeof request.clearSavedHandler !== "undefined" && typeof request.clearSavedHandler !== "boolean") {
+          throw new Error("Please provide 'clearSavedHandler' as a boolean");
+      }
       if (request.handlers) {
           request.handlers.forEach((handler) => validateIntentRequestHandler(handler));
       }
@@ -19356,10 +19419,11 @@
   };
 
   class Intents {
-      constructor(interop, windows, logger, options, appManager) {
+      constructor(interop, windows, logger, options, prefsController, appManager) {
           this.interop = interop;
           this.windows = windows;
           this.logger = logger;
+          this.prefsController = prefsController;
           this.appManager = appManager;
           this.myIntents = new Set();
           this.intentsResolverResponsePromises = {};
@@ -19401,8 +19465,16 @@
           }
           validateIntentRequest(intentRequest);
           await Promise.all(this.unregisterIntentPromises);
-          const timeout = intentRequest.timeout || DEFAULT_RAISE_TIMEOUT_MS;
+          if (intentRequest.clearSavedHandler) {
+              this.logger.trace(`User removes saved handler for intent ${intentRequest.intent}`);
+              await this.removeRememberedHandler(intentRequest.intent);
+          }
           const resolverInstance = {};
+          const timeout = intentRequest.timeout || DEFAULT_RAISE_TIMEOUT_MS;
+          const resultFromRememberedHandler = await this.checkHandleRaiseWithRememberedHandler(intentRequest, resolverInstance, timeout);
+          if (resultFromRememberedHandler) {
+              return resultFromRememberedHandler;
+          }
           const coreRaiseIntentFn = this.coreRaiseIntent.bind(this, { request: intentRequest, resolverInstance, timeout });
           if (intentRequest.waitUserResponseIndefinitely) {
               return coreRaiseIntentFn();
@@ -19603,6 +19675,10 @@
           this.logger.trace(`Returning intents for handler ${JSON.stringify(handler)}`);
           return { intents: intentsWithInfo };
       }
+      async clearSavedHandlers() {
+          this.logger.trace("Removing all saved handlers from prefs storage for current app");
+          await this.prefsController.update({ intents: undefined });
+      }
       filterHandlersBy(intents, filter) {
           const filteredIntentsWithHandlers = intents.filter((intent) => {
               if (filter.intent && filter.intent !== intent.name) {
@@ -19704,7 +19780,7 @@
       async startResolverApp({ request, method, resolverInstance }) {
           var _a, _b, _c, _d;
           (_a = this.logger) === null || _a === void 0 ? void 0 : _a.trace(`Intents Resolver UI with app name ${this.intentsResolverAppName} will be used for request: ${JSON.stringify(request)}`);
-          const responseMethodName = await this.registerIntentResolverMethod(method);
+          const responseMethodName = await this.registerIntentResolverMethod();
           (_b = this.logger) === null || _b === void 0 ? void 0 : _b.trace(`Registered interop method ${responseMethodName}`);
           const startContext = this.buildStartContext(method, request, responseMethodName);
           const startOptions = await this.buildStartOptions();
@@ -19723,7 +19799,7 @@
                 ? `for intent ${request.intent}`
                 : `for '${method}' method with filter ${JSON.stringify(request)}`}`
           });
-          const handler = await this.handleInstanceResponse(instance.id, method);
+          const handler = await this.handleInstanceResponse({ instanceId: instance.id, caller: startContext.initialCaller, method, request });
           return handler;
       }
       async windowsIdToTitle(id, windowsInfos) {
@@ -19735,13 +19811,24 @@
           const title = await (window === null || window === void 0 ? void 0 : window.getTitle());
           return title;
       }
-      async handleInstanceResponse(instanceId, method) {
-          var _a, _b;
+      async handleInstanceResponse({ instanceId, method, request, caller }) {
+          var _a, _b, _c;
           try {
               const response = await this.intentsResolverResponsePromises[instanceId].promise;
-              (_a = this.logger) === null || _a === void 0 ? void 0 : _a.trace(`Intent handler chosen ${method === "raise" ? `for intent ${response.intent} ` : ""}: ${JSON.stringify(response.handler)}. Stopping resolver instance with id ${instanceId}`);
+              const subMessage = method === "raise" ? `for intent ${response.intent} ` : "";
+              (_a = this.logger) === null || _a === void 0 ? void 0 : _a.trace(`Intent handler chosen ${subMessage}: ${JSON.stringify(response.handler)}. Stopping resolver instance with id ${instanceId}`);
               this.stopResolverInstance(instanceId);
               (_b = this.logger) === null || _b === void 0 ? void 0 : _b.trace(`Instance with id ${instanceId} successfully stopped`);
+              if ((_c = response.userSettings) === null || _c === void 0 ? void 0 : _c.preserveChoice) {
+                  await this.saveUserChoice({
+                      intent: response.intent,
+                      handler: response.handler,
+                      filter: method === "filterHandlers"
+                          ? { applicationNames: request.applicationNames, contextTypes: request.contextTypes, resultType: request.resultType }
+                          : undefined,
+                      caller
+                  });
+              }
               return response.handler;
           }
           catch (error) {
@@ -19749,14 +19836,14 @@
               throw new Error(error);
           }
       }
-      async registerIntentResolverMethod(method) {
+      async registerIntentResolverMethod() {
           const methodName = INTENTS_RESOLVER_INTEROP_PREFIX + Utils.generateId();
-          await this.interop.register(methodName, (args, callerId) => this.resolverResponseHandler(args, callerId, method));
+          await this.interop.register(methodName, (args, callerId) => this.resolverResponseHandler(args, callerId));
           return methodName;
       }
-      resolverResponseHandler(args, callerId, method) {
+      resolverResponseHandler(args, callerId) {
           const { instance } = callerId;
-          const isValid = validateIntentsResolverResponse(method, args);
+          const isValid = validateResolverResponse(args);
           if (!isValid) {
               this.logger.trace(`Intent Resolver instance with id ${callerId.instance} sent invalid response. Error: ${isValid.error}`);
               this.intentsResolverResponsePromises[instance].reject(isValid.error);
@@ -19768,7 +19855,15 @@
           this.cleanUpIntentResolverPromise(instance);
       }
       buildStartContext(method, request, methodName) {
-          const baseStartContext = { callerId: this.interop.instance.instance, methodName };
+          var _a;
+          const myAppName = this.interop.instance.application || this.interop.instance.applicationName;
+          const myAppTitle = ((_a = this.appManager.application(myAppName)) === null || _a === void 0 ? void 0 : _a.title) || "";
+          const baseStartContext = {
+              callerId: this.interop.instance.instance,
+              methodName,
+              initialCaller: { id: this.interop.instance.instance, applicationName: myAppName, applicationTitle: myAppTitle },
+              resolverApi: "1.0"
+          };
           return method === "raise"
               ? { ...baseStartContext, intent: request }
               : { ...baseStartContext, handlerFilter: request };
@@ -19956,6 +20051,64 @@
           }, []);
           return intentsWithInfo;
       }
+      async removeRememberedHandler(intentName) {
+          var _a;
+          this.logger.trace(`Removing saved handler from prefs storage for intent ${intentName}`);
+          const prefs = await this.prefsController.get();
+          const intentPrefs = (_a = prefs.data) === null || _a === void 0 ? void 0 : _a.intents;
+          if (!intentPrefs) {
+              this.logger.trace("No app prefs found for current app");
+              return;
+          }
+          delete intentPrefs[intentName];
+          const updatedPrefs = {
+              ...prefs.data,
+              intents: intentPrefs
+          };
+          await this.prefsController.update(updatedPrefs);
+          this.logger.trace(`Handler saved choice for intent ${intentName} removed successfully`);
+      }
+      async checkForRememberedHandler(intentRequest) {
+          var _a, _b;
+          const prefs = await this.prefsController.get();
+          const prefsForIntent = (_b = (_a = prefs.data) === null || _a === void 0 ? void 0 : _a.intents) === null || _b === void 0 ? void 0 : _b[intentRequest.intent];
+          return prefsForIntent === null || prefsForIntent === void 0 ? void 0 : prefsForIntent.handler;
+      }
+      async checkHandleRaiseWithRememberedHandler(intentRequest, resolverInstance, timeout) {
+          const rememberedHandler = await this.checkForRememberedHandler(intentRequest);
+          if (!rememberedHandler) {
+              return;
+          }
+          const request = {
+              ...intentRequest,
+              target: {
+                  app: rememberedHandler.applicationName,
+                  instance: rememberedHandler.instanceId
+              }
+          };
+          try {
+              const response = await this.coreRaiseIntent({ request, resolverInstance, timeout });
+              return response;
+          }
+          catch (error) {
+              this.logger.trace("Could not raise intent to remembered handler. Removing it from Prefs store");
+              await this.removeRememberedHandler(intentRequest.intent);
+          }
+      }
+      async saveUserChoice({ intent, handler, filter, caller }) {
+          var _a, _b;
+          const prevPrefs = await this.prefsController.get(caller.applicationName);
+          const prevIntentsPrefs = ((_a = prevPrefs === null || prevPrefs === void 0 ? void 0 : prevPrefs.data) === null || _a === void 0 ? void 0 : _a.intents) || {};
+          const prefsToUpdate = {
+              ...prevPrefs.data,
+              intents: {
+                  ...prevIntentsPrefs,
+                  [intent]: { handler, filter }
+              }
+          };
+          await this.prefsController.update(prefsToUpdate, { app: caller.applicationName });
+          (_b = this.logger) === null || _b === void 0 ? void 0 : _b.info(`Saved user's choice of handler for '${caller.applicationName}' app`);
+      }
   }
 
   class FactoryCallInfo {
@@ -20202,6 +20355,7 @@
       let _windows;
       let _displays;
       let _channels;
+      let _prefs;
       const _browserEventsDispatcher = new EventsDispatcher(glueConfig);
       function createWindows(core) {
           if (glueConfig.windows) {
@@ -20298,7 +20452,7 @@
           return hotkeysAPI;
       }
       function createIntents(core) {
-          const intentsAPI = new Intents(core.agm, _windows, core.logger.subLogger("intents"), options, _appManager);
+          const intentsAPI = new Intents(core.agm, _windows, core.logger.subLogger("intents"), options, _prefs, _appManager);
           debugLog(intentsAPI);
           return intentsAPI;
       }
@@ -20326,9 +20480,9 @@
       function createPrefs(core) {
           var _a, _b;
           const appName = (_b = (_a = options.application) !== null && _a !== void 0 ? _a : glue42gd === null || glue42gd === void 0 ? void 0 : glue42gd.applicationName) !== null && _b !== void 0 ? _b : core.interop.instance.application;
-          const prefs = new Prefs(appName, core.interop);
-          debugLog(prefs);
-          return prefs;
+          _prefs = new Prefs(appName, core.interop);
+          debugLog(_prefs);
+          return _prefs;
       }
       function createCookies(core) {
           const api = factory$1(core.interop, T42GDExecuteMethod);
@@ -20357,10 +20511,10 @@
               { name: "channels", create: createChannels },
               { name: "hotkeys", create: createHotkeys },
               { name: "displays", create: createDisplaysApi },
+              { name: "prefs", create: createPrefs },
               { name: "intents", create: createIntents },
               { name: "notifications", create: createNotifications },
               { name: "themes", create: createThemes },
-              { name: "prefs", create: createPrefs },
               { name: "cookies", create: createCookies }
           ],
           version,