discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-routing/lib/services/router.js

@@ -1,243 +0,0 @@
-import Service from '@ember/service';
-import { readOnly } from '@ember/object/computed';
-import { shallowEqual, resemblesURL, extractRouteArgs } from '../utils';
-
-/**
-   The Router service is the public API that provides access to the router.
-
-   The immediate benefit of the Router service is that you can inject it into components, 
-   giving them a friendly way to initiate transitions and ask questions about the current 
-   global router state.
-
-   In this example, the Router service is injected into a component to initiate a transition 
-   to a dedicated route:
-   ```javascript
-   import Component from '@ember/component';
-   import { inject as service } from '@ember/service';
-
-   export default Component.extend({
-     router: service(),
-
-     actions: {
-       next() {
-         this.get('router').transitionTo('other.route');
-       }
-     }
-   });
-   ```
-
-   Like any service, it can also be injected into helpers, routes, etc.
-
-   @public
-   @class RouterService
-   @category ember-routing-router-service
- */
-const RouterService = Service.extend({
-  /**
-     Name of the current route.
-
-     This property represent the logical name of the route,
-     which is comma separated.
-     For the following router:
-
-     ```app/router.js
-     Router.map(function() {
-       this.route('about');
-       this.route('blog', function () {
-         this.route('post', { path: ':post_id' });
-       });
-     });
-     ```
-
-     It will return:
-
-     * `index` when you visit `/`
-     * `about` when you visit `/about`
-     * `blog.index` when you visit `/blog`
-     * `blog.post` when you visit `/blog/some-post-id`
-
-     @property currentRouteName
-     @type String
-     @public
-   */
-  currentRouteName: readOnly('_router.currentRouteName'),
-
-  /**
-     Current URL for the application.
-
-    This property represent the URL path for this route.
-    For the following router:
-
-     ```app/router.js
-     Router.map(function() {
-       this.route('about');
-       this.route('blog', function () {
-         this.route('post', { path: ':post_id' });
-       });
-     });
-     ```
-
-     It will return:
-
-     * `/` when you visit `/`
-     * `/about` when you visit `/about`
-     * `/blog` when you visit `/blog`
-     * `/blog/some-post-id` when you visit `/blog/some-post-id`
-
-     @property currentURL
-     @type String
-     @public
-   */
-  currentURL: readOnly('_router.currentURL'),
-
-  /**
-    The `location` property determines the type of URL's that your
-    application will use.
-    The following location types are currently available:
-    * `auto`
-    * `hash`
-    * `history`
-    * `none`
-
-    @property location
-    @default 'hash'
-    @see {Location}
-    @public
-  */
-  location: readOnly('_router.location'),
-
-  /**
-    The `rootURL` property represents the URL of the root of
-    the application, '/' by default.
-    This prefix is assumed on all routes defined on this app.
-
-    IF you change the `rootURL` in your environment configuration
-    like so:
-
-    ```config/environment.js
-    'use strict';
-
-    module.exports = function(environment) {
-      let ENV = {
-        modulePrefix: 'router-service',
-        environment,
-        rootURL: '/my-root',
-      …
-      }
-    ]
-    ```
-
-    This property will return `/my-root`.
-
-    @property rootURL
-    @default '/'
-    @public
-  */
-  rootURL: readOnly('_router.rootURL'),
-  _router: null,
-
-  /**
-     Transition the application into another route. The route may
-     be either a single route or route path:
-
-     See [transitionTo](/api/ember/release/classes/Route/methods/transitionTo?anchor=transitionTo) for more info.
-
-     @method transitionTo
-     @category ember-routing-router-service
-     @param {String} routeNameOrUrl 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
-   */
-  transitionTo(...args) {
-    if (resemblesURL(args[0])) {
-      return this._router._doURLTransition('transitionTo', args[0]);
-    }
-
-    let { routeName, models, queryParams } = extractRouteArgs(args);
-
-    let transition = this._router._doTransition(routeName, models, queryParams, true);
-    transition._keepDefaultQueryParamValues = true;
-
-    return transition;
-  },
-
-  /**
-     Transition into another route while replacing the current URL, if possible.
-     The route may be either a single route or route path:
-
-     See [replaceWith](/api/ember/release/classes/Route/methods/replaceWith?anchor=replaceWith) for more info.
-
-     @method replaceWith
-     @category ember-routing-router-service
-     @param {String} routeNameOrUrl 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
-   */
-  replaceWith(/* routeNameOrUrl, ...models, options */) {
-    return this.transitionTo(...arguments).method('replace');
-  },
-
-  /**
-     Generate a URL based on the supplied route name.
-
-     @method urlFor
-     @category ember-routing-router-service
-     @param {String} routeName the name of the route
-     @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 {String} the string representing the generated URL
-     @public
-   */
-  urlFor(/* routeName, ...models, options */) {
-    return this._router.generate(...arguments);
-  },
-
-  /**
-     Determines whether a route is active.
-
-     @method isActive
-     @category ember-routing-router-service
-     @param {String} routeName the name of the route
-     @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 {boolean} true if the provided routeName/models/queryParams are active
-     @public
-   */
-  isActive(...args) {
-    let { routeName, models, queryParams } = extractRouteArgs(args);
-    let routerMicrolib = this._router._routerMicrolib;
-
-    if (!routerMicrolib.isActiveIntent(routeName, models, null)) {
-      return false;
-    }
-    let hasQueryParams = Object.keys(queryParams).length > 0;
-
-    if (hasQueryParams) {
-      this._router._prepareQueryParams(
-        routeName,
-        models,
-        queryParams,
-        true /* fromRouterService */
-      );
-      return shallowEqual(queryParams, routerMicrolib.state.queryParams);
-    }
-
-    return true;
-  },
-});
-
-export default RouterService;

data/dist/es/ember-routing/lib/services/routing.js

@@ -1,101 +0,0 @@
-/**
-@module ember
-*/
-
-import { assign } from '@ember/polyfills';
-import Service from '@ember/service';
-import { readOnly } from '@ember/object/computed';
-import { get } from 'ember-metal';
-
-/**
-  The Routing service is used by LinkComponent, and provides facilities for
-  the component/view layer to interact with the router.
-
-  This is a private service for internal usage only. For public usage,
-  refer to the `Router` service.
-
-  @private
-  @class RoutingService
-*/
-export default Service.extend({
-  router: null,
-
-  targetState: readOnly('router.targetState'),
-  currentState: readOnly('router.currentState'),
-  currentRouteName: readOnly('router.currentRouteName'),
-  currentPath: readOnly('router.currentPath'),
-
-  hasRoute(routeName) {
-    return get(this, 'router').hasRoute(routeName);
-  },
-
-  transitionTo(routeName, models, queryParams, shouldReplace) {
-    let router = get(this, 'router');
-
-    let transition = router._doTransition(routeName, models, queryParams);
-
-    if (shouldReplace) {
-      transition.method('replace');
-    }
-
-    return transition;
-  },
-
-  normalizeQueryParams(routeName, models, queryParams) {
-    get(this, 'router')._prepareQueryParams(routeName, models, queryParams);
-  },
-
-  generateURL(routeName, models, queryParams) {
-    let router = get(this, 'router');
-    // return early when the router microlib is not present, which is the case for {{link-to}} in integration tests
-    if (!router._routerMicrolib) {
-      return;
-    }
-
-    let visibleQueryParams = {};
-    if (queryParams) {
-      assign(visibleQueryParams, queryParams);
-      this.normalizeQueryParams(routeName, models, visibleQueryParams);
-    }
-
-    return router.generate(routeName, ...models, {
-      queryParams: visibleQueryParams,
-    });
-  },
-
-  isActiveForRoute(contexts, queryParams, routeName, routerState, isCurrentWhenSpecified) {
-    let router = get(this, 'router');
-
-    let handlers = router._routerMicrolib.recognizer.handlersFor(routeName);
-    let leafName = handlers[handlers.length - 1].handler;
-    let maximumContexts = numberOfContextsAcceptedByHandler(routeName, handlers);
-
-    // NOTE: any ugliness in the calculation of activeness is largely
-    // due to the fact that we support automatic normalizing of
-    // `resource` -> `resource.index`, even though there might be
-    // dynamic segments / query params defined on `resource.index`
-    // which complicates (and makes somewhat ambiguous) the calculation
-    // of activeness for links that link to `resource` instead of
-    // directly to `resource.index`.
-
-    // if we don't have enough contexts revert back to full route name
-    // this is because the leaf route will use one of the contexts
-    if (contexts.length > maximumContexts) {
-      routeName = leafName;
-    }
-
-    return routerState.isActiveIntent(routeName, contexts, queryParams, !isCurrentWhenSpecified);
-  },
-});
-
-function numberOfContextsAcceptedByHandler(handler, handlerInfos) {
-  let req = 0;
-  for (let i = 0; i < handlerInfos.length; i++) {
-    req += handlerInfos[i].names.length;
-    if (handlerInfos[i].handler === handler) {
-      break;
-    }
-  }
-
-  return req;
-}

data/dist/es/ember-routing/lib/system/cache.js

@@ -1,40 +0,0 @@
-/**
-  A two-tiered cache with support for fallback values when doing lookups.
-  Uses "buckets" and then "keys" to cache values.
-
-  @private
-  @class BucketCache
-*/
-export default class BucketCache {
-  constructor() {
-    this.cache = new Map();
-  }
-
-  has(bucketKey) {
-    return this.cache.has(bucketKey);
-  }
-
-  stash(bucketKey, key, value) {
-    let bucket = this.cache.get(bucketKey);
-
-    if (bucket === undefined) {
-      bucket = new Map();
-      this.cache.set(bucketKey, bucket);
-    }
-
-    bucket.set(key, value);
-  }
-
-  lookup(bucketKey, prop, defaultValue) {
-    if (!this.has(bucketKey)) {
-      return defaultValue;
-    }
-
-    let bucket = this.cache.get(bucketKey);
-    if (bucket.has(prop)) {
-      return bucket.get(prop);
-    } else {
-      return defaultValue;
-    }
-  }
-}

data/dist/es/ember-routing/lib/system/controller_for.js

@@ -1,14 +0,0 @@
-/**
-@module ember
-*/
-
-/**
-  Finds a controller instance.
-
-  @for Ember
-  @method controllerFor
-  @private
-*/
-export default function controllerFor(container, controllerName, lookupOptions) {
-  return container.lookup(`controller:${controllerName}`, lookupOptions);
-}

data/dist/es/ember-routing/lib/system/dsl.js

@@ -1,208 +0,0 @@
-import { assign } from '@ember/polyfills';
-import { assert } from '@ember/debug';
-
-let uuid = 0;
-
-class DSL {
-  constructor(name, options) {
-    this.parent = name;
-    this.enableLoadingSubstates = options && options.enableLoadingSubstates;
-    this.matches = [];
-    this.explicitIndex = undefined;
-    this.options = options;
-  }
-
-  route(name, options = {}, callback) {
-    let dummyErrorRoute = `/_unused_dummy_error_path_route_${name}/:error`;
-    if (arguments.length === 2 && typeof options === 'function') {
-      callback = options;
-      options = {};
-    }
-
-    assert(
-      `'${name}' cannot be used as a route name.`,
-      (() => {
-        if (options.overrideNameAssertion === true) {
-          return true;
-        }
-
-        return ['basic', 'application'].indexOf(name) === -1;
-      })()
-    );
-
-    assert(
-      `'${name}' is not a valid route name. It cannot contain a ':'. You may want to use the 'path' option instead.`,
-      name.indexOf(':') === -1
-    );
-
-    if (this.enableLoadingSubstates) {
-      createRoute(this, `${name}_loading`, {
-        resetNamespace: options.resetNamespace,
-      });
-      createRoute(this, `${name}_error`, {
-        resetNamespace: options.resetNamespace,
-        path: dummyErrorRoute,
-      });
-    }
-
-    if (callback) {
-      let fullName = getFullName(this, name, options.resetNamespace);
-      let dsl = new DSL(fullName, this.options);
-
-      createRoute(dsl, 'loading');
-      createRoute(dsl, 'error', { path: dummyErrorRoute });
-
-      callback.call(dsl);
-
-      createRoute(this, name, options, dsl.generate());
-    } else {
-      createRoute(this, name, options);
-    }
-  }
-
-  push(url, name, callback, serialize) {
-    let parts = name.split('.');
-
-    if (this.options.engineInfo) {
-      let localFullName = name.slice(this.options.engineInfo.fullName.length + 1);
-      let routeInfo = assign({ localFullName }, this.options.engineInfo);
-
-      if (serialize) {
-        routeInfo.serializeMethod = serialize;
-      }
-
-      this.options.addRouteForEngine(name, routeInfo);
-    } else if (serialize) {
-      throw new Error(
-        `Defining a route serializer on route '${name}' outside an Engine is not allowed.`
-      );
-    }
-
-    if (url === '' || url === '/' || parts[parts.length - 1] === 'index') {
-      this.explicitIndex = true;
-    }
-
-    this.matches.push(url, name, callback);
-  }
-
-  generate() {
-    let dslMatches = this.matches;
-
-    if (!this.explicitIndex) {
-      this.route('index', { path: '/' });
-    }
-
-    return match => {
-      for (let i = 0; i < dslMatches.length; i += 3) {
-        match(dslMatches[i]).to(dslMatches[i + 1], dslMatches[i + 2]);
-      }
-    };
-  }
-
-  mount(_name, options = {}) {
-    let engineRouteMap = this.options.resolveRouteMap(_name);
-    let name = _name;
-
-    if (options.as) {
-      name = options.as;
-    }
-
-    let fullName = getFullName(this, name, options.resetNamespace);
-
-    let engineInfo = {
-      name: _name,
-      instanceId: uuid++,
-      mountPoint: fullName,
-      fullName,
-    };
-
-    let path = options.path;
-
-    if (typeof path !== 'string') {
-      path = `/${name}`;
-    }
-
-    let callback;
-    let dummyErrorRoute = `/_unused_dummy_error_path_route_${name}/:error`;
-    if (engineRouteMap) {
-      let shouldResetEngineInfo = false;
-      let oldEngineInfo = this.options.engineInfo;
-      if (oldEngineInfo) {
-        shouldResetEngineInfo = true;
-        this.options.engineInfo = engineInfo;
-      }
-
-      let optionsForChild = assign({ engineInfo }, this.options);
-      let childDSL = new DSL(fullName, optionsForChild);
-
-      createRoute(childDSL, 'loading');
-      createRoute(childDSL, 'error', { path: dummyErrorRoute });
-
-      engineRouteMap.class.call(childDSL);
-
-      callback = childDSL.generate();
-
-      if (shouldResetEngineInfo) {
-        this.options.engineInfo = oldEngineInfo;
-      }
-    }
-
-    let localFullName = 'application';
-    let routeInfo = assign({ localFullName }, engineInfo);
-
-    if (this.enableLoadingSubstates) {
-      // These values are important to register the loading routes under their
-      // proper names for the Router and within the Engine's registry.
-      let substateName = `${name}_loading`;
-      let localFullName = `application_loading`;
-      let routeInfo = assign({ localFullName }, engineInfo);
-      createRoute(this, substateName, {
-        resetNamespace: options.resetNamespace,
-      });
-      this.options.addRouteForEngine(substateName, routeInfo);
-
-      substateName = `${name}_error`;
-      localFullName = `application_error`;
-      routeInfo = assign({ localFullName }, engineInfo);
-      createRoute(this, substateName, {
-        resetNamespace: options.resetNamespace,
-        path: dummyErrorRoute,
-      });
-      this.options.addRouteForEngine(substateName, routeInfo);
-    }
-
-    this.options.addRouteForEngine(fullName, routeInfo);
-
-    this.push(path, fullName, callback);
-  }
-}
-
-export default DSL;
-
-function canNest(dsl) {
-  return dsl.parent !== 'application';
-}
-
-function getFullName(dsl, name, resetNamespace) {
-  if (canNest(dsl) && resetNamespace !== true) {
-    return `${dsl.parent}.${name}`;
-  } else {
-    return name;
-  }
-}
-
-function createRoute(dsl, name, options = {}, callback) {
-  let fullName = getFullName(dsl, name, options.resetNamespace);
-
-  if (typeof options.path !== 'string') {
-    options.path = `/${name}`;
-  }
-
-  dsl.push(options.path, fullName, callback, options.serialize);
-}
-
-DSL.map = callback => {
-  let dsl = new DSL();
-  callback.call(dsl);
-  return dsl;
-};