@interopio/desktop 6.6.0 → 6.6.1-next.0

package/dist/desktop.umd.js

@@ -2933,7 +2933,7 @@
       }
   };
 
-  var version$1 = "6.3.4";
+  var version$1 = "6.3.5-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,23 @@
           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}`);
               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 +19835,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 +19854,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 +20050,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 +20354,7 @@
       let _windows;
       let _displays;
       let _channels;
+      let _prefs;
       const _browserEventsDispatcher = new EventsDispatcher(glueConfig);
       function createWindows(core) {
           if (glueConfig.windows) {
@@ -20298,7 +20451,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 +20479,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 +20510,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,