unpoly-rails 2.3.0 → 2.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 91c3f510e29295809e0304db849e1853897d8f14fbe6b363519458dca5c0294a
-  data.tar.gz: 43a927f3a2946f63e02c2676514eeee7d5689750e38de4528d6d140e1be2a47e
+  metadata.gz: beba0d8578cac674b4e6cda8f8a062eae1217198fdc6e1f6e0a525b6bb61c395
+  data.tar.gz: 6b962622c193cd2c3910c0dba3830a092dbfb6c7b02ea58ce47d15765dc488a4
 SHA512:
-  metadata.gz: 501d2a3533c6c3225fd702d6ce4de682c0359d13f9e8063c1390c547ec8782afb0f70597e9b768ce945b69fde2b72c21a1bcc099c13b15d7107207201ebd5300
-  data.tar.gz: 513bbe7a3764942a35696d3ea5d7335fff289b914732a1b17bbe31f5da896ca7979f263e8fa000373641dd939f1a2e1bb2c26cf6b5290325fc24598b2cff8a3a
+  metadata.gz: 00ce246b00f89e57b7996c42489e72ba249d2976747d8a46bb21a5ebd35dd3575f29acb1b00bbd012b44c25633c1d3cb41c67be4748fe0feb6044b349475eede
+  data.tar.gz: c07e6975fe87448e624eb5be7d90a862a9abdb9a4f07a970acee59dd106d0499adec32a884a18b341e38c1de1d2cb35df336ef9ef3194f7eb0ffb0a796eb3491

data/assets/unpoly/unpoly.es5.js

@@ -8,7 +8,7 @@
 @module up
 */
 window.up = {
-    version: '2.3.0'
+    version: '2.4.0'
 };
 
 
@@ -105,27 +105,63 @@ up.util = (function () {
     }
     var NORMALIZE_URL_DEFAULTS = {
         host: 'cross-domain',
-        stripTrailingSlash: false,
-        search: true,
-        hash: false
     };
     /*-
-    Normalizes the given URL or path.
+    Returns a normalized version of the given URL string.
+  
+    Two URLs that point to the same resource should normalize to the same string.
+  
+    ### Comparing normalized URLs
+  
+    The main purpose of this function is to normalize two URLs for string comparison:
+  
+    ```js
+    up.util.normalizeURL('http://current-host/path') === up.util.normalizeURL('/path') // => true
+    ```
+  
+    By default the hostname is only included if it points to a different origin:
+  
+    ```js
+    up.util.normalizeURL('http://current-host/path') // => '/path'
+    up.util.normalizeURL('http://other-host/path') // => 'http://other-host/path'
+    ```
+  
+    Relative paths are normalized to absolute paths:
+  
+    ```js
+    up.util.normalizeURL('index.html') // => '/path/index.html'
+    ```
+  
+    ### Excluding URL components
+  
+    You may pass options to exclude URL components from the normalized string:
+  
+    ```js
+    up.util.normalizeURL('/foo?query=bar', { query: false }) => '/foo'
+    up.util.normalizeURL('/bar#hash', { hash: false }) => '/bar'
+    ```
+  
+    ### Limitations
+  
+    - Username and password are always omitted from the normalized URL.
+    - Only `http` and `https` schemes are supported.
   
     @function up.util.normalizeURL
     @param {boolean} [options.host='cross-domain']
       Whether to include protocol, hostname and port in the normalized URL.
   
-      By default the host is only included if it differ's from the page's hostname.
-    @param {boolean} [options.hash=false]
-      Whether to include an `#hash` anchor in the normalized URL
+      When set to `'cross-domain'` (the default), the host is only included if it differ's from the page's hostname.
+  
+      The port is omitted if the port is the standard port for the given protocol, e.g. `:443` for `https://`.
+    @param {boolean} [options.hash=true]
+      Whether to include an `#hash` anchor in the normalized URL.
     @param {boolean} [options.search=true]
-      Whether to include a `?query` string in the normalized URL
-    @param {boolean} [options.stripTrailingSlash=false]
-      Whether to strip a trailing slash from the pathname
+      Whether to include a `?query` string in the normalized URL.
+    @param {boolean} [options.trailingSlash=true]
+      Whether to include a trailing slash from the pathname.
     @return {string}
       The normalized URL.
-    @internal
+    @experimental
     */
     function normalizeURL(urlOrAnchor, options) {
         options = newOptions(options, NORMALIZE_URL_DEFAULTS);
@@ -144,21 +180,18 @@ up.util = (function () {
             }
         }
         var pathname = parts.pathname;
-        if (options.stripTrailingSlash) {
+        if (options.trailingSlash === false && pathname !== '/') {
             pathname = pathname.replace(/\/$/, '');
         }
         normalized += pathname;
-        if (options.search) {
+        if (options.search !== false) {
             normalized += parts.search;
         }
-        if (options.hash) {
+        if (options.hash !== false) {
             normalized += parts.hash;
         }
         return normalized;
     }
-    function urlWithoutHost(url) {
-        return normalizeURL(url, { host: false });
-    }
     function matchURLs(leftURL, rightURL) {
         return normalizeURL(leftURL) === normalizeURL(rightURL);
     }
@@ -1961,7 +1994,6 @@ up.util = (function () {
     return {
         parseURL: parseURL,
         normalizeURL: normalizeURL,
-        urlWithoutHost: urlWithoutHost,
         matchURLs: matchURLs,
         normalizeMethod: normalizeMethod,
         methodAllowsPayload: methodAllowsPayload,
@@ -4035,7 +4067,7 @@ up.Change.Addition = /** @class */ (function (_super) {
         // (1) Don't set a source if { false } is passed.
         // (2) Don't set a source if the element HTML already has an [up-source] attribute.
         if (source) {
-            e.setMissingAttr(newElement, 'up-source', u.normalizeURL(source));
+            e.setMissingAttr(newElement, 'up-source', u.normalizeURL(source, { hash: false }));
         }
     };
     return Addition;
@@ -14447,7 +14479,7 @@ up.history = (function () {
     /*-
     Returns a normalized URL for the previous history entry.
   
-    Only history entries pushed by Unpoly will be considered.
+    Only history entries added by Unpoly functions will be considered.
   
     @property up.history.previousLocation
     @param {string} previousLocation
@@ -14461,14 +14493,20 @@ up.history = (function () {
         nextPreviousLocation = undefined;
         trackCurrentLocation();
     }
-    function normalizeURL(url, normalizeOptions) {
-        if (normalizeOptions === void 0) { normalizeOptions = {}; }
-        normalizeOptions.hash = true;
-        return u.normalizeURL(url, normalizeOptions);
+    var DEFAULT_NORMALIZE_OPTIONS = { hash: true };
+    function normalizeURL(url, options) {
+        // The reason why we this takes an { options } object is that
+        // isCurrentLocation() ignores a trailing slash. This is used to check whether
+        // we're already at the given URL before pushing a history state.
+        options = u.merge(DEFAULT_NORMALIZE_OPTIONS, options);
+        return u.normalizeURL(url, options);
     }
     /*-
     Returns a normalized URL for the current browser location.
   
+    The returned URL is an absolute pathname like `"/path"` without a hostname or port.
+    It will include a `#hash` fragment and query string, if present.
+  
     Note that if the current [layer](/up.layer) does not have [visible history](/up.Layer.prototype.history),
     the browser's address bar will show the location of an ancestor layer.
     To get the location of the current layer, use `up.layer.location`.
@@ -14494,11 +14532,51 @@ up.history = (function () {
         }
     }
     trackCurrentLocation();
-    function isCurrentLocation(url) {
-        // Some web frameworks care about a trailing slash, some consider it optional.
-        // Only for the equality test (is this the current URL) we consider it optional.
-        var normalizeOptions = { stripTrailingSlash: true };
-        return normalizeURL(url, normalizeOptions) === currentLocation(normalizeOptions);
+    // Some web frameworks care about a trailing slash, some consider it optional.
+    // Only for the equality test ("is this the current URL?") we consider it optional.
+    // Note that we inherit { hash: true } from DEFAULT_NORMALIZE_OPTIONS.
+    var ADDITIONAL_NORMALIZE_OPTIONS_FOR_COMPARISON = { trailingSlash: false };
+    /*-
+    Returns whether the given URL matches the [current browser location](/up.history.location).
+  
+    ### Examples
+  
+    ```js
+    location.hostname // => '/path'
+  
+    up.history.isLocation('/path') // => true
+    up.history.isLocation('/path?query') // => false
+    up.history.isLocation('/path#hash') // => false
+    up.history.isLocation('/other') // => false
+    ```
+  
+    The given URL is [normalized](/up.util.normalizeURL), so any URL string pointing to the browser location
+    will match:
+  
+    ```js
+    location.hostname // => '/current-host'
+    location.pathname // => '/foo'
+  
+    up.history.isLocation('/foo') // => true
+    up.history.isLocation('http://current-host/foo') // => true
+    up.history.isLocation('http://otgher-host/foo') // => false
+    ```
+  
+    @function up.history.isLocation
+    @param {string} url
+      The URL to compare against the current browser location.
+  
+      This can be a either an absolute pathname (`/path`), a relative filename (`index.html`) or a fully qualified URL (`https://...`).
+    @param {boolean} [options.hash=true]
+      Whether to consider `#hash` fragments in the given or current URLs.
+  
+      When set to `false` this function will consider the URLs `/foo#one` and `/foo#two` to be equal.
+    @return {boolean}
+    @experimental
+    */
+    function isLocation(url, options) {
+        options = u.merge(ADDITIONAL_NORMALIZE_OPTIONS_FOR_COMPARISON, options);
+        return normalizeURL(url, options) === currentLocation(options);
     }
     /*-
     Replaces the current history entry and updates the
@@ -14518,8 +14596,9 @@ up.history = (function () {
     */
     function replace(url, options) {
         if (options === void 0) { options = {}; }
+        url = normalizeURL(url);
         if (manipulate('replaceState', url) && (options.event !== false)) {
-            emit('up:location:changed', { url: url, reason: 'replace', log: "Replaced state for " + u.urlWithoutHost(url) });
+            emit('up:location:changed', { url: url, reason: 'replace', log: "Replaced state for " + url });
         }
     }
     /*-
@@ -14532,6 +14611,8 @@ up.history = (function () {
     Note that [fragment navigation](/navigation) will automatically update the
     browser's location bar for you.
   
+    Does not add a history entry if the the given URL is already the current browser location.
+  
     Emits event `up:location:changed`.
   
     @function up.history.push
@@ -14541,8 +14622,8 @@ up.history = (function () {
     */
     function push(url) {
         url = normalizeURL(url);
-        if (!isCurrentLocation(url) && manipulate('pushState', url)) {
-            up.emit('up:location:changed', { url: url, reason: 'push', log: "Advanced to location " + u.urlWithoutHost(url) });
+        if (!isLocation(url) && manipulate('pushState', url)) {
+            up.emit('up:location:changed', { url: url, reason: 'push', log: "Advanced to location " + url });
         }
     }
     /*-
@@ -14705,8 +14786,8 @@ up.history = (function () {
         replace: replace,
         get location() { return currentLocation(); },
         get previousLocation() { return previousLocation; },
-        isLocation: isCurrentLocation,
-        normalizeURL: normalizeURL
+        normalizeURL: normalizeURL,
+        isLocation: isLocation
     };
 })();
 
@@ -16507,7 +16588,7 @@ up.fragment = (function () {
     }
     up.on('up:framework:boot', function () {
         var body = document.body;
-        body.setAttribute('up-source', up.history.location);
+        body.setAttribute('up-source', u.normalizeURL(location.href, { hash: false }));
         hello(body);
         if (!up.browser.canPushState()) {
             return up.warn('Cannot push history changes. Next fragment update will load in a new page.');
@@ -17157,7 +17238,7 @@ up.viewport = (function () {
         var _a = parseOptions(args), viewports = _a[0], options = _a[1];
         var url = options.layer.location;
         var scrollTopsForURL = options.layer.lastScrollTops.get(url) || {};
-        up.puts('up.viewport.restoreScroll()', 'Restoring scroll positions for URL %s to %o', u.urlWithoutHost(url), scrollTopsForURL);
+        up.puts('up.viewport.restoreScroll()', 'Restoring scroll positions for URL %s to %o', url, scrollTopsForURL);
         return setScrollTops(viewports, scrollTopsForURL);
     }
     function parseOptions(args) {
@@ -18678,20 +18759,11 @@ up.network = (function () {
         }
         var request = new up.Request(parseRequestOptions(args));
         useCachedRequest(request) || queueRequest(request);
-        var solo = request.solo;
-        if (solo) {
-            // The { solo } option may also contain a function.
-            // This way users can excempt some requests from being solo-aborted
-            // by configuring up.fragment.config.navigateOptions.
-            queue.abortExcept(request, solo);
-        }
+        handleSolo(request);
         return request;
     }
     function mimicLocalRequest(options) {
-        var solo = options.solo;
-        if (solo) {
-            abortRequests(solo);
-        }
+        handleSolo(options);
         // We cannot consult config.clearCache since there is no up.Request
         // for a local update.
         var clearCache = options.clearCache;
@@ -18699,6 +18771,21 @@ up.network = (function () {
             cache.clear(clearCache);
         }
     }
+    function handleSolo(requestOrOptions) {
+        var solo = requestOrOptions.solo;
+        if (solo && isBusy()) {
+            up.puts('up.request()', 'Change with { solo } option will abort other requests');
+            // The { solo } option may also contain a function.
+            // This way users can excempt some requests from being solo-aborted
+            // by configuring up.fragment.config.navigateOptions.
+            if (requestOrOptions instanceof up.Request) {
+                queue.abortExcept(requestOrOptions, solo);
+            }
+            else {
+                abortRequests(solo);
+            }
+        }
+    }
     function parseRequestOptions(args) {
         var _a, _b;
         var options = u.extractOptions(args);
@@ -22905,10 +22992,11 @@ up.feedback = (function () {
     */
     var config = new up.Config(function () { return ({
         currentClasses: ['up-current'],
-        navSelectors: ['[up-nav]', 'nav']
+        navSelectors: ['[up-nav]', 'nav'],
     }); });
     function reset() {
         config.reset();
+        up.layer.root.feedbackLocation = null;
     }
     var CLASS_ACTIVE = 'up-active';
     var SELECTOR_LINK = 'a, [up-href]';
@@ -22917,7 +23005,7 @@ up.feedback = (function () {
     }
     function normalizeURL(url) {
         if (url) {
-            return u.normalizeURL(url, { stripTrailingSlash: true });
+            return u.normalizeURL(url, { trailingSlash: false, hash: false });
         }
     }
     function linkURLs(link) {
@@ -22952,17 +23040,11 @@ up.feedback = (function () {
         var links = u.flatMap(navs, function (nav) { return e.subtree(nav, SELECTOR_LINK); });
         updateLinks(links, options);
     }
-    var getLayerLocation = function (layer) {
-        // so multiple calls for the same layer won't unnecessarily reprocess links.
-        // We update the property on up:layer:location:changed.
-        //
-        // The { feedbackLocation } property may be nil if:
-        // (1) The layer was opened without a location, e.g. if it was created from local HTML.
-        // (2) The layer is the root layer and the location was never changed.
-        //     The initial page load does not emit an up:layer:location:changed event for
-        //     the root layer to be consistent with up:location:changed.
-        return layer.feedbackLocation || layer.location;
-    };
+    function getNormalizedLayerLocation(layer) {
+        // Don't re-use layer.feedbackLocation since the current layer returns
+        // location.href in case someone changed the history using the pushState API.
+        return layer.feedbackLocation || normalizeURL(layer.location);
+    }
     function updateLinks(links, options) {
         if (options === void 0) { options = {}; }
         if (!links.length) {
@@ -22971,7 +23053,7 @@ up.feedback = (function () {
         var layer = options.layer || up.layer.get(links[0]);
         // An overlay might not have a { location } property, e.g. if it was created
         // from local { content }. In this case we do not set .up-current.
-        var layerLocation = getLayerLocation(layer);
+        var layerLocation = getNormalizedLayerLocation(layer);
         if (layerLocation) {
             for (var _i = 0, links_1 = links; _i < links_1.length; _i++) {
                 var link = links_1[_i];
@@ -23188,6 +23270,8 @@ up.feedback = (function () {
     - the link's `[up-href]` attribute
     - the URL pattern in the link's [`[up-alias]`](/a-up-alias) attribute
   
+    Any `#hash` fragments in the link's or current URLs will be ignored.
+  
     @selector [up-nav]
     @stable
     */
@@ -23222,13 +23306,14 @@ up.feedback = (function () {
     */
     function updateLayerIfLocationChanged(layer) {
         var processedLocation = layer.feedbackLocation;
-        var currentLocation = normalizeURL(layer.location);
+        var layerLocation = getNormalizedLayerLocation(layer.location);
         // A history change might call this function multiple times,
         // since we listen to both up:location:changed and up:layer:location:changed.
+        // We also don't want to unnecessarily reprocess nav links, which is expensive.
         // For this reason we check whether the current location differs from
         // the last processed location.
-        if (!processedLocation || (processedLocation !== currentLocation)) {
-            layer.feedbackLocation = currentLocation;
+        if (!processedLocation || (processedLocation !== layerLocation)) {
+            layer.feedbackLocation = layerLocation;
             updateLinksWithinNavs(layer.element, { layer: layer });
         }
     }
@@ -23258,7 +23343,7 @@ up.feedback = (function () {
         stop: stop,
         around: around,
         aroundForOptions: aroundForOptions,
-        normalizeURL: normalizeURL
+        normalizeURL: normalizeURL,
     };
 })();