Use a load event listener to give the window time to be ready for you to add your Tab event listeners and create the polling service for the existing tab. Then use an unload event listener to do your cleanup.

If you are asking how to change the tab's DOM, I would use a content script for that. Then use postMessage to communicate between your event page and your content script if you need to, but event pages can disappear, so that may not be a reliable channel.

This is from the Google Code documentation:

chrome.browserAction.onClicked.addListener(function(tab) {
  chrome.tabs.executeScript(null,
                           {code:"document.body.bgColor='red'"});
});

If you are asking how to get the current tab, getting the current tab can vary depending on the context. Below is what has worked for me recently.

In the popup.html for a browser action I have:

  chrome.tabs.query({active: true, currentWindow: true}, function(tabs) {
      var current;
      if (_.isEmpty(tabs)) {
        return;
      }
      current = tabs[0];
   });

And in a chrome-extention:// I use:

   chrome.tabs.getCurrent(function(tab) {
   });

I can't say what's the best solution for the particular use case, but there are various points to consider when deciding what's the best tradeoff:

• the decision to use an a or button tag should not be determined by the presence of the menu. One is a navigational element and the other is used to perform actions on the page. If it's a navigation on a website, <a> is probably the right tag.
• the context menu is a browser "thing" and it's in the control sphere of the user. Depending upon your site's philosophy you should not mess up with the browser's basic functionality.
• when the user navigates away from your page, the browser will trigger the beforeunload event, which will trigger when the current page is being closed. It is a browser's native functionality (the same you get here on StackOverflow when you leave a page with unsaved changes), so it's not customizable in style, but it suits more an HTML-first approach. If you need an 'unsaved changes' message, this is the usual way to go.
• you can use good ol' window.open with target _blank in a button javascript handler if you want to expose a button with the open in new tab functionality. This way you stay in your JavaScript context and can do whatever you need.
• if you want more of a Single Page Application style, you can replace the native context menu with something else, as suggested, but you have to evaluate if you are building an application or a website. I like the websites I use to behave like websites and do not interfere with my browser's basic capabilities. YMMV.

Probably there are more considerations worth taking, but this are the ones from the top of my mind.

In window B you set a cookie and in window A you create a setTimeout function that every "x" milliseconds check if there are any new cookie.

Look at this: Javascript communication between browser tabs/windows

You should be able to do this with the keyup event. To be specific, event.target should point at the selected element and event.target.href will give you the href-value of that element. See mdn for more information.

The following code is jQuery, but apart from the boilerplate code, the rest is the same in pure javascript. This is a keyup handler that is bound to every link tag.

$('a').on( 'keyup', function( e ) {
    if( e.which == 9 ) {
        console.log( e.target.href );
    }
} );

jsFiddle: http://jsfiddle.net/4PqUF/

input.keydown(function(event){
    if (event.keyCode === 9) {
        event.preventDefault();
    }
})

On keyup is too late, you need to call the event on keydown. That worked for me.

If I get you correctly, you want to know when a tab/window is effectively closed. Well, AFAIK the only way in JavaScript to detect that is to use either onunload or onbeforeunload events.

Unfortunately (or fortunately?), those events are also fired when you leave a site over a link or your browsers back button. So this is the best answer I can give, I don't think you can natively detect a pure close in JavaScript. Correct me if I'm wrong here.

I got this one working with the beforeunload method

Went some like this:

useEffect(() => {
  window.addEventListener("beforeunload", () => {
    if (chatToEmailServer.chatToServer.length > 0) {
      emailChatHistory();
      setFirstMsg(true);
    }
  });
}, [chatToEmailServer.chatToServer, firstMsg]);

^^^ This is working, but it gives me warning on the code for dependencies.

Trying to fix the dependencies error is something in the backburner because include the emailChatHistory() in the dependencies, then I have to dig all through de code and fix communication with the API and a few other things.... basically it opens another chain of errors that I couldn't figured out.... so, until it breaks, or when I got time, I might change the code later.

The correct event binding for tab change is shown.bs.tab.

$(document).on('shown.bs.tab', 'a[data-toggle="tab"]', function (e) {
    alert('TAB CHANGED');
})

Update 11-01-2020 --- Bootstrap 4.5

This is still the correct answer however, this is a bit of additional helpful information found all the way at the bottom of the official bootstrap docs page at: https://getbootstrap.com/docs/4.5/components/navs/#tabs

$('a[data-toggle="tab"]').on('shown.bs.tab', function (e) {
  e.target // newly activated tab
  e.relatedTarget // previous active tab
})

You can determine which tab has been selected each time the code fires with e.target.

If you have unique IDs on your elements then you could do something like the following so code only runs when the appropriate tab is clicked.

$('a[data-toggle="tab"]').on('shown.bs.tab', function (e) {
  switch (e.target.id){
      case "mainTab":{
           doMainTabStuff();
           break;
      }
      case "configTab":{
           doConfigTabStuff();
           break;
      }
  }
})