ember-source 4.8.0-alpha.5 → 4.8.0-beta.2

package/dist/packages/@ember/routing/auto-location.js

@@ -1 +1,249 @@
-export { AutoLocation as default } from '@ember/-internals/routing';
+import { history, location, userAgent, window } from '@ember/-internals/browser-environment';
+import { getOwner } from '@ember/-internals/owner';
+import EmberObject, { set } from '@ember/object';
+import { assert } from '@ember/debug';
+import { getFullPath, getHash, getPath, getQuery, replacePath, supportsHashChange, supportsHistory } from './lib/location-utils';
+/**
+@module @ember/routing/auto-location
+*/
+
+/**
+  AutoLocation will select the best location option based off browser
+  support with the priority order: history, hash, none.
+
+  Clean pushState paths accessed by hashchange-only browsers will be redirected
+  to the hash-equivalent and vice versa so future transitions are consistent.
+
+  Keep in mind that since some of your users will use `HistoryLocation`, your
+  server must serve the Ember app at all the routes you define.
+
+  Browsers that support the `history` API will use `HistoryLocation`, those that
+  do not, but still support the `hashchange` event will use `HashLocation`, and
+  in the rare case neither is supported will use `NoneLocation`.
+
+  Example:
+
+  ```app/router.js
+  Router.map(function() {
+    this.route('posts', function() {
+      this.route('new');
+    });
+  });
+
+  Router.reopen({
+    location: 'auto'
+  });
+  ```
+
+  This will result in a posts.new url of `/posts/new` for modern browsers that
+  support the `history` api or `/#/posts/new` for older ones, like Internet
+  Explorer 9 and below.
+
+  When a user visits a link to your application, they will be automatically
+  upgraded or downgraded to the appropriate `Location` class, with the URL
+  transformed accordingly, if needed.
+
+  Keep in mind that since some of your users will use `HistoryLocation`, your
+  server must serve the Ember app at all the routes you define.
+
+  @class AutoLocation
+  @static
+  @protected
+*/
+
+export default class AutoLocation extends EmberObject {
+  constructor() {
+    super(...arguments);
+    this.implementation = 'auto';
+  }
+  /**
+   Called by the router to instruct the location to do any feature detection
+   necessary. In the case of AutoLocation, we detect whether to use history
+   or hash concrete implementations.
+      @private
+  */
+
+
+  detect() {
+    let rootURL = this.rootURL;
+    assert('rootURL must end with a trailing forward slash e.g. "/app/"', rootURL.charAt(rootURL.length - 1) === '/');
+    let implementation = detectImplementation({
+      location: this.location,
+      history: this.history,
+      userAgent: this.userAgent,
+      rootURL,
+      documentMode: this.documentMode,
+      global: this.global
+    });
+
+    if (implementation === false) {
+      set(this, 'cancelRouterSetup', true);
+      implementation = 'none';
+    }
+
+    let owner = getOwner(this);
+    assert('AutoLocation is unexpectedly missing an owner', owner);
+    let concrete = owner.lookup(`location:${implementation}`);
+    assert(`Could not find location '${implementation}'.`, concrete !== undefined);
+    set(concrete, 'rootURL', rootURL);
+    set(this, 'concreteImplementation', concrete);
+  }
+
+  willDestroy() {
+    let {
+      concreteImplementation
+    } = this;
+
+    if (concreteImplementation) {
+      concreteImplementation.destroy();
+    }
+  }
+
+}
+AutoLocation.reopen({
+  rootURL: '/',
+  initState: delegateToConcreteImplementation('initState'),
+  getURL: delegateToConcreteImplementation('getURL'),
+  setURL: delegateToConcreteImplementation('setURL'),
+  replaceURL: delegateToConcreteImplementation('replaceURL'),
+  onUpdateURL: delegateToConcreteImplementation('onUpdateURL'),
+  formatURL: delegateToConcreteImplementation('formatURL'),
+  location: location,
+  history: history,
+  global: window,
+  userAgent: userAgent,
+  cancelRouterSetup: false
+});
+
+function delegateToConcreteImplementation(methodName) {
+  return function (...args) {
+    var _a;
+
+    let {
+      concreteImplementation
+    } = this;
+    assert("AutoLocation's detect() method should be called before calling any other hooks.", concreteImplementation); // We need this cast because `Parameters` is deferred so that it is not
+    // possible for TS to see it will always produce the right type. However,
+    // since `AnyFn` has a rest type, it is allowed. See discussion on [this
+    // issue](https://github.com/microsoft/TypeScript/issues/47615).
+
+    return (_a = concreteImplementation[methodName]) === null || _a === void 0 ? void 0 : _a.call(concreteImplementation, ...args);
+  };
+}
+
+function detectImplementation(options) {
+  let {
+    location,
+    userAgent,
+    history,
+    documentMode,
+    global,
+    rootURL
+  } = options;
+  let implementation = 'none';
+  let cancelRouterSetup = false;
+  let currentPath = getFullPath(location);
+
+  if (supportsHistory(userAgent, history)) {
+    let historyPath = getHistoryPath(rootURL, location); // If the browser supports history and we have a history path, we can use
+    // the history location with no redirects.
+
+    if (currentPath === historyPath) {
+      implementation = 'history';
+    } else if (currentPath.substring(0, 2) === '/#') {
+      history.replaceState({
+        path: historyPath
+      }, '', historyPath);
+      implementation = 'history';
+    } else {
+      cancelRouterSetup = true;
+      replacePath(location, historyPath);
+    }
+  } else if (supportsHashChange(documentMode, global)) {
+    let hashPath = getHashPath(rootURL, location); // Be sure we're using a hashed path, otherwise let's switch over it to so
+    // we start off clean and consistent. We'll count an index path with no
+    // hash as "good enough" as well.
+
+    if (currentPath === hashPath || currentPath === '/' && hashPath === '/#/') {
+      implementation = 'hash';
+    } else {
+      // Our URL isn't in the expected hash-supported format, so we want to
+      // cancel the router setup and replace the URL to start off clean
+      cancelRouterSetup = true;
+      replacePath(location, hashPath);
+    }
+  }
+
+  if (cancelRouterSetup) {
+    return false;
+  }
+
+  return implementation;
+}
+/**
+  @private
+
+  Returns the current path as it should appear for HistoryLocation supported
+  browsers. This may very well differ from the real current path (e.g. if it
+  starts off as a hashed URL)
+*/
+
+
+export function getHistoryPath(rootURL, location) {
+  let path = getPath(location);
+  let hash = getHash(location);
+  let query = getQuery(location);
+  let rootURLIndex = path.indexOf(rootURL);
+  let routeHash;
+  let hashParts;
+  assert(`Path ${path} does not start with the provided rootURL ${rootURL}`, rootURLIndex === 0); // By convention, Ember.js routes using HashLocation are required to start
+  // with `#/`. Anything else should NOT be considered a route and should
+  // be passed straight through, without transformation.
+
+  if (hash.substring(0, 2) === '#/') {
+    // There could be extra hash segments after the route
+    hashParts = hash.substring(1).split('#'); // The first one is always the route url
+
+    routeHash = hashParts.shift(); // If the path already has a trailing slash, remove the one
+    // from the hashed route so we don't double up.
+
+    if (path.charAt(path.length - 1) === '/') {
+      routeHash = routeHash.substring(1);
+    } // This is the "expected" final order
+
+
+    path += routeHash + query;
+
+    if (hashParts.length) {
+      path += `#${hashParts.join('#')}`;
+    }
+  } else {
+    path += query + hash;
+  }
+
+  return path;
+}
+/**
+  @private
+
+  Returns the current path as it should appear for HashLocation supported
+  browsers. This may very well differ from the real current path.
+
+  @method _getHashPath
+*/
+
+export function getHashPath(rootURL, location) {
+  let path = rootURL;
+  let historyPath = getHistoryPath(rootURL, location);
+  let routePath = historyPath.substring(rootURL.length);
+
+  if (routePath !== '') {
+    if (routePath[0] !== '/') {
+      routePath = `/${routePath}`;
+    }
+
+    path += `#${routePath}`;
+  }
+
+  return path;
+}

package/dist/packages/@ember/routing/hash-location.js

@@ -1 +1,169 @@
-export { HashLocation as default } from '@ember/-internals/routing';
+import EmberObject, { set } from '@ember/object';
+import { bind } from '@ember/runloop';
+import { getHash } from './lib/location-utils';
+/**
+@module @ember/routing/hash-location
+*/
+
+/**
+  `HashLocation` implements the location API using the browser's
+  hash. At present, it relies on a `hashchange` event existing in the
+  browser.
+
+  Using `HashLocation` results in URLs with a `#` (hash sign) separating the
+  server side URL portion of the URL from the portion that is used by Ember.
+
+  Example:
+
+  ```app/router.js
+  Router.map(function() {
+    this.route('posts', function() {
+      this.route('new');
+    });
+  });
+
+  Router.reopen({
+    location: 'hash'
+  });
+  ```
+
+  This will result in a posts.new url of `/#/posts/new`.
+
+  @class HashLocation
+  @extends EmberObject
+  @protected
+*/
+
+export default class HashLocation extends EmberObject {
+  constructor() {
+    super(...arguments);
+    this.implementation = 'hash';
+    this.lastSetURL = null;
+  }
+
+  init() {
+    set(this, 'location', this._location || window.location);
+    this._hashchangeHandler = undefined;
+  }
+  /**
+    @private
+       Returns normalized location.hash
+       @since 1.5.1
+    @method getHash
+  */
+
+
+  getHash() {
+    return getHash(this.location);
+  }
+  /**
+    Returns the normalized URL, constructed from `location.hash`.
+       e.g. `#/foo` => `/foo` as well as `#/foo#bar` => `/foo#bar`.
+       By convention, hashed paths must begin with a forward slash, otherwise they
+    are not treated as a path so we can distinguish intent.
+       @private
+    @method getURL
+  */
+
+
+  getURL() {
+    let originalPath = this.getHash().substring(1);
+    let outPath = originalPath;
+
+    if (outPath[0] !== '/') {
+      outPath = '/'; // Only add the # if the path isn't empty.
+      // We do NOT want `/#` since the ampersand
+      // is only included (conventionally) when
+      // the location.hash has a value
+
+      if (originalPath) {
+        outPath += `#${originalPath}`;
+      }
+    }
+
+    return outPath;
+  }
+  /**
+    Set the `location.hash` and remembers what was set. This prevents
+    `onUpdateURL` callbacks from triggering when the hash was set by
+    `HashLocation`.
+       @private
+    @method setURL
+    @param path {String}
+  */
+
+
+  setURL(path) {
+    this.location.hash = path;
+    set(this, 'lastSetURL', path);
+  }
+  /**
+    Uses location.replace to update the url without a page reload
+    or history modification.
+       @private
+    @method replaceURL
+    @param path {String}
+  */
+
+
+  replaceURL(path) {
+    this.location.replace(`#${path}`);
+    set(this, 'lastSetURL', path);
+  }
+  /**
+    Register a callback to be invoked when the hash changes. These
+    callbacks will execute when the user presses the back or forward
+    button, but not after `setURL` is invoked.
+       @private
+    @method onUpdateURL
+    @param callback {Function}
+  */
+
+
+  onUpdateURL(callback) {
+    this._removeEventListener();
+
+    this._hashchangeHandler = bind(this, function (_event) {
+      let path = this.getURL();
+
+      if (this.lastSetURL === path) {
+        return;
+      }
+
+      set(this, 'lastSetURL', null);
+      callback(path);
+    });
+    window.addEventListener('hashchange', this._hashchangeHandler);
+  }
+  /**
+    Given a URL, formats it to be placed into the page as part
+    of an element's `href` attribute.
+       This is used, for example, when using the {{action}} helper
+    to generate a URL based on an event.
+       @private
+    @method formatURL
+    @param url {String}
+  */
+
+
+  formatURL(url) {
+    return `#${url}`;
+  }
+  /**
+    Cleans up the HashLocation event listener.
+       @private
+    @method willDestroy
+  */
+
+
+  willDestroy() {
+    this._removeEventListener();
+  }
+
+  _removeEventListener() {
+    if (this._hashchangeHandler) {
+      window.removeEventListener('hashchange', this._hashchangeHandler);
+    }
+  }
+
+}

package/dist/packages/@ember/routing/history-location.js

@@ -1 +1,289 @@
-export { HistoryLocation as default } from '@ember/-internals/routing';
+import EmberObject, { set } from '@ember/object';
+import { getHash } from './lib/location-utils';
+/**
+@module @ember/routing/history-location
+*/
+
+let popstateFired = false;
+
+function _uuid() {
+  return 'xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx'.replace(/[xy]/g, function (c) {
+    let r, v;
+    r = Math.random() * 16 | 0;
+    v = c === 'x' ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+/**
+  HistoryLocation implements the location API using the browser's
+  history.pushState API.
+
+  Using `HistoryLocation` results in URLs that are indistinguishable from a
+  standard URL. This relies upon the browser's `history` API.
+
+  Example:
+
+  ```app/router.js
+  Router.map(function() {
+    this.route('posts', function() {
+      this.route('new');
+    });
+  });
+
+  Router.reopen({
+    location: 'history'
+  });
+  ```
+
+  This will result in a posts.new url of `/posts/new`.
+
+  Keep in mind that your server must serve the Ember app at all the routes you
+  define.
+
+  Using `HistoryLocation` will also result in location states being recorded by
+  the browser `history` API with the following schema:
+
+  ```
+  window.history.state -> { path: '/', uuid: '3552e730-b4a6-46bd-b8bf-d8c3c1a97e0a' }
+  ```
+
+  This allows each in-app location state to be tracked uniquely across history
+  state changes via the `uuid` field.
+
+  @class HistoryLocation
+  @extends EmberObject
+  @protected
+*/
+
+
+export default class HistoryLocation extends EmberObject {
+  constructor() {
+    super(...arguments);
+    this.implementation = 'history';
+    /**
+      Will be pre-pended to path upon state change
+             @property rootURL
+      @default '/'
+      @private
+    */
+
+    this.rootURL = '/';
+  }
+  /**
+    @private
+       Returns normalized location.hash
+       @method getHash
+  */
+
+
+  getHash() {
+    return getHash(this.location);
+  }
+
+  init() {
+    var _a;
+
+    this._super(...arguments);
+
+    let base = document.querySelector('base');
+    let baseURL = '';
+
+    if (base !== null && base.hasAttribute('href')) {
+      baseURL = (_a = base.getAttribute('href')) !== null && _a !== void 0 ? _a : '';
+    }
+
+    set(this, 'baseURL', baseURL);
+    set(this, 'location', this.location || window.location);
+    this._popstateHandler = undefined;
+  }
+  /**
+    Used to set state on first call to setURL
+       @private
+    @method initState
+  */
+
+
+  initState() {
+    let history = this.history || window.history;
+    set(this, 'history', history);
+    let {
+      state
+    } = history;
+    let path = this.formatURL(this.getURL());
+
+    if (state && state.path === path) {
+      // preserve existing state
+      // used for webkit workaround, since there will be no initial popstate event
+      this._previousURL = this.getURL();
+    } else {
+      this.replaceState(path);
+    }
+  }
+  /**
+    Returns the current `location.pathname` without `rootURL` or `baseURL`
+       @private
+    @method getURL
+    @return url {String}
+  */
+
+
+  getURL() {
+    let {
+      location,
+      rootURL,
+      baseURL
+    } = this;
+    let path = location.pathname; // remove trailing slashes if they exists
+
+    rootURL = rootURL.replace(/\/$/, '');
+    baseURL = baseURL.replace(/\/$/, ''); // remove baseURL and rootURL from start of path
+
+    let url = path.replace(new RegExp(`^${baseURL}(?=/|$)`), '').replace(new RegExp(`^${rootURL}(?=/|$)`), '').replace(/\/\//g, '/'); // remove extra slashes
+
+    let search = location.search || '';
+    url += search + this.getHash();
+    return url;
+  }
+  /**
+    Uses `history.pushState` to update the url without a page reload.
+       @private
+    @method setURL
+    @param path {String}
+  */
+
+
+  setURL(path) {
+    let {
+      state
+    } = this.history;
+    path = this.formatURL(path);
+
+    if (!state || state.path !== path) {
+      this.pushState(path);
+    }
+  }
+  /**
+    Uses `history.replaceState` to update the url without a page reload
+    or history modification.
+       @private
+    @method replaceURL
+    @param path {String}
+  */
+
+
+  replaceURL(path) {
+    let {
+      state
+    } = this.history;
+    path = this.formatURL(path);
+
+    if (!state || state.path !== path) {
+      this.replaceState(path);
+    }
+  }
+  /**
+   Pushes a new state.
+      @private
+   @method pushState
+   @param path {String}
+  */
+
+
+  pushState(path) {
+    let state = {
+      path,
+      uuid: _uuid()
+    };
+    this.history.pushState(state, null, path); // used for webkit workaround
+
+    this._previousURL = this.getURL();
+  }
+  /**
+   Replaces the current state.
+      @private
+   @method replaceState
+   @param path {String}
+  */
+
+
+  replaceState(path) {
+    let state = {
+      path,
+      uuid: _uuid()
+    };
+    this.history.replaceState(state, null, path); // used for webkit workaround
+
+    this._previousURL = this.getURL();
+  }
+  /**
+    Register a callback to be invoked whenever the browser
+    history changes, including using forward and back buttons.
+       @private
+    @method onUpdateURL
+    @param callback {Function}
+  */
+
+
+  onUpdateURL(callback) {
+    this._removeEventListener();
+
+    this._popstateHandler = () => {
+      // Ignore initial page load popstate event in Chrome
+      if (!popstateFired) {
+        popstateFired = true;
+
+        if (this.getURL() === this._previousURL) {
+          return;
+        }
+      }
+
+      callback(this.getURL());
+    };
+
+    window.addEventListener('popstate', this._popstateHandler);
+  }
+  /**
+    Used when using `{{action}}` helper.  The url is always appended to the rootURL.
+       @private
+    @method formatURL
+    @param url {String}
+    @return formatted url {String}
+  */
+
+
+  formatURL(url) {
+    let {
+      rootURL,
+      baseURL
+    } = this;
+
+    if (url !== '') {
+      // remove trailing slashes if they exists
+      rootURL = rootURL.replace(/\/$/, '');
+      baseURL = baseURL.replace(/\/$/, '');
+    } else if (baseURL[0] === '/' && rootURL[0] === '/') {
+      // if baseURL and rootURL both start with a slash
+      // ... remove trailing slash from baseURL if it exists
+      baseURL = baseURL.replace(/\/$/, '');
+    }
+
+    return baseURL + rootURL + url;
+  }
+  /**
+    Cleans up the HistoryLocation event listener.
+       @private
+    @method willDestroy
+  */
+
+
+  willDestroy() {
+    this._removeEventListener();
+  }
+
+  _removeEventListener() {
+    if (this._popstateHandler) {
+      window.removeEventListener('popstate', this._popstateHandler);
+    }
+  }
+
+}