Reverted .json configuration changes made by npm. Added tests for PUSH functionality, new flag 'allowPost' to explicitly enable POST data, remove (-1) in the URL splitting.

src/openseadragon.js

@@ -659,6 +659,15 @@
   * @property {Object} [ajaxHeaders={}]
   *     A set of headers to include when making AJAX requests for tile sources or tiles.
   *
+  * @property {Boolean} [splitHashDataForPost=false]
+  *     Allows to treat _first_ hash ('#') symbol as a separator for POST data:
+  *     URL to be opened by a {@link OpenSeadragon.TileSource} can thus look like: http://some.url#postdata=here .
+  *     The URL is split to 'http://some.url' and 'postdata=here'; post data is given to the
+  *     {@link OpenSeadragon.TileSource} of the choice and can be further used within tile requests
+  *     (see TileSource methods). {@link OpenSeadragon.TileSource.prototype.configure} return value
+  *     should contain the post data so that it is given to its subclass in the constructor.
+  *     NOTE: post data is expected to be ampersand-separated (just like GET parameters), and is not used
+  *     to fetch tile image data if loadTilesWithAjax=false (but it is still used for the initial request).
   */
 
  /**
@@ -1140,6 +1149,7 @@ function OpenSeadragon( options ){
             ajaxWithCredentials:    false,
             loadTilesWithAjax:      false,
             ajaxHeaders:            {},
+            splitHashDataForPost:   false,
 
             //PAN AND ZOOM SETTINGS AND CONSTRAINTS
             panHorizontal:          true,

src/tile.js

@@ -45,16 +45,16 @@
  * @param {Boolean} exists Is this tile a part of a sparse image? ( Also has
  *      this tile failed to load? )
  * @param {String} url The URL of this tile's image.
- * @param {String} postData post parameters or null
  * @param {CanvasRenderingContext2D} context2D The context2D of this tile if it
  * is provided directly by the tile source.
  * @param {Boolean} loadWithAjax Whether this tile image should be loaded with an AJAX request .
  * @param {Object} ajaxHeaders The headers to send with this tile's AJAX request (if applicable).
  * @param {OpenSeadragon.Rect} sourceBounds The portion of the tile to use as the source of the
+ * @param {String} postData post parameters or null
  * drawing operation, in pixels. Note that this only works when drawing with canvas; when drawing
  * with HTML the entire tile is always used.
  */
-$.Tile = function(level, x, y, bounds, exists, url, postData, context2D, loadWithAjax, ajaxHeaders, sourceBounds) {
+$.Tile = function(level, x, y, bounds, exists, url, context2D, loadWithAjax, ajaxHeaders, sourceBounds, postData) {
     /**
      * The zoom level this tile belongs to.
      * @member {Number} level

src/tiledimage.js

@@ -1542,11 +1542,11 @@ function getTile(
             bounds,
             exists,
             url,
-            post,
             context2D,
             tiledImage.loadTilesWithAjax,
             ajaxHeaders,
-            sourceBounds
+            sourceBounds,
+            post
         );
 
         if (tiledImage.getFlip()) {

src/tilesource.js

@@ -69,6 +69,9 @@
  *      the XHR's withCredentials (for accessing secure data).
  * @param {Object} [options.ajaxHeaders]
  *      A set of headers to include in AJAX requests.
+ * @param {Boolean} [options.splitHashDataForPost]
+ *      First occurrence of '#' in the options.url is used to split URL
+ *      and the latter part is treated as POST data (applies to getImageInfo(...))
  * @param {Number} [options.width]
  *      Width of the source image at max resolution in pixels.
  * @param {Number} [options.height]
@@ -446,10 +449,16 @@ $.TileSource.prototype = {
         }
 
         var postData = null;
-        var hashIdx = url.indexOf("#");
-        if (hashIdx !== -1) {
-            postData = url.substring(hashIdx + 1);
-            url = url.substr(0, hashIdx - 1);
+        if (this.allowPost) {
+            if (!this.loadTilesWithAjax) {
+                console.warn("Ajax is not enabled, but post data are used. Post data is ignored " +
+                    "without ajax in subsequent tile requests.");
+            }
+            var hashIdx = url.indexOf("#");
+            if (hashIdx !== -1) {
+                postData = url.substring(hashIdx + 1);
+                url = url.substr(0, hashIdx);
+            }
         }
 
         callback = function( data ){
@@ -545,11 +554,13 @@ $.TileSource.prototype = {
                      * @property {OpenSeadragon.TileSource} eventSource - A reference to the TileSource which raised the event.
                      * @property {String} message
                      * @property {String} source
+                     * @property {String} postData or null
                      * @property {?Object} userData - Arbitrary subscriber-defined object.
                      */
                     _this.raiseEvent( 'open-failed', {
                         message: msg,
-                        source: url
+                        source: url,
+                        postData: postData
                     });
                 }
             });
@@ -588,7 +599,8 @@ $.TileSource.prototype = {
      *      from if any.
      * @param {String} postData value obtained from the url after '#' sign or null
      * @return {Object} options - A dictionary of keyword arguments sufficient
-     *      to configure this tile sources constructor.
+     *      to configure the tile source constructor (include all values you want to
+     *      instantiate the TileSource subclass with - what _options_ object should contain).
      * @throws {Error}
      */
     configure: function( data, url, postData ) {

src/viewer.js

@@ -2432,6 +2432,7 @@ function getTileSourceImplementation( viewer, tileSource, imgOptions, successCal
                 ajaxWithCredentials: viewer.ajaxWithCredentials,
                 ajaxHeaders: imgOptions.ajaxHeaders ?
                     imgOptions.ajaxHeaders : viewer.ajaxHeaders,
+                splitHashDataForPost: viewer.splitHashDataForPost,
                 useCanvas: viewer.useCanvas,
                 success: function( event ) {
                     successCallback( event.tileSource );

test/coverage.html

@@ -86,6 +86,7 @@
     <script src="/test/modules/spring.js"></script>
     <script src="/test/modules/rectangle.js"></script>
     <script src="/test/modules/ajax-tiles.js"></script>
+    <script src="/test/modules/ajax-post-data.js"></script>
     <script src="/test/modules/imageloader.js"></script>
     <script src="/test/modules/iiif.js"></script>
     <!-- The navigator tests are the slowest (for now; hopefully they can be sped up)

test/modules/ajax-post-data.js

@@ -0,0 +1,276 @@
+/* global QUnit, testLog, Util */
+
+//Testing of POST data propagation through the system
+
+(function() {
+    var POST_CAN_BE_MISSING = false;
+    var POST_DATA = "";
+    var URL_USED = "";
+    var ASSERT = null;
+    var testPostData = function(data, context) {
+        ASSERT.ok((POST_CAN_BE_MISSING && (data === undefined || data === null))
+            || data === POST_DATA,
+            `${context} ${POST_CAN_BE_MISSING ? "has no POST data" : "receives expected POST data"}`);
+    };
+    var testUrl = function (url, context) {
+        ASSERT.ok((!POST_CAN_BE_MISSING && URL_USED.startsWith(url) && (url.indexOf(POST_DATA) === -1 || POST_DATA === ""))
+            || url === URL_USED,
+            `${context} ${POST_CAN_BE_MISSING ? "URL was not modified" : "URL was stripped of POST data"}`);
+    };
+
+    //each test must call these
+    var configure = function(postDataNotAccepted, postDataUsed, urlUsed, assert) {
+        POST_CAN_BE_MISSING = postDataNotAccepted;
+        POST_DATA = postDataUsed;
+        URL_USED = urlUsed;
+        ASSERT = assert;
+    };
+
+    var viewer = null;
+    var OriginalLoader = OpenSeadragon.ImageLoader;
+    var OriginalAjax = OpenSeadragon.makeAjaxRequest;
+
+    QUnit.module('AjaxPostData', {
+        beforeEach: function () {
+            testLog.reset();
+            $("#qunit-fixture").html("<div id='example'></div>");
+
+            //Substitute OSD parts so that it reports what it is doing
+            OpenSeadragon.PostTestTileSource = function( options ) {
+                //double test, actually received from configure(...)
+                testPostData(options.postData, "TileSource::constructor");
+                OpenSeadragon.TileSource.apply( this, [ options ] );
+            };
+
+            OpenSeadragon.extend( OpenSeadragon.PostTestTileSource.prototype, OpenSeadragon.TileSource.prototype, {
+                supports: function( data, url ){
+                    return url.indexOf('.post') !== -1;
+                },
+
+                configure: function( data, url, postData ){
+                    testUrl(url, "TileSource::configure");
+                    testPostData(postData, "TileSource::configure");
+                    //some default data to trigger painting
+                    return {
+                        postData: postData, //!important, pass to options object in the constructor
+                        tilesUrl: url,
+                        fileFormat: "jpg",
+                        sizeData: {Width: 55, Height: 55},
+                        width: 55,
+                        height: 55,
+                        tileSize: 55,
+                        tileOverlap: 55,
+                        minLevel: 1,
+                        maxLevel: 1,
+                        displayRects: []
+                    };
+                },
+
+                getTileUrl: function( level, x, y ) {
+                    return URL_USED;
+                },
+
+                getTileAjaxHeaders: function( level, x, y ) {
+                    return {'Content-type': 'application/x-www-form-urlencoded'};
+                },
+
+                getTilePostData: function(level, x, y) {
+                    return this.postData;
+                },
+
+                tileExists: function ( level, x, y ) {
+                    return true;
+                }
+            });
+
+            var Loader = function(options) {
+                OriginalLoader.apply(this, [options]);
+            };
+
+            OpenSeadragon.extend( Loader.prototype, OpenSeadragon.ImageLoader.prototype, {
+                addJob: function(options) {
+                    testUrl(options.src, "ImageJob::addJob");
+                    testPostData(options.postData, "ImageJob::addJob");
+
+                    if (viewer.loadTilesWithAjax) {
+                        OriginalLoader.prototype.addJob.apply(this, [options]);
+                    } else {
+                        //no ajax means we would wait for invalid image link to load, close - passed
+                        viewer.close();
+                    }
+                }
+            });
+            OpenSeadragon.ImageLoader = Loader;
+
+            var ajaxCounter = 0;
+            OpenSeadragon.makeAjaxRequest = function( url, onSuccess, onError ) {
+                var withCredentials;
+                var headers;
+                var responseType;
+                var postData;
+                var options;
+
+                // Note that our preferred API is that you pass in a single object; the named
+                // arguments are for legacy support.
+                if( $.isPlainObject( url ) ){
+                    onSuccess = url.success;
+                    onError = url.error;
+                    withCredentials = url.withCredentials;
+                    headers = url.headers;
+                    responseType = url.responseType || null;
+                    postData = url.postData || null;
+                    options = url; //save original stuff
+                    url = url.url;
+
+                    //since we test that postData value equals to "" but here is correctly parsed to null
+                    //to avoid POST request
+                    if (options.postData === "") {
+                        ASSERT.ok(postData == null, "Empty post data is parsed as null");
+                    } else {
+                        testPostData(postData, "AJAX");
+                    }
+                } else {
+                    testPostData(postData, "AJAX");
+                }
+
+                testUrl(url, "AJAX");
+
+                //first AJAX firing is the image info getter, second is the first tile request: can exit
+                ajaxCounter++;
+                if (ajaxCounter > 1) {
+                    viewer.close();
+                    return null;
+                }
+
+                var request = Promise.resolve(url);
+                //some required properties to pass through processResponse(...)
+                request.responseText = "some text";
+                request.status = 200;
+
+                onSuccess(request);
+                return request;
+            };
+        },
+
+        afterEach: function () {
+            ASSERT = null;
+
+            if (viewer && viewer.close) {
+                viewer.close();
+            }
+            viewer = null;
+
+            OpenSeadragon.ImageLoader = OriginalLoader;
+            OpenSeadragon.makeAjaxRequest = OriginalAjax;
+        }
+    });
+
+
+    // ----------
+    var testOpenUrl = function(withPost, withAjax) {
+        testOpen(URL_USED, withPost, withAjax);
+    };
+
+    var testOpen = function(tileSource, withPost, withAjax) {
+        var timeWatcher = Util.timeWatcher(ASSERT, 7000);
+
+        viewer = OpenSeadragon({
+            id:            'example',
+            prefixUrl:     '/build/openseadragon/images/',
+            tileSources:   tileSource,
+            loadTilesWithAjax: withAjax,
+            splitHashDataForPost: withPost,
+        });
+
+        var failHandler = function (event) {
+            testPostData(event.postData, "event: 'open-failed'");
+            viewer.removeHandler('open-failed', failHandler);
+            viewer.close();
+        };
+        viewer.addHandler('open-failed', failHandler);
+
+        var readyHandler = function (event) {
+            //relies on Tilesource contructor extending itself with options object
+            testPostData(event.postData, "event: 'ready'");
+            viewer.removeHandler('ready', readyHandler);
+        };
+        viewer.addHandler('ready', readyHandler);
+
+
+        var openHandler = function(event) {
+            viewer.removeHandler('open', openHandler);
+            ASSERT.ok(true, 'Open event was sent');
+            viewer.addHandler('close', closeHandler);
+            viewer.world.draw();
+        };
+
+        var closeHandler = function(event) {
+            viewer.removeHandler('close', closeHandler);
+            $('#example').empty();
+            ASSERT.ok(true, 'Close event was sent');
+            timeWatcher.done();
+        };
+        viewer.addHandler('open', openHandler);
+    };
+
+    // ----------
+    QUnit.test('Without Post Data, Without Ajax', function(assert) {
+        configure(true, "", 'someURL.post#somePostData=1&key=2', assert);
+        testOpenUrl(false, false);
+    });
+
+    QUnit.test('Without Post Data: Ajax GET', function(assert) {
+        configure(true, "", 'someURL.post#somePostData=1&key=2', assert);
+        testOpenUrl(false, true);
+    });
+
+    QUnit.test('With Post Data: Ajax POST', function(assert) {
+        configure(false, "testingPostDataSimple", 'someURL.post#testingPostDataSimple', assert);
+        testOpenUrl(true, true, assert);
+    });
+
+    QUnit.test('With Post Data But No Ajax', function(assert) {
+        configure(false, "somePostData=1&key=2", 'someURL.post#somePostData=1&key=2', assert);
+        testOpenUrl(true, false, assert);
+    });
+
+    QUnit.test('With Post Data BUT no post data', function(assert) {
+        configure(false, null, 'someURL.post', assert);
+        testOpenUrl(true, true, assert);
+    });
+
+    QUnit.test('With Post Data Empty post data', function(assert) {
+        configure(false, "", 'someURL.post#', assert);
+        testOpenUrl(true, true, assert);
+    });
+
+    QUnit.test('CustomTileSource No Ajax', function(assert) {
+        configure(true, "", 'someURL.post', assert);
+        testOpen({
+            height: 512 * 256,
+            width: 512 * 256,
+            tileSize: 256,
+            minLevel: 8,
+            getTileUrl: function (level, x, y) {
+                return "someURL.post";
+            }
+        }, false, true);
+    });
+
+    QUnit.test('CustomTileSource With Ajax', function(assert) {
+        configure(false, "d1=a1&d2=a2###", 'someURL.post', assert);
+        testOpen({
+            height: 512 * 256,
+            width: 512 * 256,
+            tileSize: 256,
+            minLevel: 8,
+            getTileUrl: function (level, x, y) {
+                return "someURL.post";
+            },
+            getTilePostData (level, x, y) {
+                return "d1=a1&d2=a2###";
+            },
+        }, true, true);
+    });
+
+})();

test/test.html

@@ -44,6 +44,7 @@
     <script src="/test/modules/spring.js"></script>
     <script src="/test/modules/rectangle.js"></script>
     <script src="/test/modules/ajax-tiles.js"></script>
+    <script src="/test/modules/ajax-post-data.js"></script>
     <script src="/test/modules/imageloader.js"></script>
     <script src="/test/modules/iiif.js"></script>
     <!--The navigator tests are the slowest (for now; hopefully they can be sped up)