ember-source 4.0.0-beta.1 → 4.0.0-beta.10

package/dist/header/license.js

@@ -5,5 +5,5 @@
  *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
  * @license   Licensed under MIT license
  *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
- * @version   4.0.0-beta.1
+ * @version   4.0.0-beta.10
  */

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

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

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

@@ -145,18 +145,6 @@ const ENV = {
   */
   _DEBUG_RENDER_TREE: DEBUG,
 
-  /**
-    Whether the app is using jQuery. See RFC #294.
-       This is not intended to be set directly, as the implementation may change in
-    the future. Use `@ember/optional-features` instead.
-       @property _JQUERY_INTEGRATION
-    @for EmberENV
-    @type Boolean
-    @default true
-    @private
-  */
-  _JQUERY_INTEGRATION: true,
-
   /**
     Whether the app defaults to using async observers.
        This is not intended to be set directly, as the implementation may change in
@@ -180,21 +168,6 @@ const ENV = {
     @private
    */
   _RERENDER_LOOP_LIMIT: 1000,
-
-  /**
-    Allows disabling the implicit this property fallback deprecation. This could be useful
-    as a way to control the volume of deprecations that are issued by temporarily disabling
-    the implicit this fallback deprecations, which would allow the other deprecations to be more easily
-    identified in the console).
-       NOTE: The fallback behavior **will be removed** in Ember 4.0.0, disabling **_IS NOT_**
-    a viable strategy for handling this deprecation.
-       @property _DISABLE_PROPERTY_FALLBACK_DEPRECATION
-    @for EmberENV
-    @type boolean
-    @default false
-    @private
-   */
-  _DISABLE_PROPERTY_FALLBACK_DEPRECATION: false,
   EMBER_LOAD_HOOKS: {},
   FEATURES: {}
 };

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

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