It is not within your control to dictate whether a browser opens a new tab or window when executing code or displaying content. This decision is determined by the user's browser settings.

Attempting to override this behavior would present significant security vulnerabilities.

Explaining the basic workings of pop-up blockers.

When a user triggers a function to open a new URL, the pop-up blocker will allow it (applicable to most modern browsers such as Firefox and Chrome).

However, if the trigger is not from the user (such as a background JavaScript function or promise), the browser will block it unless the user manually whitelists the site.

An example that fails:

function launchPopup() {
    window.open('http://stackoverflow.com','_blank');
}

launchPopup();//fails

An example that works:

<h1><button onclick="launchPopup()">Open Popup - working</button></h1>

I have created a simple version on Plunkr for demonstration purposes - http://plnkr.co/edit/FfhsAtTg7bzeNwHj35PQ?p=preview

Therefore, answering your question, it is impossible unless the user authorizes it through triggering or whitelisting the site.

A quote from Firefox:

Pop-up windows, or pop-ups, are windows that appear automatically without your permission.

For more information, visit:

*Whether opening in a new tab or new window, the pop-up blocker will still activate. It does not guarantee allowance even when opening in a new tab; this behavior varies based on certain browser default settings.

Possible Solution:

You can explicitly ask the user to trigger the function to open in a new tab after the background execution.
You can also prompt the user with a message in the UI to guide them on opening the URL. Example - http://plnkr.co/edit/Ubjkml32BlaspqrPk98G?p=preview

Opening new windows within click event handlers is limited to interactions initiated by the user.

The primary rationale behind this restriction is centered on enhancing the overall browsing experience.

While not all browsers may enforce this constraint universally, certain browsers prevent unauthorized scripts from launching new windows surreptitiously, as it can be disruptive and bothersome for visitors.

For a practical demonstration, refer to this DEMO (validated across Chrome and Firefox). Even when generating a click event programmatically, most browsers intercept attempts to spawn pop-ups.

$("#test").click(function(){
    openInNewTab();
});

$("#test").click();

Unlike within ajax success callbacks, you are unable to trigger window creation since the callback executes after the completion of the click event handler's operation.

A workaround solution for such scenarios can be found through this resource.

Interestingly, replicating the same code within a promise callback yields different outcomes, opening the file in a separate window instead.

Surprisingly, despite encountering challenges, one may still succeed in initiating new window instances. Nonetheless, the issue largely revolves around respecting the boundaries outlined for user-triggered click events.

Your issue has multiple layers of complexity, all of which venture into uncharted waters.

In the early days of web browsers, the window.open function did exactly what its name suggests - it opened a new window. This was before the advent of tabbed browsing. When tabs were introduced, they were essentially treated as windows for compatibility reasons, and this practice continues today. Due to the recent standardization of window.open, JavaScript struggles to differentiate between tabs and windows.

There is no definitive method to specify if a link should open in a new tab or not. However, there is a workaround: you can set a custom window size when using the window.open function, like this:

window.open('http://example.com', '', 'width=' + screen.width);

This trick will prompt most browsers to open a separate window because tabs cannot have customized dimensions.

In the realm of JavaScript, there exist two categories of events: trusted and untrusted. Trusted events include authentic user actions like clicking on a link, while untrusted events encompass scenarios such as manual calls to the click() function.

New windows or tabs can only be opened by trusted event handlers. This safety measure is in place to guard against client-side attacks that could potentially crash the browser or overwhelm the user with an excessive number of tabs triggered by events like mouseover.

The scenario where your attempted popup fails is due to the popup blocker intercepting the untrusted event initiated by the click() function. Despite originating from a genuine user click, the interruption caused by the asynchronous call disrupts the thread of trustworthiness.

live demo

$http.get('https://api.example.com/data').then(openNewTab());

UPDATE----------------

Not sure why, but triggering a click() function from a callback behaves differently than directly calling it.

Take a look at an example using setInterval.

That's why I opted to call the function directly instead of through a callback.

check it out with timer callback

Alternatively, the $window service can be utilized. For more details, please refer to: http://plnkr.co/edit/8egebfFj4T3LwM0Kd64s?p=preview

angular.module("Example", []).controller("ExampleCtrl", function($scope, $http, $window) {
  $scope.url = 'http://martinfowler.com/ieeeSoftware/whenType.pdf';

  function openNewTab() {

    var linkElement = angular.element('<a href="' + $scope.url + '" target="_blank"></a>');

    angular.element(document.body).append(linkElement);

    linkElement[0].click();
    linkElement.remove();
  }

  $scope.successfulLaunch = openNewTab;

  $scope.unsuccessfulLaunch = function() {
    $http.get('https://api.github.com/users/angular').then($window.open($scope.url));
  };
});

Our solution that proved to be effective involved utilizing the method outlined in this blog post:

To summarize, we kept track of the new tab reference and then modified its location accordingly.