I used a variation of the above but instead of printing html I built a form and submitted it to the 3rd party url:

    var mapForm = document.createElement("form");
    mapForm.target = "Map";
    mapForm.method = "POST"; // or "post" if appropriate
    mapForm.action = "http://www.url.com/map.php";

    var mapInput = document.createElement("input");
    mapInput.type = "text";
    mapInput.name = "addrs";
    mapInput.value = data;
    mapForm.appendChild(mapInput);

    document.body.appendChild(mapForm);

    map = window.open("", "Map", "status=0,title=0,height=600,width=800,scrollbars=1");

if (map) {
    mapForm.submit();
} else {
    alert('You must allow popups for this map to work.');
}

Try with HttpSession to save the state of the user specific data that can be accessed by any page within the same domain.

Steps to follow:

• Simply make a GWT RPC call to pass the JSON string to the server in post request.
• At server side of RPC call save the JSON string in HTTP Session to access it later
• Now open a new page (having same domain) that will access the JSON string from the HTTP Session

Complete Sample code including GWT PRC classes as well

@RemoteServiceRelativePath("greet")
public interface GreetingService extends RemoteService {
    public void setJSON(String json)throws IllegalArgumentException;
}

public interface GreetingServiceAsync {  
    void setJSON(String json, AsyncCallback<Void> callback);
}

public class GreetingServiceImpl extends RemoteServiceServlet implements GreetingService {
    @Override
    public void setJSON(String json) throws IllegalArgumentException {
        // set the JSON string in HTTP Session
        getThreadLocalRequest().getSession().setAttribute("json", json);
    }
}

web.xml:

<servlet>
    <servlet-name>greetServlet</servlet-name>
    <servlet-class>com.x.y.z.server.GreetingServiceImpl</servlet-class>
</servlet>

<servlet-mapping>
    <servlet-name>greetServlet</servlet-name>
    <url-pattern>/modulename/greet</url-pattern>
</servlet-mapping>

Entry Point class:

GreetingServiceAsync greetingService = GWT.create(GreetingService.class);
public class GWTProject implements EntryPoint {
    public void openNewWindow(final String json) {
        greetingService.setJSON(json, new AsyncCallback<Void>() {

            @Override
            public void onFailure(Throwable caught) {

            }

            @Override
            public void onSuccess(Void result) {
                // open any page within the same domain
                Window.open("/page.jsp", "", "");
            }
        });
 }

If the two pages are on the same domain, a third way is to use HTML5 localStorage: http://diveintohtml5.info/storage.html

In fact localStorage is precisely intended for what you want. Dealing with GET params or window/document JS references is not very portable (even if, I know, all browsers do not support localStorage).

No.

Only fetch and XMLHttpRequest can be used to make a request with an application/json body, and the response to those can only be handled with JS.

Instead of writing a form into the new window (which is tricky to get correct, with encoding of values in the HTML code), just open an empty window and post a form to it.

Example:

<form id="TheForm" method="post" action="test.asp" target="TheWindow">
<input type="hidden" name="something" value="something" />
<input type="hidden" name="more" value="something" />
<input type="hidden" name="other" value="something" />
</form>

<script type="text/javascript">
window.open('', 'TheWindow');
document.getElementById('TheForm').submit();
</script>

Edit:

To set the values in the form dynamically, you can do like this:

function openWindowWithPost(something, additional, misc) {
  var f = document.getElementById('TheForm');
  f.something.value = something;
  f.more.value = additional;
  f.other.value = misc;
  window.open('', 'TheWindow');
  f.submit();
}

To post the form you call the function with the values, like openWindowWithPost('a','b','c');.

Note: I varied the parameter names in relation to the form names to show that they don't have to be the same. Usually you would keep them similar to each other to make it simpler to track the values.

var data = {
    name: 'name',
    info:{
        info1: 'uvbiuonns',
        info2: 'aisbsiece',
    }
}

var qs = function(obj, prefix){
  var str = [];
  for (var p in obj) {
    var k = prefix ? prefix + "[" + p + "]" : p, 
        v = obj[k];
    str.push(angular.isObject(v) ? qs(v, k) : (k) + "=" + encodeURIComponent(v));
  }
  return str.join("&");
}

window.open("popup.html/?" + decodeURIComponent(qs(data)), "winName", "width=200, height=100");

Also the jQuery one will do:

window.open("popup.html/?" + decodeURIComponent($.param(data)), "MsgWindow", "width=200, height=100");

You could pass options as a URL parameter:

window.open( myURL + "/?options=" + JSON.stringify(options) );

You may create a form (on the fly) with an input (where you fill the value with the JSON) and a target-attribute regarding to name of the popup (second parameter of window.open()).

Then send this form.

Use the write()-Method of the Popup's document to put your markup there:

$.post(url, function (data) {
    var w = window.open('about:blank');
    w.document.open();
    w.document.write(data);
    w.document.close();
});

If you just want a link that opens a POST-requested page in a new window here are some ideas. However, be aware a POST request can't be bookmarked.

• You can make a button that opens a POST-requested page in a new window.

  <form method="post" action="http://example.com/example.php"
    target="_blank">
  <input type="hidden" name="name1" value="value1">
  <input type="hidden" name="name2" value="value2">
  <input type="submit" value="Open results in a new window"> 
  </form>
  

• If you want it to look like a link, you can make a link with an onClick attribute that submits the form.

  <form name="myform" method="post" action="http://example.com/example.php"
    target="_blank">
  <input type="hidden" name="name1" value="value1">
  <input type="hidden" name="name2" value="value2">
  </form>
  
  <a href="http://example.com/example.php"
    onClick="document.forms['myform'].submit(); return false;">Open results
    in a new window</a>
  

  The onClick part submits the form, which opens the POST-requested page in a new window. The return false prevents the browser from also going to the href address in the current window at the same time. If Javascript is disabled or the link is bookmarked, the href address is used as a fallback, but the resulting page won't receive any POST values. This might be confusing or unfriendly for your users if they bookmark the link.

If you want the link to be bookmarkable, investigate if your page can accept GET parameters. If so, then you can make a bookmarkable link.

 <a href="http://example.com/example.php?name1=value1&name2=value2"
   target="_blank">Open results in a new window</a>

Hello Philipp

Welcome to the Microsoft Community.

This is not a bug but a result of how the Edge JSON Viewer behaves when opening a URL programmatically via window.open. Here's an explanation of what's happening and how you can address the issue:

Explanation:

1. Manual URL Entry:
   • When you manually input the JSON URL in Edge's address bar, Edge knows it's serving JSON content and uses its built-in JSON Viewer to pretty-print it.
2. window.open() Behavior:
   • When you use window.open() to programmatically open the URL, Edge does not automatically invoke its JSON Viewer. Instead, it treats the opened page as plain text or raw JSON, and the pretty-print functionality is not applied.
3. Reason:
   • Edge's JSON Viewer may only be triggered when the request is a direct manual navigation or when the JSON content is properly formatted and served with the correct Content-Type (application/json) header, but window.open doesn't trigger the JSON Viewer in the same way.

Solutions:

1. Manually Open the URL

• The simplest workaround is to let the user click the JSON URL (e.g., Open JSON), which will behave like manual navigation and trigger the JSON Viewer.

2. Open the JSON in a New Tab with Pretty Formatting

• You can use a JavaScript library (e.g., JSON.stringify) to pretty-print the JSON content before displaying it in a new tab or window. Example:

    fetch("https://api.open-meteo.com/v1/forecast?latitude=52.52&longitude=13.41&hourly=temperature_2m")
        .then(response => response.json())
        .then(data => {
            const prettyJSON = JSON.stringify(data, null, 2); // Pretty printconst newWindow = window.open();
            newWindow.document.write(`
  ${prettyJSON}
  `);
            newWindow.document.close();
        });
  

  This fetches the JSON data, formats it nicely, and displays it in a new window or tab using

   tags.

3. Use an External JSON Viewer Tool

• If you frequently need to pretty-print JSON, you can use tools like:
  • jsonviewer.stack.hu
  • jsonformatter.org
  • These tools can take raw JSON data and pretty-print it in a visually appealing manner.
  • Disclaimer: This is a non-Microsoft website. The page appears to be providing accurate and safe information. Watch out for ads on the site that may advertise products frequently classified as PUP (Potentially Unwanted Products). Thoroughly research any product advertised on the site before you decide to download and install it.

Summary:

• The behavior you're seeing is by design and not a bug. To ensure JSON is always pretty-printed when using window.open, either fetch the data and format it programmatically (Solution 2) or let the user manually click a link (Solution 1).

Best Regards,

William.Y | Microsoft Community Support Specialist