Deprecations Added in Ember 6.x

The foundational APIs of @ember/array, including the A() function and the core mixins (EmberArray, MutableArray, NativeArray), are deprecated. These were used to create and extend arrays with Ember's observability. The modern approach is to use native JavaScript arrays, and TrackedArray from tracked-built-ins when reactivity is needed.

A() Function and Core Mixins

The A() function would wrap a native array, making it an EmberArray. The EmberArray and MutableArray mixins could be used to build custom array-like classes.

Before

import { A } from '@ember/array';
import EmberObject from '@ember/object';
import { MutableArray } from '@ember/array';

let emberArr = A([1, 2, 3]);
emberArr.pushObject(4);

const MyArray = EmberObject.extend(MutableArray, {
  // ... implementation ...
});

After Use native arrays for standard array operations. For arrays that need to be tracked for reactivity in components and other classes, use TrackedArray from the tracked-built-ins addon.

// For a standard array
let nativeArr = [1, 2, 3];
nativeArr.push(4);

// For a tracked array
import { TrackedArray } from 'tracked-built-ins';
let trackedArr = new TrackedArray([1, 2, 3]);
trackedArr.push(4); // This mutation is tracked

Utility Functions: isArray and makeArray

These functions helped create and check for arrays.

Before

import { isArray, makeArray } from '@ember/array';
let isArr = isArray([]);
let ensuredArr = makeArray('hello');

After Use native JavaScript equivalents.

// isArray() -> Array.isArray()
let isArr = Array.isArray([]);

// makeArray() -> custom helper or ensure data is correct
function ensureArray(value) {
  if (value === null || value === undefined) return [];
  return Array.isArray(value) ? value : [value];
}
let ensuredArr = ensureArray('hello');

Creating Custom Arrays with Proxies

For advanced use cases where you might have created a custom class based on MutableArray to add special behaviors to your array, the modern JavaScript equivalent is to use a Proxy. A Proxy object allows you to intercept and redefine fundamental operations for a target object (like an array), enabling you to create powerful custom wrappers.

Example: A Logging Array

Imagine you want to log every time an item is pushed to an array.

Before, you might have done this with MutableArray:

import EmberObject from '@ember/object';
import { MutableArray } from '@ember/array';

const LoggingArray = EmberObject.extend(MutableArray, {
  // Internal content array
  _content: null,

  init() {
    this._super(...arguments);
    this._content = this._content || [];
  },

  // Required primitives
  objectAt(idx) { return this._content[idx]; },
  get length() { return this._content.length; },

  // Override replace to add logging
  replace(idx, amt, objects) {
    if (amt === 0) {
      console.log(`Adding items: ${objects.join(', ')}`);
    }
    this._content.splice(idx, amt, ...objects);
    this.arrayContentDidChange(idx, amt, objects.length);
  }
});

let arr = LoggingArray.create({ _content: [1, 2] });
arr.pushObject(3); // Logs: "Adding items: 3"

After, you can achieve the same result more cleanly by wrapping a TrackedArray in a Proxy. This allows you to add custom behavior while preserving the reactivity provided by TrackedArray.

import { TrackedArray } from 'tracked-built-ins';

function createTrackedLoggingArray(initialItems) {
  // Start with a TrackedArray instance
  const trackedArr = new TrackedArray(initialItems);

  return new Proxy(trackedArr, {
    get(target, prop, receiver) {
      // Intercept the 'push' method
      if (prop === 'push') {
        return function(...args) {
          console.log(`Adding items via push: ${args.join(', ')}`);
          // Call the original push method on the TrackedArray
          // This will trigger reactivity automatically.
          return target.push(...args);
        }
      }

      // Forward all other property access and method calls to the TrackedArray
      const value = Reflect.get(target, prop, receiver);
      return typeof value === 'function' ? value.bind(target) : value;
    },

    set(target, prop, value, receiver) {
      // Intercept direct index assignment
      if (!isNaN(parseInt(prop, 10))) {
        console.log(`Setting index ${prop} to ${value}`);
      }
      // Forward the set operation to the TrackedArray to trigger reactivity
      return Reflect.set(target, prop, value, receiver);
    }
  });
}

// In a component:
class MyComponent {
  loggingArray = createTrackedLoggingArray([1, 2]);

  addItem() {
    this.loggingArray.push(3); // Logs and triggers an update
  }

  updateItem() {
    this.loggingArray[0] = 'new value'; // Logs and triggers an update
  }
}

This Proxy approach is very powerful. By wrapping a TrackedArray, you can layer in custom logic while letting it handle the complexities of reactivity. This is the recommended pattern for creating advanced, observable array-like objects in modern Ember.

All read-only methods and computed properties from @ember/array are deprecated. You should use native JavaScript array methods and properties instead. This guide covers the common read-only APIs and their native equivalents.

firstObject and lastObject

These computed properties provided safe access to the first and last elements of an array.

Before

import { A } from '@ember/array';
let arr = A(['a', 'b', 'c']);
let first = arr.get('firstObject'); // 'a'
let last = arr.get('lastObject');   // 'c'

After Use native array bracket notation, or the at() method for accessing elements from the end of the array.

let arr = ['a', 'b', 'c'];
let first = arr[0];
let last = arr.at(-1);

objectAt and objectsAt

These methods provided safe, index-based access to array elements.

Before

import { A } from '@ember/array';
let arr = A(['a', 'b', 'c']);
let middle = arr.objectAt(1);     // 'b'
let some = arr.objectsAt([0, 2]); // ['a', 'c']

After Use native array bracket notation for objectAt. For objectsAt, you can use map.

let arr = ['a', 'b', 'c'];
let middle = arr[1];
let some = [0, 2].map(index => arr[index]);

mapBy, filterBy, rejectBy, findBy

These methods were shortcuts for common mapping and filtering operations on arrays of objects.

Before

import { A } from '@ember/array';
let users = A([
  { name: 'John', isActive: true },
  { name: 'Jane', isActive: false },
]);
let names = users.mapBy('name');
let active = users.filterBy('isActive', true);
let john = users.findBy('name', 'John');

After Use the native map, filter, and find methods with arrow functions.

let users = [
  { name: 'John', isActive: true },
  { name: 'Jane', isActive: false },
];
let names = users.map(user => user.name);
let active = users.filter(user => user.isActive === true);
let john = users.find(user => user.name === 'John');

uniqBy

uniqBy created a new array with unique elements based on a property.

Before

import { uniqBy } from '@ember/array';
let users = [{ id: 1 }, { id: 2 }, { id: 1 }];
let unique = uniqBy(users, 'id');

After Use a Map to efficiently create a unique list.

let users = [{ id: 1 }, { id: 2 }, { id: 1 }];
let unique = Array.from(
  users.reduce((map, user) => map.set(user.id, user), new Map()).values()
);

All methods from @ember/array that mutate or "write" to an array are deprecated. This includes observable methods like pushObject.

The modern approach is to use TrackedArray from the tracked-built-ins addon. This class provides a tracked version of the native JavaScript Array that can be mutated directly, and these mutations will be tracked automatically.

First, install the addon:

ember install tracked-built-ins

Observable Write Methods

Methods like pushObject, popObject, removeObject, insertAt, and removeAt were used to modify arrays in a way that Ember's classic observability system could track.

Before

import { A } from '@ember/array';
let arr = A([1, 2, 3]);

arr.pushObject(4);
arr.removeAt(1, 1); // remove 1 item at index 1

After Use TrackedArray and mutate it directly with standard JavaScript array methods. Using TrackedArray provides an ergonomic API that is nearly identical to working with plain JavaScript arrays, while providing the reactivity needed for your application's UI to update automatically.

import { TrackedArray } from 'tracked-built-ins';

// In a component or class
class MyComponent {
  myArray = new TrackedArray([1, 2, 3]);

  addItem() {
    // pushObject -> push
    this.myArray.push(4);
  }

  removeItem() {
    // removeAt -> splice
    this.myArray.splice(1, 1);
  }

  clearItems() {
    // clear -> set length to 0
    this.myArray.length = 0;
  }
}

This pattern applies to all mutation methods. Here is a brief mapping for the most common methods:

| @ember/array Method | Native TrackedArray Method | |-----------------------|------------------------------| | pushObject(s) | push / ... (spread) | | popObject() | pop | | shiftObject() | shift | | unshiftObject(s) | unshift | | insertAt(idx, obj) | splice(idx, 0, obj) | | removeAt(idx, len) | splice(idx, len) | | clear() | length = 0 | | replace() | splice |

Handling Uniqueness and Specific Objects

For methods like addObject and removeObject that deal with specific object instances or uniqueness, you need a bit more logic.

// In your component class with `myArray = new TrackedArray([...])`

// removeObject replacement
removeItem(item) {
  const index = this.myArray.indexOf(item);
  if (index > -1) {
    this.myArray.splice(index, 1);
  }
}

// addObject replacement
addUniqueItem(item) {
  if (!this.myArray.includes(item)) {
    this.myArray.push(item);
  }
}

Alternatively, if you are working with a list that must be unique, consider using a Set or TrackedSet from tracked-built-ins, as they handle uniqueness automatically.

Importing inject from @ember/service is deprecated. Please import service instead.

Example:

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

export default class MyRoute extends Route {
  @service store;
}

You can use the ember-codemod-remove-inject-as-service codemod, to fix all violations.

If you're working on a library that needs to support ember-source prior to 4.1, you can support both styles of service via:

import * as emberService from '@ember/service';

const service = emberService.service ?? emberService.inject;

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.