ember-source 3.28.5 → 4.0.0-beta.10

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

@@ -3,8 +3,8 @@
 */
 import { DEBUG } from '@glimmer/env';
 import { PROXY_CONTENT } from '@ember/-internals/metal';
-import { setEmberArray, HAS_NATIVE_PROXY } 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 { setEmberArray } from '@ember/-internals/utils';
+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';
@@ -126,7 +126,7 @@ function insertAt(array, index, item) {
 export function isArray(_obj) {
   let obj = _obj;
 
-  if (DEBUG && HAS_NATIVE_PROXY && typeof _obj === 'object' && _obj !== null) {
+  if (DEBUG && typeof _obj === 'object' && _obj !== null) {
     let possibleProxyContent = _obj[PROXY_CONTENT];
 
     if (possibleProxyContent !== undefined) {
@@ -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

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

@@ -2,7 +2,7 @@
 @module @ember/object
 */
 import { peekMeta } from '@ember/-internals/meta';
-import { get, getWithDefault, set, getProperties, setProperties, Mixin, hasListeners, beginPropertyChanges, notifyPropertyChange, endPropertyChanges, addObserver, removeObserver } from '@ember/-internals/metal';
+import { get, set, getProperties, setProperties, Mixin, hasListeners, beginPropertyChanges, notifyPropertyChange, endPropertyChanges, addObserver, removeObserver } from '@ember/-internals/metal';
 import { assert } from '@ember/debug';
 /**
   ## Overview
@@ -339,23 +339,6 @@ export default Mixin.create({
     return hasListeners(this, `${key}:change`);
   },
 
-  /**
-    Retrieves the value of a property, or a default value in the case that the
-    property returns `undefined`.
-     ```javascript
-    person.getWithDefault('lastName', 'Doe');
-    ```
-     @method getWithDefault
-    @param {String} keyName The name of the property to retrieve
-    @param {Object} defaultValue The value to return if the property value is undefined
-    @return {Object} The property value or the defaultValue.
-    @public
-    @deprecated
-  */
-  getWithDefault(keyName, defaultValue) {
-    return getWithDefault(this, keyName, defaultValue);
-  },
-
   /**
     Set the value of a property to the current value plus some amount.
      ```javascript

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

@@ -3,14 +3,8 @@
 */
 import { context } from '@ember/-internals/environment';
 import { get, Mixin, computed } from '@ember/-internals/metal';
-import { assert, deprecate } from '@ember/debug';
+import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
-
-if (DEBUG && true
-/* EMBER_MODERNIZED_BUILT_IN_COMPONENTS */
-) {
-  Mixin._disableDebugSeal = true;
-}
 /**
 `Ember.TargetActionSupport` is a mixin that can be included in a class
 to add a `triggerAction` method with semantics similar to the Handlebars
@@ -24,7 +18,6 @@ doing more complex event handling in Components.
 @private
 */
 
-
 const TargetActionSupport = Mixin.create({
   target: null,
   action: null,
@@ -151,41 +144,8 @@ function getTarget(instance) {
   return null;
 }
 
-if (true
-/* EMBER_MODERNIZED_BUILT_IN_COMPONENTS */
-) {
-  Object.defineProperty(TargetActionSupport, '_wasReopened', {
-    configurable: true,
-    enumerable: false,
-    writable: true,
-    value: false
-  });
-  Object.defineProperty(TargetActionSupport, 'reopen', {
-    configurable: true,
-    enumerable: false,
-    writable: true,
-    value: function reopen(...args) {
-      if (this === TargetActionSupport) {
-        deprecate('Reopening Ember.TargetActionSupport is deprecated.', false, {
-          id: 'ember.built-in-components.reopen',
-          for: 'ember-source',
-          since: {
-            enabled: '3.27.0'
-          },
-          until: '4.0.0',
-          url: 'https://deprecations.emberjs.com/v3.x#toc_ember-built-in-components-reopen'
-        });
-        TargetActionSupport._wasReopened = true;
-      }
-
-      return Mixin.prototype.reopen.call(this, ...args);
-    }
-  });
-
-  if (DEBUG) {
-    Object.seal(TargetActionSupport);
-    Mixin._disableDebugSeal = false;
-  }
+if (DEBUG) {
+  Object.seal(TargetActionSupport);
 }
 
 export default TargetActionSupport;

package/dist/packages/@ember/-internals/runtime/lib/system/array_proxy.js

@@ -1,7 +1,7 @@
 /**
 @module @ember/array
 */
-import { get, objectAt, alias, PROPERTY_DID_CHANGE, addArrayObserver, removeArrayObserver, replace, arrayContentDidChange, tagForProperty } from '@ember/-internals/metal';
+import { get, objectAt, alias, PROPERTY_DID_CHANGE, addArrayObserver, removeArrayObserver, replace, arrayContentDidChange, arrayContentWillChange, tagForProperty } from '@ember/-internals/metal';
 import { isObject } from '@ember/-internals/utils';
 import EmberObject from './object';
 import { isArray, MutableArray } from '../mixins/array';
@@ -237,11 +237,11 @@ export default class ArrayProxy extends EmberObject {
 
     this._removeArrangedContentArrayObserver();
 
-    this.arrayContentWillChange(0, oldLength, newLength);
+    arrayContentWillChange(this, 0, oldLength, newLength);
 
     this._invalidate();
 
-    this.arrayContentDidChange(0, oldLength, newLength);
+    arrayContentDidChange(this, 0, oldLength, newLength, false);
 
     this._addArrangedContentArrayObserver(arrangedContent);
   }
@@ -250,21 +250,21 @@ export default class ArrayProxy extends EmberObject {
     if (arrangedContent && !arrangedContent.isDestroyed) {
       assert("Can't set ArrayProxy's content to itself", arrangedContent !== this);
       assert(`ArrayProxy expects an Array or ArrayProxy, but you passed ${typeof arrangedContent}`, isArray(arrangedContent) || arrangedContent.isDestroyed);
-      addArrayObserver(arrangedContent, this, ARRAY_OBSERVER_MAPPING, true);
+      addArrayObserver(arrangedContent, this, ARRAY_OBSERVER_MAPPING);
       this._arrangedContent = arrangedContent;
     }
   }
 
   _removeArrangedContentArrayObserver() {
     if (this._arrangedContent) {
-      removeArrayObserver(this._arrangedContent, this, ARRAY_OBSERVER_MAPPING, true);
+      removeArrayObserver(this._arrangedContent, this, ARRAY_OBSERVER_MAPPING);
     }
   }
 
   _arrangedContentArrayWillChange() {}
 
   _arrangedContentArrayDidChange(proxy, idx, removedCnt, addedCnt) {
-    this.arrayContentWillChange(idx, removedCnt, addedCnt);
+    arrayContentWillChange(this, idx, removedCnt, addedCnt);
     let dirtyIndex = idx;
 
     if (dirtyIndex < 0) {
@@ -277,7 +277,7 @@ export default class ArrayProxy extends EmberObject {
     }
 
     this._lengthDirty = true;
-    this.arrayContentDidChange(idx, removedCnt, addedCnt);
+    arrayContentDidChange(this, idx, removedCnt, addedCnt, false);
   }
 
   _invalidate() {
@@ -324,12 +324,5 @@ ArrayProxy.reopen(MutableArray, {
      @property arrangedContent
     @public
   */
-  arrangedContent: alias('content'),
-
-  // Array proxies don't need to notify when they change since their `[]` tag is
-  // already dependent on the `[]` tag of `arrangedContent`
-  arrayContentDidChange(startIdx, removeAmt, addAmt) {
-    return arrayContentDidChange(this, startIdx, removeAmt, addAmt, false);
-  }
-
+  arrangedContent: alias('content')
 });

package/dist/packages/@ember/-internals/runtime/lib/system/core_object.js

@@ -1,14 +1,13 @@
 /**
   @module @ember/object
 */
-import { getFactoryFor, setFactoryFor, INIT_FACTORY } from '@ember/-internals/container';
-import { getOwner, LEGACY_OWNER } from '@ember/-internals/owner';
-import { assign } from '@ember/polyfills';
-import { guidFor, lookupDescriptor, inspect, makeArray, HAS_NATIVE_PROXY, HAS_NATIVE_SYMBOL, isInternalSymbol } from '@ember/-internals/utils';
+import { getFactoryFor, setFactoryFor } from '@ember/-internals/container';
+import { getOwner } from '@ember/-internals/owner';
+import { guidFor, makeArray, isInternalSymbol } from '@ember/-internals/utils';
 import { meta } from '@ember/-internals/meta';
-import { PROXY_CONTENT, sendEvent, Mixin, activateObserver, applyMixin, defineProperty, descriptorForProperty, isClassicDecorator, DEBUG_INJECTION_FUNCTIONS, TrackedDescriptor } from '@ember/-internals/metal';
+import { PROXY_CONTENT, sendEvent, Mixin, activateObserver, applyMixin, defineProperty, descriptorForProperty, isClassicDecorator, DEBUG_INJECTION_FUNCTIONS } from '@ember/-internals/metal';
 import ActionHandler from '../mixins/action_handler';
-import { assert, deprecate } from '@ember/debug';
+import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 import { _WeakSet as WeakSet } from '@glimmer/util';
 import { destroy, isDestroying, isDestroyed, registerDestructor } from '@glimmer/destroyable';
@@ -32,22 +31,6 @@ function initialize(obj, properties) {
   if (properties !== undefined) {
     assert('EmberObject.create only accepts objects.', typeof properties === 'object' && properties !== null);
     assert('EmberObject.create no longer supports mixing in other ' + 'definitions, use .extend & .create separately instead.', !(properties instanceof Mixin));
-    let injectedProperties;
-
-    if (DEBUG) {
-      // these are all the implicit injectinos
-      injectedProperties = [];
-      let factory = getFactoryFor(obj);
-
-      if (factory) {
-        for (let injection in factory.injections) {
-          if (factory.injections[injection] === properties[injection]) {
-            injectedProperties.push(injection);
-          }
-        }
-      }
-    }
-
     let concatenatedProperties = obj.concatenatedProperties;
     let mergedProperties = obj.mergedProperties;
     let hasConcatenatedProps = concatenatedProperties !== undefined && concatenatedProperties.length > 0;
@@ -76,58 +59,17 @@ function initialize(obj, properties) {
 
         if (hasMergedProps && mergedProperties.indexOf(keyName) > -1) {
           let baseValue = obj[keyName];
-          value = assign({}, baseValue, value);
+          value = Object.assign({}, baseValue, value);
         }
       }
 
       if (isDescriptor) {
-        if (DEBUG && injectedProperties.indexOf(keyName) !== -1) {
-          // need to check if implicit injection owner.inject('component:my-component', 'foo', 'service:bar') does not match explicit injection @service foo
-          // implicit injection takes precedence so need to tell user to rename property on obj
-          let isInjectedProperty = DEBUG_INJECTION_FUNCTIONS.has(possibleDesc._getter);
-
-          if (isInjectedProperty && value !== possibleDesc.get(obj, keyName)) {
-            implicitInjectionDeprecation(keyName, `You have explicitly defined a service injection for the '${keyName}' property on ${inspect(obj)}. However, a different service or value was injected via implicit injections which overrode your explicit injection. Implicit injections have been deprecated, and will be removed in the near future. In order to prevent breakage, you should inject the same value explicitly that is currently being injected implicitly.`);
-          } else if (possibleDesc instanceof TrackedDescriptor) {
-            let descValue = possibleDesc.get(obj, keyName);
-
-            if (value !== descValue) {
-              implicitInjectionDeprecation(keyName, `A value was injected implicitly on the '${keyName}' tracked property of an instance of ${inspect(obj)}, overwriting the original value which was ${inspect(descValue)}. Implicit injection is now deprecated, please add an explicit injection for this value. If the injected value is a service, consider using the @service decorator.`);
-            }
-          } else if (possibleDesc._setter === undefined) {
-            implicitInjectionDeprecation(keyName, `A value was injected implicitly on the '${keyName}' computed property of an instance of ${inspect(obj)}. Implicit injection is now deprecated, please add an explicit injection for this value. If the injected value is a service, consider using the @service decorator.`);
-          }
-        }
-
         possibleDesc.set(obj, keyName, value);
       } else if (typeof obj.setUnknownProperty === 'function' && !(keyName in obj)) {
         obj.setUnknownProperty(keyName, value);
       } else {
         if (DEBUG) {
-          // If deprecation, either 1) an accessor descriptor or 2) class field declaration 3) only an implicit injection
-          let desc = lookupDescriptor(obj, keyName);
-
-          if (injectedProperties.indexOf(keyName) === -1) {
-            // Value was not an injected property, define in like normal
-            defineProperty(obj, keyName, null, value, m); // setup mandatory setter
-          } else if (desc) {
-            // If the property is a value prop, and it isn't the expected value,
-            // then we can warn the user when they attempt to use the value
-            if ('value' in desc && desc.value !== value) {
-              // implicit injection does not match value descriptor set on object
-              defineSelfDestructingImplicitInjectionGetter(obj, keyName, value, `A value was injected implicitly on the '${keyName}' property of an instance of ${inspect(obj)}, overwriting the original value which was ${inspect(desc.value)}. Implicit injection is now deprecated, please add an explicit injection for this value. If the injected value is a service, consider using the @service decorator.`);
-            } else {
-              // Otherwise, the value is either a getter/setter, or it is the correct value.
-              // If it is a getter/setter, then we don't know what activating it might do - it could
-              // be that the user only defined a getter, and so the value will not be set at all. It
-              // could be that the setter is a no-op that does nothing. Both of these are valid ways
-              // to "override" an implicit injection, so we can't really warn here. So, assign the
-              // value like we would normally.
-              obj[keyName] = value;
-            }
-          } else {
-            defineSelfDestructingImplicitInjectionGetter(obj, keyName, value, `A value was injected implicitly on the '${keyName}' property of an instance of ${inspect(obj)}. Implicit injection is now deprecated, please add an explicit injection for this value. If the injected value is a service, consider using the @service decorator.`);
-          }
+          defineProperty(obj, keyName, null, value, m); // setup mandatory setter
         } else {
           obj[keyName] = value;
         }
@@ -152,23 +94,6 @@ function initialize(obj, properties) {
 
   sendEvent(obj, 'init', undefined, undefined, undefined, m);
 }
-
-function defineSelfDestructingImplicitInjectionGetter(obj, keyName, value, message) {
-  Object.defineProperty(obj, keyName, {
-    configurable: true,
-    enumerable: true,
-
-    get() {
-      // only want to deprecate on first access so we make this self destructing
-      Object.defineProperty(obj, keyName, {
-        value
-      });
-      implicitInjectionDeprecation(keyName, message);
-      return value;
-    }
-
-  });
-}
 /**
   `CoreObject` is the base class for all Ember constructs. It establishes a
   class system based on Ember's Mixin system, and provides the basis for the
@@ -234,15 +159,12 @@ function defineSelfDestructingImplicitInjectionGetter(obj, keyName, value, messa
 
 class CoreObject {
   constructor(owner) {
-    // setOwner has to set both OWNER and LEGACY_OWNER for backwards compatibility, and
-    // LEGACY_OWNER is enumerable, so setting it would add an enumerable property to the object,
-    // so we just set `OWNER` directly here.
     this[OWNER] = owner; // prepare prototype...
 
     this.constructor.proto();
     let self = this;
 
-    if (DEBUG && HAS_NATIVE_PROXY && typeof self.unknownProperty === 'function') {
+    if (DEBUG && typeof self.unknownProperty === 'function') {
       let messageFor = (obj, property) => {
         return `You attempted to access the \`${String(property)}\` property (of ${obj}).\n` + `Since Ember 3.1, this is usually fine as you no longer need to use \`.get()\`\n` + `to access computed properties. However, in this case, the object in question\n` + `is a special kind of Ember object (a proxy). Therefore, it is still necessary\n` + `to use \`.get('${String(property)}')\` in this case.\n\n` + `If you encountered this error because of third-party code that you don't control,\n` + `there is more information at https://github.com/emberjs/ember.js/issues/16148, and\n` + `you can help us improve this error message by telling us more about what happened in\n` + `this situation.`;
       };
@@ -277,11 +199,7 @@ class CoreObject {
     if (DEBUG && self !== this) {
       return self;
     }
-  } // Empty setter for absorbing setting the LEGACY_OWNER, which should _not_
-  // become an enumerable property, and should not be used in general.
-
-
-  set [LEGACY_OWNER](value) {}
+  }
 
   reopen(...args) {
     applyMixin(this, args);
@@ -928,7 +846,7 @@ function flattenProps(...props) {
 
       if (hasMergedProps && mergedProperties.indexOf(keyName) > -1) {
         let baseValue = initProperties[keyName];
-        value = assign({}, baseValue, value);
+        value = Object.assign({}, baseValue, value);
       }
 
       initProperties[keyName] = value;
@@ -993,53 +911,4 @@ if (DEBUG) {
   };
 }
 
-if (!HAS_NATIVE_SYMBOL) {
-  // Allows OWNER and INIT_FACTORY to be non-enumerable in IE11
-  let instanceOwner = new WeakMap();
-  let instanceFactory = new WeakMap();
-  Object.defineProperty(CoreObject.prototype, OWNER, {
-    get() {
-      return instanceOwner.get(this);
-    },
-
-    set(value) {
-      instanceOwner.set(this, value);
-    }
-
-  });
-  Object.defineProperty(CoreObject.prototype, INIT_FACTORY, {
-    get() {
-      return instanceFactory.get(this);
-    },
-
-    set(value) {
-      instanceFactory.set(this, value);
-    }
-
-  });
-  Object.defineProperty(CoreObject, INIT_FACTORY, {
-    get() {
-      return instanceFactory.get(this);
-    },
-
-    set(value) {
-      instanceFactory.set(this, value);
-    },
-
-    enumerable: false
-  });
-}
-
-function implicitInjectionDeprecation(keyName, msg = null) {
-  deprecate(msg, false, {
-    id: 'implicit-injections',
-    until: '4.0.0',
-    url: 'https://deprecations.emberjs.com/v3.x#toc_implicit-injections',
-    for: 'ember-source',
-    since: {
-      enabled: '3.26.0'
-    }
-  });
-}
-
 export default CoreObject;