ember-source 4.5.0-beta.1 → 4.6.0-alpha.3

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.5.0-beta.1
+ * @version   4.6.0-alpha.3
  */

package/dist/packages/@ember/-internals/error-handling/index.js

@@ -13,7 +13,7 @@ export function getOnerror() {
 export function setOnerror(handler) {
   onerror = handler;
 }
-let dispatchOverride; // allows testing adapter to override dispatch
+let dispatchOverride = null; // allows testing adapter to override dispatch
 
 export function getDispatchOverride() {
   return dispatchOverride;

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

@@ -2957,14 +2957,25 @@ function escapeExpression(string) {
   return string.replace(badChars, escapeChar);
 }
 /**
-  Mark a string as safe for unescaped output with Ember templates. If you
-  return HTML from a helper, use this function to
-  ensure Ember's rendering layer does not escape the HTML.
+  Use this method to indicate that a string should be rendered as HTML
+  when the string is used in a template. To say this another way,
+  strings marked with `htmlSafe` will not be HTML escaped.
+
+  A word of warning -   The `htmlSafe` method does not make the string safe;
+  it only tells the framework to treat the string as if it is safe to render
+  as HTML. If a string contains user inputs or other untrusted
+  data, you must sanitize the string before using the `htmlSafe` method.
+  Otherwise your code is vulnerable to
+  [Cross-Site Scripting](https://owasp.org/www-community/attacks/DOM_Based_XSS).
+  There are many open source sanitization libraries to choose from,
+  both for front end and server-side sanitization.
 
   ```javascript
   import { htmlSafe } from '@ember/template';
 
-  htmlSafe('<div>someString</div>')
+  const someTrustedOrSanitizedString = "<div>Hello!</div>"
+
+  htmlSafe(someTrustedorSanitizedString)
   ```
 
   @method htmlSafe
@@ -5166,10 +5177,13 @@ class DynamicScope {
     return value;
   }
 
-} // This wrapper logic prevents us from rerendering in case of a hard failure
+}
+
+const NO_OP = () => {}; // This wrapper logic prevents us from rerendering in case of a hard failure
 // during render. This prevents infinite revalidation type loops from occuring,
 // and ensures that errors are not swallowed by subsequent follow on failures.
 
+
 function errorLoopTransaction(fn$$1) {
   if (DEBUG) {
     return () => {
@@ -5270,10 +5284,6 @@ function loopBegin() {
   }
 }
 
-function K() {
-  /* noop */
-}
-
 let renderSettledDeferred = null;
 /*
   Returns a promise which will resolve when rendering has settled. Settled in
@@ -5292,7 +5302,7 @@ function renderSettled() {
 
     if (!_getCurrentRunLoop()) {
       // ensure a runloop has been kicked off
-      _backburner.schedule('actions', null, K);
+      _backburner.schedule('actions', null, NO_OP);
     }
   }
 
@@ -5321,7 +5331,7 @@ function loopEnd() {
       }
 
       loops++;
-      return _backburner.join(null, K);
+      return _backburner.join(null, NO_OP);
     }
   }
 

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

@@ -14,9 +14,6 @@ import VERSION from 'ember/version';
 import { INIT_FACTORY } from '@ember/-internals/container';
 import { getOwner } from '@ember/-internals/owner';
 
-/**
-@module @ember/object
-*/
 /*
   The event system uses a series of nested hashes to store listeners on an
   object. When a listener is registered, or when an event arrives, these
@@ -628,12 +625,19 @@ function objectAt(array, index) {
   } else {
     return array.objectAt(index);
   }
+} // Ideally, we'd use MutableArray.detect but for unknown reasons this causes
+// the node tests to fail strangely.
+
+function isMutableArray(obj) {
+  return obj != null && typeof obj.replace === 'function';
 }
+
 function replace(array, start, deleteCount, items = EMPTY_ARRAY) {
-  if (Array.isArray(array)) {
-    replaceInNativeArray(array, start, deleteCount, items);
-  } else {
+  if (isMutableArray(array)) {
     array.replace(start, deleteCount, items);
+  } else {
+    assert('Can only replace content of a native array or MutableArray', Array.isArray(array));
+    replaceInNativeArray(array, start, deleteCount, items);
   }
 }
 const CHUNK_SIZE = 60000; // To avoid overflowing the stack, we splice up to CHUNK_SIZE items at a time.
@@ -3149,7 +3153,10 @@ class Mixin {
 
 
   keys() {
-    return _keys(this);
+    let keys = _keys(this);
+
+    assert('[BUG] Missing keys for mixin!', keys);
+    return keys;
   }
   /** @internal */
 
@@ -3225,8 +3232,8 @@ function _keys(mixin, ret = new Set(), seen = new Set()) {
   if (mixin.properties) {
     let props = Object.keys(mixin.properties);
 
-    for (let i = 0; i < props.length; i++) {
-      ret.add(props[i]);
+    for (let prop of props) {
+      ret.add(prop);
     }
   } else if (mixin.mixins) {
     mixin.mixins.forEach(x => _keys(x, ret, seen));

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

@@ -12,10 +12,6 @@ import { calculateCacheKey, extractRouteArgs, getActiveTargetName, resemblesURL
 import DSL from './dsl';
 import { defaultSerialize, getFullQueryParams, hasDefaultSerialize, ROUTE_CONNECTIONS } from './route';
 import RouterState from './router_state';
-/**
-@module @ember/routing
-*/
-
 import Router, { logAbort, STATE_SYMBOL } from 'router_js';
 import EngineInstance from '@ember/engine/instance';
 

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

@@ -35,9 +35,10 @@ const TYPE_ORDER = {
 //                                              SSt  `------'`
 
 function spaceship(a, b) {
-  let diff = a - b; // SAFETY: Number casts true into 1 and false into 0. Therefore, this must end up as one of the Compare values.
-
-  return Number(diff > 0) - Number(diff < 0);
+  // SAFETY: `Math.sign` always returns `-1` for negative, `0` for zero, and `1`
+  // for positive numbers. (The extra precision is useful for the way we use
+  // this in the context of `compare`.)
+  return Math.sign(a - b);
 }
 /**
  @module @ember/utils