@interopio/desktop 6.11.0 → 6.12.0

package/dist/desktop.browser.js

@@ -2944,7 +2944,7 @@
       }
   };
 
-  var version$1 = "6.5.2";
+  var version$1 = "6.5.2-fmr-beta";
 
   function prepareConfig$1 (configuration, ext, glue42gd) {
       let nodeStartingContext;
@@ -5664,7 +5664,10 @@
           this._contextIdToName = {};
           delete this._protocolVersion;
           this._contextsTempCache = Object.keys(this._contextNameToData).reduce((cacheSoFar, ctxName) => {
-              cacheSoFar[ctxName] = this._contextNameToData[ctxName].context;
+              const contextData = this._contextNameToData[ctxName];
+              if (contextData.isAnnounced && (contextData.activityId || contextData.sentExplicitSubscription)) {
+                  cacheSoFar[ctxName] = this._contextNameToData[ctxName].context;
+              }
               return cacheSoFar;
           }, {});
           this._contextNameToData = {};
@@ -11596,21 +11599,12 @@
   const INTEROP_METHOD_RESPONSE_TIMEOUT_MS = 90000;
   const INTEROP_METHOD_WAIT_TIMEOUT_MS = 90000;
 
-  // This alphabet uses `A-Za-z0-9_-` symbols.
-  // The order of characters is optimized for better gzip and brotli compression.
-  // References to the same file (works both for gzip and brotli):
-  // `'use`, `andom`, and `rict'`
-  // References to the brotli default dictionary:
-  // `-26T`, `1983`, `40px`, `75px`, `bush`, `jack`, `mind`, `very`, and `wolf`
   let urlAlphabet =
     'useandom-26T198340PX75pxJACKVERYMINDBUSHWOLF_GQZbfghjklqvwyzrict';
-
   let nanoid = (size = 21) => {
     let id = '';
-    // A compact alternative for `for (var i = 0; i < step; i++)`.
     let i = size | 0;
     while (i--) {
-      // `| 0` is more compact and faster than `Math.floor()`.
       id += urlAlphabet[(Math.random() * 64) | 0];
     }
     return id
@@ -12142,10 +12136,11 @@
                   }, 0);
               };
               this._logger.trace(`waiting for window with id ${this._id} to appear`);
+              const timeoutInSeconds = 60;
               const timeout = setTimeout(() => {
-                  this._logger.trace(`window with id ${this._id} did not appear in 30 sec`);
+                  this._logger.trace(`window with id ${this._id} did not appear in ${timeoutInSeconds} sec`);
                   done(new Error(`can not find a window with id ${this._id}`));
-              }, 30000);
+              }, timeoutInSeconds * 1000);
               const unsub = this._windows.onWindowAdded((w) => {
                   if (w.id === this._id) {
                       this._logger.trace(`window with id ${this._id} appeared`);
@@ -14967,52 +14962,12 @@
           return w;
       }
       async activate(w) {
-          let unFocusChanged;
-          let unClosed;
-          try {
-              const done = new Promise((resolve, reject) => {
-                  unFocusChanged = w.onFocusChanged(() => {
-                      resolve();
-                  });
-                  unClosed = w.onClose(() => {
-                      reject(new Error("Window was closed"));
-                  });
-              });
-              await Promise.all([this.execute("activate", { windowId: w.id }, "FocusChanged"), done]);
-              return w;
-          }
-          finally {
-              if (unFocusChanged) {
-                  unFocusChanged();
-              }
-              if (unClosed) {
-                  unClosed();
-              }
-          }
+          await this.execute("activate", { windowId: w.id });
+          return w;
       }
       async focus(w) {
-          let unFocusChanged;
-          let unClosed;
-          try {
-              const done = new Promise((resolve, reject) => {
-                  unFocusChanged = w.onFocusChanged(() => {
-                      resolve();
-                  });
-                  unClosed = w.onClose(() => {
-                      reject(new Error("Window was closed"));
-                  });
-              });
-              await Promise.all([this.execute("focus", { windowId: w.id }, "FocusChanged"), done]);
-              return w;
-          }
-          finally {
-              if (unFocusChanged) {
-                  unFocusChanged();
-              }
-              if (unClosed) {
-                  unClosed();
-              }
-          }
+          await this.execute("focus", { windowId: w.id });
+          return w;
       }
       async maximizeRestore(w) {
           await this.execute("maximizeRestore", { windowId: w.id }, "StateChanged");
@@ -17913,7 +17868,7 @@
           });
       }
       leaveChannel(channel) {
-          const channelsToLeave = new MultiChannelId(channel);
+          const channelsToLeave = new MultiChannelId(channel !== null && channel !== void 0 ? channel : this.channels);
           channelsToLeave.all().forEach((c) => {
               this.channels = this.channels.filter((ch) => ch !== c);
           });
@@ -17937,35 +17892,37 @@
   }
 
   let interop;
-  let windowId;
+  let myInstanceId;
+  let logger;
   const T42_ANNOUNCE_METHOD_NAME = "T42.Channels.Announce";
-  async function setupInterop(interopLib, channels) {
+  const T42_COMMAND_METHOD_NAME = "T42.Channels.Command";
+  async function setupInterop(interopLib, channels, loggerAPI) {
       var _a, _b;
+      logger = loggerAPI;
       interop = interopLib;
       if (typeof window !== "undefined") {
           if (window.glue42gd) {
-              windowId = window.glue42gd.windowId;
+              myInstanceId = window.glue42gd.windowId;
           }
       }
-      if (!windowId) {
-          return;
+      if (!myInstanceId) {
+          myInstanceId = interopLib.instance.instance;
       }
-      await interop.register("T42.Channels.Command", (args) => {
+      await interop.register(T42_COMMAND_METHOD_NAME, (args) => {
           const command = args.command;
           if (!command) {
               throw new Error("missing command argument");
           }
+          logger.trace(`received command "${command}" with ${JSON.stringify(args)}`);
           if (command === "join") {
               const id = args.channel;
               if (!id) {
                   throw new Error("missing argument id");
               }
-              channels.joinNoSelectorSwitch(id);
-              return;
+              return channels.joinNoSelectorSwitch(id);
           }
           if (command === "leave") {
-              channels.leaveNoSelectorSwitch();
-              return;
+              return channels.leaveNoSelectorSwitch();
           }
           if (command === "get") {
               const id = channels.current();
@@ -17985,37 +17942,37 @@
               if (!channelsToJoin) {
                   throw new Error("missing argument channelsToJoin");
               }
-              channels.joinNoSelectorSwitch(new MultiChannelId(channelsToJoin).toString());
-              return;
+              return channels.joinNoSelectorSwitch(new MultiChannelId(channelsToJoin).toString());
           }
           if (command === "leave-multi") {
               const channelsToLeave = args.channelsToLeave;
-              channels.leaveNoSelectorSwitch(new MultiChannelId(channelsToLeave).toString());
-              return;
+              return channels.leaveNoSelectorSwitch(new MultiChannelId(channelsToLeave).toString());
           }
           throw new Error(`unknown command ${command}`);
       });
-      const result = await interop.invoke(T42_ANNOUNCE_METHOD_NAME, { swId: windowId, instance: interop.instance.instance }, "best", {
+      const result = await interop.invoke(T42_ANNOUNCE_METHOD_NAME, { swId: myInstanceId, instance: interop.instance.instance }, "best", {
           waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
           methodResponseTimeoutMs: INTEROP_METHOD_RESPONSE_TIMEOUT_MS
       });
       if ((_a = result.returned) === null || _a === void 0 ? void 0 : _a.restrictions) {
-          channels.handleRestrictionsChanged((_b = result.returned) === null || _b === void 0 ? void 0 : _b.restrictions, windowId);
+          channels.handleRestrictionsChanged((_b = result.returned) === null || _b === void 0 ? void 0 : _b.restrictions, myInstanceId);
       }
+      return result.returned;
   }
   async function sendLeaveChannel(channel, winId) {
-      await invoke("leaveChannel", { channel }, winId !== null && winId !== void 0 ? winId : windowId);
+      var _a;
+      await invoke("leaveChannel", { channel }, (_a = winId !== null && winId !== void 0 ? winId : winId) !== null && _a !== void 0 ? _a : myInstanceId);
   }
   async function sendSwitchChannelUI(channel, winId) {
-      await invoke("switchChannel", { newChannel: channel }, winId !== null && winId !== void 0 ? winId : windowId);
+      await invoke("switchChannel", { newChannel: channel }, winId !== null && winId !== void 0 ? winId : myInstanceId);
   }
   async function setRestrictions(restrictions) {
       var _a;
-      await invoke("restrict", restrictions, (_a = restrictions.windowId) !== null && _a !== void 0 ? _a : windowId);
+      await invoke("restrict", restrictions, (_a = restrictions.windowId) !== null && _a !== void 0 ? _a : myInstanceId);
   }
   async function getRestrictionsByWindow(id) {
       try {
-          const result = await invoke("getRestrictions", {}, id !== null && id !== void 0 ? id : windowId);
+          const result = await invoke("getRestrictions", {}, id !== null && id !== void 0 ? id : myInstanceId);
           return result.returned;
       }
       catch (e) {
@@ -18023,37 +17980,47 @@
   }
   async function setRestrictionsForAllChannels(restrictions) {
       var _a;
-      await invoke("restrictAll", restrictions, (_a = restrictions.windowId) !== null && _a !== void 0 ? _a : windowId);
+      await invoke("restrictAll", restrictions, (_a = restrictions.windowId) !== null && _a !== void 0 ? _a : myInstanceId);
   }
-  async function getWindowsWithChannels(filter) {
+  async function getChannelsInfo(filter) {
       const result = await invoke("getChannelsInfo", { filter });
       return result.returned;
   }
   async function addOrRemoveChannel(command, id, color, label) {
       await invoke(command, { id, color, label });
   }
-  async function getChannelsMode(config, i) {
+  async function getChannelInitInfo(config, i) {
       if (typeof config.operationMode !== "boolean" && typeof config.operationMode === "string") {
           validateMode(config.operationMode);
-          return config.operationMode;
+          return { mode: config.operationMode, initialChannel: undefined };
       }
       try {
           const result = await i.invoke(T42_ANNOUNCE_METHOD_NAME, { command: "getChannelsMode" }, "best", {
               waitTimeoutMs: INTEROP_METHOD_WAIT_TIMEOUT_MS,
               methodResponseTimeoutMs: INTEROP_METHOD_RESPONSE_TIMEOUT_MS,
           });
+          const initialChannel = result.returned.initialChannel;
           if (result.returned.mode === "single") {
-              return "single";
+              return {
+                  mode: "single",
+                  initialChannel
+              };
           }
           else if (result.returned.mode === "multi") {
-              return "multi";
+              return {
+                  mode: "multi",
+                  initialChannel
+              };
           }
           else {
-              return "single";
+              return {
+                  mode: "single",
+                  initialChannel
+              };
           }
       }
       catch (e) {
-          return "single";
+          return { mode: "single", initialChannel: undefined };
       }
   }
   function invoke(command, data, swId) {
@@ -18105,6 +18072,9 @@
           if (contextData[LATEST_FDC3_TYPE]) {
               return this.getContextWithFdc3Data(contextData);
           }
+          else {
+              delete contextData[LATEST_FDC3_TYPE];
+          }
           return contextData;
       }
       updateChannel(name, data) {
@@ -18154,6 +18124,10 @@
               throw new Error("setPaths is not supported!");
           }
       }
+      clearContextData(name) {
+          const contextName = this.createContextName(name);
+          return this.contexts.update(contextName, { data: {}, [LATEST_FDC3_TYPE]: undefined });
+      }
       isChannel(name) {
           return this.all().some((channelName) => channelName === name);
       }
@@ -18270,6 +18244,7 @@
       unsubscribe() {
           if (this.unsubscribeFunc) {
               this.unsubscribeFunc();
+              this.unsubscribeFunc = undefined;
           }
       }
   }
@@ -18284,9 +18259,10 @@
   };
 
   class ChannelsImpl {
-      constructor(interop, getWindows, logger) {
+      constructor(interop, getWindowsAPI, getAppManagerAPI, logger) {
           this.interop = interop;
-          this.getWindows = getWindows;
+          this.getWindowsAPI = getWindowsAPI;
+          this.getAppManagerAPI = getAppManagerAPI;
           this.logger = logger;
           this.subsKey = "subs";
           this.changedKey = "changed";
@@ -18309,17 +18285,20 @@
           }
           return result;
       }
-      init(shared, mode) {
+      async init(shared, mode, initial) {
           this.mode = mode;
           this.shared = shared;
           this.shared.subscribe(this.handler.bind(this));
           this.subscribeForChannelRestrictionsChange();
+          let initialChannel = initial;
           if (typeof window !== "undefined" && typeof window.glue42gd !== "undefined") {
-              const initial = window.glue42gd.initialChannel;
-              this.currentChannelID = this.getID(initial);
-              if (this.currentChannelID.isJoinedToAnyChannel) {
-                  this.joinNoSelectorSwitch(this.currentChannelID.toString());
-              }
+              initialChannel = window.glue42gd.initialChannel;
+          }
+          this.currentChannelID = this.getID(initialChannel);
+          this.logger.trace(`initialized with mode: "${mode}" and initial channel: "${initialChannel}"`);
+          if (this.currentChannelID.isJoinedToAnyChannel) {
+              this.logger.trace(`joining initial channel: "${this.currentChannelID.toString()}"`);
+              await this.joinNoSelectorSwitch(this.currentChannelID.toString());
           }
       }
       subscribe(callback, options) {
@@ -18384,11 +18363,34 @@
           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.currentChannelID.toString()}`);
+          if (this.mode === "multi") {
+              const channelsToPublish = new MultiChannelId(channelName).all();
+              const restrictedChannels = [];
+              for (const cn of channelsToPublish) {
+                  const canPublish = (await this.getRestrictionsByChannel(cn)).write;
+                  if (!canPublish) {
+                      restrictedChannels.push(cn);
+                      continue;
+                  }
+                  await this.shared.updateData(cn, data);
+              }
+              if (restrictedChannels.length > 0) {
+                  const restrictedChannelsErr = `Unable to publish due to restrictions to the following channels: ${restrictedChannels.join(", ")}`;
+                  if (restrictedChannels.length === channelsToPublish.length) {
+                      throw new Error(restrictedChannelsErr);
+                  }
+                  else {
+                      this.logger.warn(restrictedChannelsErr);
+                  }
+              }
+          }
+          else {
+              const canPublish = (await this.getRestrictionsByChannel(channelName)).write;
+              if (!canPublish) {
+                  throw new Error(`Window does not have permission to write to channel ${channelName}`);
+              }
+              return this.shared.updateData(channelName, data);
           }
-          return this.shared.updateData(channelName, data);
       }
       async setPaths(paths, name) {
           if (name) {
@@ -18471,14 +18473,30 @@
       async join(name, windowId) {
           if (windowId !== undefined && windowId !== null) {
               this.validateWindowIdArg(windowId);
+              this.logger.trace(`joining channel ${name} for window: ${windowId}`);
               return sendSwitchChannelUI(name, windowId);
           }
           return this.joinCore(name);
       }
-      async joinNoSelectorSwitch(id) {
-          return this.joinCore(id, false);
+      async joinNoSelectorSwitch(channelName) {
+          this.logger.trace(`joining channel "${channelName}" from command`);
+          return this.joinCore(channelName, false);
       }
-      leave(windowId, channelName) {
+      leave(options) {
+          this.logger.trace(`leaving channel with options: ${JSON.stringify(options)}`);
+          let windowId;
+          let channelName;
+          if (typeof options === "string") {
+              windowId = options;
+          }
+          else if (typeof options === "object" && !Array.isArray(options) && options !== null && options !== undefined) {
+              if (options.windowId) {
+                  windowId = options.windowId;
+              }
+              if (options.channel) {
+                  channelName = options.channel;
+              }
+          }
           if (this.mode === "multi") {
               return this.leaveWhenMulti(channelName, windowId);
           }
@@ -18487,7 +18505,8 @@
           }
       }
       leaveNoSelectorSwitch(channelName) {
-          return this.leave(undefined, channelName);
+          this.logger.trace(`leaving channel "${channelName}" from command`);
+          return this.leaveCore(false, channelName);
       }
       current() {
           return this.currentChannelID.toString();
@@ -18503,13 +18522,18 @@
           if (typeof callback !== "function") {
               throw new Error("Please provide the callback as a function!");
           }
+          let timeoutId;
           const current = this.current();
           if (current) {
-              setTimeout(() => {
+              timeoutId = setTimeout(() => {
                   callback(this.myChannels());
               }, 0);
           }
-          return this.registry.add(this.channelsChangedKey, callback);
+          const un = this.registry.add(this.channelsChangedKey, callback);
+          return () => {
+              un();
+              clearTimeout(timeoutId);
+          };
       }
       changed(callback) {
           if (typeof callback !== "function") {
@@ -18556,14 +18580,16 @@
               meta: info.meta || {},
               data: info.data || {}
           };
-          await this.shared.updateChannel(info.name, context);
+          this.logger.trace(`adding channel: ${info.name}`);
           await addOrRemoveChannel("addChannel", info.name, info.meta.color, (_a = info.meta) === null || _a === void 0 ? void 0 : _a.label);
+          await this.shared.updateChannel(info.name, context);
           return context;
       }
       async remove(channel) {
           if (typeof channel !== "string") {
               throw new Error("Please provide the channel name as a string!");
           }
+          this.logger.trace(`removing channel: ${channel}`);
           await this.shared.remove(channel);
           await addOrRemoveChannel("removeChannel", channel);
       }
@@ -18575,17 +18601,18 @@
       async getWindowsWithChannels(filter) {
           this.validateWindowsWithChannelsFilter(filter);
           try {
-              const info = await getWindowsWithChannels(filter);
-              const windows = this.getWindows();
+              const info = await getChannelsInfo(filter);
+              const windowsAPI = this.getWindowsAPI();
               if (info === null || info === void 0 ? void 0 : info.windows) {
-                  return info.windows.map((windowInfo) => {
-                      const window = windows.findById(windowInfo.windowId);
-                      return {
+                  return info.windows.reduce((memo, windowInfo) => {
+                      const window = windowsAPI.findById(windowInfo.windowId);
+                      memo.push({
                           window,
                           channel: windowInfo.channel,
                           application: windowInfo.application
-                      };
-                  });
+                      });
+                      return memo;
+                  }, []);
               }
           }
           catch (er) {
@@ -18613,6 +18640,20 @@
               windowId
           });
       }
+      async clearChannelData(channel) {
+          const channelName = typeof channel === "string" ? channel : this.currentChannelID.toString();
+          if (!channelName) {
+              return;
+          }
+          if (!this.shared.isChannel(channelName)) {
+              return;
+          }
+          const canPublish = (await this.getRestrictionsByChannel(channelName)).write;
+          if (!canPublish) {
+              return;
+          }
+          return this.shared.clearContextData(channelName);
+      }
       handler(data, context, updaterId) {
           if (!context && !updaterId) {
               this.lastUpdate = undefined;
@@ -18623,22 +18664,28 @@
           this.registry.execute(this.subsKey, data, context, updaterId);
       }
       async joinCore(name, changeSelector = true) {
+          this.logger.trace(`joining channel "${name}" ${changeSelector ? "" : "from command"}`);
           if (typeof name !== "string") {
               throw new Error("Please provide the channel name as a string!");
           }
           const newId = this.getID(name);
-          if (!this.isInitialJoin && this.currentChannelID.equals(newId)) {
+          if (!this.isInitialJoin && this.currentChannelID.isOnChannel(newId.toString())) {
+              this.logger.trace(`already on channel: "${name}" ${changeSelector ? "" : "from command"}`);
               return;
           }
           this.isInitialJoin = false;
           await Promise.all(newId.all().map((n) => this.verifyChannelExists(n)));
           this.currentChannelID.joinChannel(name);
           this.lastUpdate = undefined;
+          this.logger.trace(`switching channel context to: "${name}" ${changeSelector ? "" : "from command"}`);
           await this.shared.switchChannel(this.currentChannelID.toString());
           if (changeSelector) {
+              this.logger.trace(`switching UI channel to: "${name}" ${changeSelector ? "" : "from command"}`);
               await sendSwitchChannelUI(name);
+              this.logger.trace(`switched UI channel to: "${name}" ${changeSelector ? "" : "from command"}`);
           }
           this.raiseChannelsChangedEvents();
+          this.logger.trace(`joined channel: ${name} ${changeSelector ? "" : "from command"} - current channel/s: ${this.currentChannelID.toString()}`);
       }
       async verifyChannelExists(name) {
           const doesChannelExist = (channelName) => {
@@ -18663,21 +18710,46 @@
           }
       }
       async leaveCore(changeSelector = true, channelID) {
+          if (!this.currentChannelID.isJoinedToAnyChannel) {
+              this.logger.trace(`leave called ${changeSelector ? "" : "from command"} when not joined to any channel change selector`);
+              return;
+          }
+          if (channelID && !this.currentChannelID.isOnChannel(channelID)) {
+              this.logger.trace(`leave called ${changeSelector ? "" : "from command"} when not joined to channel: "${channelID}"`);
+              return;
+          }
+          this.logger.trace(`leaving context channel: "${channelID}" ${changeSelector ? "" : "from command"}`);
           this.currentChannelID.leaveChannel(channelID);
           await this.shared.leave(channelID);
+          this.lastUpdate = undefined;
           this.raiseChannelsChangedEvents();
           if (changeSelector) {
+              this.logger.trace(`switching UI channel to: "${channelID}" ${changeSelector ? "" : "from command"}`);
               await sendSwitchChannelUI(this.currentChannelID.toString());
+              this.logger.trace(`switched UI channel to: "${channelID}" ${changeSelector ? "" : "from command"}`);
           }
+          this.logger.trace(`left single channel: "${channelID}" ${changeSelector ? "" : "from command"} - current channel/s: "${this.currentChannelID.toString()}"`);
           return Promise.resolve();
       }
       async leaveCoreMulti(changeSelector = true, channelID) {
-          this.currentChannelID.leaveChannel(channelID);
-          await this.shared.leave(channelID);
+          this.logger.trace(`leaving multi channel: "${channelID.toString()}" ${changeSelector ? "" : "from command"}`);
+          const currentChannels = this.currentChannelID.all();
+          const isJoinedToChannel = currentChannels.some((c) => channelID.isOnChannel(c));
+          if (!isJoinedToChannel || !this.currentChannelID.isJoinedToAnyChannel) {
+              this.logger.trace(`leave called ${changeSelector ? "" : "from command"} when not joined to any channel`);
+              return;
+          }
+          const channelName = channelID.toString();
+          this.currentChannelID.leaveChannel(channelName);
+          await this.shared.leave(channelName);
+          this.lastUpdate = undefined;
           this.raiseChannelsChangedEvents();
           if (changeSelector) {
-              sendLeaveChannel(channelID);
+              this.logger.trace(`switching UI channel to: "${channelName}" ${changeSelector ? "" : "from command"}`);
+              await sendLeaveChannel(channelName);
+              this.logger.trace(`switched UI channel to: "${channelName}" ${changeSelector ? "" : "from command"}`);
           }
+          this.logger.trace(`left multi channel: "${channelName}" ${changeSelector ? "" : "from command"} - current channel/s: ${this.currentChannelID.toString()}`);
           return Promise.resolve();
       }
       raiseChannelsChangedEvents() {
@@ -18705,9 +18777,11 @@
               return;
           }
           this.onRestrictionsChangedSub = this.registry.add("restrictions-changed", ({ restrictions }) => {
+              this.logger.trace(`restrictions changed - ${JSON.stringify(restrictions)}`);
               this.pendingRestrictionCallbacks.forEach(({ cb, channelName }, id) => {
                   const currentChannel = restrictions.channels.find((c) => c.name === channelName);
                   if (!currentChannel) {
+                      this.logger.trace(`channel "${channelName}" not found in restrictions`);
                       return;
                   }
                   if (currentChannel.read) {
@@ -18723,6 +18797,7 @@
       }
       subscribeForChannelRestrictionsChange() {
           this.registry.add("restrictions-changed", (r) => {
+              this.logger.trace(`channel restrictions changed - ${JSON.stringify(r.restrictions)}`);
               this.channelRestrictions = r.restrictions;
           });
       }
@@ -18887,21 +18962,28 @@
       }
       leaveWhenSingle(channelName, windowId) {
           if (windowId) {
+              this.logger.trace(`leaving single channel "${channelName}" for window: "${windowId}"`);
               return sendSwitchChannelUI(undefined, windowId);
           }
+          this.logger.trace(`leaving single channel "${channelName}" for our window`);
           return this.leaveCore(true, channelName);
       }
       async leaveWhenMulti(channelName, windowId) {
           if (windowId) {
+              this.logger.trace(`leaving multi channel "${channelName}" for window: "${windowId}"`);
               return sendLeaveChannel(channelName, windowId);
           }
-          return this.leaveCoreMulti(true, channelName);
+          else {
+              const channelId = channelName ? new MultiChannelId(channelName) : this.currentChannelID;
+              this.logger.trace(`leaving multi channel "${channelId.toString()}" for our window`);
+              return this.leaveCoreMulti(true, channelId);
+          }
       }
       validateWindowIdArg(windowId) {
           if (typeof windowId !== "string") {
               throw new Error("The window ID must be a non-empty string!");
           }
-          const windows = this.getWindows();
+          const windows = this.getWindowsAPI();
           if (!windows.findById(windowId)) {
               throw new Error(`Window with ID "${windowId}" doesn't exist!`);
           }
@@ -18951,18 +19033,18 @@
       }
   }
 
-  function factory$4(config, contexts, agm, getWindows, logger) {
-      const channelsReadyPromise = getChannelsMode(config, agm)
-          .then(async (mode) => {
+  function factory$4(config, contexts, agm, getWindowsAPI, getAppManagerAPI, logger) {
+      const channelsReadyPromise = getChannelInitInfo(config, agm)
+          .then(async ({ mode, initialChannel }) => {
           const sharedContexts = mode === "single" ? new SharedContextSubscriber(contexts) : new MultiSharedContextSubscriber(contexts);
           if (mode === "multi") {
               logger.info(`multi-channel mode enabled`);
           }
-          channels.init(sharedContexts, mode);
-          await setupInterop(agm, channels);
+          await channels.init(sharedContexts, mode, initialChannel);
+          await setupInterop(agm, channels, logger);
           return true;
       });
-      const channels = new ChannelsImpl(agm, getWindows, logger);
+      const channels = new ChannelsImpl(agm, getWindowsAPI, getAppManagerAPI, logger);
       return {
           subscribe: channels.subscribe.bind(channels),
           subscribeFor: channels.subscribeFor.bind(channels),
@@ -18976,6 +19058,7 @@
           leave: channels.leave.bind(channels),
           restrict: channels.restrict.bind(channels),
           getRestrictions: channels.getRestrictions.bind(channels),
+          clearChannelData: channels.clearChannelData.bind(channels),
           restrictAll: channels.restrictAll.bind(channels),
           current: channels.current.bind(channels),
           my: channels.my.bind(channels),
@@ -19093,7 +19176,7 @@
       };
   }
 
-  var version = "6.11.0";
+  var version = "6.12.0";
 
   var prepareConfig = (options) => {
       function getLibConfig(value, defaultMode, trueMode) {
@@ -22920,7 +23003,7 @@
               logger.error("Channels library requires Contexts library to be initialized.");
               return;
           }
-          _channels = factory$4({ operationMode: glueConfig.channels.operationMode }, core.contexts, core.agm, () => _windows, logger);
+          _channels = factory$4({ operationMode: glueConfig.channels.operationMode }, core.contexts, core.agm, () => _windows, () => _appManager, logger);
           debugLog(_channels);
           return _channels;
       }