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

package/dist/packages/@ember/-internals/routing/lib/ext/controller.js

@@ -1,224 +0,0 @@
-import { get } from '@ember/-internals/metal';
-import { getOwner } from '@ember/-internals/owner';
-import ControllerMixin from '@ember/controller/lib/controller_mixin';
-import { deprecateTransitionMethods, prefixRouteNameArg } from '../utils';
-/**
-@module ember
-*/
-
-ControllerMixin.reopen({
-  concatenatedProperties: ['queryParams'],
-
-  init() {
-    this._super(...arguments);
-
-    let owner = getOwner(this);
-
-    if (owner) {
-      this.namespace = owner.lookup('application:main');
-      this.target = owner.lookup('router:main');
-    }
-  },
-
-  /**
-    Defines which query parameters the controller accepts.
-    If you give the names `['category','page']` it will bind
-    the values of these query parameters to the variables
-    `this.category` and `this.page`.
-       By default, query parameters are parsed as strings. This
-    may cause unexpected behavior if a query parameter is used with `toggleProperty`,
-    because the initial value set for `param=false` will be the string `"false"`, which is truthy.
-       To avoid this, you may specify that the query parameter should be parsed as a boolean
-    by using the following verbose form with a `type` property:
-    ```javascript
-      queryParams: [{
-        category: {
-          type: 'boolean'
-        }
-      }]
-    ```
-    Available values for the `type` parameter are `'boolean'`, `'number'`, `'array'`, and `'string'`.
-    If query param type is not specified, it will default to `'string'`.
-       @for Ember.ControllerMixin
-    @property queryParams
-    @public
-  */
-  queryParams: null,
-
-  /**
-   This property is updated to various different callback functions depending on
-   the current "state" of the backing route. It is used by
-   `Controller.prototype._qpChanged`.
-      The methods backing each state can be found in the `Route.prototype._qp` computed
-   property return value (the `.states` property). The current values are listed here for
-   the sanity of future travelers:
-      * `inactive` - This state is used when this controller instance is not part of the active
-     route hierarchy. Set in `Route.prototype._reset` (a `router.js` microlib hook) and
-     `Route.prototype.actions.finalizeQueryParamChange`.
-   * `active` - This state is used when this controller instance is part of the active
-     route hierarchy. Set in `Route.prototype.actions.finalizeQueryParamChange`.
-   * `allowOverrides` - This state is used in `Route.prototype.setup` (`route.js` microlib hook).
-       @method _qpDelegate
-    @private
-  */
-  _qpDelegate: null,
-
-  /**
-   During `Route#setup` observers are created to invoke this method
-   when any of the query params declared in `Controller#queryParams` property
-   are changed.
-      When invoked this method uses the currently active query param update delegate
-   (see `Controller.prototype._qpDelegate` for details) and invokes it with
-   the QP key/value being changed.
-       @method _qpChanged
-    @private
-  */
-  _qpChanged(controller, _prop) {
-    let dotIndex = _prop.indexOf('.[]');
-
-    let prop = dotIndex === -1 ? _prop : _prop.slice(0, dotIndex);
-    let delegate = controller._qpDelegate;
-    let value = get(controller, prop);
-    delegate(prop, value);
-  },
-
-  /**
-    Transition the application into another route. The route may
-    be either a single route or route path:
-       ```javascript
-    aController.transitionToRoute('blogPosts');
-    aController.transitionToRoute('blogPosts.recentEntries');
-    ```
-       Optionally supply a model for the route in question. The model
-    will be serialized into the URL using the `serialize` hook of
-    the route:
-       ```javascript
-    aController.transitionToRoute('blogPost', aPost);
-    ```
-       If a literal is passed (such as a number or a string), it will
-    be treated as an identifier instead. In this case, the `model`
-    hook of the route will be triggered:
-       ```javascript
-    aController.transitionToRoute('blogPost', 1);
-    ```
-       Multiple models will be applied last to first recursively up the
-    route tree.
-       ```app/router.js
-    Router.map(function() {
-      this.route('blogPost', { path: ':blogPostId' }, function() {
-        this.route('blogComment', { path: ':blogCommentId', resetNamespace: true });
-      });
-    });
-    ```
-       ```javascript
-    aController.transitionToRoute('blogComment', aPost, aComment);
-    aController.transitionToRoute('blogComment', 1, 13);
-    ```
-       It is also possible to pass a URL (a string that starts with a
-    `/`).
-       ```javascript
-    aController.transitionToRoute('/');
-    aController.transitionToRoute('/blog/post/1/comment/13');
-    aController.transitionToRoute('/blog/posts?sort=title');
-    ```
-       An options hash with a `queryParams` property may be provided as
-    the final argument to add query parameters to the destination URL.
-       ```javascript
-    aController.transitionToRoute('blogPost', 1, {
-      queryParams: { showComments: 'true' }
-    });
-       // if you just want to transition the query parameters without changing the route
-    aController.transitionToRoute({ queryParams: { sort: 'date' } });
-    ```
-       See also [replaceRoute](/ember/release/classes/Ember.ControllerMixin/methods/replaceRoute?anchor=replaceRoute).
-       @for Ember.ControllerMixin
-    @method transitionToRoute
-    @deprecated Use transitionTo from the Router service instead.
-    @param {String} [name] the name of the route or a URL
-    @param {...Object} models the model(s) or identifier(s) to be used
-      while transitioning to the route.
-    @param {Object} [options] optional hash with a queryParams property
-      containing a mapping of query parameters
-    @return {Transition} the transition object associated with this
-      attempted transition
-    @public
-  */
-  transitionToRoute(...args) {
-    var _a;
-
-    deprecateTransitionMethods('controller', 'transitionToRoute'); // target may be either another controller or a router
-
-    let target = get(this, 'target'); // SAFETY: We can't actually assert that this is a full Controller or Router since some tests
-    // mock out an object that only has the single method. Since this is deprecated, I think it's
-    // ok to be a little less than proper here.
-
-    let method = (_a = target.transitionToRoute) !== null && _a !== void 0 ? _a : target.transitionTo;
-    return method.apply(target, prefixRouteNameArg(this, args));
-  },
-
-  /**
-    Transition into another route while replacing the current URL, if possible.
-    This will replace the current history entry instead of adding a new one.
-    Beside that, it is identical to `transitionToRoute` in all other respects.
-       ```javascript
-    aController.replaceRoute('blogPosts');
-    aController.replaceRoute('blogPosts.recentEntries');
-    ```
-       Optionally supply a model for the route in question. The model
-    will be serialized into the URL using the `serialize` hook of
-    the route:
-       ```javascript
-    aController.replaceRoute('blogPost', aPost);
-    ```
-       If a literal is passed (such as a number or a string), it will
-    be treated as an identifier instead. In this case, the `model`
-    hook of the route will be triggered:
-       ```javascript
-    aController.replaceRoute('blogPost', 1);
-    ```
-       Multiple models will be applied last to first recursively up the
-    route tree.
-       ```app/router.js
-    Router.map(function() {
-      this.route('blogPost', { path: ':blogPostId' }, function() {
-        this.route('blogComment', { path: ':blogCommentId', resetNamespace: true });
-      });
-    });
-    ```
-       ```
-    aController.replaceRoute('blogComment', aPost, aComment);
-    aController.replaceRoute('blogComment', 1, 13);
-    ```
-       It is also possible to pass a URL (a string that starts with a
-    `/`).
-       ```javascript
-    aController.replaceRoute('/');
-    aController.replaceRoute('/blog/post/1/comment/13');
-    ```
-       @for Ember.ControllerMixin
-    @method replaceRoute
-    @deprecated Use replaceWith from the Router service instead.
-    @param {String} [name] the name of the route or a URL
-    @param {...Object} models the model(s) or identifier(s) to be used
-    while transitioning to the route.
-    @param {Object} [options] optional hash with a queryParams property
-    containing a mapping of query parameters
-    @return {Transition} the transition object associated with this
-      attempted transition
-    @public
-  */
-  replaceRoute(...args) {
-    var _a;
-
-    deprecateTransitionMethods('controller', 'replaceRoute'); // target may be either another controller or a router
-
-    let target = get(this, 'target'); // SAFETY: We can't actually assert that this is a full Controller or Router since some tests
-    // mock out an object that only has the single method. Since this is deprecated, I think it's
-    // ok to be a little less than proper here.
-
-    let method = (_a = target.replaceRoute) !== null && _a !== void 0 ? _a : target.replaceWith;
-    return method.apply(target, prefixRouteNameArg(this, args));
-  }
-
-});
-export default ControllerMixin;

package/dist/packages/@ember/-internals/routing/lib/location/api.js

@@ -1,104 +0,0 @@
-import { assert, deprecate } from '@ember/debug';
-/**
-@module @ember/routing
-*/
-
-/**
-  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/-internals/routing/lib/location/auto_location.js

@@ -1,250 +0,0 @@
-import { history, location, userAgent, window } from '@ember/-internals/browser-environment';
-import { set } from '@ember/-internals/metal';
-import { getOwner } from '@ember/-internals/owner';
-import { Object as EmberObject } from '@ember/-internals/runtime';
-import { assert } from '@ember/debug';
-import { getFullPath, getHash, getPath, getQuery, replacePath, supportsHashChange, supportsHistory } from './util';
-/**
-@module @ember/routing
-*/
-
-/**
-  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;
-}