unpoly-rails 2.3.0 → 2.4.0

data/assets/unpoly/unpoly.js

@@ -8,7 +8,7 @@
 @module up
 */
 window.up = {
-    version: '2.3.0'
+    version: '2.4.0'
 };
 
 
@@ -96,27 +96,63 @@ up.util = (function () {
     }
     const 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);
@@ -135,21 +171,18 @@ up.util = (function () {
             }
         }
         let { pathname } = parts;
-        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);
     }
@@ -1911,7 +1944,6 @@ up.util = (function () {
     return {
         parseURL,
         normalizeURL,
-        urlWithoutHost,
         matchURLs,
         normalizeMethod,
         methodAllowsPayload,
@@ -3858,7 +3890,7 @@ up.Change.Addition = class Addition extends up.Change {
         // (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 }));
         }
     }
 };
@@ -12962,7 +12994,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
@@ -12976,13 +13008,20 @@ up.history = (function () {
         nextPreviousLocation = undefined;
         trackCurrentLocation();
     }
-    function normalizeURL(url, normalizeOptions = {}) {
-        normalizeOptions.hash = true;
-        return u.normalizeURL(url, normalizeOptions);
+    const 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`.
@@ -13008,11 +13047,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.
-        const 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.
+    const 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
@@ -13031,8 +13110,9 @@ up.history = (function () {
     @internal
     */
     function replace(url, options = {}) {
+        url = normalizeURL(url);
         if (manipulate('replaceState', url) && (options.event !== false)) {
-            emit('up:location:changed', { url, reason: 'replace', log: `Replaced state for ${u.urlWithoutHost(url)}` });
+            emit('up:location:changed', { url, reason: 'replace', log: `Replaced state for ${url}` });
         }
     }
     /*-
@@ -13045,6 +13125,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
@@ -13054,8 +13136,8 @@ up.history = (function () {
     */
     function push(url) {
         url = normalizeURL(url);
-        if (!isCurrentLocation(url) && manipulate('pushState', url)) {
-            up.emit('up:location:changed', { url, reason: 'push', log: `Advanced to location ${u.urlWithoutHost(url)}` });
+        if (!isLocation(url) && manipulate('pushState', url)) {
+            up.emit('up:location:changed', { url, reason: 'push', log: `Advanced to location ${url}` });
         }
     }
     /*-
@@ -13204,8 +13286,8 @@ up.history = (function () {
         replace,
         get location() { return currentLocation(); },
         get previousLocation() { return previousLocation; },
-        isLocation: isCurrentLocation,
-        normalizeURL
+        normalizeURL,
+        isLocation
     };
 })();
 
@@ -14957,7 +15039,7 @@ up.fragment = (function () {
     }
     up.on('up:framework:boot', function () {
         const { body } = document;
-        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.');
@@ -15585,7 +15667,7 @@ up.viewport = (function () {
         const [viewports, options] = parseOptions(args);
         const url = options.layer.location;
         const 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) {
@@ -17031,20 +17113,11 @@ up.network = (function () {
     function makeRequest(...args) {
         const request = new up.Request(parseRequestOptions(args));
         useCachedRequest(request) || queueRequest(request);
-        let 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) {
-        let solo = options.solo;
-        if (solo) {
-            abortRequests(solo);
-        }
+        handleSolo(options);
         // We cannot consult config.clearCache since there is no up.Request
         // for a local update.
         let clearCache = options.clearCache;
@@ -17052,6 +17125,21 @@ up.network = (function () {
             cache.clear(clearCache);
         }
     }
+    function handleSolo(requestOrOptions) {
+        let 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) {
         const options = u.extractOptions(args);
         if (!options.url) {
@@ -21156,10 +21244,11 @@ up.feedback = (function () {
     */
     const config = new up.Config(() => ({
         currentClasses: ['up-current'],
-        navSelectors: ['[up-nav]', 'nav']
+        navSelectors: ['[up-nav]', 'nav'],
     }));
     function reset() {
         config.reset();
+        up.layer.root.feedbackLocation = null;
     }
     const CLASS_ACTIVE = 'up-active';
     const SELECTOR_LINK = 'a, [up-href]';
@@ -21168,7 +21257,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) {
@@ -21203,17 +21292,11 @@ up.feedback = (function () {
         const links = u.flatMap(navs, nav => e.subtree(nav, SELECTOR_LINK));
         updateLinks(links, options);
     }
-    const getLayerLocation = layer => // We store the last processed location in layer.feedbackLocation,
-     
-    // 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.
-    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 (!links.length) {
             return;
@@ -21221,7 +21304,7 @@ up.feedback = (function () {
         const 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.
-        let layerLocation = getLayerLocation(layer);
+        let layerLocation = getNormalizedLayerLocation(layer);
         if (layerLocation) {
             for (let link of links) {
                 const isCurrent = linkURLs(link).isCurrent(layerLocation);
@@ -21436,6 +21519,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
     */
@@ -21470,13 +21555,14 @@ up.feedback = (function () {
     */
     function updateLayerIfLocationChanged(layer) {
         const processedLocation = layer.feedbackLocation;
-        const currentLocation = normalizeURL(layer.location);
+        const 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 });
         }
     }
@@ -21506,7 +21592,7 @@ up.feedback = (function () {
         stop,
         around,
         aroundForOptions,
-        normalizeURL
+        normalizeURL,
     };
 })();