ember-source 4.4.0-alpha.7 → 4.5.0-alpha.2

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.4.0-alpha.7
+ * @version   4.5.0-alpha.2
  */

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

@@ -116,8 +116,7 @@ class Container {
     @private
    @method lookup
    @param {String} fullName
-   @param {Object} [options]
-   @param {String} [options.source] The fullname of the request source (used for local lookup)
+   @param {TypeOptions} [options]
    @return {any}
    */
 
@@ -197,9 +196,7 @@ class Container {
     }
 
     let normalizedName = this.registry.normalize(fullName);
-    assert('fullName must be a proper full name', this.registry.isValidFullName(normalizedName)); // TODO: This needs to return a Factory to be compatible with Owner.
-    // We should correctly the types so that this cast is not necessary.
-
+    assert('fullName must be a proper full name', this.registry.isValidFullName(normalizedName));
     return factoryFor(this, normalizedName, fullName);
   }
 
@@ -458,7 +455,6 @@ class Registry {
     this.fallback = options.fallback || null;
     this.resolver = options.resolver || null;
     this.registrations = dictionary(options.registrations || null);
-    this._localLookupCache = Object.create(null);
     this._normalizeCache = dictionary(null);
     this._resolveCache = dictionary(null);
     this._failSet = new Set();
@@ -551,7 +547,6 @@ class Registry {
   unregister(fullName) {
     assert('fullName must be a proper full name', this.isValidFullName(fullName));
     let normalizedName = this.normalize(fullName);
-    this._localLookupCache = Object.create(null);
     delete this.registrations[normalizedName];
     delete this._resolveCache[normalizedName];
     delete this._options[normalizedName];
@@ -582,8 +577,6 @@ class Registry {
       @private
    @method resolve
    @param {String} fullName
-   @param {Object} [options]
-   @param {String} [options.source] the fullname of the request source (used for local lookups)
    @return {Function} fullName's factory
    */
 
@@ -592,7 +585,7 @@ class Registry {
     let factory = resolve(this, this.normalize(fullName));
 
     if (factory === undefined && this.fallback !== null) {
-      factory = this.fallback.resolve(...arguments);
+      factory = this.fallback.resolve(fullName);
     }
 
     return factory;

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

@@ -1,6 +1,6 @@
 import { templateFactory, programCompilationContext } from '@glimmer/opcode-compiler';
 export { templateFactory as template, templateCacheCounters } from '@glimmer/opcode-compiler';
-import { setOwner, getOwner } from '@ember/-internals/owner';
+import { setOwner, getOwner, isFactory } from '@ember/-internals/owner';
 import { guidFor, symbol, enumerableSymbol, getDebugName, isProxy, isEmberArray, isObject, uuid } from '@ember/-internals/utils';
 import { assert, warn, debugFreeze, inspect, deprecate } from '@ember/debug';
 import { setComponentTemplate, setInternalComponentManager, setInternalHelperManager, getInternalHelperManager, helperCapabilities, setHelperManager, capabilityFlagsFrom, setInternalModifierManager, getComponentTemplate, getInternalComponentManager, componentCapabilities, modifierCapabilities, setComponentManager } from '@glimmer/manager';
@@ -2733,6 +2733,7 @@ class Helper extends FrameworkObject {
   init(properties) {
     super.init(properties);
     this[RECOMPUTE_TAG] = createTag();
+    assert('expected compute to be defined', this.compute);
   }
   /**
     On a class-based helper, it may be useful to force a recomputation of that
@@ -2785,6 +2786,14 @@ class ClassicHelperManager {
 
   createHelper(definition, args) {
     let instance = isFactoryManager(definition) ? definition.create() : definition.create(this.ownerInjection);
+    assert('expected HelperInstance', function (instance) {
+      if (instance !== null && typeof instance === 'object') {
+        let cast = instance;
+        return typeof cast.compute === 'function' && typeof cast.destroy === 'function';
+      }
+
+      return false;
+    }(instance));
     return {
       instance,
       args
@@ -3042,9 +3051,12 @@ class OutletComponentManager {
         assert('Expected currentOwner to be an EngineInstance', currentOwner instanceof EngineInstance);
         let mountPoint = currentOwner.mountPoint;
         state.engine = currentOwner;
-        state.engineBucket = {
-          mountPoint
-        };
+
+        if (mountPoint) {
+          state.engineBucket = {
+            mountPoint
+          };
+        }
       }
     }
 
@@ -4814,7 +4826,7 @@ function layoutFor(name, owner, options) {
 function lookupComponentPair(owner, name, options) {
   let component = componentFor(name, owner);
 
-  if (component !== null && component.class !== undefined) {
+  if (isFactory(component) && component.class) {
     let layout = getComponentTemplate(component.class);
 
     if (layout !== undefined) {
@@ -4896,13 +4908,13 @@ class ResolverImpl {
 
   lookupHelper(name, owner) {
     assert(`You attempted to overwrite the built-in helper "${name}" which is not allowed. Please rename the helper.`, !(BUILTIN_HELPERS[name] && owner.hasRegistration(`helper:${name}`)));
-    const helper$$1 = BUILTIN_HELPERS[name];
+    let helper$$1 = BUILTIN_HELPERS[name];
 
     if (helper$$1 !== undefined) {
       return helper$$1;
     }
 
-    const factory = owner.factoryFor(`helper:${name}`);
+    let factory = owner.factoryFor(`helper:${name}`);
 
     if (factory === undefined) {
       return null;

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

@@ -1,4 +1,7 @@
 import { getOwner as glimmerGetOwner, setOwner as glimmerSetOwner } from '@glimmer/owner';
+export function isFactory(obj) {
+  return obj != null && typeof obj.create === 'function';
+}
 /**
   Framework objects in an Ember application (components, services, routes, etc.)
   are created via a factory and dependency injection system. Each of these

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

@@ -78,6 +78,8 @@ const {
 */
 
 class EmberRouter extends EmberObject.extend(Evented) {
+  // Note that owner is actually required in this scenario, but since it is strictly
+  // optional in other contexts trying to make it required here confuses TS.
   constructor(owner) {
     super(owner);
     this._didSetupRouter = false;
@@ -97,6 +99,7 @@ class EmberRouter extends EmberObject.extend(Evented) {
     this._slowTransitionTimer = null;
     this.currentState = null;
     this.targetState = null;
+    assert('BUG: Missing owner', owner);
 
     this._resetQueuedQueryParameterChanges();
 

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

@@ -4,6 +4,7 @@
 import { NAMESPACES, NAMESPACES_BY_ID, addNamespace, findNamespace, findNamespaces, get, processNamespace, processAllNamespaces, removeNamespace } from '@ember/-internals/metal'; // Preloaded into namespaces
 
 import { getName, guidFor, setName } from '@ember/-internals/utils';
+import { assert } from '@ember/debug';
 import EmberObject from './object';
 /**
   A Namespace is an object usually used to contain other objects or methods
@@ -23,20 +24,22 @@ import EmberObject from './object';
   @public
 */
 
-export default class Namespace extends EmberObject {
-  init() {
+class Namespace extends EmberObject {
+  init(properties) {
+    super.init(properties);
     addNamespace(this);
   }
 
   toString() {
-    let name = get(this, 'name') || get(this, 'modulePrefix');
+    let existing_name = get(this, 'name') || get(this, 'modulePrefix');
 
-    if (name) {
-      return name;
+    if (existing_name) {
+      assert("name wasn't a string", typeof existing_name === 'string');
+      return existing_name;
     }
 
     findNamespaces();
-    name = getName(this);
+    let name = getName(this);
 
     if (name === undefined) {
       name = guidFor(this);
@@ -52,12 +55,15 @@ export default class Namespace extends EmberObject {
 
   destroy() {
     removeNamespace(this);
-    super.destroy();
+    return super.destroy();
   }
 
 }
-Namespace.prototype.isNamespace = true;
+
 Namespace.NAMESPACES = NAMESPACES;
 Namespace.NAMESPACES_BY_ID = NAMESPACES_BY_ID;
 Namespace.processAll = processAllNamespaces;
-Namespace.byName = findNamespace;
+Namespace.byName = findNamespace; // Declare on the prototype to have a single shared value.
+
+Namespace.prototype.isNamespace = true;
+export default Namespace;

package/dist/packages/@ember/-internals/views/lib/views/core_view.js

@@ -10,11 +10,7 @@ import { inject } from '@ember/-internals/metal';
 import { ActionHandler, Evented, FrameworkObject } from '@ember/-internals/runtime';
 import states from './states';
 
-class CoreView extends FrameworkObject.extend(Evented, ActionHandler, {
-  // Continue to declare `_states` here so that we have a single reference on the prototype
-  // instead of one on each instance.
-  _states: states
-}) {
+class CoreView extends FrameworkObject.extend(Evented, ActionHandler) {
   constructor() {
     super(...arguments);
     this.isView = true;
@@ -72,6 +68,8 @@ class CoreView extends FrameworkObject.extend(Evented, ActionHandler, {
 
 CoreView.isViewFactory = true;
 
-__decorate([inject('renderer', '-dom')], CoreView.prototype, "renderer", void 0);
+__decorate([inject('renderer', '-dom')], CoreView.prototype, "renderer", void 0); // Declare on the prototype to have a single shared value.
 
+
+CoreView.prototype._states = states;
 export default CoreView;