ember-source 4.3.0-alpha.2 → 4.4.0-alpha.1

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

@@ -1505,7 +1505,11 @@ function installAttributeBinding(component, rootRef, parsed, operations) {
   operations.setAttribute(attribute, reference, false, null);
 }
 function createClassNameBindingRef(rootRef, microsyntax, operations) {
-  let [prop, truthy, falsy] = microsyntax.split(':');
+  let parts = microsyntax.split(':');
+  let [prop, truthy, falsy] = parts; // NOTE: This could be an empty string
+
+  assert('has prop', prop !== undefined); // Will always have at least one part
+
   let isStatic = prop === '';
 
   if (isStatic) {
@@ -1889,9 +1893,10 @@ var action$1 = internalHelper(args => {
   // Anything else is an action argument.
 
   let [context, action$$1, ...restArgs] = positional;
+  assert('hash position arguments', context && action$$1);
   let debugKey = action$$1.debugLabel;
-  let target = 'target' in named ? named.target : context;
-  let processArgs = makeArgsProcessor('value' in named && named.value, restArgs);
+  let target = 'target' in named && named.target ? named.target : context;
+  let processArgs = makeArgsProcessor('value' in named && named.value || false, restArgs);
   let fn$$1;
 
   if (isInvokableRef(action$$1)) {
@@ -2001,6 +2006,7 @@ function processComponentArgs(namedArgs) {
 
   for (let name in namedArgs) {
     let ref = namedArgs[name];
+    assert('expected ref', ref);
     let value = valueForRef(ref);
     let isAction = typeof value === 'function' && ACTIONS.has(value);
 
@@ -2064,6 +2070,7 @@ function applyAttributeBindings(attributeBindings, component, rootRef, operation
 
   while (i !== -1) {
     let binding = attributeBindings[i];
+    assert('has binding', binding);
     let parsed = parseAttributeBinding(binding);
     let attribute = parsed[1];
 
@@ -2090,6 +2097,7 @@ class CurlyComponentManager {
       layoutName
     } = component;
     let owner = getOwner(component);
+    assert('Component is unexpectedly missing an owner', owner);
     let factory;
 
     if (layout === undefined) {
@@ -2142,8 +2150,9 @@ class CurlyComponentManager {
           {
         __ARGS__
       } = _b,
-          rest = __rest(_b, ["__ARGS__"]); // does this need to be untracked?
+          rest = __rest(_b, ["__ARGS__"]);
 
+      assert('[BUG] unexpectedly missing __ARGS__ after check', __ARGS__); // does this need to be untracked?
 
       let __args__ = valueForRef(__ARGS__);
 
@@ -2177,14 +2186,8 @@ class CurlyComponentManager {
       Object.assign(named, args.named.capture());
 
       for (let i = 0; i < count; i++) {
-        // As of TS 3.7, tsc is giving us the following error on this line without the type annotation
-        //
-        //   TS7022: 'name' implicitly has type 'any' because it does not have a type annotation and is
-        //   referenced directly or indirectly in its own initializer.
-        //
-        // This is almost certainly a TypeScript bug, feel free to try and remove the annotation after
-        // upgrading if it is not needed anymore.
-        const name = positionalParams[i];
+        let name = positionalParams[i];
+        assert('Expected at least one positional param', name);
         assert(`You cannot specify both a positional param (at position ${i}) and the hash argument \`${name}\`.`, !args.named.has(name));
         named[name] = args.positional.at(i);
       }
@@ -2444,9 +2447,7 @@ function processComponentInitializationAssertions(component, props) {
       classNameBindings
     } = component;
 
-    for (let i = 0; i < classNameBindings.length; i++) {
-      let binding = classNameBindings[i];
-
+    for (let binding of classNameBindings) {
       if (binding.split(' ').length > 1) {
         return false;
       }
@@ -3160,6 +3161,7 @@ const Component = CoreView.extend(ChildViewsSupport, ViewStateSupport, ClassName
   get _dispatcher() {
     if (this.__dispatcher === undefined) {
       let owner = getOwner(this);
+      assert('Component is unexpectedly missing an owner', owner);
 
       if (owner.lookup('-environment:main').isInteractive) {
         this.__dispatcher = owner.lookup('event_dispatcher:main');
@@ -3404,6 +3406,59 @@ const Component = CoreView.extend(ChildViewsSupport, ViewStateSupport, ClassName
    @since 1.13.0
    */
   didUpdate() {}
+  /**
+   Called when the component has updated and rerendered itself.
+   Called only during a rerender, not during an initial render.
+   @event didUpdate
+   @public
+   @since 1.13.0
+   */
+
+  /**
+    Layout can be used to wrap content in a component.
+    @property layout
+    @type Function
+    @public
+  */
+
+  /**
+    The name of the layout to lookup if no layout is provided.
+    By default `Component` will lookup a template with this name in
+    `Ember.TEMPLATES` (a shared global object).
+    @property layoutName
+    @type String
+    @default null
+    @private
+  */
+
+  /**
+    The HTML `id` of the component's element in the DOM. You can provide this
+    value yourself but it must be unique (just as in HTML):
+     ```handlebars
+    {{my-component elementId="a-really-cool-id"}}
+    ```
+     ```handlebars
+    <MyComponent @elementId="a-really-cool-id" />
+    ```
+    If not manually set a default value will be provided by the framework.
+    Once rendered an element's `elementId` is considered immutable and you
+    should never change it. If you need to compute a dynamic value for the
+    `elementId`, you should do this when the component or element is being
+    instantiated:
+     ```javascript
+    export default Component.extend({
+      init() {
+        this._super(...arguments);
+         var index = this.get('index');
+        this.set('elementId', `component-id${index}`);
+      }
+    });
+    ```
+     @property elementId
+    @type String
+    @public
+  */
+
 
 });
 
@@ -3418,60 +3473,15 @@ setInternalComponentManager(CURLY_COMPONENT_MANAGER, Component);
 /**
 @module @ember/component
 */
+var _a;
 const RECOMPUTE_TAG = symbol('RECOMPUTE_TAG');
-/**
-  Ember Helpers are functions that can compute values, and are used in templates.
-  For example, this code calls a helper named `format-currency`:
-
-  ```app/templates/application.hbs
-  <Cost @cents={{230}} />
-  ```
-
-  ```app/components/cost.hbs
-  <div>{{format-currency @cents currency="$"}}</div>
-  ```
-
-  Additionally a helper can be called as a nested helper.
-  In this example, we show the formatted currency value if the `showMoney`
-  named argument is truthy.
+const IS_CLASSIC_HELPER = Symbol('IS_CLASSIC_HELPER');
 
-  ```handlebars
-  {{if @showMoney (format-currency @cents currency="$")}}
-  ```
-
-  Helpers defined using a class must provide a `compute` function. For example:
-
-  ```app/helpers/format-currency.js
-  import Helper from '@ember/component/helper';
-
-  export default class extends Helper {
-    compute([cents], { currency }) {
-      return `${currency}${cents * 0.01}`;
-    }
-  }
-  ```
-
-  Each time the input to a helper changes, the `compute` function will be
-  called again.
-
-  As instances, these helpers also have access to the container and will accept
-  injected dependencies.
-
-  Additionally, class helpers can call `recompute` to force a new computation.
-
-  @class Helper
-  @extends CoreObject
-  @public
-  @since 1.13.0
-*/
-
-let Helper = FrameworkObject.extend({
+class Helper extends FrameworkObject {
   init() {
-    this._super(...arguments);
-
+    super.init();
     this[RECOMPUTE_TAG] = createTag();
-  },
-
+  }
   /**
     On a class-based helper, it may be useful to force a recomputation of that
     helpers value. This is akin to `rerender` on a component.
@@ -3495,14 +3505,17 @@ let Helper = FrameworkObject.extend({
     @public
     @since 1.13.0
   */
+
+
   recompute() {
     join(() => dirtyTag(this[RECOMPUTE_TAG]));
   }
 
-});
-const IS_CLASSIC_HELPER = symbol('IS_CLASSIC_HELPER');
+}
+
+_a = IS_CLASSIC_HELPER;
 Helper.isHelperFactory = true;
-Helper[IS_CLASSIC_HELPER] = true;
+Helper[_a] = true;
 function isClassicHelper(obj) {
   return obj[IS_CLASSIC_HELPER] === true;
 }
@@ -3519,7 +3532,7 @@ class ClassicHelperManager {
   }
 
   createHelper(definition, args) {
-    let instance = definition.class === undefined ? definition.create(this.ownerInjection) : definition.create();
+    let instance = isFactoryManager(definition) ? definition.create() : definition.create(this.ownerInjection);
     return {
       instance,
       args
@@ -3551,6 +3564,10 @@ class ClassicHelperManager {
 
 }
 
+function isFactoryManager(obj) {
+  return obj != null && 'class' in obj;
+}
+
 setHelperManager(owner => {
   return new ClassicHelperManager(owner);
 }, Helper);
@@ -4131,7 +4148,8 @@ class EachInWrapper {
 var eachIn = internalHelper(({
   positional
 }) => {
-  let inner = positional[0];
+  const inner = positional[0];
+  assert('expected at least one positional arg', inner);
   return createComputeRef(() => {
     let iterable = valueForRef(inner);
     consumeTag(tagForObject(iterable));
@@ -4270,18 +4288,14 @@ class ObjectIterator extends BoundedIterator {
 
   static fromIndexable(obj) {
     let keys = Object.keys(obj);
-    let {
-      length
-    } = keys;
 
-    if (length === 0) {
+    if (keys.length === 0) {
       return null;
     } else {
       let values = [];
 
-      for (let i = 0; i < length; i++) {
+      for (let key of keys) {
         let value;
-        let key = keys[i];
         value = obj[key]; // Add the tag of the returned value if it is an array, since arrays
         // should always cause updates if they are consumed and then changed
 
@@ -4541,14 +4555,14 @@ var disallowDynamicResolution = internalHelper(({
   positional,
   named
 }) => {
-  assert(`[BUG] wrong number of positional arguments, expecting 1, got ${positional.length}`, positional.length === 1);
-  let nameOrValueRef = positional[0];
-  assert(`[BUG] expecting \`type\` named argument`, 'type' in named);
-  assert(`[BUG] expecting \`loc\` named argument`, 'loc' in named);
-  assert(`[BUG] expecting \`original\` named argument`, 'original' in named);
+  const nameOrValueRef = positional[0];
+  assert(`[BUG] wrong number of positional arguments, expecting 1, got ${positional.length}`, positional.length === 1 && nameOrValueRef);
   let typeRef = named.type;
   let locRef = named.loc;
-  let originalRef = named.original; // Bug: why do these fail?
+  let originalRef = named.original;
+  assert(`[BUG] expecting \`type\` named argument`, typeRef);
+  assert(`[BUG] expecting \`loc\` named argument`, locRef);
+  assert(`[BUG] expecting \`original\` named argument`, originalRef); // Bug: why do these fail?
   // assert('[BUG] expecting a string literal for the `type` argument', isConstRef(typeRef));
   // assert('[BUG] expecting a string literal for the `loc` argument', isConstRef(locRef));
   // assert('[BUG] expecting a string literal for the `original` argument', isConstRef(originalRef));
@@ -4570,7 +4584,8 @@ let helper$1;
 
 if (DEBUG) {
   helper$1 = args => {
-    let inner = args.positional[0];
+    const inner = args.positional[0];
+    assert('expected at least one positional arg', inner);
     return createComputeRef(() => {
       let value = valueForRef(inner);
       assert('You cannot pass a null or undefined destination element to in-element', value !== null && value !== undefined);
@@ -4578,7 +4593,11 @@ if (DEBUG) {
     });
   };
 } else {
-  helper$1 = args => args.positional[0];
+  helper$1 = args => {
+    let arg = args.positional[0];
+    assert('expected at least one positional arg', arg);
+    return arg;
+  };
 }
 
 var inElementNullCheckHelper = internalHelper(helper$1);
@@ -4587,9 +4606,14 @@ var normalizeClassHelper = internalHelper(({
   positional
 }) => {
   return createComputeRef(() => {
-    let classNameParts = valueForRef(positional[0]).split('.');
+    let classNameArg = positional[0];
+    let valueArg = positional[1];
+    assert('expected at least two positional args', classNameArg && valueArg);
+    let classNameParts = valueForRef(classNameArg).split('.');
     let className = classNameParts[classNameParts.length - 1];
-    let value = valueForRef(positional[1]);
+    assert('has className', className); // Always at least one split result
+
+    let value = valueForRef(valueArg);
 
     if (value === true) {
       return dasherize(className);
@@ -4610,7 +4634,7 @@ var resolve = internalHelper(({
   assert('[BUG] missing owner', owner);
   assert(`[BUG] wrong number of positional arguments, expecting 1, got ${positional.length}`, positional.length === 1);
   let fullNameRef = positional[0];
-  assert('[BUG] expecting a string literal as argument', isConstRef(fullNameRef));
+  assert('[BUG] expecting a string literal as argument', fullNameRef && isConstRef(fullNameRef));
   let fullName = valueForRef(fullNameRef);
   assert('[BUG] expecting a string literal as argument', typeof fullName === 'string');
   assert('[BUG] expecting a valid full name', fullName.split(':').length === 2);
@@ -4635,7 +4659,8 @@ var resolve = internalHelper(({
 var trackArray = internalHelper(({
   positional
 }) => {
-  let inner = positional[0];
+  const inner = positional[0];
+  assert('expected at least one positional arg', inner);
   return createComputeRef(() => {
     let iterable = valueForRef(inner);
 
@@ -4727,7 +4752,8 @@ var trackArray = internalHelper(({
 var mut = internalHelper(({
   positional
 }) => {
-  let ref = positional[0]; // TODO: Improve this error message. This covers at least two distinct
+  let ref = positional[0];
+  assert('expected at least one positional arg', ref); // TODO: Improve this error message. This covers at least two distinct
   // cases:
   //
   // 1. (mut "not a path") – passing a literal, result from a helper
@@ -4863,7 +4889,9 @@ var mut = internalHelper(({
 var readonly = internalHelper(({
   positional
 }) => {
-  return createReadOnlyRef(positional[0]);
+  let firstArg = positional[0];
+  assert('has first arg', firstArg);
+  return createReadOnlyRef(firstArg);
 });
 
 /**
@@ -4902,7 +4930,7 @@ var unbound = internalHelper(({
   named
 }) => {
   assert('unbound helper cannot be called with multiple params or hash params', positional.length === 1 && Object.keys(named).length === 0);
-  return createUnboundRef(valueForRef(positional[0]), '(resurt of an `unbound` helper)');
+  return createUnboundRef(valueForRef(positional[0]), '(result of an `unbound` helper)');
 });
 
 const MODIFIERS = ['alt', 'shift', 'meta', 'ctrl'];
@@ -5121,6 +5149,7 @@ class ActionModifierManager {
       positional
     } = actionState;
     let actionNameRef = positional[1];
+    assert('Expected at least one positional arg', actionNameRef);
 
     if (!isInvokableRef(actionNameRef)) {
       actionState.actionName = valueForRef(actionNameRef);
@@ -5414,7 +5443,9 @@ const outletHelper = internalHelper((args, owner, scope) => {
   if (args.positional.length === 0) {
     nameRef = createPrimitiveRef('main');
   } else {
-    nameRef = args.positional[0];
+    let maybeNameRef = args.positional[0];
+    assert('Expected at least one positional arg', maybeNameRef);
+    nameRef = maybeNameRef;
   }
 
   let outletRef = createComputeRef(() => {
@@ -5854,8 +5885,8 @@ function deregister(renderer) {
 }
 
 function loopBegin() {
-  for (let i = 0; i < renderers.length; i++) {
-    renderers[i]._scheduleRevalidate();
+  for (let renderer of renderers) {
+    renderer._scheduleRevalidate();
   }
 }
 
@@ -5900,12 +5931,12 @@ function resolveRenderPromise() {
 let loops = 0;
 
 function loopEnd() {
-  for (let i = 0; i < renderers.length; i++) {
-    if (!renderers[i]._isValid()) {
+  for (let renderer of renderers) {
+    if (!renderer._isValid()) {
       if (loops > ENV._RERENDER_LOOP_LIMIT) {
         loops = 0; // TODO: do something better
 
-        renderers[i].destroy();
+        renderer.destroy();
         throw new Error('infinite rendering invalidation detected');
       }
 
@@ -5949,12 +5980,13 @@ class Renderer {
     let {
       _viewRegistry
     } = props;
-    let document = getOwner(props).lookup('service:-document');
-    let env = getOwner(props).lookup('-environment:main');
     let owner = getOwner(props);
+    assert('Renderer is unexpectedly missing an owner', owner);
+    let document = owner.lookup('service:-document');
+    let env = owner.lookup('-environment:main');
     let rootTemplate = owner.lookup(privatize`template:-root`);
     let builder = owner.lookup('service:-dom-builder');
-    return new this(getOwner(props), document, env, rootTemplate, _viewRegistry, builder);
+    return new this(owner, document, env, rootTemplate, _viewRegistry, builder);
   }
 
   get debugRenderTree() {
@@ -6027,6 +6059,7 @@ class Renderer {
 
     while (i--) {
       let root = roots[i];
+      assert('has root', root);
 
       if (root.isFor(view)) {
         root.destroy();
@@ -6098,6 +6131,7 @@ class Renderer {
         // each root is processed
         for (let i = 0; i < roots.length; i++) {
           let root = roots[i];
+          assert('has root', root);
 
           if (root.destroyed) {
             // add to the list of roots to be removed
@@ -6160,8 +6194,7 @@ class Renderer {
   _clearAllRoots() {
     let roots = this._roots;
 
-    for (let i = 0; i < roots.length; i++) {
-      let root = roots[i];
+    for (let root of roots) {
       root.destroy();
     }
 
@@ -6282,6 +6315,7 @@ class OutletView {
       template: templateFactory$$1
     } = options;
     let owner = getOwner(options);
+    assert('OutletView is unexpectedly missing an owner', owner);
     let template = templateFactory$$1(owner);
     return new OutletView(_environment, owner, template, namespace);
   }
@@ -6319,7 +6353,9 @@ function setupApplicationRegistry(registry) {
   // association won't leak
   registry.register('service:-dom-builder', {
     create(props) {
-      let env = getOwner(props).lookup('-environment:main');
+      let owner = getOwner(props);
+      assert('DomBuilderService is unexpectedly missing an owner', owner);
+      let env = owner.lookup('-environment:main');
 
       switch (env._renderMode) {
         case 'serialize':

package/dist/packages/@ember/-internals/meta/lib/meta.js

@@ -356,7 +356,8 @@ export class Meta {
         sync
       });
     } else {
-      let listener = listeners[i]; // If the listener is our own listener and we are trying to remove it, we
+      let listener = listeners[i];
+      assert('has listener', listener); // If the listener is our own listener and we are trying to remove it, we
       // want to splice it out entirely so we don't hold onto a reference.
 
       if (kind === 2
@@ -447,8 +448,7 @@ export class Meta {
               this._inheritedEnd = 0;
             }
 
-            for (let i = 0; i < parentListeners.length; i++) {
-              let listener = parentListeners[i];
+            for (let listener of parentListeners) {
               let index = indexOfListener(listeners, listener.event, listener.target, listener.method);
 
               if (index === -1) {
@@ -481,10 +481,9 @@ export class Meta {
     }
 
     if (listeners !== undefined) {
-      for (let index = 0; index < listeners.length; index++) {
-        let listener = listeners[index]; // REMOVE listeners are placeholders that tell us not to
+      for (let listener of listeners) {
+        // REMOVE listeners are placeholders that tell us not to
         // inherit, so they never match. Only ADD and ONCE can match.
-
         if (listener.event === eventName && (listener.kind === 0
         /* ADD */
         || listener.kind === 1
@@ -517,10 +516,9 @@ export class Meta {
     }
 
     if (listeners !== undefined) {
-      for (let index = 0; index < listeners.length; index++) {
-        let listener = listeners[index]; // REMOVE listeners are placeholders that tell us not to
+      for (let listener of listeners) {
+        // REMOVE listeners are placeholders that tell us not to
         // inherit, so they never match. Only ADD and ONCE can match.
-
         if ((listener.kind === 0
         /* ADD */
         || listener.kind === 1
@@ -642,6 +640,7 @@ export { counters };
 function indexOfListener(listeners, event, target, method) {
   for (let i = listeners.length - 1; i >= 0; i--) {
     let listener = listeners[i];
+    assert('has listener', listener);
 
     if (listener.event === event && listener.target === target && listener.method === method) {
       return i;