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

package/dist/packages/@ember/{-internals/routing/lib/system → routing/lib}/router_state.js

@@ -1,4 +1,4 @@
-import { shallowEqual } from '../utils';
+import { shallowEqual } from './utils';
 export default class RouterState {
   constructor(emberRouter, router, routerJsState) {
     this.emberRouter = emberRouter;

package/dist/packages/@ember/{-internals/routing/lib/services/routing.js → routing/lib/routing-service.js}

@@ -5,8 +5,8 @@ import { getOwner } from '@ember/-internals/owner';
 import { assert } from '@ember/debug';
 import { readOnly } from '@ember/object/computed';
 import Service from '@ember/service';
-import EmberRouter from '../system/router';
-import { ROUTER } from './router';
+import EmberRouter from '@ember/routing/router';
+import { ROUTER } from '@ember/routing/router-service';
 /**
   The Routing service is used by LinkTo, and provides facilities for
   the component/view layer to interact with the router.

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

@@ -1 +1,104 @@
-export { Location as default } from '@ember/-internals/routing';
+import { assert, deprecate } from '@ember/debug';
+/**
+@module @ember/routing/location
+*/
+
+/**
+  Location returns an instance of the correct implementation of
+  the `location` API.
+
+  ## Implementations
+
+  You can pass an implementation name (`hash`, `history`, `none`, `auto`) to force a
+  particular implementation to be used in your application.
+
+  See [HashLocation](/ember/release/classes/HashLocation).
+  See [HistoryLocation](/ember/release/classes/HistoryLocation).
+  See [NoneLocation](/ember/release/classes/NoneLocation).
+  See [AutoLocation](/ember/release/classes/AutoLocation).
+
+  ## Location API
+
+  Each location implementation must provide the following methods:
+
+  * implementation: returns the string name used to reference the implementation.
+  * getURL: returns the current URL.
+  * setURL(path): sets the current URL.
+  * replaceURL(path): replace the current URL (optional).
+  * onUpdateURL(callback): triggers the callback when the URL changes.
+  * formatURL(url): formats `url` to be placed into `href` attribute.
+  * detect() (optional): instructs the location to do any feature detection
+      necessary. If the location needs to redirect to a different URL, it
+      can cancel routing by setting the `cancelRouterSetup` property on itself
+      to `false`.
+
+  Calling setURL or replaceURL will not trigger onUpdateURL callbacks.
+
+  ## Custom implementation
+
+  Ember scans `app/locations/*` for extending the Location API.
+
+  Example:
+
+  ```javascript
+  import HistoryLocation from '@ember/routing/history-location';
+
+  export default class MyHistory {
+    implementation = 'my-custom-history';
+
+    constructor() {
+      this._history = HistoryLocation.create(...arguments);
+    }
+
+    create() {
+      return new this(...arguments);
+    }
+
+    pushState(path) {
+       this._history.pushState(path);
+    }
+  }
+  ```
+
+  @class Location
+  @private
+*/
+
+export default {
+  /**
+   This is deprecated in favor of using the container to lookup the location
+   implementation as desired.
+      For example:
+      ```javascript
+   // Given a location registered as follows:
+   container.register('location:history-test', HistoryTestLocation);
+      // You could create a new instance via:
+   container.lookup('location:history-test');
+   ```
+       @method create
+    @param {Object} options
+    @return {Object} an instance of an implementation of the `location` API
+    @deprecated Use the container to lookup the location implementation that you
+    need.
+    @private
+  */
+  create(options) {
+    let implementation = options === null || options === void 0 ? void 0 : options.implementation;
+    assert("Location.create: you must specify a 'implementation' option", implementation);
+    let implementationClass = this.implementations[implementation];
+    assert(`Location.create: ${implementation} is not a valid implementation`, implementationClass);
+    deprecate("Calling `create` on Location class is deprecated. Instead, use `container.lookup('location:my-location')` to lookup the location you need.", false, {
+      id: 'deprecate-auto-location',
+      until: '5.0.0',
+      url: 'https://emberjs.com/deprecations/v4.x#toc_deprecate-auto-location',
+      for: 'ember-source',
+      since: {
+        available: '4.1.0',
+        enabled: '4.1.0'
+      }
+    });
+    return implementationClass.create(...arguments);
+  },
+
+  implementations: {}
+};

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

@@ -1 +1,123 @@
-export { NoneLocation as default } from '@ember/-internals/routing';
+import EmberObject, { set } from '@ember/object';
+import { assert } from '@ember/debug';
+/**
+@module @ember/routing/none-location
+*/
+
+/**
+  NoneLocation does not interact with the browser. It is useful for
+  testing, or when you need to manage state with your Router, but temporarily
+  don't want it to muck with the URL (for example when you embed your
+  application in a larger page).
+
+  Using `NoneLocation` causes Ember to not store the applications URL state
+  in the actual URL. This is generally used for testing purposes, and is one
+  of the changes made when calling `App.setupForTesting()`.
+
+  @class NoneLocation
+  @extends EmberObject
+  @protected
+*/
+
+export default class NoneLocation extends EmberObject {
+  constructor() {
+    super(...arguments);
+    this.implementation = 'none';
+  }
+
+  initState() {
+    this._super(...arguments);
+
+    let {
+      rootURL
+    } = this; // This assert doesn't have anything to do with state initialization,
+    // but we're hijacking this method since it's called after the route has
+    // set the rootURL property on its Location instance.
+
+    assert('rootURL must end with a trailing forward slash e.g. "/app/"', rootURL.charAt(rootURL.length - 1) === '/');
+  }
+  /**
+    Returns the current path without `rootURL`.
+       @private
+    @method getURL
+    @return {String} path
+  */
+
+
+  getURL() {
+    let {
+      path,
+      rootURL
+    } = this; // remove trailing slashes if they exists
+
+    rootURL = rootURL.replace(/\/$/, ''); // remove rootURL from url
+
+    return path.replace(new RegExp(`^${rootURL}(?=/|$)`), '');
+  }
+  /**
+    Set the path and remembers what was set. Using this method
+    to change the path will not invoke the `updateURL` callback.
+       @private
+    @method setURL
+    @param path {String}
+  */
+
+
+  setURL(path) {
+    set(this, 'path', path);
+  }
+  /**
+    Register a callback to be invoked when the path 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.updateCallback = callback;
+  }
+  /**
+    Sets the path and calls the `updateURL` callback.
+       @private
+    @method handleURL
+    @param url {String}
+  */
+
+
+  handleURL(url) {
+    set(this, 'path', url);
+    this.updateCallback(url);
+  }
+  /**
+    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}
+    @return {String} url
+  */
+
+
+  formatURL(url) {
+    let {
+      rootURL
+    } = this;
+
+    if (url !== '') {
+      // remove trailing slashes if they exists
+      rootURL = rootURL.replace(/\/$/, '');
+    }
+
+    return rootURL + url;
+  }
+
+}
+NoneLocation.reopen({
+  path: '',
+  rootURL: '/'
+});