ember-source 4.1.0-alpha.2 → 4.1.0-alpha.6

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.1.0-alpha.2
+ * @version   4.1.0-alpha.6
  */

package/dist/header/loader.js

@@ -1,5 +1,6 @@
 /* eslint-disable no-var */
 /* globals global globalThis self */
+/* eslint-disable-next-line no-unused-vars */
 var define, require;
 
 (function () {

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

@@ -1,6 +1,6 @@
 import { setOwner } from '@ember/-internals/owner';
 import { dictionary, symbol, intern } from '@ember/-internals/utils';
-import { assert } from '@ember/debug';
+import { assert, deprecate } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 
 let leakTracking;
@@ -347,53 +347,6 @@ function instantiateFactory(container, normalizedName, fullName, options) {
   throw new Error('Could not create factory');
 }
 
-function processInjections(container, injections, result) {
-  if (DEBUG) {
-    container.registry.validateInjections(injections);
-  }
-
-  let hash = result.injections;
-
-  for (let i = 0; i < injections.length; i++) {
-    let {
-      property,
-      specifier
-    } = injections[i];
-    hash[property] = lookup(container, specifier);
-
-    if (!result.isDynamic) {
-      result.isDynamic = !isSingleton(container, specifier);
-    }
-  }
-}
-
-function buildInjections(container, typeInjections, injections) {
-  let injectionsHash = {};
-  setOwner(injectionsHash, container.owner);
-  let result = {
-    injections: injectionsHash,
-    isDynamic: false
-  };
-
-  if (typeInjections !== undefined) {
-    processInjections(container, typeInjections, result);
-  }
-
-  if (injections !== undefined) {
-    processInjections(container, injections, result);
-  }
-
-  return result;
-}
-
-function injectionsFor(container, fullName) {
-  let registry = container.registry;
-  let [type] = fullName.split(':');
-  let typeInjections = registry.getTypeInjections(type);
-  let injections = registry.getInjections(fullName);
-  return buildInjections(container, typeInjections, injections);
-}
-
 function destroyDestroyables(container) {
   let cache = container.cache;
   let keys = Object.keys(cache);
@@ -445,7 +398,7 @@ class FactoryManager {
     this.injections = undefined;
     setFactoryFor(this, this);
 
-    if (factory) {
+    if (isInstantiatable(container, fullName)) {
       setFactoryFor(factory, this);
     }
   }
@@ -467,20 +420,9 @@ class FactoryManager {
       throw new Error(`Can not create new instances after the owner has been destroyed (you attempted to create ${this.fullName})`);
     }
 
-    let props = this.injections;
-
-    if (props === undefined) {
-      let {
-        injections,
-        isDynamic
-      } = injectionsFor(this.container, this.normalizedName);
-      setFactoryFor(injections, this);
-      props = injections;
-
-      if (!isDynamic) {
-        this.injections = injections;
-      }
-    }
+    let props = {};
+    setOwner(props, container.owner);
+    setFactoryFor(props, this);
 
     if (options !== undefined) {
       props = Object.assign({}, props, options);
@@ -525,8 +467,6 @@ class Registry {
     this.fallback = options.fallback || null;
     this.resolver = options.resolver || null;
     this.registrations = dictionary(options.registrations || null);
-    this._typeInjections = dictionary(null);
-    this._injections = dictionary(null);
     this._localLookupCache = Object.create(null);
     this._normalizeCache = dictionary(null);
     this._resolveCache = dictionary(null);
@@ -554,18 +494,6 @@ class Registry {
    @type InheritingDict
    */
 
-  /**
-   @private
-      @property _typeInjections
-   @type InheritingDict
-   */
-
-  /**
-   @private
-      @property _injections
-   @type InheritingDict
-   */
-
   /**
    @private
       @property _normalizeCache
@@ -864,93 +792,27 @@ class Registry {
     return undefined;
   }
   /**
-   Used only via `injection`.
-      Provides a specialized form of injection, specifically enabling
-   all objects of one type to be injected with a reference to another
-   object.
-      For example, provided each object of type `controller` needed a `router`.
-   one would do the following:
-      ```javascript
-   let registry = new Registry();
-   let container = registry.container();
-      registry.register('router:main', Router);
-   registry.register('controller:user', UserController);
-   registry.register('controller:post', PostController);
-      registry.typeInjection('controller', 'router', 'router:main');
-      let user = container.lookup('controller:user');
-   let post = container.lookup('controller:post');
-      user.router instanceof Router; //=> true
-   post.router instanceof Router; //=> true
-      // both controllers share the same router
-   user.router === post.router; //=> true
-   ```
-      @private
-   @method typeInjection
-   @param {String} type
-   @param {String} property
-   @param {String} fullName
-   */
-
-
-  typeInjection(type, property, fullName) {
-    assert('fullName must be a proper full name', this.isValidFullName(fullName));
-    let fullNameType = fullName.split(':')[0];
-    assert(`Cannot inject a '${fullName}' on other ${type}(s).`, fullNameType !== type);
-    let injections = this._typeInjections[type] || (this._typeInjections[type] = []);
-    injections.push({
-      property,
-      specifier: fullName
-    });
-  }
-  /**
-   Defines injection rules.
-      These rules are used to inject dependencies onto objects when they
-   are instantiated.
-      Two forms of injections are possible:
-      * Injecting one fullName on another fullName
-   * Injecting one fullName on a type
-      Example:
-      ```javascript
-   let registry = new Registry();
-   let container = registry.container();
-      registry.register('source:main', Source);
-   registry.register('model:user', User);
-   registry.register('model:post', Post);
-      // injecting one fullName on another fullName
-   // eg. each user model gets a post model
-   registry.injection('model:user', 'post', 'model:post');
-      // injecting one fullName on another type
-   registry.injection('model', 'source', 'source:main');
-      let user = container.lookup('model:user');
-   let post = container.lookup('model:post');
-      user.source instanceof Source; //=> true
-   post.source instanceof Source; //=> true
-      user.post instanceof Post; //=> true
-      // and both models share the same source
-   user.source === post.source; //=> true
+   This is deprecated in favor of explicit injection of dependencies.
+      Reference: https://deprecations.emberjs.com/v3.x#toc_implicit-injections
    ```
       @private
    @method injection
    @param {String} factoryName
    @param {String} property
    @param {String} injectionName
+   @deprecated
    */
 
 
-  injection(fullName, property, injectionName) {
-    assert(`Invalid injectionName, expected: 'type:name' got: ${injectionName}`, this.isValidFullName(injectionName));
-    let normalizedInjectionName = this.normalize(injectionName);
-
-    if (fullName.indexOf(':') === -1) {
-      return this.typeInjection(fullName, property, normalizedInjectionName);
-    }
-
-    assert('fullName must be a proper full name', this.isValidFullName(fullName));
-    let normalizedName = this.normalize(fullName);
-    let injections = this._injections[normalizedName] || (this._injections[normalizedName] = []);
-    injections.push({
-      property,
-      specifier: normalizedInjectionName
+  injection(fullName, property) {
+    deprecate(`As of Ember 4.0.0, owner.inject no longer injects values into resolved instances, and calling the method has been deprecated. Since this method no longer does anything, it is fully safe to remove this injection. As an alternative to this API, you can refactor to explicitly inject \`${property}\` on \`${fullName}\`, or look it up directly using the \`getOwner\` API.`, false, {
+      id: 'remove-owner-inject',
+      until: '5.0.0',
+      url: 'https://deprecations.emberjs.com/v4.x#toc_implicit-injections',
+      for: 'ember-source',
+      since: {
+        enabled: '4.0.0'
+      }
     });
   }
   /**
@@ -990,34 +852,6 @@ class Registry {
     return VALID_FULL_NAME_REGEXP.test(fullName);
   }
 
-  getInjections(fullName) {
-    let injections = this._injections[fullName];
-
-    if (this.fallback !== null) {
-      let fallbackInjections = this.fallback.getInjections(fullName);
-
-      if (fallbackInjections !== undefined) {
-        injections = injections === undefined ? fallbackInjections : injections.concat(fallbackInjections);
-      }
-    }
-
-    return injections;
-  }
-
-  getTypeInjections(type) {
-    let injections = this._typeInjections[type];
-
-    if (this.fallback !== null) {
-      let fallbackInjections = this.fallback.getTypeInjections(type);
-
-      if (fallbackInjections !== undefined) {
-        injections = injections === undefined ? fallbackInjections : injections.concat(fallbackInjections);
-      }
-    }
-
-    return injections;
-  }
-
 }
 
 if (DEBUG) {

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

@@ -145,18 +145,6 @@ const ENV = {
   */
   _DEBUG_RENDER_TREE: DEBUG,
 
-  /**
-    Whether the app is using jQuery. See RFC #294.
-       This is not intended to be set directly, as the implementation may change in
-    the future. Use `@ember/optional-features` instead.
-       @property _JQUERY_INTEGRATION
-    @for EmberENV
-    @type Boolean
-    @default true
-    @private
-  */
-  _JQUERY_INTEGRATION: true,
-
   /**
     Whether the app defaults to using async observers.
        This is not intended to be set directly, as the implementation may change in

package/dist/packages/@ember/-internals/extension-support/lib/container_debug_adapter.js

@@ -1,5 +1,6 @@
 import { classify, dasherize } from '@ember/string';
 import { A as emberA, typeOf, Namespace, Object as EmberObject } from '@ember/-internals/runtime';
+import { getOwner } from '@ember/-internals/owner';
 /**
 @module @ember/debug
 */
@@ -40,6 +41,12 @@ import { A as emberA, typeOf, Namespace, Object as EmberObject } from '@ember/-i
 */
 
 export default EmberObject.extend({
+  init() {
+    this._super(...arguments);
+
+    this.resolver = getOwner(this).lookup('resolver-for-debugging:main');
+  },
+
   /**
     The resolver instance of the application
     being debugged. This property will be injected

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

@@ -19,7 +19,7 @@ export { DOMChanges, DOMTreeConstruction, isSerializationFirstNode } from '@glim
 import { CoreObject, TargetActionSupport, FrameworkObject, _contentFor, isArray } from '@ember/-internals/runtime';
 import { hasDOM } from '@ember/-internals/browser-environment';
 import { getEngineParent } from '@ember/engine';
-import { inject } from '@ember/service';
+import { service } from '@ember/service';
 import { action } from '@ember/object';
 import { ENV } from '@ember/-internals/environment';
 import { getFactoryFor, privatize } from '@ember/-internals/container';
@@ -452,7 +452,7 @@ const ACTIONS = new _WeakSet();
 
   ```app/controllers/application.js
   import Controller from '@ember/controller';
-  import { inject as service } from '@ember/service';
+  import { service } from '@ember/service';
 
   export default class extends Controller {
     @service someService;
@@ -1743,34 +1743,6 @@ const Component = CoreView.extend(ChildViewsSupport, ViewStateSupport, ClassName
       assert( // tslint:disable-next-line:max-line-length
       `You can not define \`${eventNames}\` function(s) to handle DOM event in the \`${this}\` tagless component since it doesn't have any DOM element.`, !eventNames.length);
     }
-
-    deprecate(`${this}: Using \`mouseEnter\` event handler methods in components has been deprecated.`, this.mouseEnter === undefined, {
-      id: 'ember-views.event-dispatcher.mouseenter-leave-move',
-      until: '4.0.0',
-      url: 'https://deprecations.emberjs.com/v3.x#toc_component-mouseenter-leave-move',
-      for: 'ember-source',
-      since: {
-        enabled: '3.13.0-beta.1'
-      }
-    });
-    deprecate(`${this}: Using \`mouseLeave\` event handler methods in components has been deprecated.`, this.mouseLeave === undefined, {
-      id: 'ember-views.event-dispatcher.mouseenter-leave-move',
-      until: '4.0.0',
-      url: 'https://deprecations.emberjs.com/v3.x#toc_component-mouseenter-leave-move',
-      for: 'ember-source',
-      since: {
-        enabled: '3.13.0-beta.1'
-      }
-    });
-    deprecate(`${this}: Using \`mouseMove\` event handler methods in components has been deprecated.`, this.mouseMove === undefined, {
-      id: 'ember-views.event-dispatcher.mouseenter-leave-move',
-      until: '4.0.0',
-      url: 'https://deprecations.emberjs.com/v3.x#toc_component-mouseenter-leave-move',
-      for: 'ember-source',
-      since: {
-        enabled: '3.13.0-beta.1'
-      }
-    });
   },
 
   get _dispatcher() {
@@ -2047,8 +2019,11 @@ setInternalComponentManager(CURLY_COMPONENT_MANAGER, Component);
         deprecate('Reopening the Ember.Component super class itself is deprecated. ' + 'Consider alternatives such as installing event listeners on ' + 'the document or add the customizations to specific subclasses.', false, {
           id: 'ember.component.reopen',
           for: 'ember-source',
-          since: {},
-          until: '4.0.0'
+          since: {
+            enabled: '4.0.0'
+          },
+          url: 'https://deprecations.emberjs.com/v4.x#toc_ember-component-reopen',
+          until: '5.0.0'
         });
         Component._wasReopened = true;
       }
@@ -2065,8 +2040,11 @@ setInternalComponentManager(CURLY_COMPONENT_MANAGER, Component);
         deprecate('Reopening the Ember.Component super class itself is deprecated. ' + 'Consider alternatives such as installing event listeners on ' + 'the document or add the customizations to specific subclasses.', false, {
           id: 'ember.component.reopen',
           for: 'ember-source',
-          since: {},
-          until: '4.0.0'
+          url: 'https://deprecations.emberjs.com/v4.x#toc_ember-component-reopen',
+          since: {
+            enabled: '4.0.0'
+          },
+          until: '5.0.0'
         });
         Component._wasReopened = true;
       }
@@ -3031,7 +3009,7 @@ const LinkComponent = Component.extend({
     this.on(eventName, this, this._invoke);
   },
 
-  _routing: inject('-routing'),
+  _routing: service('-routing'),
   _currentRoute: alias('_routing.currentRouteName'),
   _currentRouterState: alias('_routing.currentState'),
   _targetRouterState: alias('_routing.targetState'),
@@ -4733,7 +4711,7 @@ let Helper = FrameworkObject.extend({
     session service changes:
        ```app/helpers/current-user-email.js
     import Helper from '@ember/component/helper'
-    import { inject as service } from '@ember/service'
+    import { service } from '@ember/service'
     import { observer } from '@ember/object'
        export default Helper.extend({
       session: service(),
@@ -6409,17 +6387,7 @@ class ActionModifierManager {
     }
 
     let actionId = uuid();
-    let actionState = new ActionState(element, owner, actionId, actionArgs, named, positional);
-    deprecate(`Using the \`{{action}}\` modifier with \`${actionState.eventName}\` events has been deprecated.`, actionState.eventName !== 'mouseEnter' && actionState.eventName !== 'mouseLeave' && actionState.eventName !== 'mouseMove', {
-      id: 'ember-views.event-dispatcher.mouseenter-leave-move',
-      until: '4.0.0',
-      url: 'https://deprecations.emberjs.com/v3.x#toc_action-mouseenter-leave-move',
-      for: 'ember-source',
-      since: {
-        enabled: '3.13.0-beta.1'
-      }
-    });
-    return actionState;
+    return new ActionState(element, owner, actionId, actionArgs, named, positional);
   }
 
   getDebugName() {
@@ -7277,7 +7245,7 @@ class Renderer {
     this._destroyed = false;
     this._owner = owner;
     this._rootTemplate = rootTemplate(owner);
-    this._viewRegistry = viewRegistry;
+    this._viewRegistry = viewRegistry || owner.lookup('-view-registry:main');
     this._roots = [];
     this._removedRoots = [];
     this._builder = builder;
@@ -7295,12 +7263,13 @@ class Renderer {
 
   static create(props) {
     let {
-      document,
-      env,
-      rootTemplate,
-      _viewRegistry,
-      builder
+      _viewRegistry
     } = props;
+    let document = getOwner(props).lookup('service:-document');
+    let env = getOwner(props).lookup('-environment:main');
+    let owner = getOwner(props);
+    let rootTemplate = owner.lookup(privatize`template:-root`);
+    let builder = owner.lookup('service:-dom-builder');
     return new this(getOwner(props), document, env, rootTemplate, _viewRegistry, builder);
   }
 
@@ -7858,7 +7827,7 @@ class LinkTo extends InternalComponent {
 
 }
 
-__decorate$3([inject('-routing')], LinkTo.prototype, "routing", void 0);
+__decorate$3([service('-routing')], LinkTo.prototype, "routing", void 0);
 
 __decorate$3([action], LinkTo.prototype, "click", null); // Deprecated features
 
@@ -8039,6 +8008,7 @@ __decorate$3([action], LinkTo.prototype, "click", null); // Deprecated features
             deprecate('Passing the `@disabledWhen` argument to <LinkTo> is deprecated. ' + 'Use the `@disabled` argument instead.', false, {
               id: 'ember.link-to.disabled-when',
               for: 'ember-source',
+              url: 'https://deprecations.emberjs.com/v4.x#toc_ember-link-to-disabled-when',
               since: {},
               until: '4.0.0'
             });
@@ -8060,6 +8030,7 @@ __decorate$3([action], LinkTo.prototype, "click", null); // Deprecated features
           deprecate('Passing the `@disabledWhen` argument to <LinkTo> is deprecated. ' + 'Use the `@disabled` argument instead.', false, {
             id: 'ember.link-to.disabled-when',
             for: 'ember-source',
+            url: 'https://deprecations.emberjs.com/v4.x#toc_ember-link-to-disabled-when',
             since: {},
             until: '4.0.0'
           });
@@ -8163,10 +8134,11 @@ var OutletTemplate = templateFactory({
 const TOP_LEVEL_NAME = '-top-level';
 const TOP_LEVEL_OUTLET = 'main';
 class OutletView {
-  constructor(_environment, owner, template) {
+  constructor(_environment, owner, template, namespace) {
     this._environment = _environment;
     this.owner = owner;
     this.template = template;
+    this.namespace = namespace;
     let outletStateTag = createTag();
     let outletState = {
       outlets: {
@@ -8218,12 +8190,13 @@ class OutletView {
 
   static create(options) {
     let {
-      _environment,
+      environment: _environment,
+      application: namespace,
       template: templateFactory$$1
     } = options;
     let owner = getOwner(options);
     let template = templateFactory$$1(owner);
-    return new OutletView(_environment, owner, template);
+    return new OutletView(_environment, owner, template, namespace);
   }
 
   appendTo(selector) {
@@ -8254,19 +8227,14 @@ class OutletView {
 }
 
 function setupApplicationRegistry(registry) {
-  registry.injection('renderer', 'env', '-environment:main'); // because we are using injections we can't use instantiate false
+  // because we are using injections we can't use instantiate false
   // we need to use bind() to copy the function so factory for
   // association won't leak
-
   registry.register('service:-dom-builder', {
-    create({
-      bootOptions
-    }) {
-      let {
-        _renderMode
-      } = bootOptions;
+    create(props) {
+      let env = getOwner(props).lookup('-environment:main');
 
-      switch (_renderMode) {
+      switch (env._renderMode) {
         case 'serialize':
           return serializeBuilder.bind(null);
 
@@ -8279,12 +8247,8 @@ function setupApplicationRegistry(registry) {
     }
 
   });
-  registry.injection('service:-dom-builder', 'bootOptions', '-environment:main');
-  registry.injection('renderer', 'builder', 'service:-dom-builder');
   registry.register(privatize`template:-root`, RootTemplate);
-  registry.injection('renderer', 'rootTemplate', privatize`template:-root`);
   registry.register('renderer:-dom', Renderer);
-  registry.injection('renderer', 'document', 'service:-document');
 }
 function setupEngineRegistry(registry) {
   registry.optionsForType('template', {
@@ -8292,7 +8256,6 @@ function setupEngineRegistry(registry) {
   });
   registry.register('view:-outlet', OutletView);
   registry.register('template:-outlet', OutletTemplate);
-  registry.injection('view:-outlet', 'template', 'template:-outlet');
   registry.optionsForType('helper', {
     instantiate: false
   });

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

@@ -2241,7 +2241,7 @@ function isEmpty(obj) {
     return none;
   }
 
-  if (typeof obj.size === 'number') {
+  if (typeof obj.unknownProperty !== 'function' && typeof obj.size === 'number') {
     return !obj.size;
   }
 
@@ -3478,6 +3478,69 @@ class TrackedDescriptor {
 
 }
 
+// NOTE: copied from: https://github.com/glimmerjs/glimmer.js/pull/358
+/**
+ * @decorator
+ *
+ * The `@cached` decorator can be used on getters in order to cache the return
+ * value of the getter. This is useful when a getter is expensive and used very
+ * often.
+ *
+ *
+ * @example
+ *
+ * in this guest list class, we have the `sortedGuests`
+ * getter that sorts the guests alphabetically:
+ *
+ * ```js
+ * import { tracked } from '@glimmer/tracking';
+ *
+ * class GuestList {
+ *   @tracked guests = ['Zoey', 'Tomster'];
+ *
+ *   get sortedGuests() {
+ *     return this.guests.slice().sort()
+ *   }
+ * }
+ * ```
+ *
+ * Every time `sortedGuests` is accessed, a new array will be created and sorted,
+ * because JavaScript getters do not cache by default. When the guest list is
+ * small, like the one in the example, this is not a problem. However, if the guest
+ * list were to grow very large, it would mean that we would be doing a large
+ * amount of work each time we accessed `sortedGetters`. With `@cached`, we can
+ * cache the value instead:
+ *
+ * ```js
+ * import { tracked, cached } from '@glimmer/tracking';
+ *
+ * class GuestList {
+ *   @tracked guests = ['Zoey', 'Tomster'];
+ *
+ *   @cached
+ *   get sortedGuests() {
+ *     return this.guests.slice().sort()
+ *   }
+ * }
+ * ```
+ *
+ * Now the `sortedGuests` getter will be cached based on _autotracking_. It will
+ * only rerun and create a new sorted array when the `guests` tracked property is
+ * updated.
+ *
+ * In general, you should avoid using `@cached` unless you have confirmed that the
+ * getter you are decorating is computationally expensive. `@cached` adds a small
+ * amount of overhead to the getter, making it more expensive. While this overhead
+ * is small, if `@cached` is overused it can add up to a large impact overall in
+ * your app. Many getters and tracked properties are only accessed once, rendered,
+ * and then never rerendered, so adding `@cached` when it is unnecessary can
+ * negatively impact performance.
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+
+const cached = (...args) => {
+};
+
 /**
   Ember uses caching based on trackable values to avoid updating large portions
   of the application. This caching is exposed via a cache primitive that can be
@@ -3600,4 +3663,4 @@ class TrackedDescriptor {
   @public
 */
 
-export { computed, autoComputed, isComputed, ComputedProperty, getCachedValueFor, alias, deprecateProperty, PROXY_CONTENT, _getPath, get, _getProp, set, _setProp, trySet, objectAt, replace, replaceInNativeArray, addArrayObserver, removeArrayObserver, arrayContentWillChange, arrayContentDidChange, eachProxyArrayWillChange, eachProxyArrayDidChange, addListener, hasListeners, on, removeListener, sendEvent, isNone, isEmpty, isBlank, isPresent, beginPropertyChanges, changeProperties, endPropertyChanges, notifyPropertyChange, PROPERTY_DID_CHANGE, defineProperty, isElementDescriptor, nativeDescDecorator, descriptorForDecorator, descriptorForProperty, isClassicDecorator, setClassicDecorator, LIBRARIES as libraries, Libraries, getProperties, setProperties, expandProperties, ASYNC_OBSERVERS, SYNC_OBSERVERS, addObserver, activateObserver, removeObserver, flushAsyncObservers, Mixin, mixin, observer, applyMixin, inject, DEBUG_INJECTION_FUNCTIONS, tagForProperty, tagForObject, markObjectAsDirty, tracked, TrackedDescriptor, NAMESPACES, NAMESPACES_BY_ID, addNamespace, findNamespace, findNamespaces, processNamespace, processAllNamespaces, removeNamespace, isSearchDisabled as isNamespaceSearchDisabled, setSearchDisabled as setNamespaceSearchDisabled };
+export { computed, autoComputed, isComputed, ComputedProperty, getCachedValueFor, alias, deprecateProperty, PROXY_CONTENT, _getPath, get, _getProp, set, _setProp, trySet, objectAt, replace, replaceInNativeArray, addArrayObserver, removeArrayObserver, arrayContentWillChange, arrayContentDidChange, eachProxyArrayWillChange, eachProxyArrayDidChange, addListener, hasListeners, on, removeListener, sendEvent, isNone, isEmpty, isBlank, isPresent, beginPropertyChanges, changeProperties, endPropertyChanges, notifyPropertyChange, PROPERTY_DID_CHANGE, defineProperty, isElementDescriptor, nativeDescDecorator, descriptorForDecorator, descriptorForProperty, isClassicDecorator, setClassicDecorator, LIBRARIES as libraries, Libraries, getProperties, setProperties, expandProperties, ASYNC_OBSERVERS, SYNC_OBSERVERS, addObserver, activateObserver, removeObserver, flushAsyncObservers, Mixin, mixin, observer, applyMixin, inject, DEBUG_INJECTION_FUNCTIONS, tagForProperty, tagForObject, markObjectAsDirty, tracked, TrackedDescriptor, cached, NAMESPACES, NAMESPACES_BY_ID, addNamespace, findNamespace, findNamespaces, processNamespace, processAllNamespaces, removeNamespace, isSearchDisabled as isNamespaceSearchDisabled, setSearchDisabled as setNamespaceSearchDisabled };

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

@@ -197,6 +197,7 @@ ControllerMixin.reopen({
     @method replaceRoute
     @return {Transition} the transition object associated with this
       attempted transition
+    @deprecated Use replaceWith from the Router service instead.
     @public
   */
   replaceRoute(...args) {