@interopio/desktop 6.6.1-next.0 → 6.6.1

package/dist/desktop.umd.js

@@ -2933,7 +2933,7 @@
       }
   };
 
-  var version$1 = "6.3.5-next.0";
+  var version$1 = "6.3.5";
 
   function prepareConfig$1 (configuration, ext, glue42gd) {
       let nodeStartingContext;
@@ -17573,9 +17573,6 @@
               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 });
@@ -17674,7 +17671,8 @@
           const contextName = this.createContextName(name);
           const contextData = await this.contexts.get(contextName);
           if (contextData[LATEST_FDC3_TYPE]) {
-              return this.getContextWithFdc3Data(contextData);
+              const { latest_fdc3_type, ...data } = contextData;
+              return data;
           }
           return contextData;
       }
@@ -17753,21 +17751,6 @@
           }
           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 {
@@ -17797,7 +17780,17 @@
           }
           const id = Utils.generateId();
           this.pendingReplays[id] = true;
-          const wrappedCallback = this.getWrappedSubscribeCallback(callback, id);
+          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);
+              }
+          };
           if (this.lastUpdate) {
               let lastUpdate = Object.assign({}, this.lastUpdate);
               setTimeout(async () => {
@@ -17805,12 +17798,12 @@
                       if (this.lastUpdate) {
                           lastUpdate = this.lastUpdate;
                       }
-                      wrappedCallback(lastUpdate.context.data, lastUpdate.context, lastUpdate.updaterId);
+                      callbackWithPermissionCheck(lastUpdate.context.data, lastUpdate.context, lastUpdate.updaterId);
                   }
                   delete this.pendingReplays[id];
               }, 0);
           }
-          const unsub = this.registry.add(this.subsKey, wrappedCallback);
+          const unsub = this.registry.add(this.subsKey, callbackWithPermissionCheck);
           return () => {
               this.pendingReplays[id] = false;
               this.pendingRestrictionCallbacks.delete(id);
@@ -17825,35 +17818,46 @@
               throw new Error("Please provide the callback as a function!");
           }
           const id = Utils.generateId();
-          const wrappedCallback = this.getWrappedSubscribeCallback(callback, id);
-          const unsub = await this.shared.subscribeFor(name, wrappedCallback);
+          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);
           return () => {
               this.pendingRestrictionCallbacks.delete(id);
               unsub();
           };
       }
-      async publish(data, options) {
+      async publish(data, name) {
           if (typeof data !== "object") {
               throw new Error("Please provide the data as an object!");
           }
-          if (options) {
-              this.validatePublishOptions(options);
-          }
-          if (typeof options === "object") {
-              return this.publishWithOptions(data, options);
+          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);
           }
-          const channelName = typeof options === "string" ? options : this.currentContext;
-          if (!channelName) {
+          if (!this.currentContext) {
               throw new Error("Not joined to any channel!");
           }
-          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) {
+          if (!(await this.getRestrictionsByChannel(this.currentContext)).write) {
               throw new Error(`Window does not have permission to write to channel ${this.currentContext}`);
           }
-          return this.shared.updateData(channelName, data);
+          return this.shared.updateData(this.currentContext, data);
       }
       async setPaths(paths, name) {
           if (name) {
@@ -18157,82 +18161,6 @@
               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) {
@@ -19264,6 +19192,28 @@
       }
       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;
@@ -19350,27 +19300,14 @@
           throw new Error(errorMsg);
       }
   };
-  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 validateIntentsResolverResponse = (method, responseObj) => {
+      return method === "raise" ? validateRaiseIntentsResolverResponse(responseObj) : validateFilterHandlersResolverResponse(responseObj);
   };
   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));
       }
@@ -19419,11 +19356,10 @@
   };
 
   class Intents {
-      constructor(interop, windows, logger, options, prefsController, appManager) {
+      constructor(interop, windows, logger, options, appManager) {
           this.interop = interop;
           this.windows = windows;
           this.logger = logger;
-          this.prefsController = prefsController;
           this.appManager = appManager;
           this.myIntents = new Set();
           this.intentsResolverResponsePromises = {};
@@ -19465,16 +19401,8 @@
           }
           validateIntentRequest(intentRequest);
           await Promise.all(this.unregisterIntentPromises);
-          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 resolverInstance = {};
           const coreRaiseIntentFn = this.coreRaiseIntent.bind(this, { request: intentRequest, resolverInstance, timeout });
           if (intentRequest.waitUserResponseIndefinitely) {
               return coreRaiseIntentFn();
@@ -19675,10 +19603,6 @@
           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) {
@@ -19780,7 +19704,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();
+          const responseMethodName = await this.registerIntentResolverMethod(method);
           (_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();
@@ -19799,7 +19723,7 @@
                 ? `for intent ${request.intent}`
                 : `for '${method}' method with filter ${JSON.stringify(request)}`}`
           });
-          const handler = await this.handleInstanceResponse({ instanceId: instance.id, caller: startContext.initialCaller, method, request });
+          const handler = await this.handleInstanceResponse(instance.id, method);
           return handler;
       }
       async windowsIdToTitle(id, windowsInfos) {
@@ -19811,23 +19735,13 @@
           const title = await (window === null || window === void 0 ? void 0 : window.getTitle());
           return title;
       }
-      async handleInstanceResponse({ instanceId, method, request, caller }) {
-          var _a, _b, _c;
+      async handleInstanceResponse(instanceId, method) {
+          var _a, _b;
           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) {
@@ -19835,14 +19749,14 @@
               throw new Error(error);
           }
       }
-      async registerIntentResolverMethod() {
+      async registerIntentResolverMethod(method) {
           const methodName = INTENTS_RESOLVER_INTEROP_PREFIX + Utils.generateId();
-          await this.interop.register(methodName, (args, callerId) => this.resolverResponseHandler(args, callerId));
+          await this.interop.register(methodName, (args, callerId) => this.resolverResponseHandler(args, callerId, method));
           return methodName;
       }
-      resolverResponseHandler(args, callerId) {
+      resolverResponseHandler(args, callerId, method) {
           const { instance } = callerId;
-          const isValid = validateResolverResponse(args);
+          const isValid = validateIntentsResolverResponse(method, 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);
@@ -19854,15 +19768,7 @@
           this.cleanUpIntentResolverPromise(instance);
       }
       buildStartContext(method, request, 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"
-          };
+          const baseStartContext = { callerId: this.interop.instance.instance, methodName };
           return method === "raise"
               ? { ...baseStartContext, intent: request }
               : { ...baseStartContext, handlerFilter: request };
@@ -20050,64 +19956,6 @@
           }, []);
           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 {
@@ -20354,7 +20202,6 @@
       let _windows;
       let _displays;
       let _channels;
-      let _prefs;
       const _browserEventsDispatcher = new EventsDispatcher(glueConfig);
       function createWindows(core) {
           if (glueConfig.windows) {
@@ -20451,7 +20298,7 @@
           return hotkeysAPI;
       }
       function createIntents(core) {
-          const intentsAPI = new Intents(core.agm, _windows, core.logger.subLogger("intents"), options, _prefs, _appManager);
+          const intentsAPI = new Intents(core.agm, _windows, core.logger.subLogger("intents"), options, _appManager);
           debugLog(intentsAPI);
           return intentsAPI;
       }
@@ -20479,9 +20326,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;
-          _prefs = new Prefs(appName, core.interop);
-          debugLog(_prefs);
-          return _prefs;
+          const prefs = new Prefs(appName, core.interop);
+          debugLog(prefs);
+          return prefs;
       }
       function createCookies(core) {
           const api = factory$1(core.interop, T42GDExecuteMethod);
@@ -20510,10 +20357,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,