ember-source 3.28.5 → 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   3.28.5
+ * @version   4.0.0-beta.10
  */

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

@@ -1,63 +1,10 @@
-import { context } from '@ember/-internals/environment';
-import { onEmberGlobalAccess } from '@ember/-internals/overrides';
-import { deprecate } from '@ember/debug';
-import { DEBUG } from '@glimmer/env';
 import require from 'require';
 
 (function bootstrap() {
-  let Ember;
-
-  let get = () => {
-    if (!Ember) {
-      // tslint:disable-next-line: no-require-imports
-      Ember = require('ember').default;
-    }
-
-    return Ember;
-  };
-
-  if (DEBUG) {
-    let defaultHandler = () => {
-      return 'Usage of the Ember Global is deprecated. You should import the Ember module or the specific API instead.';
-    };
-
-    let handler = onEmberGlobalAccess || defaultHandler;
-    let _get = get;
-
-    get = () => {
-      let message = handler();
-
-      if (message !== null) {
-        deprecate(message, false, {
-          id: 'ember-global',
-          until: '4.0.0',
-          url: 'https://deprecations.emberjs.com/v3.x/#toc_ember-global',
-          for: 'ember-source',
-          since: {
-            enabled: '3.27.0'
-          }
-        });
-      }
-
-      return _get();
-    };
-  }
-
-  function defineEmber(key) {
-    Object.defineProperty(context.exports, key, {
-      enumerable: true,
-      configurable: true,
-      get
-    });
-  } // Bootstrap the global
-
-
-  defineEmber('Ember');
-  defineEmber('Em'); // Bootstrap Node module
+  // Bootstrap Node module
   // eslint-disable-next-line no-undef
-
   if (typeof module === 'object' && typeof module.require === 'function') {
     // tslint:disable-next-line: no-require-imports
-    module.exports = Ember = require('ember').default;
+    module.exports = require('ember').default;
   }
 })();

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

@@ -1,7 +1,6 @@
 import { setOwner } from '@ember/-internals/owner';
-import { dictionary, HAS_NATIVE_PROXY, HAS_NATIVE_SYMBOL, symbol, intern } from '@ember/-internals/utils';
-import { assert } from '@ember/debug';
-import { assign } from '@ember/polyfills';
+import { dictionary, symbol, intern } from '@ember/-internals/utils';
+import { assert, deprecate } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 
 let leakTracking;
@@ -215,29 +214,25 @@ if (DEBUG) {
 
 
 function wrapManagerInDeprecationProxy(manager) {
-  if (HAS_NATIVE_PROXY) {
-    let validator = {
-      set(_obj, prop) {
-        throw new Error(`You attempted to set "${prop}" on a factory manager created by container#factoryFor. A factory manager is a read-only construct.`);
-      }
-
-    }; // Note:
-    // We have to proxy access to the manager here so that private property
-    // access doesn't cause the above errors to occur.
+  let validator = {
+    set(_obj, prop) {
+      throw new Error(`You attempted to set "${prop}" on a factory manager created by container#factoryFor. A factory manager is a read-only construct.`);
+    }
 
-    let m = manager;
-    let proxiedManager = {
-      class: m.class,
+  }; // Note:
+  // We have to proxy access to the manager here so that private property
+  // access doesn't cause the above errors to occur.
 
-      create(props) {
-        return m.create(props);
-      }
+  let m = manager;
+  let proxiedManager = {
+    class: m.class,
 
-    };
-    return new Proxy(proxiedManager, validator);
-  }
+    create(props) {
+      return m.create(props);
+    }
 
-  return manager;
+  };
+  return new Proxy(proxiedManager, validator);
 }
 
 function isSingleton(container, fullName) {
@@ -352,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);
@@ -450,7 +398,7 @@ class FactoryManager {
     this.injections = undefined;
     setFactoryFor(this, this);
 
-    if (isInstantiatable(container, fullName) && (HAS_NATIVE_SYMBOL || INIT_FACTORY in factory)) {
+    if (isInstantiatable(container, fullName)) {
       setFactoryFor(factory, this);
     }
   }
@@ -472,23 +420,12 @@ 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 = assign({}, props, options);
+      props = Object.assign({}, props, options);
     }
 
     if (DEBUG) {
@@ -530,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);
@@ -559,18 +494,6 @@ class Registry {
    @type InheritingDict
    */
 
-  /**
-   @private
-      @property _typeInjections
-   @type InheritingDict
-   */
-
-  /**
-   @private
-      @property _injections
-   @type InheritingDict
-   */
-
   /**
    @private
       @property _normalizeCache
@@ -869,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'
+      }
     });
   }
   /**
@@ -988,41 +845,13 @@ class Registry {
       resolverKnown = this.resolver.knownForType(type);
     }
 
-    return assign({}, fallbackKnown, localKnown, resolverKnown);
+    return Object.assign({}, fallbackKnown, localKnown, resolverKnown);
   }
 
   isValidFullName(fullName) {
     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

@@ -1,4 +1,3 @@
-import { FUNCTION_PROTOTYPE_EXTENSIONS } from '@ember/deprecated-features';
 import { DEBUG } from '@glimmer/env';
 
 // from lodash to catch fake globals
@@ -52,7 +51,7 @@ const ENV = {
   ENABLE_OPTIONAL_FEATURES: false,
 
   /**
-    Determines whether Ember should add to `Array`, `Function`, and `String`
+    Determines whether Ember should add to `Array`
     native object prototypes, a few extra methods in order to provide a more
     friendly API.
        We generally recommend leaving this option set to true however, if you need
@@ -68,9 +67,7 @@ const ENV = {
     @public
   */
   EXTEND_PROTOTYPES: {
-    Array: true,
-    Function: true,
-    String: true
+    Array: true
   },
 
   /**
@@ -148,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
@@ -183,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: {}
 };
@@ -222,22 +192,9 @@ const ENV = {
 
   if (EXTEND_PROTOTYPES !== undefined) {
     if (typeof EXTEND_PROTOTYPES === 'object' && EXTEND_PROTOTYPES !== null) {
-      ENV.EXTEND_PROTOTYPES.String = EXTEND_PROTOTYPES.String !== false;
-
-      if (FUNCTION_PROTOTYPE_EXTENSIONS) {
-        ENV.EXTEND_PROTOTYPES.Function = EXTEND_PROTOTYPES.Function !== false;
-      }
-
       ENV.EXTEND_PROTOTYPES.Array = EXTEND_PROTOTYPES.Array !== false;
     } else {
-      let isEnabled = EXTEND_PROTOTYPES !== false;
-      ENV.EXTEND_PROTOTYPES.String = isEnabled;
-
-      if (FUNCTION_PROTOTYPE_EXTENSIONS) {
-        ENV.EXTEND_PROTOTYPES.Function = isEnabled;
-      }
-
-      ENV.EXTEND_PROTOTYPES.Array = isEnabled;
+      ENV.EXTEND_PROTOTYPES.Array = EXTEND_PROTOTYPES !== false;
     }
   } // TODO this does not seem to be used by anything,
   //      can we remove it? do we need to deprecate it?

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

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

@@ -2,12 +2,11 @@ import { getOwner } from '@ember/-internals/owner';
 import { _backburner } from '@ember/runloop';
 import { get } from '@ember/-internals/metal';
 import { dasherize } from '@ember/string';
-import { HAS_NATIVE_SYMBOL } from '@ember/-internals/utils';
 import { Namespace, Object as EmberObject, A as emberA } from '@ember/-internals/runtime';
 import { consumeTag, createCache, getValue, tagFor, untrack } from '@glimmer/validator';
 
 function iterate(arr, fn) {
-  if (HAS_NATIVE_SYMBOL && Symbol.iterator in arr) {
+  if (Symbol.iterator in arr) {
     for (let item of arr) {
       fn(item);
     }