ember-source 2.18.0.beta.3 → 2.18.0.beta.4

data/dist/ember.prod.js

@@ -6,7 +6,7 @@
  *            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   2.18.0-beta.3
+ * @version   2.18.0-beta.4
  */
 
 /*global process */
@@ -21085,7 +21085,7 @@ enifed('ember-glimmer/utils/string', ['exports', 'ember-debug'], function (expor
       ```
     
       @method htmlSafe
-      @for @ember/string
+      @for @ember/template
       @static
       @return {Handlebars.SafeString} A string that will not be HTML escaped by Handlebars.
       @public
@@ -21113,7 +21113,7 @@ enifed('ember-glimmer/utils/string', ['exports', 'ember-debug'], function (expor
       ```
     
       @method isHTMLSafe
-      @for @ember/string
+      @for @ember/template
       @static
       @return {Boolean} `true` if the string was decorated with `htmlSafe`, `false` otherwise.
       @public
@@ -22668,7 +22668,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
 
     if (counter === 1) {
       m.writeWatching(keyPath, 0);
-      m.readableChains().remove(keyPath);
+      m.writableChains(makeChainNode).remove(keyPath);
     } else if (counter > 1) {
       m.writeWatching(keyPath, counter - 1);
     }
@@ -22913,11 +22913,8 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
       if (paths === undefined) {
         return;
       }
-
       if (paths[path] > 0) {
         paths[path]--;
-      } else {
-        return;
       }
 
       var key = firstKey(path);
@@ -25172,14 +25169,15 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     call.
   
     ```javascript
+    import { run } from '@ember/runloop';
+  
     run(function() {
       // code to be executed within a RunLoop
     });
     ```
-  
-    @class @ember/runloop
+    @method run
+    @for @ember/runloop
     @static
-    @constructor
     @param {Object} [target] target of method to call
     @param {Function|String} method Method to invoke.
       May be a function or a string. If you pass a string
@@ -25202,7 +25200,9 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     If invoked when not within a run loop:
   
     ```javascript
-    run.join(function() {
+    import { join } from '@ember/runloop';
+  
+    join(function() {
       // creates a new run-loop
     });
     ```
@@ -25210,9 +25210,12 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     Alternatively, if called within an existing run loop:
   
     ```javascript
+    import { run, join } from '@ember/runloop';
+  
     run(function() {
       // creates a new run-loop
-      run.join(function() {
+  
+      join(function() {
         // joins with the existing run-loop, and queues for invocation on
         // the existing run-loops action queue.
       });
@@ -25241,7 +25244,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     makes this method a great way to asynchronously integrate third-party libraries
     into your Ember application.
   
-    `run.bind` takes two main arguments, the desired context and the function to
+    `bind` takes two main arguments, the desired context and the function to
     invoke in that context. Any additional arguments will be supplied as arguments
     to the function that is passed in.
   
@@ -25253,10 +25256,11 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   
     ```app/components/rich-text-editor.js
     import Component from '@ember/component';
+    import { on } from '@ember/object/evented';
     import { bind } from '@ember/runloop';
   
     export default Component.extend({
-      initializeTinyMCE: Ember.on('didInsertElement', function() {
+      initializeTinyMCE: on('didInsertElement', function() {
         tinymce.init({
           selector: '#' + this.$().prop('id'),
           setup: Ember.run.bind(this, this.setupEditor)
@@ -25324,9 +25328,11 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     a lower-level way to use a RunLoop instead of using `run()`.
   
     ```javascript
-    run.begin();
+    import { begin, end } from '@ember/runloop';
+  
+    begin();
     // code to be executed within a RunLoop
-    run.end();
+    end();
     ```
   
     @method begin
@@ -25345,9 +25351,11 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     to use a RunLoop instead of using `run()`.
   
     ```javascript
-    run.begin();
+    import { begin, end } from '@ember/runloop';
+  
+    begin();
     // code to be executed within a RunLoop
-    run.end();
+    end();
     ```
   
     @method end
@@ -25383,12 +25391,14 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     the `run.queues` property.
   
     ```javascript
-    run.schedule('sync', this, function() {
+    import { schedule } from '@ember/runloop';
+  
+    schedule('sync', this, function() {
       // this will be executed in the first RunLoop queue, when bindings are synced
       console.log('scheduled on sync queue');
     });
   
-    run.schedule('actions', this, function() {
+    schedule('actions', this, function() {
       // this will be executed in the 'actions' queue, after bindings have synced.
       console.log('scheduled on actions queue');
     });
@@ -25464,7 +25474,9 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     together, which is often more efficient than using a real setTimeout.
   
     ```javascript
-    run.later(myContext, function() {
+    import { later } from '@ember/runloop';
+  
+    later(myContext, function() {
       // code here will execute within a RunLoop in about 500ms with this == myContext
     }, 500);
     ```
@@ -25523,13 +25535,15 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     calls.
   
     ```javascript
+    import { run, scheduleOnce } from '@ember/runloop';
+  
     function sayHi() {
       console.log('hi');
     }
   
     run(function() {
-      run.scheduleOnce('afterRender', myContext, sayHi);
-      run.scheduleOnce('afterRender', myContext, sayHi);
+      scheduleOnce('afterRender', myContext, sayHi);
+      scheduleOnce('afterRender', myContext, sayHi);
       // sayHi will only be executed once, in the afterRender queue of the RunLoop
     });
     ```
@@ -25543,7 +25557,7 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     }
   
     function scheduleIt() {
-      run.scheduleOnce('actions', myContext, log);
+      scheduleOnce('actions', myContext, log);
     }
   
     scheduleIt();
@@ -25553,8 +25567,10 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     But this other case will schedule the function multiple times:
   
     ```javascript
+    import { scheduleOnce } from '@ember/runloop';
+  
     function scheduleIt() {
-      run.scheduleOnce('actions', myContext, function() {
+      scheduleOnce('actions', myContext, function() {
         console.log('Closure');
       });
     }
@@ -25593,7 +25609,9 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     `run.later` with a wait time of 1ms.
   
     ```javascript
-    run.next(myContext, function() {
+    import { next } from '@ember/runloop';
+  
+    next(myContext, function() {
       // code to be executed in the next run loop,
       // which will be scheduled after the current one
     });
@@ -25615,11 +25633,12 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   
     ```app/components/my-component.js
     import Component from '@ember/component';
+    import { scheduleOnce } from '@ember/runloop';
   
     export Component.extend({
       didInsertElement() {
         this._super(...arguments);
-        run.scheduleOnce('afterRender', this, 'processChildElements');
+        scheduleOnce('afterRender', this, 'processChildElements');
       },
   
       processChildElements() {
@@ -25666,53 +25685,63 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
   };
 
   /**
-    Cancels a scheduled item. Must be a value returned by `run.later()`,
-    `run.once()`, `run.scheduleOnce()`, `run.next()`, `run.debounce()`, or
-    `run.throttle()`.
+    Cancels a scheduled item. Must be a value returned by `later()`,
+    `once()`, `scheduleOnce()`, `next()`, `debounce()`, or
+    `throttle()`.
   
     ```javascript
-    let runNext = run.next(myContext, function() {
+    import {
+      next,
+      cancel,
+      later,
+      scheduleOnce,
+      once,
+      throttle,
+      debounce
+    } from '@ember/runloop';
+  
+    let runNext = next(myContext, function() {
       // will not be executed
     });
   
-    run.cancel(runNext);
+    cancel(runNext);
   
-    let runLater = run.later(myContext, function() {
+    let runLater = later(myContext, function() {
       // will not be executed
     }, 500);
   
-    run.cancel(runLater);
+    cancel(runLater);
   
-    let runScheduleOnce = run.scheduleOnce('afterRender', myContext, function() {
+    let runScheduleOnce = scheduleOnce('afterRender', myContext, function() {
       // will not be executed
     });
   
-    run.cancel(runScheduleOnce);
+    cancel(runScheduleOnce);
   
-    let runOnce = run.once(myContext, function() {
+    let runOnce = once(myContext, function() {
       // will not be executed
     });
   
-    run.cancel(runOnce);
+    cancel(runOnce);
   
-    let throttle = run.throttle(myContext, function() {
+    let throttle = throttle(myContext, function() {
       // will not be executed
     }, 1, false);
   
-    run.cancel(throttle);
+    cancel(throttle);
   
-    let debounce = run.debounce(myContext, function() {
+    let debounce = debounce(myContext, function() {
       // will not be executed
     }, 1);
   
-    run.cancel(debounce);
+    cancel(debounce);
   
-    let debounceImmediate = run.debounce(myContext, function() {
+    let debounceImmediate = debounce(myContext, function() {
       // will be executed since we passed in true (immediate)
     }, 100, true);
   
     // the 100ms delay until this method can be called again will be canceled
-    run.cancel(debounceImmediate);
+    cancel(debounceImmediate);
     ```
   
     @method cancel
@@ -25738,16 +25767,18 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     happen once scrolling has ceased.
   
     ```javascript
+    import { debounce } from '@ember/runloop';
+  
     function whoRan() {
       console.log(this.name + ' ran.');
     }
   
     let myContext = { name: 'debounce' };
   
-    run.debounce(myContext, whoRan, 150);
+    debounce(myContext, whoRan, 150);
   
     // less than 150ms passes
-    run.debounce(myContext, whoRan, 150);
+    debounce(myContext, whoRan, 150);
   
     // 150ms passes
     // whoRan is invoked with context myContext
@@ -25761,26 +25792,27 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     the method can be called again.
   
     ```javascript
+    import { debounce } from '@ember/runloop';
+  
     function whoRan() {
       console.log(this.name + ' ran.');
     }
   
     let myContext = { name: 'debounce' };
   
-    run.debounce(myContext, whoRan, 150, true);
+    debounce(myContext, whoRan, 150, true);
   
     // console logs 'debounce ran.' one time immediately.
     // 100ms passes
-    run.debounce(myContext, whoRan, 150, true);
+    debounce(myContext, whoRan, 150, true);
   
     // 150ms passes and nothing else is logged to the console and
     // the debouncee is no longer being watched
-    run.debounce(myContext, whoRan, 150, true);
+    debounce(myContext, whoRan, 150, true);
   
     // console logs 'debounce ran.' one time immediately.
     // 150ms passes and nothing else is logged to the console and
     // the debouncee is no longer being watched
-  
     ```
   
     @method debounce
@@ -25806,24 +25838,26 @@ enifed('ember-metal', ['exports', 'ember-environment', 'ember-utils', 'ember-deb
     the specified spacing period. The target method is called immediately.
   
     ```javascript
+    import { throttle } from '@ember/runloop';
+  
     function whoRan() {
       console.log(this.name + ' ran.');
     }
   
     let myContext = { name: 'throttle' };
   
-    run.throttle(myContext, whoRan, 150);
+    throttle(myContext, whoRan, 150);
     // whoRan is invoked with context myContext
     // console logs 'throttle ran.'
   
     // 50ms passes
-    run.throttle(myContext, whoRan, 150);
+    throttle(myContext, whoRan, 150);
   
     // 50ms passes
-    run.throttle(myContext, whoRan, 150);
+    throttle(myContext, whoRan, 150);
   
     // 150ms passes
-    run.throttle(myContext, whoRan, 150);
+    throttle(myContext, whoRan, 150);
     // whoRan is invoked with context myContext
     // console logs 'throttle ran.'
     ```
@@ -43842,7 +43876,7 @@ enifed('ember/index', ['exports', 'require', 'ember-environment', 'node-module',
 enifed("ember/version", ["exports"], function (exports) {
   "use strict";
 
-  exports.default = "2.18.0-beta.3";
+  exports.default = "2.18.0-beta.4";
 });
 /*global enifed */
 enifed('node-module', ['exports'], function(_exports) {

data/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ember-source",
-  "version": "2.18.0-beta.3",
+  "version": "2.18.0-beta.4",
   "description": "A JavaScript framework for creating ambitious web applications",
   "keywords": [
     "ember-addon"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ember-source
 version: !ruby/object:Gem::Version
-  version: 2.18.0.beta.3
+  version: 2.18.0.beta.4
 platform: ruby
 authors:
 - Yehuda Katz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-12 00:00:00.000000000 Z
+date: 2017-12-20 00:00:00.000000000 Z
 dependencies: []
 description: Ember.js source code wrapper for use with Ruby libs.
 email: