ember-source 4.1.0-alpha.6 → 4.1.0

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

@@ -1,10 +1,10 @@
 import { meta, peekMeta } from '@ember/-internals/meta';
-import { setListeners, isObject, setupMandatorySetter, symbol, toString, enumerableSymbol, getDebugName, inspect, setWithMandatorySetter, Cache, isEmberArray, setProxy, lookupDescriptor, getName, setName, guidFor, makeArray, observerListenerMetaFor, ROOT, setObservers, wrap } from '@ember/-internals/utils';
+import { setListeners, isObject, setupMandatorySetter, symbol, toString, enumerableSymbol, inspect, setWithMandatorySetter, Cache, isEmberArray, setProxy, lookupDescriptor, getName, setName, guidFor, makeArray, observerListenerMetaFor, ROOT, setObservers, wrap } from '@ember/-internals/utils';
 import { assert, deprecate, debug, warn } from '@ember/debug';
 import { ENV, context } from '@ember/-internals/environment';
 import { schedule } from '@ember/runloop';
 import { registerDestructor, isDestroyed } from '@glimmer/destroyable';
-import { CURRENT_TAG, tagMetaFor, validateTag, valueForTag, CONSTANT_TAG, dirtyTagFor, tagFor, combine, createUpdatableTag, updateTag, ALLOW_CYCLES, consumeTag, track, untrack, deprecateMutationsInTrackingTransaction, isTracking, trackedData } from '@glimmer/validator';
+import { CURRENT_TAG, tagMetaFor, validateTag, valueForTag, CONSTANT_TAG, dirtyTagFor, tagFor, combine, createUpdatableTag, updateTag, ALLOW_CYCLES, consumeTag, track, untrack, isTracking, trackedData, createCache, getValue } from '@glimmer/validator';
 export { createCache, getValue, isConst } from '@glimmer/validator';
 import { DEBUG } from '@glimmer/env';
 import { getCustomTagFor } from '@glimmer/manager';
@@ -651,43 +651,29 @@ function replaceInNativeArray(array, start, deleteCount, items) {
   arrayContentDidChange(array, start, deleteCount, items.length);
 }
 
-function arrayObserversHelper(obj, target, opts, operation, notify) {
-  let willChange = opts && opts.willChange || 'arrayWillChange';
-  let didChange = opts && opts.didChange || 'arrayDidChange';
-  let hasObservers = obj.hasArrayObservers;
+function arrayObserversHelper(obj, target, opts, operation) {
+  var _a;
+
+  let {
+    willChange,
+    didChange
+  } = opts;
   operation(obj, '@array:before', target, willChange);
   operation(obj, '@array:change', target, didChange);
+  /*
+   * Array proxies have a `_revalidate` method which must be called to set
+   * up their internal array observation systems.
+   */
 
-  if (hasObservers === notify) {
-    notifyPropertyChange(obj, 'hasArrayObservers');
-  }
-
+  (_a = obj._revalidate) === null || _a === void 0 ? void 0 : _a.call(obj);
   return obj;
 }
 
-function addArrayObserver(array, target, opts, suppress = false) {
-  deprecate(`Array observers have been deprecated. Added an array observer to ${getDebugName === null || getDebugName === void 0 ? void 0 : getDebugName(array)}.`, suppress, {
-    id: 'array-observers',
-    url: 'https://deprecations.emberjs.com/v3.x#toc_array-observers',
-    until: '4.0.0',
-    for: 'ember-source',
-    since: {
-      enabled: '3.26.0-beta.1'
-    }
-  });
-  return arrayObserversHelper(array, target, opts, addListener, false);
+function addArrayObserver(array, target, opts) {
+  return arrayObserversHelper(array, target, opts, addListener);
 }
-function removeArrayObserver(array, target, opts, suppress = false) {
-  deprecate(`Array observers have been deprecated. Removed an array observer from ${getDebugName === null || getDebugName === void 0 ? void 0 : getDebugName(array)}.`, suppress, {
-    id: 'array-observers',
-    url: 'https://deprecations.emberjs.com/v3.x#toc_array-observers',
-    until: '4.0.0',
-    for: 'ember-source',
-    since: {
-      enabled: '3.26.0-beta.1'
-    }
-  });
-  return arrayObserversHelper(array, target, opts, removeListener, true);
+function removeArrayObserver(array, target, opts) {
+  return arrayObserversHelper(array, target, opts, removeListener);
 }
 
 const CHAIN_PASS_THROUGH = new _WeakSet();
@@ -1842,13 +1828,7 @@ function _getProp(obj, keyName) {
     }
 
     if (value === undefined && isObject$$1 && !(keyName in obj) && typeof obj.unknownProperty === 'function') {
-      if (DEBUG) {
-        deprecateMutationsInTrackingTransaction(() => {
-          value = obj.unknownProperty(keyName);
-        });
-      } else {
-        value = obj.unknownProperty(keyName);
-      }
+      value = obj.unknownProperty(keyName);
     }
 
     if (isTracking()) {
@@ -3115,9 +3095,7 @@ class Mixin {
 
       guidFor(this);
 
-      if (true
-      /* EMBER_MODERNIZED_BUILT_IN_COMPONENTS */
-      && Mixin._disableDebugSeal !== true) {
+      if (Mixin._disableDebugSeal !== true) {
         Object.seal(this);
       }
     }
@@ -3240,9 +3218,7 @@ class Mixin {
 
 }
 
-if (DEBUG && true
-/* EMBER_MODERNIZED_BUILT_IN_COMPONENTS */
-) {
+if (DEBUG) {
   Object.defineProperty(Mixin, '_disableDebugSeal', {
     configurable: true,
     enumerable: false,
@@ -3479,68 +3455,46 @@ 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) => {
+  {
+    const [target, key, descriptor] = args; // Error on `@cached()`, `@cached(...args)`, and `@cached propName = value;`
+
+    if (DEBUG && target === undefined) throwCachedExtraneousParens();
+
+    if (DEBUG && (typeof target !== 'object' || typeof key !== 'string' || typeof descriptor !== 'object' || args.length !== 3)) {
+      throwCachedInvalidArgsError(args);
+    }
+
+    if (DEBUG && (!('get' in descriptor) || typeof descriptor.get !== 'function')) {
+      throwCachedGetterOnlyError(key);
+    }
+
+    const caches = new WeakMap();
+    const getter = descriptor.get;
+
+    descriptor.get = function () {
+      if (!caches.has(this)) {
+        caches.set(this, createCache(getter.bind(this)));
+      }
+
+      return getValue(caches.get(this));
+    };
+  }
 };
 
+function throwCachedExtraneousParens() {
+  throw new Error('You attempted to use @cached(), which is not necessary nor supported. Remove the parentheses and you will be good to go!');
+}
+
+function throwCachedGetterOnlyError(key) {
+  throw new Error(`The @cached decorator must be applied to getters. '${key}' is not a getter.`);
+}
+
+function throwCachedInvalidArgsError(args = []) {
+  throw new Error(`You attempted to use @cached on with ${args.length > 1 ? 'arguments' : 'an argument'} ( @cached(${args.map(d => `'${d}'`).join(', ')}), which is not supported. Dependencies are automatically tracked, so you can just use ${'`@cached`'}`);
+}
+
 /**
   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

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

@@ -1,4 +1,4 @@
-import { assert } from '@ember/debug';
+import { assert, deprecate } from '@ember/debug';
 /**
 @module @ember/routing
 */
@@ -87,6 +87,15 @@ export default {
     assert("Location.create: you must specify a 'implementation' option", Boolean(implementation));
     let implementationClass = this.implementations[implementation];
     assert(`Location.create: ${implementation} is not a valid implementation`, Boolean(implementationClass));
+    deprecate("Calling `create` on Location class is deprecated. Instead, use `container.lookup('location:my-location')` to lookup the location you need.", false, {
+      id: 'deprecate-auto-location',
+      until: '5.0.0',
+      url: 'https://emberjs.com/deprecations/v4.x#toc_deprecate-auto-location',
+      for: 'ember-source',
+      since: {
+        enabled: '4.1.0'
+      }
+    });
     return implementationClass.create(...arguments);
   },
 

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

@@ -26,10 +26,15 @@ export default class NoneLocation extends EmberObject {
     this.implementation = 'none';
   }
 
-  detect() {
+  initState() {
+    this._super(...arguments);
+
     let {
       rootURL
-    } = this;
+    } = this; // This assert doesn't have anything to do with state initialization,
+    // but we're hijacking this method since it's called after the route has
+    // set the rootURL property on its Location instance.
+
     assert('rootURL must end with a trailing forward slash e.g. "/app/"', rootURL.charAt(rootURL.length - 1) === '/');
   }
   /**

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

@@ -373,7 +373,7 @@ export default class RouterService extends Service {
 
 }
 
-if (false
+if (true
 /* EMBER_ROUTING_ROUTER_SERVICE_REFRESH */
 ) {
   RouterService.reopen({

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

@@ -7,7 +7,7 @@ import { readOnly } from '@ember/object/computed';
 import Service from '@ember/service';
 const ROUTER = symbol('ROUTER');
 /**
-  The Routing service is used by LinkComponent, and provides facilities for
+  The Routing service is used by LinkTo, and provides facilities for
   the component/view layer to interact with the router.
 
   This is a private service for internal usage only. For public usage,

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

@@ -11,8 +11,7 @@ import { addObserver, computed, defineProperty, descriptorForProperty, flushAsyn
 import { getOwner } from '@ember/-internals/owner';
 import { A as emberA, ActionHandler, Evented, Object as EmberObject, typeOf } from '@ember/-internals/runtime';
 import { isProxy, lookupDescriptor, symbol } from '@ember/-internals/utils';
-import { assert, deprecate, info, isTesting } from '@ember/debug';
-import { ROUTER_EVENTS } from '@ember/deprecated-features';
+import { assert, info, isTesting } from '@ember/debug';
 import { dependentKeyCompat } from '@ember/object/compat';
 import { once } from '@ember/runloop';
 import { classify } from '@ember/string';
@@ -256,7 +255,8 @@ class Route extends EmberObject.extend(ActionHandler, Evented) {
 
 
   _optionsForQueryParam(qp) {
-    return get(this, `queryParams.${qp.urlKey}`) || get(this, `queryParams.${qp.prop}`) || {};
+    const queryParams = get(this, 'queryParams');
+    return get(queryParams, qp.urlKey) || get(queryParams, qp.prop) || queryParams[qp.urlKey] || queryParams[qp.prop] || {};
   }
   /**
     A hook you can use to reset controller values either when the model
@@ -1946,43 +1946,4 @@ Route.reopen({
 
   }
 });
-export let ROUTER_EVENT_DEPRECATIONS;
-
-if (ROUTER_EVENTS) {
-  ROUTER_EVENT_DEPRECATIONS = {
-    on(name) {
-      this._super(...arguments);
-
-      let hasDidTransition = name === 'didTransition';
-      let hasWillTransition = name === 'willTransition';
-
-      if (hasDidTransition) {
-        deprecate('You attempted to listen to the "didTransition" event which is deprecated. Please inject the router service and listen to the "routeDidChange" event.', false, {
-          id: 'deprecate-router-events',
-          until: '4.0.0',
-          url: 'https://deprecations.emberjs.com/v3.x#toc_deprecate-router-events',
-          for: 'ember-source',
-          since: {
-            enabled: '3.11.0'
-          }
-        });
-      }
-
-      if (hasWillTransition) {
-        deprecate('You attempted to listen to the "willTransition" event which is deprecated. Please inject the router service and listen to the "routeWillChange" event.', false, {
-          id: 'deprecate-router-events',
-          until: '4.0.0',
-          url: 'https://deprecations.emberjs.com/v3.x#toc_deprecate-router-events',
-          for: 'ember-source',
-          since: {
-            enabled: '3.11.0'
-          }
-        });
-      }
-    }
-
-  };
-  Route.reopen(ROUTER_EVENT_DEPRECATIONS);
-}
-
 export default Route;

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

@@ -3,14 +3,13 @@ import { computed, get, set } from '@ember/-internals/metal';
 import { getOwner } from '@ember/-internals/owner';
 import { A as emberA, Evented, Object as EmberObject, typeOf } from '@ember/-internals/runtime';
 import { assert, deprecate, info } from '@ember/debug';
-import { ROUTER_EVENTS } from '@ember/deprecated-features';
 import EmberError from '@ember/error';
 import { cancel, once, run, scheduleOnce } from '@ember/runloop';
 import { DEBUG } from '@glimmer/env';
 import EmberLocation from '../location/api';
 import { calculateCacheKey, extractRouteArgs, getActiveTargetName, resemblesURL } from '../utils';
 import DSL from './dsl';
-import { defaultSerialize, getFullQueryParams, hasDefaultSerialize, ROUTE_CONNECTIONS, ROUTER_EVENT_DEPRECATIONS } from './route';
+import { defaultSerialize, getFullQueryParams, hasDefaultSerialize, ROUTE_CONNECTIONS } from './route';
 import RouterState from './router_state';
 import Router, { logAbort, STATE_SYMBOL } from 'router_js';
 
@@ -20,10 +19,7 @@ function defaultDidTransition(infos) {
   this._cancelSlowTransitionTimer();
 
   this.notifyPropertyChange('url');
-  this.set('currentState', this.targetState); // Put this in the runloop so url will be accurate. Seems
-  // less surprising than didTransition being out of sync.
-
-  once(this, this.trigger, 'didTransition');
+  this.set('currentState', this.targetState);
 
   if (DEBUG) {
     // @ts-expect-error namespace isn't public
@@ -34,9 +30,7 @@ function defaultDidTransition(infos) {
   }
 }
 
-function defaultWillTransition(oldInfos, newInfos, transition) {
-  once(this, this.trigger, 'willTransition', transition);
-
+function defaultWillTransition(oldInfos, newInfos) {
   if (DEBUG) {
     // @ts-expect-error namespace isn't public
     if (this.namespace.LOG_TRANSITIONS) {
@@ -256,42 +250,18 @@ class EmberRouter extends EmberObject.extend(Evented) {
           location.setURL(path);
           set(router, 'currentURL', path);
         });
-      }
+      } // TODO: merge into routeDidChange
 
-      didTransition(infos) {
-        if (ROUTER_EVENTS) {
-          if (router.didTransition !== defaultDidTransition) {
-            deprecate('You attempted to override the "didTransition" method which is deprecated. Please inject the router service and listen to the "routeDidChange" event.', false, {
-              id: 'deprecate-router-events',
-              until: '4.0.0',
-              url: 'https://deprecations.emberjs.com/v3.x#toc_deprecate-router-events',
-              for: 'ember-source',
-              since: {
-                enabled: '3.11.0'
-              }
-            });
-          }
-        }
 
+      didTransition(infos) {
+        assert('You attempted to override the "didTransition" method which has been deprecated. Please inject the router service and listen to the "routeDidChange" event.', router.didTransition === defaultDidTransition);
         router.didTransition(infos);
-      }
+      } // TODO: merge into routeWillChange
 
-      willTransition(oldInfos, newInfos, transition) {
-        if (ROUTER_EVENTS) {
-          if (router.willTransition !== defaultWillTransition) {
-            deprecate('You attempted to override the "willTransition" method which is deprecated. Please inject the router service and listen to the "routeWillChange" event.', false, {
-              id: 'deprecate-router-events',
-              until: '4.0.0',
-              url: 'https://deprecations.emberjs.com/v3.x#toc_deprecate-router-events',
-              for: 'ember-source',
-              since: {
-                enabled: '3.11.0'
-              }
-            });
-          }
-        }
 
-        router.willTransition(oldInfos, newInfos, transition);
+      willTransition(oldInfos, newInfos) {
+        assert('You attempted to override the "willTransition" method which has been deprecated. Please inject the router service and listen to the "routeWillChange" event.', router.willTransition === defaultWillTransition);
+        router.willTransition(oldInfos, newInfos);
       }
 
       triggerEvent(routeInfos, ignoreFailure, name, args) {
@@ -752,6 +722,18 @@ class EmberRouter extends EmberObject.extend(Evented) {
     if ('string' === typeof location) {
       let resolvedLocation = owner.lookup(`location:${location}`);
 
+      if (location === 'auto') {
+        deprecate("Router location 'auto' is deprecated. Most users will want to set `locationType` to 'history' in config/environment.js for no change in behavior. See deprecation docs for details.", false, {
+          id: 'deprecate-auto-location',
+          until: '5.0.0',
+          url: 'https://emberjs.com/deprecations/v4.x#toc_deprecate-auto-location',
+          for: 'ember-source',
+          since: {
+            enabled: '4.1.0'
+          }
+        });
+      }
+
       if (resolvedLocation !== undefined) {
         location = set(this, 'location', resolvedLocation);
       } else {
@@ -772,6 +754,18 @@ class EmberRouter extends EmberObject.extend(Evented) {
 
 
       if (typeof location.detect === 'function') {
+        if (this.location !== 'auto') {
+          deprecate('The `detect` method on the Location object is deprecated. If you need detection you can run your detection code in app.js, before setting the location type.', false, {
+            id: 'deprecate-auto-location',
+            until: '5.0.0',
+            url: 'https://emberjs.com/deprecations/v4.x#toc_deprecate-auto-location',
+            for: 'ember-source',
+            since: {
+              enabled: '4.1.0'
+            }
+          });
+        }
+
         location.detect();
       } // ensure that initState is called AFTER the rootURL is set on
       // the location instance
@@ -1415,7 +1409,8 @@ export function triggerEvent(routeInfos, ignoreFailure, name, args) {
   if (!routeInfos) {
     if (ignoreFailure) {
       return;
-    }
+    } // TODO: update?
+
 
     throw new EmberError(`Can't trigger action '${name}' because your app hasn't finished transitioning into its first route. To trigger an action on destination routes during a transition, you can call \`.send()\` on the \`Transition\` object passed to the \`model/beforeModel/afterModel\` hooks.`);
   }
@@ -1624,9 +1619,4 @@ EmberRouter.reopen({
     return location.getURL();
   })
 });
-
-if (ROUTER_EVENTS) {
-  EmberRouter.reopen(ROUTER_EVENT_DEPRECATIONS);
-}
-
 export default EmberRouter;

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

@@ -4,7 +4,7 @@
 import { DEBUG } from '@glimmer/env';
 import { PROXY_CONTENT } from '@ember/-internals/metal';
 import { setEmberArray } from '@ember/-internals/utils';
-import { get, set, objectAt, replaceInNativeArray, replace, computed, Mixin, hasListeners, beginPropertyChanges, endPropertyChanges, addArrayObserver, removeArrayObserver, arrayContentWillChange, arrayContentDidChange, nativeDescDecorator as descriptor } from '@ember/-internals/metal';
+import { get, set, objectAt, replaceInNativeArray, replace, computed, Mixin, beginPropertyChanges, endPropertyChanges } from '@ember/-internals/metal';
 import { assert } from '@ember/debug';
 import Enumerable from './enumerable';
 import compare from '../compare';
@@ -441,177 +441,6 @@ const ArrayMixin = Mixin.create(Enumerable, {
     return -1;
   },
 
-  // ..........................................................
-  // ARRAY OBSERVERS
-  //
-
-  /**
-    Adds an array observer to the receiving array. The array observer object
-    normally must implement two methods:
-     * `willChange(observedObj, start, removeCount, addCount)` - This method will be
-      called just before the array is modified.
-    * `didChange(observedObj, start, removeCount, addCount)` - This method will be
-      called just after the array is modified.
-     Both callbacks will be passed the observed object, starting index of the
-    change as well as a count of the items to be removed and added. You can use
-    these callbacks to optionally inspect the array during the change, clear
-    caches, or do any other bookkeeping necessary.
-     In addition to passing a target, you can also include an options hash
-    which you can use to override the method names that will be invoked on the
-    target.
-     @method addArrayObserver
-    @param {Object} target The observer object.
-    @param {Object} opts Optional hash of configuration options including
-      `willChange` and `didChange` option.
-    @return {EmberArray} receiver
-    @public
-    @example
-        import Service from '@ember/service';
-         export default Service.extend({
-          data: Ember.A(),
-           init() {
-            this._super(...arguments);
-             this.data.addArrayObserver(this, {
-              willChange: 'dataWillChange',
-              didChange: 'dataDidChange'
-            });
-          },
-           dataWillChange(array, start, removeCount, addCount) {
-            console.log('array will change', array, start, removeCount, addCount);
-          },
-           dataDidChange(array, start, removeCount, addCount) {
-            console.log('array did change', array, start, removeCount, addCount);
-          }
-        });
-  */
-  addArrayObserver(target, opts) {
-    return addArrayObserver(this, target, opts);
-  },
-
-  /**
-    Removes an array observer from the object if the observer is current
-    registered. Calling this method multiple times with the same object will
-    have no effect.
-     @method removeArrayObserver
-    @param {Object} target The object observing the array.
-    @param {Object} opts Optional hash of configuration options including
-      `willChange` and `didChange` option.
-    @return {EmberArray} receiver
-    @public
-  */
-  removeArrayObserver(target, opts) {
-    return removeArrayObserver(this, target, opts);
-  },
-
-  /**
-    Becomes true whenever the array currently has observers watching changes
-    on the array.
-     ```javascript
-    let arr = [1, 2, 3, 4, 5];
-    arr.hasArrayObservers; // false
-     arr.addArrayObserver(this, {
-      willChange() {
-        console.log('willChange');
-      }
-    });
-    arr.hasArrayObservers; // true
-    ```
-     @property {Boolean} hasArrayObservers
-    @public
-  */
-  hasArrayObservers: descriptor({
-    configurable: true,
-    enumerable: false,
-
-    get() {
-      return hasListeners(this, '@array:change') || hasListeners(this, '@array:before');
-    }
-
-  }),
-
-  /**
-    If you are implementing an object that supports `EmberArray`, call this
-    method just before the array content changes to notify any observers and
-    invalidate any related properties. Pass the starting index of the change
-    as well as a delta of the amounts to change.
-     ```app/components/show-post.js
-    import Component from '@ember/component';
-    import EmberObject from '@ember/object';
-     const Post = EmberObject.extend({
-      body: '',
-      save() {}
-    })
-     export default Component.extend({
-      attemptsToModify: 0,
-      successfulModifications: 0,
-      posts: null,
-       init() {
-        this._super(...arguments);
-         this.posts = [1, 2, 3].map(i => Post.create({ body: i }));
-        this.posts.addArrayObserver(this, {
-          willChange() {
-            this.incrementProperty('attemptsToModify');
-          },
-          didChange() {
-            this.incrementProperty('successfulModifications');
-          }
-        });
-      },
-       actions: {
-        editPost(post, newContent) {
-          let oldContent = post.body,
-              postIndex = this.posts.indexOf(post);
-           this.posts.arrayContentWillChange(postIndex, 0, 0); // attemptsToModify = 1
-          post.set('body', newContent);
-           post.save()
-            .then(response => {
-              this.posts.arrayContentDidChange(postIndex, 0, 0); // successfulModifications = 1
-            })
-            .catch(error => {
-              post.set('body', oldContent);
-            })
-        }
-      }
-    });
-    ```
-     @method arrayContentWillChange
-    @param {Number} startIdx The starting index in the array that will change.
-    @param {Number} removeAmt The number of items that will be removed. If you
-      pass `null` assumes 0
-    @param {Number} addAmt The number of items that will be added. If you
-      pass `null` assumes 0.
-    @return {EmberArray} receiver
-    @public
-  */
-  arrayContentWillChange(startIdx, removeAmt, addAmt) {
-    return arrayContentWillChange(this, startIdx, removeAmt, addAmt);
-  },
-
-  /**
-    If you are implementing an object that supports `EmberArray`, call this
-    method just after the array content changes to notify any observers and
-    invalidate any related properties. Pass the starting index of the change
-    as well as a delta of the amounts to change.
-     ```javascript
-    let arr = [1, 2, 3, 4, 5];
-     arr.copyWithin(-2); // [1, 2, 3, 1, 2]
-    // arr.lastObject = 5
-    arr.arrayContentDidChange(3, 2, 2);
-    // arr.lastObject = 2
-    ```
-     @method arrayContentDidChange
-    @param {Number} startIdx The starting index in the array that did change.
-    @param {Number} removeAmt The number of items that were removed. If you
-      pass `null` assumes 0
-    @param {Number} addAmt The number of items that were added. If you
-      pass `null` assumes 0.
-    @return {EmberArray} receiver
-    @public
-  */
-  arrayContentDidChange(startIdx, removeAmt, addAmt) {
-    return arrayContentDidChange(this, startIdx, removeAmt, addAmt);
-  },
-
   /**
     Iterates through the array, calling the passed function on each
     item. This method corresponds to the `forEach()` method defined in
@@ -1339,7 +1168,7 @@ const MutableArray = Mixin.create(ArrayMixin, MutableEnumerable, {
     __Required.__ You must implement this method to apply this mixin.
      This is one of the primitives you must implement to support `Array`.
     You should replace amt objects started at idx with the objects in the
-    passed array. You should also call `this.arrayContentDidChange()`
+    passed array.
      Note that this method is expected to validate the type(s) of objects that it expects.
      @method replace
     @param {Number} idx Starting index in the array to replace. If