Deprecations Added in Ember 5.x

Previously, if no Route#model hook was specified and a _id parameter was present, Ember would attempt to figure out how to load that model for you. Specify your own model hook to load from the store, if desired.

An optional feature, called no-implicit-route-model, can be turned on to clear this deprecation and opt in to the new behaviour. This optional feature is enabled in blueprints as of v5.7.0 and will be removed in v6.0.0. For more information, see the optional features guides.

For example:

import { Route } from '@ember/routing/route';
import { service } from '@ember/service';

export default class MyModelRoute extends Route {
  @service store;

  model({ my_model_id }) {
    return this.store.findRecord('my-model', my_model_id);
  }
}

For more background, read the RFC.

Scenario: action is passed a string

Before:

<button type="button" {{action "plusOne"}}>
  Click Me
</button>

After:

<button type="button" {{on 'click' this.plusOne}}>
  Click Me
</button>

or, if plusOne is passed in as an argument:

<button type="button" {{on 'click' @plusOne}}>
  Click Me
</button>

If the plusOne action is in an actions object, it needs to move out:

For Glimmer components

Before:

import Component from '@glimmer/component';

export default class Demo extends Component {
    actions = {
        plusOne() {
           /* ... */ 
        }
    }
}

After:

import Component from '@glimmer/component';
import { action } from '@ember/object';

export default class Demo extends Component {
    @action
    plusOne() {
       /* ... */ 
    }
}

or

For Classic Components with native classes

Before:

import Component from '@ember/component';

export default class Demo extends Component {
    doMath() {
      this.send('plusOne');
    }

    actions = {
        plusOne() {
           /* ... */ 
        }
    }
}

After:

import Component from '@ember/component';
import { action } from '@ember/object';

export default class Demo extends Component {
    doMath() {
      this.plusOne();
    }

    @action
    plusOne() {
       /* ... */ 
    }
}

or

For Classic Components with EmberObject.extend

Before:

import Component from '@ember/component';

export default Component.extend({
    actions: {
        plusOne() {
           /* ... */ 
        }
    }
})

After:

import Component from '@ember/component';
import { action } from '@ember/object';

export default Component.extend({
  plusOne: action(function() {
      /* ... */ 
  }),
})

If (action) or {{action}} is passed a string, it's possible that the referenced method is declared on the caller, and not the immediate component -- that is, (action) and {{action}} bubble up the render tree from route templates -> controllers -> routes.

Note that @action is completely different from (action) or {{action}} (and is partly a motivator for deprecating (action) and {{action}}, to reduce ambiguity).

@action binds the this on the method to the instance of the class.

Scenario: action is passed a function reference

Before:

<SomeComponent @update={{action this.plusOne}} />

After

<SomeComponent @update={{this.plusOne}} />

Scenario: action is passed parameters

Before:

<SomeComponent @update={{action this.plus 1}} />

After:

<SomeComponent @update={{fn this.plus 1}} />

Scenario: action is used with mut

Before:

<SomeComponent @update={{action (mut @value.property}} />

After:

// parent.js
import Component from '@glimmer/component';
import { action } from '@ember/object';

export default class SomeComponent extends Component {
    @action
    handleUpdate(value) {
        this.args.property = value; 
    }
}

{{! parent.hbs }}
<SomeComponent @update={{this.handleUpdate}} />

Related, Combining function arguments with action functions

For more background, read the RFC

There are two types of paths to migrate off the old layouts

• use a currently supported multi-file layout (keeping separate js, ts, and hbs files)
• migrate the component entirely to the latest component format, gjs, gts, (aka <template>)

There are some tools to help with this:

• Classic to Colocation
• Convert pods to Colocation

Specifically, these layouts are no longer supported:

{app,addon}/
  components/
    foo.js
    namespace/
      bar.js
  templates/
    components/
      foo.hbs
      namespace/
        bar.hbs

{app,addon}/
  components/
    foo/
      component.js
      template.hbs
    namespace/
      bar/
        component.js
        template.hbs

The above example(s) can be migrated to:

{app,addon}/
  components/
    foo.js 
    foo.hbs
    namespace/
      bar.js
      bar.hbs

Or using --component-structure=nested

{app,addon}/
  components/
    foo/
      index.js 
      index.hbs
    namespace/
      bar/
        index.js
        index.hbs

Note, however, that classic components importing the layout and setting it on an @ember/component will still work. The key thing being deprecated is the runtime resolution of templates, so if there is an import involved, there is no runtime resolution.

Previously, __loader could be accessed via the Ember import:

import Ember from 'ember';

Ember.__loader

There is no replacement for this API.

Previously, _action could be accessed via the Ember import:

import Ember from 'ember';

Ember._action

If needed, _action can be imported:

import { action } from '@ember/object';

Previously, _array could be accessed via the Ember import:

import Ember from 'ember';

Ember._array

If needed, _array can be imported:

import { array } from '@ember/helper';

Previously, _assertDestroyablesDestroyed could be accessed via the Ember import:

import Ember from 'ember';

Ember._assertDestroyablesDestroyed

If needed, _assertDestroyablesDestroyed can be imported:

import { assertDestroyablesDestroyed } from '@ember/destroyable';

Previously, _associateDestroyableChild could be accessed via the Ember import:

import Ember from 'ember';

Ember._associateDestroyableChild

If needed, _associateDestroyableChild can be imported:

import { associateDestroyableChild } from '@ember/destroyable';

Previously, _Backburner could be accessed via the Ember import:

import Ember from 'ember';

Ember._Backburner

_Backburner is also private.

There is no replacement for this API.

Previously, _Cache could be accessed via the Ember import:

import Ember from 'ember';

Ember._Cache

There is no replacement for this API.

Previously, _cacheGetValue could be accessed via the Ember import:

import Ember from 'ember';

Ember._cacheGetValue

If needed, _cacheGetValue can be imported:

import { getValue } from '@glimmer/tracking/primitives/cache';

Previously, _cacheIsConst could be accessed via the Ember import:

import Ember from 'ember';

Ember._cacheIsConst

If needed, _cacheIsConst can be imported:

import { isConst } from '@glimmer/tracking/primitives/cache';

Previously, _captureRenderTree could be accessed via the Ember import:

import Ember from 'ember';

Ember._captureRenderTree

_captureRenderTree is also private.

If needed, _captureRenderTree can be imported:

import { captureRenderTree } from '@ember/debug';

However, due to _captureRenderTree being private, it is not recommended, nor supported.

Previously, _componentManagerCapabilities could be accessed via the Ember import:

import Ember from 'ember';

Ember._componentManagerCapabilities

If needed, _componentManagerCapabilities can be imported:

import { capabilities } from '@ember/component';

Previously, _concat could be accessed via the Ember import:

import Ember from 'ember';

Ember._concat

If needed, _concat can be imported:

import { concat } from '@ember/helper';

Previously, _ContainerProxyMixin could be accessed via the Ember import:

import Ember from 'ember';

Ember._ContainerProxyMixin

_ContainerProxyMixin is also private.

There is no replacement for this API.

Previously, _createCache could be accessed via the Ember import:

import Ember from 'ember';

Ember._createCache

If needed, _createCache can be imported:

import { createCache } from '@glimmer/tracking/primitives/cache';

Previously, _dependentKeyCompat could be accessed via the Ember import:

import Ember from 'ember';

Ember._dependentKeyCompat

If needed, _dependentKeyCompat can be imported:

import { dependentKeyCompat } from '@ember/object/compat';

Previously, _descriptor could be accessed via the Ember import:

import Ember from 'ember';

Ember._descriptor

There is no replacement for this API.

Previously, _enableDestroyableTracking could be accessed via the Ember import:

import Ember from 'ember';

Ember._enableDestroyableTracking

If needed, _enableDestroyableTracking can be imported:

import { enableDestroyableTracking } from '@ember/destroyable';

Previously, _fn could be accessed via the Ember import:

import Ember from 'ember';

Ember._fn

If needed, _fn can be imported:

import { fn } from '@ember/helper';

Previously, _getComponentTemplate could be accessed via the Ember import:

import Ember from 'ember';

Ember._getComponentTemplate

If needed, _getComponentTemplate can be imported:

import { getComponentTemplate } from '@ember/component';

Previously, _get could be accessed via the Ember import:

import Ember from 'ember';

Ember._get

If needed, _get can be imported:

import { get } from '@ember/helper';

Previously, _getPath could be accessed via the Ember import:

import Ember from 'ember';

Ember._getPath

There is no replacement for this API.

Previously, _hash could be accessed via the Ember import:

import Ember from 'ember';

Ember._hash

If needed, _hash can be imported:

import { hash } from '@ember/helper';

Previously, _helperManagerCapabilities could be accessed via the Ember import:

import Ember from 'ember';

Ember._helperManagerCapabilities

If needed, _helperManagerCapabilities can be imported:

import { capabilities } from '@ember/helper';

Previously, _Input could be accessed via the Ember import:

import Ember from 'ember';

Ember._Input

If needed, _Input can be imported:

import { Input }  from '@ember/component';

Previously, _invokeHelper could be accessed via the Ember import:

import Ember from 'ember';

Ember._invokeHelper

If needed, _invokeHelper can be imported:

import { invokeHelper } from '@ember/helper';

Previously, _isDestroyed could be accessed via the Ember import:

import Ember from 'ember';

Ember._isDestroyed

If needed, _isDestroyed can be imported:

import { isDestroyed } from '@ember/destroyable';

Previously, _isDestroying could be accessed via the Ember import:

import Ember from 'ember';

Ember._isDestroying

If needed, _isDestroying can be imported:

import { isDestroying } from '@ember/destroyable';

Previously, _modifierManagerCapabilities could be accessed via the Ember import:

import Ember from 'ember';

Ember._modifierManagerCapabilities

If needed, _modifierManagerCapabilities can be imported:

import { capabilities } from '@ember/modifier';

Previously, _on could be accessed via the Ember import:

import Ember from 'ember';

Ember._on

If needed, _on can be imported:

import { on } from '@ember/modifier';

Previously, _ProxyMixin could be accessed via the Ember import:

import Ember from 'ember';

Ember._ProxyMixin

_ProxyMixin is also private.

There is no replacement for this API.

Previously, _registerDestructor could be accessed via the Ember import:

import Ember from 'ember';

Ember._registerDestructor

If needed, _registerDestructor can be imported:

import { registerDestructor } from '@ember/destroyable';

Previously, _RegistryProxyMixin could be accessed via the Ember import:

import Ember from 'ember';

Ember._RegistryProxyMixin

_RegistryProxyMixin is also private.

There is no replacement for this API.

Previously, _setClassicDecorator could be accessed via the Ember import:

import Ember from 'ember';

Ember._setClassicDecorator

_setClassicDecorator is also private.

There is no replacement for this API.

Previously, _setComponentManager could be accessed via the Ember import:

import Ember from 'ember';

Ember._setComponentManager

If needed, _setComponentManager can be imported:

import { setComponentManager } from '@ember/component';

Previously, _setComponentTemplate could be accessed via the Ember import:

import Ember from 'ember';

Ember._setComponentTemplate

If needed, _setComponentTemplate can be imported:

import { setComponentTemplate } from '@ember/component';

Previously, _setHelperManager could be accessed via the Ember import:

import Ember from 'ember';

Ember._setHelperManager

If needed, _setHelperManager can be imported:

import { setHelperManager } from '@ember/helper';

Previously, _setModifierManager could be accessed via the Ember import:

import Ember from 'ember';

Ember._setModifierManager

If needed, _setModifierManager can be imported:

import { setModifierManager } from '@ember/modifier';

Previously, _templateOnlyComponent could be accessed via the Ember import:

import Ember from 'ember';

Ember._templateOnlyComponent

If needed, _templateOnlyComponent can be imported:

import templateOnly from '@ember/component/template-only';

Previously, _tracked could be accessed via the Ember import:

import Ember from 'ember';

Ember._tracked

If needed, _tracked can be imported:

import { tracked } from '@glimmer/tracking';

Previously, _unregisterDestructor could be accessed via the Ember import:

import Ember from 'ember';

Ember._unregisterDestructor

If needed, _unregisterDestructor can be imported:

import { unregisterDestructor } from '@ember/destroyable';

Previously, A could be accessed via the Ember import:

import Ember from 'ember';

Ember.A

If needed, A can be imported:

import { A }  from '@ember/array';

Previously, ActionHandler could be accessed via the Ember import:

import Ember from 'ember';

Ember.ActionHandler

ActionHandler is also private.

There is no replacement for this API.

Previously, addListener could be accessed via the Ember import:

import Ember from 'ember';

Ember.addListener

If needed, addListener can be imported:

import { addListener } from '@ember/object/events';

Previously, addObserver could be accessed via the Ember import:

import Ember from 'ember';

Ember.addObserver

If needed, addObserver can be imported:

import { addObserver } from '@ember/object/observers';

Previously, Application could be accessed via the Ember import:

import Ember from 'ember';

Ember.Application

If needed, Application can be imported:

import Application from '@ember/application';

Previously, ApplicationInstance could be accessed via the Ember import:

import Ember from 'ember';

Ember.ApplicationInstance

If needed, ApplicationInstance can be imported:

import ApplicationInstance from '@ember/application/instance';

Previously, Array could be accessed via the Ember import:

import Ember from 'ember';

Ember.Array

If needed, Array can be imported:

import Array  from '@ember/array';

Previously, ArrayProxy could be accessed via the Ember import:

import Ember from 'ember';

Ember.ArrayProxy

If needed, ArrayProxy can be imported:

import ArrayProxy  from '@ember/array/proxy';

Previously, assert could be accessed via the Ember import:

import Ember from 'ember';

Ember.assert

If needed, assert can be imported:

import { assert } from '@ember/debug';

Previously, beginPropertyChanges could be accessed via the Ember import:

import Ember from 'ember';

Ember.beginPropertyChanges

beginPropertyChanges is also private.

There is no replacement for this API.

Previously, BOOTED could be accessed via the Ember import:

import Ember from 'ember';

Ember.BOOTED

BOOTED is also private.

There is no replacement for this API.

Previously, cacheFor could be accessed via the Ember import:

import Ember from 'ember';

Ember.cacheFor

There is no replacement for this API.

Previously, canInvoke could be accessed via the Ember import:

import Ember from 'ember';

Ember.canInvoke

canInvoke is also private.

There is no replacement for this API.

Previously, changeProperties could be accessed via the Ember import:

import Ember from 'ember';

Ember.changeProperties

changeProperties is also private.

There is no replacement for this API.

Previously, Comparable could be accessed via the Ember import:

import Ember from 'ember';

Ember.Comparable

Comparable is also private.

There is no replacement for this API.

Previously, compare could be accessed via the Ember import:

import Ember from 'ember';

Ember.compare

If needed, compare can be imported:

import { compare } from '@ember/utils';

Previously, Component could be accessed via the Ember import:

import Ember from 'ember';

Ember.Component

If needed, Component can be imported:

import Component  from '@ember/component';

Previously, computed could be accessed via the Ember import:

import Ember from 'ember';

Ember.computed

If needed, computed can be imported:

import { computed } from '@ember/object';

Previously, ComputedProperty could be accessed via the Ember import:

import Ember from 'ember';

Ember.ComputedProperty

There is no replacement for this API.

Previously, ContainerDebugAdapter could be accessed via the Ember import:

import Ember from 'ember';

Ember.ContainerDebugAdapter

If needed, ContainerDebugAdapter can be imported:

import ContainerDebugAdapter from '@ember/debug/container-debug-adapter';

Previously, Container could be accessed via the Ember import:

import Ember from 'ember';

Ember.Container

Container is also private.

There is no replacement for this API.

Previously, controllerFor could be accessed via the Ember import:

import Ember from 'ember';

Ember.controllerFor

controllerFor is also private.

There is no replacement for this API.

Previously, Controller could be accessed via the Ember import:

import Ember from 'ember';

Ember.Controller

If needed, Controller can be imported:

import Controller  from '@ember/controller';

Previously, ControllerMixin could be accessed via the Ember import:

import Ember from 'ember';

Ember.ControllerMixin

ControllerMixin is also private.

If needed, ControllerMixin can be imported:

import { ControllerMixin } from '@ember/controller';

However, due to ControllerMixin being private, it is not recommended, nor supported.

Previously, CoreObject could be accessed via the Ember import:

import Ember from 'ember';

Ember.CoreObject

If needed, CoreObject can be imported:

import EmberObject from '@ember/object';

Previously, DataAdapter could be accessed via the Ember import:

import Ember from 'ember';

Ember.DataAdapter

If needed, DataAdapter can be imported:

import DataAdapter from '@ember/debug/data-adapter';

Previously, debug could be accessed via the Ember import:

import Ember from 'ember';

Ember.debug

If needed, debug can be imported:

import { debug } from '@ember/debug';

Previously, defineProperty could be accessed via the Ember import:

import Ember from 'ember';

Ember.defineProperty

If needed, defineProperty can be imported:

import { defineProperty } from '@ember/object';

Previously, deprecate could be accessed via the Ember import:

import Ember from 'ember';

Ember.deprecate

If needed, deprecate can be imported:

import { deprecate } from '@ember/debug';

Previously, deprecateFunc could be accessed via the Ember import:

import Ember from 'ember';

Ember.deprecateFunc

If needed, deprecateFunc can be imported:

import { deprecateFunc } from '@ember/debug';

Previously, destroy could be accessed via the Ember import:

import Ember from 'ember';

Ember.destroy

If needed, destroy can be imported:

import { destroy } from '@ember/destroyable';

Previously, endPropertyChanges could be accessed via the Ember import:

import Ember from 'ember';

Ember.endPropertyChanges

endPropertyChanges is also private.

There is no replacement for this API.

Previously, Engine could be accessed via the Ember import:

import Ember from 'ember';

Ember.Engine

If needed, Engine can be imported:

import Engine from '@ember/engine';

Previously, EngineInstance could be accessed via the Ember import:

import Ember from 'ember';

Ember.EngineInstance

If needed, EngineInstance can be imported:

import Engine from '@ember/engine/instance';

Previously, Enumerable could be accessed via the Ember import:

import Ember from 'ember';

Ember.Enumerable

Enumerable is also private.

If needed, Enumerable can be imported:

import Enumerable from '@ember/enumerable';

However, due to Enumerable being private, it is not recommended, nor supported.

Previously, ENV could be accessed via the Ember import:

import Ember from 'ember';

Ember.ENV

If needed, ENV can be imported:

import MyEnv from '<my-app>/config/environment';

For addons, getting access to the environment requires having access to the owner:

import { getOwner } from '@ember/owner';

// ...

let env = getOwner(this).resolveRegistration('config:environment');

Previously, Evented could be accessed via the Ember import:

import Ember from 'ember';

Ember.Evented

If needed, Evented can be imported:

import Evented from '@ember/object/evented';

Previously, expandProperties could be accessed via the Ember import:

import Ember from 'ember';

Ember.expandProperties

If needed, expandProperties can be imported:

import { expandProperties } from '@ember/object/computed';

Previously, FEATURES could be accessed via the Ember import:

import Ember from 'ember';

Ember.FEATURES

If needed, FEATURES can be imported:

import { isEnabled, FEATURES } from '@ember/canary-features';

Previously, generateControllerFactory could be accessed via the Ember import:

import Ember from 'ember';

Ember.generateControllerFactory

generateControllerFactory is also private.

There is no replacement for this API.

Previously, generateController could be accessed via the Ember import:

import Ember from 'ember';

Ember.generateController

generateController is also private.

There is no replacement for this API.

Previously, generateGuid could be accessed via the Ember import:

import Ember from 'ember';

Ember.generateGuid

generateGuid is also private.

There is no replacement for this API.

Previously, get could be accessed via the Ember import:

import Ember from 'ember';

Ember.get

If needed, get can be imported:

import { get } from '@ember/object';

Previously, getOwner could be accessed via the Ember import:

import Ember from 'ember';

Ember.getOwner

If needed, getOwner can be imported:

import { getOwner } from '@ember/owner';

If you're working in a library and need to support earlier than ember-source@4.11, you may use @embroider/macros to selectively import from the old location

import {
  macroCondition,
  dependencySatisfies,
  importSync,
} from '@embroider/macros';

let getOwner;

if (macroCondition(dependencySatisfies('ember-source', '>= 4.11'))) {
  getOwner = importSync('@ember/owner').getOwner;
} else {
  getOwner = importSync('@ember/application').getOwner;
}

Previously, getProperties could be accessed via the Ember import:

import Ember from 'ember';

Ember.getProperties

If needed, getProperties can be imported:

import { getProperties } from '@ember/object';

Previously, guidFor could be accessed via the Ember import:

import Ember from 'ember';

Ember.guidFor

If needed, guidFor can be imported:

import { guidFor } from '@ember/object/internals';

Previously, GUID_KEY could be accessed via the Ember import:

import Ember from 'ember';

Ember.GUID_KEY

GUID_KEY is also private.

There is no replacement for this API.

Previously, Handlebars could be accessed via the Ember import:

import Ember from 'ember';

Ember.Handlebars

There is no replacement for this API.

Previously, hasListeners could be accessed via the Ember import:

import Ember from 'ember';

Ember.hasListeners

There is no replacement for this API.

Previously, HashLocation could be accessed via the Ember import:

import Ember from 'ember';

Ember.HashLocation

If needed, HashLocation can be imported:

import HashLocation from '@ember/routing/hash-location';

Previously, Helper could be accessed via the Ember import:

import Ember from 'ember';

Ember.Helper

If needed, Helper can be imported:

import Helper  from '@ember/component/helper';

Previously, HistoryLocation could be accessed via the Ember import:

import Ember from 'ember';

Ember.HistoryLocation

If needed, HistoryLocation can be imported:

import HistoryLocation from '@ember/routing/history-location';

Previously, HTMLBars could be accessed via the Ember import:

import Ember from 'ember';

Ember.HTMLBars

There is no replacement for this API.

Previously, inject could be accessed via the Ember import:

import Ember from 'ember';

Ember.inject

There is no replacement for this API.

Previously, inspect could be accessed via the Ember import:

import Ember from 'ember';

Ember.inspect

inspect is also private.

There is no replacement for this API.

Previously, instrument could be accessed via the Ember import:

import Ember from 'ember';

Ember.instrument

instrument is also private.

If needed, instrument can be imported:

import { instrument } from '@ember/instrumentation';

However, due to instrument being private, it is not recommended, nor supported.

Previously, Instrumentation could be accessed via the Ember import:

import Ember from 'ember';

Ember.Instrumentation

Instrumentation is also private.

If needed, Instrumentation can be imported:

import { * } from '@ember/instrumentation';

However, due to Instrumentation being private, it is not recommended, nor supported.

Previously, isArray could be accessed via the Ember import:

import Ember from 'ember';

Ember.isArray

If needed, isArray can be imported:

import { isArray }  from '@ember/array';

Previously, isBlank could be accessed via the Ember import:

import Ember from 'ember';

Ember.isBlank

If needed, isBlank can be imported:

import { isBlank } from '@ember/utils';

Previously, isEmpty could be accessed via the Ember import:

import Ember from 'ember';

Ember.isEmpty

If needed, isEmpty can be imported:

import { isEmpty } from '@ember/utils';

Previously, isEqual could be accessed via the Ember import:

import Ember from 'ember';

Ember.isEqual

If needed, isEqual can be imported:

import { isEqual } from '@ember/utils';

Previously, isNamespace could be accessed via the Ember import:

import Ember from 'ember';

Ember.isNamespace

There is no replacement for this API.

Previously, isPresent could be accessed via the Ember import:

import Ember from 'ember';

Ember.isPresent

If needed, isPresent can be imported:

import { isPresent } from '@ember/utils';

Previously, libraries could be accessed via the Ember import:

import Ember from 'ember';

Ember.libraries

There is no replacement for this API.

If needed, libraries can be imported from a private module:

import { libraries } from '@ember/-internals/metal';

Instead of using this import, consider using a build plugin for your packager. Some options:

• https://github.com/ubilabs/webpack-node-modules-list
• https://github.com/yjl9903/unplugin-info

These are both more automatic than Ember's libraries utility.

Previously, lookup could be accessed via the Ember import:

import Ember from 'ember';

Ember.lookup

There is no replacement for this API.

Previously, makeArray could be accessed via the Ember import:

import Ember from 'ember';

Ember.makeArray

makeArray is also private.

If needed, makeArray can be imported:

import { makeArray }  from '@ember/array';

However, due to makeArray being private, it is not recommended, nor supported.

Previously, meta could be accessed via the Ember import:

import Ember from 'ember';

Ember.meta

meta is also private.

If needed, meta can be imported:

import { meta } from '@ember/-internals/meta';

However, due to meta being private, it is not recommended, nor supported.

Previously, mixin could be accessed via the Ember import:

import Ember from 'ember';

Ember.mixin

mixin is also private.

If needed, mixin can be imported:

import { mixin } from '@ember/object/mixin';

However, due to mixin being private, it is not recommended, nor supported.

Previously, MutableArray could be accessed via the Ember import:

import Ember from 'ember';

Ember.MutableArray

If needed, MutableArray can be imported:

import MutableArray  from '@ember/array/mutable';

Previously, MutableEnumerable could be accessed via the Ember import:

import Ember from 'ember';

Ember.MutableEnumerable

MutableEnumerable is also private.

If needed, MutableEnumerable can be imported:

import MutableEnumerable from '@ember/enumerable/mutable';

However, due to MutableEnumerable being private, it is not recommended, nor supported.

Previously, Namespace could be accessed via the Ember import:

import Ember from 'ember';

Ember.Namespace

If needed, Namespace can be imported:

import Namespace from '@ember/application/namespace';

Previously, NativeArray could be accessed via the Ember import:

import Ember from 'ember';

Ember.NativeArray

If needed, NativeArray can be imported:

import { NativeArray }  from '@ember/array';

Previously, NoneLocation could be accessed via the Ember import:

import Ember from 'ember';

Ember.NoneLocation

If needed, NoneLocation can be imported:

import NoneLocation from '@ember/routing/none-location';

Previously, notifyPropertyChange could be accessed via the Ember import:

import Ember from 'ember';

Ember.notifyPropertyChange

If needed, notifyPropertyChange can be imported:

import { notifyPropertyChange } from '@ember/object';

Previously, Object could be accessed via the Ember import:

import Ember from 'ember';

Ember.Object

If needed, Object can be imported:

import Object from '@ember/object';

Previously, ObjectProxy could be accessed via the Ember import:

import Ember from 'ember';

Ember.ObjectProxy

If needed, ObjectProxy can be imported:

import ObjectProxy from '@ember/object/proxy';

Previously, Observable could be accessed via the Ember import:

import Ember from 'ember';

Ember.Observable

If needed, Observable can be imported:

import Observable from '@ember/object/observable';

Previously, observer could be accessed via the Ember import:

import Ember from 'ember';

Ember.observer

If needed, observer can be imported:

import { observer } from '@ember/object';

Previously, on could be accessed via the Ember import:

import Ember from 'ember';

Ember.on

If needed, on can be imported:

import { on } from '@ember/object/evented';

Previously, onLoad could be accessed via the Ember import:

import Ember from 'ember';

Ember.onLoad

If needed, onLoad can be imported:

import { onLoad } from '@ember/application';

Previously, onerror could be accessed via the Ember import:

import Ember from 'ember';

Ember.onerror

There is no replacement for this API.

Previously, PromiseProxyMixin could be accessed via the Ember import:

import Ember from 'ember';

Ember.PromiseProxyMixin

If needed, PromiseProxyMixin can be imported:

import EmberPromiseProxyMixin from '@ember/object/promise-proxy-mixin';

Previously, Registry could be accessed via the Ember import:

import Ember from 'ember';

Ember.Registry

Registry is also private.

There is no replacement for this API.

Previously, removeListener could be accessed via the Ember import:

import Ember from 'ember';

Ember.removeListener

If needed, removeListener can be imported:

import { removeListener } from '@ember/object/events';

Previously, removeObserver could be accessed via the Ember import:

import Ember from 'ember';

Ember.removeObserver

If needed, removeObserver can be imported:

import { removeObserver } from '@ember/object/observers';

Previously, Route could be accessed via the Ember import:

import Ember from 'ember';

Ember.Route

If needed, Route can be imported:

import Route from '@ember/routing/route';

Previously, RouterDSL could be accessed via the Ember import:

import Ember from 'ember';

Ember.RouterDSL

There is no replacement for this API.

Previously, RSVP could be accessed via the Ember import:

import Ember from 'ember';

Ember.RSVP

If needed, RSVP can be imported:

import RSVP from 'rsvp';

Previously, run could be accessed via the Ember import:

import Ember from 'ember';

Ember.run

If needed, run can be imported:

import { run } from '@ember/runloop';

Previously, runInDebug could be accessed via the Ember import:

import Ember from 'ember';

Ember.runInDebug

If needed, runInDebug can be imported:

import { runInDebug } from '@ember/debug';

Previously, runLoadHooks could be accessed via the Ember import:

import Ember from 'ember';

Ember.runLoadHooks

If needed, runLoadHooks can be imported:

import { runLoadHooks } from '@ember/application';

Previously, sendEvent could be accessed via the Ember import:

import Ember from 'ember';

Ember.sendEvent

If needed, sendEvent can be imported:

import { sendEvent } from '@ember/object/events';

Previously, Service could be accessed via the Ember import:

import Ember from 'ember';

Ember.Service

If needed, Service can be imported:

import Service from '@ember/service';

Previously, set could be accessed via the Ember import:

import Ember from 'ember';

Ember.set

If needed, set can be imported:

import { set } from '@ember/object';

Previously, setOwner could be accessed via the Ember import:

import Ember from 'ember';

Ember.setOwner

If needed, setOwner can be imported:

import { setOwner } from '@ember/owner';

If you're working in a library and need to support earlier than ember-source@4.11, you may use @embroider/macros to selectively import from the old location

import {
  macroCondition,
  dependencySatisfies,
  importSync,
} from '@embroider/macros';

let setOwner;

if (macroCondition(dependencySatisfies('ember-source', '>= 4.11'))) {
  setOwner = importSync('@ember/owner').setOwner;
} else {
  setOwner = importSync('@ember/application').setOwner;
}

Previously, setProperties could be accessed via the Ember import:

import Ember from 'ember';

Ember.setProperties

If needed, setProperties can be imported:

import { setProperties } from '@ember/object';

Previously, setupForTesting could be accessed via the Ember import:

import Ember from 'ember';

Ember.setupForTesting

There is no replacement for this API.

Previously, subscribe could be accessed via the Ember import:

import Ember from 'ember';

Ember.subscribe

subscribe is also private.

If needed, subscribe can be imported:

import { subscribe } from '@ember/instrumentation';

However, due to subscribe being private, it is not recommended, nor supported.

Previously, TEMPLATES could be accessed via the Ember import:

import Ember from 'ember';

Ember.TEMPLATES

TEMPLATES is also private.

There is no replacement for this API.

Previously, Test could be accessed via the Ember import:

import Ember from 'ember';

Ember.Test

There is no replacement for this API.

Previously, testing could be accessed via the Ember import:

import Ember from 'ember';

Ember.testing

There is no replacement for this API.

Previously, toString could be accessed via the Ember import:

import Ember from 'ember';

Ember.toString

There is no replacement for this API.

Previously, trySet could be accessed via the Ember import:

import Ember from 'ember';

Ember.trySet

If needed, trySet can be imported:

import { trySet } from '@ember/object';

Previously, typeOf could be accessed via the Ember import:

import Ember from 'ember';

Ember.typeOf

If needed, typeOf can be imported:

import { typeOf } from '@ember/utils';

Previously, uuid could be accessed via the Ember import:

import Ember from 'ember';

Ember.uuid

There is no replacement for this API.

Previously, VERSION could be accessed via the Ember import:

import Ember from 'ember';

Ember.VERSION

If needed, VERSION can be imported:

import { VERSION } from '@ember/version';

Previously, ViewUtils could be accessed via the Ember import:

import Ember from 'ember';

Ember.ViewUtils

ViewUtils is also private.

If needed, ViewUtils can be imported:

import { isSerializationFirstNode } from '@ember/-internals/glimmer';

However, due to ViewUtils being private, it is not recommended, nor supported.

Previously, warn could be accessed via the Ember import:

import Ember from 'ember';

Ember.warn

If needed, warn can be imported:

import { warn } from '@ember/debug';

Previously, wrap could be accessed via the Ember import:

import Ember from 'ember';

Ember.wrap

wrap is also private.

There is no replacement for this API.