ember-source 4.4.0-alpha.1 → 4.4.0-alpha.2

package/dist/header/license.js

@@ -5,5 +5,5 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   4.4.0-alpha.1
+ * @version   4.4.0-alpha.2
  */

package/dist/packages/@ember/-internals/container/index.js

@@ -187,8 +187,6 @@ class Container {
     @public
    @method factoryFor
    @param {String} fullName
-   @param {Object} [options]
-   @param {String} [options.source] The fullname of the request source (used for local lookup)
    @return {any}
    */
 
@@ -199,7 +197,9 @@ class Container {
     }
 
     let normalizedName = this.registry.normalize(fullName);
-    assert('fullName must be a proper full name', this.registry.isValidFullName(normalizedName));
+    assert('fullName must be a proper full name', this.registry.isValidFullName(normalizedName)); // TODO: This needs to return a Factory to be compatible with Owner.
+    // We should correctly the types so that this cast is not necessary.
+
     return factoryFor(this, normalizedName, fullName);
   }
 

package/dist/packages/@ember/-internals/glimmer/index.js

@@ -9,8 +9,9 @@ import { untrack, consumeTag, createCache, getValue, tagFor, beginUntrackFrame,
 import { tracked, get, PROPERTY_DID_CHANGE, tagForObject, objectAt, tagForProperty, set, _getProp, _setProp } from '@ember/-internals/metal';
 import { action } from '@ember/object';
 import { hasDOM } from '@ember/-internals/browser-environment';
-import { isSimpleClick, clearElementView, clearViewElement, getViewElement, MUTABLE_CELL, addChildView, setElementView, setViewElement, ActionSupport, ChildViewsSupport, ClassNamesSupport, CoreView, ViewMixin, ViewStateSupport, constructStyleDeprecationMessage, ActionManager, getViewId } from '@ember/-internals/views';
+import { isSimpleClick, clearElementView, clearViewElement, getViewElement, MUTABLE_CELL, addChildView, setElementView, setViewElement, ActionSupport, ChildViewsSupport, ClassNamesSupport, CoreView, EventDispatcher, ViewMixin, ViewStateSupport, constructStyleDeprecationMessage, ActionManager, getViewId } from '@ember/-internals/views';
 import { getEngineParent } from '@ember/engine';
+import EngineInstance from '@ember/engine/instance';
 import { flaggedInstrument, _instrumentStart } from '@ember/instrumentation';
 import { service } from '@ember/service';
 import { DEBUG } from '@glimmer/env';
@@ -1099,11 +1100,13 @@ class LinkTo extends InternalComponent {
   }
 
   get isEngine() {
-    return getEngineParent(this.owner) !== undefined;
+    let owner = this.owner;
+    return owner instanceof EngineInstance && getEngineParent(owner) !== undefined;
   }
 
   get engineMountPoint() {
-    return this.owner.mountPoint;
+    let owner = this.owner;
+    return owner instanceof EngineInstance ? owner.mountPoint : undefined;
   }
 
   classFor(state) {
@@ -3165,6 +3168,7 @@ const Component = CoreView.extend(ChildViewsSupport, ViewStateSupport, ClassName
 
       if (owner.lookup('-environment:main').isInteractive) {
         this.__dispatcher = owner.lookup('event_dispatcher:main');
+        assert('Expected dispatcher to be an EventDispatcher', this.__dispatcher instanceof EventDispatcher);
       } else {
         // In FastBoot we have no EventDispatcher. Set to null to not try again to look it up.
         this.__dispatcher = null;
@@ -3787,11 +3791,9 @@ class OutletComponentManager {
       let currentOwner = valueForRef(currentStateRef).render.owner;
 
       if (parentOwner && parentOwner !== currentOwner) {
-        let engine = currentOwner;
-        assert('invalid engine: missing mountPoint', typeof currentOwner.mountPoint === 'string');
-        assert('invalid engine: missing routable', currentOwner.routable === true);
-        let mountPoint = engine.mountPoint;
-        state.engine = engine;
+        assert('Expected currentOwner to be an EngineInstance', currentOwner instanceof EngineInstance);
+        let mountPoint = currentOwner.mountPoint;
+        state.engine = currentOwner;
         state.engineBucket = {
           mountPoint
         };
@@ -4575,7 +4577,7 @@ var disallowDynamicResolution = internalHelper(({
   assert('[BUG] expecting a string literal for the `original` argument', typeof original === 'string');
   return createComputeRef(() => {
     let nameOrValue = valueForRef(nameOrValueRef);
-    assert(`Passing a dynamic string to the \`(${type})\` keyword is disallowed. ` + `(You specified \`(${type} ${original})\` and \`${original}\` evaluated into "${nameOrValue}".) ` + `This ensures we can statically analyze the template and determine which ${type}s are used. ` + `If the ${type} name is always the same, use a string literal instead, i.e. \`(${type} "${nameOrValue}")\`. ` + `Otherwise, import the ${type}s into JavaScript and pass them to the ${type} keyword. ` + 'See https://github.com/emberjs/rfcs/blob/master/text/0496-handlebars-strict-mode.md#4-no-dynamic-resolution for details. ' + loc, typeof nameOrValue !== 'string');
+    assert(`Passing a dynamic string to the \`(${type})\` keyword is disallowed. ` + `(You specified \`(${type} ${original})\` and \`${original}\` evaluated into "${nameOrValue}".) ` + `This ensures we can statically analyze the template and determine which ${type}s are used. ` + `If the ${type} name is always the same, use a string literal instead, i.e. \`(${type} "${nameOrValue}")\`. ` + `Otherwise, import the ${type}s into JavaScript and pass them directly. ` + 'See https://github.com/emberjs/rfcs/blob/master/text/0496-handlebars-strict-mode.md#4-no-dynamic-resolution for details. ' + loc, typeof nameOrValue !== 'string');
     return nameOrValue;
   });
 });
@@ -5165,6 +5167,7 @@ class ActionModifierManager {
 
   ensureEventSetup(actionState) {
     let dispatcher = actionState.owner.lookup('event_dispatcher:main');
+    assert('Expected dispatcher to be an EventDispatcher', dispatcher instanceof EventDispatcher);
     dispatcher === null || dispatcher === void 0 ? void 0 : dispatcher.setupHandlerForEmberEvent(actionState.eventName);
   }
 
@@ -5218,6 +5221,7 @@ class MountManager {
     // mount is a runtime helper, this shouldn't use dynamic layout
     // we should resolve the engine app template in the helper
     // it also should use the owner that looked up the mount helper.
+    assert('Expected owner to be an EngineInstance', owner instanceof EngineInstance);
     let engine = owner.buildChildEngineInstance(name);
     engine.boot();
     let applicationFactory = engine.factoryFor(`controller:application`);
@@ -5430,28 +5434,17 @@ const mountHelper = internalHelper((args, owner) => {
   Note: Your content __will not render__ if there isn't an `{{outlet}}` for it.
 
   @method outlet
-  @param {String} [name]
   @for Ember.Templates.helpers
   @public
 */
 
-const outletHelper = internalHelper((args, owner, scope) => {
+const outletHelper = internalHelper((_args, owner, scope) => {
   assert('Expected owner to be present, {{outlet}} requires an owner', owner);
   assert('Expected dynamic scope to be present. You may have attempted to use the {{outlet}} keyword dynamically. This keyword cannot be used dynamically.', scope);
-  let nameRef;
-
-  if (args.positional.length === 0) {
-    nameRef = createPrimitiveRef('main');
-  } else {
-    let maybeNameRef = args.positional[0];
-    assert('Expected at least one positional arg', maybeNameRef);
-    nameRef = maybeNameRef;
-  }
-
   let outletRef = createComputeRef(() => {
     let state = valueForRef(scope.get('outletState'));
     let outlets = state !== undefined ? state.outlets : undefined;
-    return outlets !== undefined ? outlets[valueForRef(nameRef)] : undefined;
+    return outlets !== undefined ? outlets.main : undefined;
   });
   let lastState = null;
   let definition = null;
@@ -5541,9 +5534,9 @@ function instrumentationPayload$1(name) {
   };
 }
 
-function componentFor(name, owner, options) {
+function componentFor(name, owner) {
   let fullName = `component:${name}`;
-  return owner.factoryFor(fullName, options) || null;
+  return owner.factoryFor(fullName) || null;
 }
 
 function layoutFor(name, owner, options) {
@@ -5552,7 +5545,7 @@ function layoutFor(name, owner, options) {
 }
 
 function lookupComponentPair(owner, name, options) {
-  let component = componentFor(name, owner, options);
+  let component = componentFor(name, owner);
 
   if (component !== null && component.class !== undefined) {
     let layout = getComponentTemplate(component.class);

package/dist/packages/@ember/-internals/metal/index.js

@@ -1782,20 +1782,20 @@ function get(obj, keyName) {
   return isPath(keyName) ? _getPath(obj, keyName) : _getProp(obj, keyName);
 }
 function _getProp(obj, keyName) {
-  let type = typeof obj;
-  let isObject$$1 = type === 'object';
-  let isFunction = type === 'function';
-  let isObjectLike = isObject$$1 || isFunction;
+  if (obj == null) {
+    return;
+  }
+
   let value;
 
-  if (isObjectLike) {
+  if (typeof obj === 'object' || typeof obj === 'function') {
     if (DEBUG) {
       value = getPossibleMandatoryProxyValue(obj, keyName);
     } else {
       value = obj[keyName];
     }
 
-    if (value === undefined && isObject$$1 && !(keyName in obj) && typeof obj.unknownProperty === 'function') {
+    if (value === undefined && typeof obj === 'object' && !(keyName in obj) && typeof obj.unknownProperty === 'function') {
       value = obj.unknownProperty(keyName);
     }
 
@@ -1809,13 +1809,13 @@ function _getProp(obj, keyName) {
       }
     }
   } else {
+    // SAFETY: It should be ok to access properties on any non-nullish value
     value = obj[keyName];
   }
 
   return value;
 }
-function _getPath(root, path) {
-  let obj = root;
+function _getPath(obj, path) {
   let parts = typeof path === 'string' ? path.split('.') : path;
 
   for (let part of parts) {
@@ -1838,12 +1838,12 @@ _getProp({}, 'a');
 _getProp({}, 1);
 
 _getProp({
-  unkonwnProperty() {}
+  unknownProperty() {}
 
 }, 'a');
 
 _getProp({
-  unkonwnProperty() {}
+  unknownProperty() {}
 
 }, 1);
 
@@ -2201,13 +2201,7 @@ function isEmpty(obj) {
     if (typeof size === 'number') {
       return !size;
     }
-  }
 
-  if (typeof obj.length === 'number' && objectType !== 'function') {
-    return !obj.length;
-  }
-
-  if (objectType === 'object') {
     let length = get(obj, 'length');
 
     if (typeof length === 'number') {
@@ -2215,6 +2209,10 @@ function isEmpty(obj) {
     }
   }
 
+  if (typeof obj.length === 'number' && objectType !== 'function') {
+    return !obj.length;
+  }
+
   return false;
 }
 

package/dist/packages/@ember/-internals/routing/lib/services/router.js

@@ -13,6 +13,7 @@ import { assert } from '@ember/debug';
 import { readOnly } from '@ember/object/computed';
 import Service from '@ember/service';
 import { consumeTag, tagFor } from '@glimmer/validator';
+import EmberRouter from '../system/router';
 import { extractRouteArgs, resemblesURL, shallowEqual } from '../utils';
 const ROUTER = symbol('ROUTER');
 
@@ -133,6 +134,7 @@ class RouterService extends Service.extend(Evented) {
     let owner = getOwner(this);
     assert('RouterService is unexpectedly missing an owner', owner);
     router = owner.lookup('router:main');
+    assert('ROUTER SERVICE BUG: Expected router to be an instance of EmberRouter', router instanceof EmberRouter);
     return this[ROUTER] = router;
   }
 

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

@@ -6,6 +6,7 @@ import { symbol } from '@ember/-internals/utils';
 import { assert } from '@ember/debug';
 import { readOnly } from '@ember/object/computed';
 import Service from '@ember/service';
+import EmberRouter from '../system/router';
 const ROUTER = symbol('ROUTER');
 /**
   The Routing service is used by LinkTo, and provides facilities for
@@ -29,6 +30,7 @@ export default class RoutingService extends Service {
     let owner = getOwner(this);
     assert('RoutingService is unexpectedly missing an owner', owner);
     router = owner.lookup('router:main');
+    assert('ROUTING SERVICE BUG: Expected router to be an instance of EmberRouter', router instanceof EmberRouter);
     router.setupRouter();
     return this[ROUTER] = router;
   }

package/dist/packages/@ember/-internals/routing/lib/system/generate_controller.js

@@ -1,5 +1,6 @@
 import { get } from '@ember/-internals/metal';
-import { info } from '@ember/debug';
+import Controller from '@ember/controller';
+import { assert, info } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 /**
 @module ember
@@ -39,6 +40,7 @@ export default function generateController(owner, controllerName) {
   generateControllerFactory(owner, controllerName);
   let fullName = `controller:${controllerName}`;
   let instance = owner.lookup(fullName);
+  assert('Expected an instance of controller', instance instanceof Controller);
 
   if (DEBUG) {
     if (get(instance, 'namespace.LOG_ACTIVE_GENERATION')) {

package/dist/packages/@ember/-internals/routing/lib/system/route.js

@@ -9,27 +9,31 @@ var __decorate = this && this.__decorate || function (decorators, target, key, d
 import { privatize as P } from '@ember/-internals/container';
 import { addObserver, computed, defineProperty, descriptorForProperty, flushAsyncObservers, get, getProperties, isEmpty, set, setProperties } from '@ember/-internals/metal';
 import { getOwner } from '@ember/-internals/owner';
+import { BucketCache } from '@ember/-internals/routing';
 import { A as emberA, ActionHandler, Evented, Object as EmberObject, typeOf } from '@ember/-internals/runtime';
 import { isProxy, lookupDescriptor, symbol } from '@ember/-internals/utils';
+import Controller from '@ember/controller';
 import { assert, info, isTesting } from '@ember/debug';
+import EngineInstance from '@ember/engine/instance';
 import { dependentKeyCompat } from '@ember/object/compat';
 import { once } from '@ember/runloop';
 import { DEBUG } from '@glimmer/env';
 import { PARAMS_SYMBOL, STATE_SYMBOL } from 'router_js';
 import { calculateCacheKey, deprecateTransitionMethods, normalizeControllerQueryParams, prefixRouteNameArg, stashParamNames } from '../utils';
 import generateController from './generate_controller';
+import EmberRouter from './router';
 export const ROUTE_CONNECTIONS = new WeakMap();
 const RENDER = symbol('render');
 
 class Route extends EmberObject.extend(ActionHandler, Evented) {
   constructor(owner) {
-    super(...arguments);
+    super(owner);
     this.context = {};
 
     if (owner) {
       let router = owner.lookup('router:main');
       let bucketCache = owner.lookup(P`-bucket-cache:main`);
-      assert('ROUTER BUG: Expected route injections to be defined on the route. This is an internal bug, please open an issue on Github if you see this message!', router && bucketCache);
+      assert('ROUTER BUG: Expected route injections to be defined on the route. This is an internal bug, please open an issue on Github if you see this message!', router instanceof EmberRouter && bucketCache instanceof BucketCache);
       this._router = router;
       this._bucketCache = bucketCache;
       this._topLevelViewTemplate = owner.lookup('template:-outlet');
@@ -110,7 +114,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
   _setRouteName(name) {
     this.routeName = name;
     let owner = getOwner(this);
-    assert('Route is unexpectedly missing an owner', owner);
+    assert('Expected route to have EngineInstance as owner', owner instanceof EngineInstance);
     this.fullRouteName = getEngineRouteName(owner, name);
   }
   /**
@@ -943,6 +947,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
     //   passed a model to skip the assertion.
 
     assert(`The controller named '${name}' could not be found. Make sure that this route exists and has already been entered at least once. If you are accessing a controller not associated with a route, make sure the controller class is explicitly defined.`, controller !== undefined || _skipAssert === true);
+    assert(`Expected controller:${name} to be an instance of Controller`, controller === undefined || controller instanceof Controller);
     return controller;
   }
   /**
@@ -1007,7 +1012,7 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
   modelFor(_name) {
     let name;
     let owner = getOwner(this);
-    assert('Route is unexpectedly missing an owner', owner);
+    assert('Expected router owner to be an EngineInstance', owner instanceof EngineInstance);
     let transition = this._router && this._router._routerMicrolib ? this._router._routerMicrolib.activeTransition : undefined; // Only change the route name when there is an active transition.
     // Otherwise, use the passed in route name.
 
@@ -1135,10 +1140,11 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
     let hasRouterDefinedQueryParams = Object.keys(queryParameterConfiguraton).length > 0;
 
     if (controller) {
-      // the developer has authored a controller class in their application for
+      assert('Expected an instance of controller', controller instanceof Controller); // the developer has authored a controller class in their application for
       // this route find its query params and normalize their object shape them
       // merge in the query params for the route. As a mergedProperty,
       // Route#queryParams is always at least `{}`
+
       let controllerDefinedQueryParameterConfiguration = get(controller, 'queryParams') || [];
       let normalizedControllerQueryParameterConfiguration = normalizeControllerQueryParams(controllerDefinedQueryParameterConfiguration);
       combinedQueryParameterConfiguration = mergeEachQueryParams(normalizedControllerQueryParameterConfiguration, queryParameterConfiguraton);
@@ -1298,7 +1304,7 @@ function buildRenderOptions(route, nameOrOptions, options) {
   let owner = getOwner(route);
   assert('Route is unexpectedly missing an owner', owner);
   let name, templateName, into, outlet, model;
-  let controller = undefined;
+  let controller;
 
   if (options) {
     into = options.into && options.into.replace(/\//g, '.');
@@ -1331,6 +1337,8 @@ function buildRenderOptions(route, nameOrOptions, options) {
     assert(`You passed \`controller: '${controllerName}'\` into the \`render\` method, but no such controller could be found.`, isDefaultRender || controller !== undefined);
   }
 
+  assert('Expected an instance of controller', controller instanceof Controller);
+
   if (model === undefined) {
     model = route.currentModel;
   } else {

package/dist/packages/@ember/-internals/routing/lib/system/router.js

@@ -1,6 +1,7 @@
 import { privatize as P } from '@ember/-internals/container';
 import { computed, get, set } from '@ember/-internals/metal';
 import { getOwner } from '@ember/-internals/owner';
+import { BucketCache } from '@ember/-internals/routing';
 import { A as emberA, Evented, Object as EmberObject, typeOf } from '@ember/-internals/runtime';
 import { assert, deprecate, info } from '@ember/debug';
 import EmberError from '@ember/error';
@@ -16,6 +17,7 @@ import RouterState from './router_state';
 */
 
 import Router, { logAbort, STATE_SYMBOL } from 'router_js';
+import EngineInstance from '@ember/engine/instance';
 
 function defaultDidTransition(infos) {
   updatePaths(this);
@@ -77,7 +79,7 @@ const {
 
 class EmberRouter extends EmberObject.extend(Evented) {
   constructor(owner) {
-    super(...arguments);
+    super(owner);
     this._didSetupRouter = false;
     this._initialTransitionStarted = false;
     this.currentURL = null;
@@ -99,7 +101,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
 
     this.namespace = owner.lookup('application:main');
     let bucketCache = owner.lookup(P`-bucket-cache:main`);
-    assert('BUG: BucketCache should always be present', bucketCache !== undefined);
+    assert('BUG: BucketCache should always be present', bucketCache instanceof BucketCache);
     this._bucketCache = bucketCache;
     let routerService = owner.lookup('service:router');
     assert('BUG: RouterService should always be present', routerService !== undefined);
@@ -1221,7 +1223,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
 
     if (!engineInstance) {
       let owner = getOwner(this);
-      assert('Router is unexpectedly missing an owner', owner);
+      assert('Expected router to have EngineInstance as owner', owner instanceof EngineInstance);
       assert(`You attempted to mount the engine '${name}' in your router map, but the engine can not be found.`, owner.hasRegistration(`engine:${name}`));
       engineInstance = owner.buildChildEngineInstance(name, {
         routable: true,
@@ -1526,16 +1528,6 @@ function updatePaths(router) {
   set(router, 'currentPath', path);
   set(router, 'currentRouteName', currentRouteName);
   set(router, 'currentURL', currentURL);
-  let owner = getOwner(router);
-  assert('Router is unexpectedly missing an owner', owner);
-  let appController = owner.lookup('controller:application');
-
-  if (!appController) {
-    // appController might not exist when top-level loading/error
-    // substates have been entered since ApplicationRoute hasn't
-    // actually been entered at that point.
-    return;
-  }
 }
 
 function didBeginTransition(transition, router) {

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

@@ -1,6 +1,7 @@
 import { get } from '@ember/-internals/metal';
 import { getOwner } from '@ember/-internals/owner';
 import { assert, deprecate } from '@ember/debug';
+import EngineInstance from '@ember/engine/instance';
 import EmberError from '@ember/error';
 import { STATE_SYMBOL } from 'router_js';
 const ALL_PERIODS_REGEX = /\./g;
@@ -219,7 +220,7 @@ export function resemblesURL(str) {
 export function prefixRouteNameArg(route, args) {
   let routeName;
   let owner = getOwner(route);
-  assert('Route is unexpectedly missing an owner', owner);
+  assert('Expected route to have EngineInstance as owner', owner instanceof EngineInstance);
   let prefix = owner.mountPoint; // only alter the routeName if it's actually referencing a route.
 
   if (owner.routable && typeof args[0] === 'string') {

package/dist/packages/@ember/-internals/runtime/lib/mixins/container_proxy.js

@@ -15,7 +15,7 @@ import { Mixin } from '@ember/-internals/metal';
 let containerProxyMixin = {
   /**
    The container stores state.
-      @private
+    @private
    @property {Ember.Container} __container__
    */
   __container__: null,
@@ -23,16 +23,16 @@ let containerProxyMixin = {
   /**
    Returns an object that can be used to provide an owner to a
    manually created instance.
-      Example:
-      ```
+    Example:
+    ```
    import { getOwner } from '@ember/application';
-      let owner = getOwner(this);
-      User.create(
+    let owner = getOwner(this);
+    User.create(
      owner.ownerInjection(),
      { username: 'rwjblue' }
    )
    ```
-      @public
+    @public
    @method ownerInjection
    @since 2.3.0
    @return {Object}
@@ -43,30 +43,30 @@ let containerProxyMixin = {
 
   /**
    Given a fullName return a corresponding instance.
-      The default behavior is for lookup to return a singleton instance.
+    The default behavior is for lookup to return a singleton instance.
    The singleton is scoped to the container, allowing multiple containers
    to all have their own locally scoped singletons.
-      ```javascript
+    ```javascript
    let registry = new Registry();
    let container = registry.container();
-      registry.register('api:twitter', Twitter);
-      let twitter = container.lookup('api:twitter');
-      twitter instanceof Twitter; // => true
-      // by default the container will return singletons
+    registry.register('api:twitter', Twitter);
+    let twitter = container.lookup('api:twitter');
+    twitter instanceof Twitter; // => true
+    // by default the container will return singletons
    let twitter2 = container.lookup('api:twitter');
    twitter2 instanceof Twitter; // => true
-      twitter === twitter2; //=> true
+    twitter === twitter2; //=> true
    ```
-      If singletons are not wanted an optional flag can be provided at lookup.
-      ```javascript
+    If singletons are not wanted an optional flag can be provided at lookup.
+    ```javascript
    let registry = new Registry();
    let container = registry.container();
-      registry.register('api:twitter', Twitter);
-      let twitter = container.lookup('api:twitter', { singleton: false });
+    registry.register('api:twitter', Twitter);
+    let twitter = container.lookup('api:twitter', { singleton: false });
    let twitter2 = container.lookup('api:twitter', { singleton: false });
-      twitter === twitter2; //=> false
+    twitter === twitter2; //=> false
    ```
-      @public
+    @public
    @method lookup
    @param {String} fullName
    @param {Object} options
@@ -91,32 +91,32 @@ let containerProxyMixin = {
 
   /**
   Given a fullName return a factory manager.
-     This method returns a manager which can be used for introspection of the
+   This method returns a manager which can be used for introspection of the
   factory's class or for the creation of factory instances with initial
   properties. The manager is an object with the following properties:
-     * `class` - The registered or resolved class.
+   * `class` - The registered or resolved class.
   * `create` - A function that will create an instance of the class with
     any dependencies injected.
-     For example:
-     ```javascript
+   For example:
+   ```javascript
   import { getOwner } from '@ember/application';
-     let owner = getOwner(otherInstance);
+   let owner = getOwner(otherInstance);
   // the owner is commonly the `applicationInstance`, and can be accessed via
   // an instance initializer.
-     let factory = owner.factoryFor('service:bespoke');
-     factory.class;
+   let factory = owner.factoryFor('service:bespoke');
+   factory.class;
   // The registered or resolved class. For example when used with an Ember-CLI
   // app, this would be the default export from `app/services/bespoke.js`.
-     let instance = factory.create({
+   let instance = factory.create({
     someProperty: 'an initial property value'
   });
   // Create an instance with any injections and the passed options as
   // initial properties.
   ```
-     Any instances created via the factory's `.create()` method *must* be destroyed
+   Any instances created via the factory's `.create()` method *must* be destroyed
   manually by the caller of `.create()`. Typically, this is done during the creating
   objects own `destroy` or `willDestroy` methods.
-     @public
+   @public
   @method factoryFor
   @param {String} fullName
   @param {Object} options