ember-source 5.6.0-alpha.2 → 5.6.0-alpha.4

package/dist/dependencies/rsvp.js

@@ -217,12 +217,12 @@ function configure(name, value) {
   }
 }
 
-const queue = [];
+const queue$1 = [];
 
-function scheduleFlush() {
+function scheduleFlush$1() {
   setTimeout(() => {
-    for (let i = 0; i < queue.length; i++) {
-      let entry = queue[i];
+    for (let i = 0; i < queue$1.length; i++) {
+      let entry = queue$1[i];
 
       let payload = entry.payload;
 
@@ -234,12 +234,12 @@ function scheduleFlush() {
 
       config['trigger'](entry.name, entry.payload);
     }
-    queue.length = 0;
+    queue$1.length = 0;
   }, 50);
 }
 
 function instrument(eventName, promise, child) {
-  if (1 === queue.push({
+  if (1 === queue$1.push({
     name: eventName,
     payload: {
       key: promise._guidKey,
@@ -251,7 +251,7 @@ function instrument(eventName, promise, child) {
       timeStamp: Date.now(),
       error: config["instrument-with-stack"] ? new Error(promise._label) : null
     }})) {
-      scheduleFlush();
+      scheduleFlush$1();
     }
   }
 
@@ -292,7 +292,7 @@ function instrument(eventName, promise, child) {
   @return {Promise} a promise that will become fulfilled with the given
   `value`
 */
-function resolve(object, label) {
+function resolve$2(object, label) {
   /*jshint validthis:true */
   let Constructor = this;
 
@@ -345,13 +345,13 @@ function handleForeignThenable(promise, thenable, then) {
         if (sealed) { return; }
         sealed = true;
 
-        reject(promise, reason);
+        reject$2(promise, reason);
       },
       'Settle: ' + (promise._label || ' unknown promise')
     );
     if (!sealed && error) {
       sealed = true;
-      reject(promise, error);
+      reject$2(promise, error);
     }
   }, promise);
 }
@@ -361,7 +361,7 @@ function handleOwnThenable(promise, thenable) {
     fulfill(promise, thenable._result);
   } else if (thenable._state === REJECTED) {
     thenable._onError = null;
-    reject(promise, thenable._result);
+    reject$2(promise, thenable._result);
   } else {
     subscribe(thenable, undefined, value => {
       if (thenable === value) {
@@ -369,7 +369,7 @@ function handleOwnThenable(promise, thenable) {
       } else {
         resolve$1(promise, value);
       }
-    }, reason => reject(promise, reason));
+    }, reason => reject$2(promise, reason));
   }
 }
 
@@ -377,7 +377,7 @@ function handleMaybeThenable(promise, maybeThenable, then$1) {
   let isOwnThenable =
     maybeThenable.constructor === promise.constructor &&
     then$1 === then &&
-    promise.constructor.resolve === resolve;
+    promise.constructor.resolve === resolve$2;
 
   if (isOwnThenable) {
     handleOwnThenable(promise, maybeThenable);
@@ -396,7 +396,7 @@ function resolve$1(promise, value) {
     try {
       then = value.then;
     } catch (error) {
-      reject(promise, error);
+      reject$2(promise, error);
       return;
     }
     handleMaybeThenable(promise, value, then);
@@ -428,7 +428,7 @@ function fulfill(promise, value) {
   }
 }
 
-function reject(promise, reason) {
+function reject$2(promise, reason) {
   if (promise._state !== PENDING) { return; }
   promise._state = REJECTED;
   promise._result = reason;
@@ -492,15 +492,15 @@ function invokeCallback(state, promise, callback, result) {
   }
 
   if (promise._state !== PENDING) ; else if (value === promise) {
-    reject(promise, withOwnPromise());
+    reject$2(promise, withOwnPromise());
   } else if (succeeded === false) {
-    reject(promise, error);
+    reject$2(promise, error);
   } else if (hasCallback) {
     resolve$1(promise, value);
   } else if (state === FULFILLED) {
     fulfill(promise, value);
   } else if (state === REJECTED) {
-    reject(promise, value);
+    reject$2(promise, value);
   }
 }
 
@@ -514,10 +514,10 @@ function initializePromise(promise, resolver) {
     }, reason => {
       if (resolved) { return; }
       resolved = true;
-      reject(promise, reason);
+      reject$2(promise, reason);
     });
   } catch(e) {
-    reject(promise, e);
+    reject$2(promise, e);
   }
 }
 
@@ -552,8 +552,8 @@ class Enumerator {
     this._instanceConstructor = Constructor;
     this.promise = new Constructor(noop, label);
     this._abortOnReject = abortOnReject;
-    this._isUsingOwnPromise = Constructor === Promise;
-    this._isUsingOwnResolve = Constructor.resolve === resolve;
+    this._isUsingOwnPromise = Constructor === Promise$2;
+    this._isUsingOwnResolve = Constructor.resolve === resolve$2;
 
     this._init(...arguments);
   }
@@ -605,7 +605,7 @@ class Enumerator {
       } else if (this._isUsingOwnPromise) {
         let promise = new c(noop);
         if (succeeded === false) {
-          reject(promise, error);
+          reject$2(promise, error);
         } else {
           handleMaybeThenable(promise, entry, then$1);
           this._willSettleAt(promise, i, firstPass);
@@ -631,7 +631,7 @@ class Enumerator {
 
     if (promise._state === PENDING) {
       if (this._abortOnReject && state === REJECTED) {
-        reject(promise, value);
+        reject$2(promise, value);
       } else {
         this._setResultAt(state, i, value, firstPass);
         this._checkFullfillment();
@@ -719,7 +719,7 @@ function setSettledResult(state, i, value) {
   fulfilled, or rejected if any of them become rejected.
   @static
 */
-function all(entries, label) {
+function all$1(entries, label) {
   if (!Array.isArray(entries)) {
     return this.reject(new TypeError("Promise.all must be called with an array"), label);
   }
@@ -799,14 +799,14 @@ function all(entries, label) {
   @return {Promise} a promise which settles in the same way as the first passed
   promise to settle.
 */
-function race(entries, label) {
+function race$1(entries, label) {
   /*jshint validthis:true */
   let Constructor = this;
 
   let promise = new Constructor(noop, label);
 
   if (!Array.isArray(entries)) {
-    reject(promise, new TypeError('Promise.race must be called with an array'));
+    reject$2(promise, new TypeError('Promise.race must be called with an array'));
     return promise;
   }
 
@@ -814,7 +814,7 @@ function race(entries, label) {
     subscribe(
       Constructor.resolve(entries[i]), undefined,
       value  => resolve$1(promise, value),
-      reason => reject(promise, reason)
+      reason => reject$2(promise, reason)
     );
   }
 
@@ -865,7 +865,7 @@ function reject$1(reason, label) {
   /*jshint validthis:true */
   let Constructor = this;
   let promise = new Constructor(noop, label);
-  reject(promise, reason);
+  reject$2(promise, reason);
   return promise;
 }
 
@@ -985,7 +985,7 @@ function needsNew() {
   Useful for tooling.
   @constructor
 */
-class Promise {
+let Promise$1 = class Promise {
   constructor(resolver, label) {
     this._id = counter++;
     this._label = label;
@@ -1092,15 +1092,15 @@ class Promise {
 
     return promise.then(callback, callback);
   }
-}
+};
 
-Promise.cast = resolve; // deprecated
-Promise.all = all;
-Promise.race = race;
-Promise.resolve = resolve;
-Promise.reject = reject$1;
+Promise$1.cast = resolve$2; // deprecated
+Promise$1.all = all$1;
+Promise$1.race = race$1;
+Promise$1.resolve = resolve$2;
+Promise$1.reject = reject$1;
 
-Promise.prototype._guidKey = guidKey;
+Promise$1.prototype._guidKey = guidKey;
 
 /**
   The primary way of interacting with a promise is through its `then` method,
@@ -1296,7 +1296,9 @@ Promise.prototype._guidKey = guidKey;
   Useful for tooling.
   @return {Promise}
 */
-Promise.prototype.then = then;
+Promise$1.prototype.then = then;
+
+var Promise$2 = Promise$1;
 
 function makeObject(_, argumentNames) {
   let obj = {};
@@ -1473,14 +1475,14 @@ function denodeify(nodeFunc, options) {
       // TODO: this code really needs to be cleaned up
       if (!promiseInput) {
         if (arg !== null && typeof arg === 'object') {
-          if (arg.constructor === Promise) {
+          if (arg.constructor === Promise$2) {
             promiseInput = true;
           } else {
             try {
               promiseInput = arg.then;
             } catch(error) {
-              let p = new Promise(noop);
-              reject(p, error);
+              let p = new Promise$2(noop);
+              reject$2(p, error);
               return p;
             }
           }
@@ -1494,11 +1496,11 @@ function denodeify(nodeFunc, options) {
       args[i] = arg;
     }
 
-    let promise = new Promise(noop);
+    let promise = new Promise$2(noop);
 
     args[l] = function(err, val) {
       if (err) {
-        reject(promise, err);
+        reject$2(promise, err);
       } else if (options === undefined) {
         resolve$1(promise, val);
       } else if (options === true) {
@@ -1526,13 +1528,13 @@ function handleValueInput(promise, args, nodeFunc, self) {
   try {
     nodeFunc.apply(self, args);
   } catch (error) {
-    reject(promise, error);
+    reject$2(promise, error);
   }
   return promise;
 }
 
 function handlePromiseInput(promise, args, nodeFunc, self){
-  return Promise.all(args)
+  return Promise$2.all(args)
     .then(args => handleValueInput(promise, args, nodeFunc, self));
 }
 
@@ -1547,8 +1549,8 @@ function handlePromiseInput(promise, args, nodeFunc, self){
   @param {String} [label] An optional label. This is useful
   for tooling.
 */
-function all$1(array, label) {
-  return Promise.all(array, label);
+function all(array, label) {
+  return Promise$2.all(array, label);
 }
 
 /**
@@ -1619,10 +1621,10 @@ AllSettled.prototype._setResultAt = setSettledResult;
 
 function allSettled(entries, label) {
   if (!Array.isArray(entries)) {
-    return Promise.reject(new TypeError("Promise.allSettled must be called with an array"), label);
+    return Promise$2.reject(new TypeError("Promise.allSettled must be called with an array"), label);
   }
 
-  return new AllSettled(Promise, entries, label).promise;
+  return new AllSettled(Promise$2, entries, label).promise;
 }
 
 /**
@@ -1636,8 +1638,8 @@ function allSettled(entries, label) {
   @param {String} [label] An optional label. This is useful
   for tooling.
  */
-function race$1(array, label) {
-  return Promise.race(array, label);
+function race(array, label) {
+  return Promise$2.race(array, label);
 }
 
 class PromiseHash extends Enumerator {
@@ -1759,12 +1761,12 @@ class PromiseHash extends Enumerator {
   have been fulfilled, or rejected if any of them become rejected.
 */
 function hash(object, label) {
-  return Promise.resolve(object, label)
+  return Promise$2.resolve(object, label)
     .then(function(object) {
       if (object === null || typeof object !== 'object') {
         throw new TypeError("Promise.hash must be called with an object");
       }
-      return new PromiseHash(Promise, object, label).promise;
+      return new PromiseHash(Promise$2, object, label).promise;
     });
 }
 
@@ -1886,13 +1888,13 @@ HashSettled.prototype._setResultAt = setSettledResult;
 */
 
 function hashSettled(object, label) {
-  return Promise.resolve(object, label)
+  return Promise$2.resolve(object, label)
     .then(function(object) {
       if (object === null || typeof object !== 'object') {
         throw new TypeError("hashSettled must be called with an object");
       }
 
-      return new HashSettled(Promise, object, false, label).promise;
+      return new HashSettled(Promise$2, object, false, label).promise;
     });
 }
 
@@ -1983,7 +1985,7 @@ function rethrow(reason) {
 function defer(label) {
   let deferred = { resolve: undefined, reject: undefined };
 
-  deferred.promise = new Promise((resolve, reject) => {
+  deferred.promise = new Promise$2((resolve, reject) => {
     deferred.resolve = resolve;
     deferred.reject = reject;
   }, label);
@@ -2104,15 +2106,15 @@ class MapEnumerator extends Enumerator {
 */
 function map(promises, mapFn, label) {
   if (typeof mapFn !== 'function') {
-    return Promise.reject(new TypeError("map expects a function as a second argument"), label);
+    return Promise$2.reject(new TypeError("map expects a function as a second argument"), label);
   }
 
-  return Promise.resolve(promises, label)
+  return Promise$2.resolve(promises, label)
     .then(function(promises) {
       if (!Array.isArray(promises)) {
         throw new TypeError("map must be called with an array");
       }
-      return new MapEnumerator(Promise, promises, mapFn, label).promise;
+      return new MapEnumerator(Promise$2, promises, mapFn, label).promise;
     });
 }
 
@@ -2129,8 +2131,8 @@ function map(promises, mapFn, label) {
   @return {Promise} a promise that will become fulfilled with the given
   `value`
 */
-function resolve$2(value, label) {
-  return Promise.resolve(value, label);
+function resolve(value, label) {
+  return Promise$2.resolve(value, label);
 }
 
 /**
@@ -2145,8 +2147,8 @@ function resolve$2(value, label) {
   Useful for tooling.
   @return {Promise} a promise rejected with the given `reason`.
 */
-function reject$2(reason, label) {
-  return Promise.reject(reason, label);
+function reject(reason, label) {
+  return Promise$2.reject(reason, label);
 }
 
 const EMPTY_OBJECT = {};
@@ -2276,29 +2278,29 @@ class FilterEnumerator extends MapEnumerator {
 
 function filter(promises, filterFn, label) {
   if (typeof filterFn !== 'function') {
-    return Promise.reject(new TypeError("filter expects function as a second argument"), label);
+    return Promise$2.reject(new TypeError("filter expects function as a second argument"), label);
   }
 
-  return Promise.resolve(promises, label)
+  return Promise$2.resolve(promises, label)
     .then(function(promises) {
       if (!Array.isArray(promises)) {
         throw new TypeError("filter must be called with an array");
       }
-      return new FilterEnumerator(Promise, promises, filterFn, label).promise;
+      return new FilterEnumerator(Promise$2, promises, filterFn, label).promise;
     });
 }
 
 let len = 0;
 let vertxNext;
 function asap(callback, arg) {
-  queue$1[len] = callback;
-  queue$1[len + 1] = arg;
+  queue[len] = callback;
+  queue[len + 1] = arg;
   len += 2;
   if (len === 2) {
     // If len is 1, that means that we need to schedule an async flush.
     // If additional callbacks are queued before the queue is flushed, they
     // will be processed by this flush that we are scheduling.
-    scheduleFlush$1();
+    scheduleFlush();
   }
 }
 
@@ -2355,17 +2357,17 @@ function useSetTimeout() {
   return () => setTimeout(flush, 1);
 }
 
-const queue$1 = new Array(1000);
+const queue = new Array(1000);
 
 function flush() {
   for (let i = 0; i < len; i+=2) {
-    let callback = queue$1[i];
-    let arg = queue$1[i+1];
+    let callback = queue[i];
+    let arg = queue[i+1];
 
     callback(arg);
 
-    queue$1[i] = undefined;
-    queue$1[i+1] = undefined;
+    queue[i] = undefined;
+    queue[i+1] = undefined;
   }
 
   len = 0;
@@ -2381,24 +2383,24 @@ function attemptVertex() {
   }
 }
 
-let scheduleFlush$1;
+let scheduleFlush;
 // Decide what async method to use to triggering processing of queued callbacks:
 if (isNode) {
-  scheduleFlush$1 = useNextTick();
+  scheduleFlush = useNextTick();
 } else if (BrowserMutationObserver) {
-  scheduleFlush$1 = useMutationObserver();
+  scheduleFlush = useMutationObserver();
 } else if (isWorker) {
-  scheduleFlush$1 = useMessageChannel();
+  scheduleFlush = useMessageChannel();
 } else if (browserWindow === undefined && typeof require === 'function') {
-  scheduleFlush$1 = attemptVertex();
+  scheduleFlush = attemptVertex();
 } else {
-  scheduleFlush$1 = useSetTimeout();
+  scheduleFlush = useSetTimeout();
 }
 
 // defaults
 config.async = asap;
 config.after = cb => setTimeout(cb, 0);
-const cast = resolve$2;
+const cast = resolve;
 
 const async = (callback, arg) => config.async(callback, arg);
 
@@ -2426,11 +2428,11 @@ if (typeof window !== 'undefined' && typeof window['__PROMISE_INSTRUMENTATION__'
 var rsvp = {
   asap,
   cast,
-  Promise,
+  Promise: Promise$2,
   EventTarget,
-  all: all$1,
+  all,
   allSettled,
-  race: race$1,
+  race,
   hash,
   hashSettled,
   rethrow,
@@ -2439,12 +2441,11 @@ var rsvp = {
   configure,
   on,
   off,
-  resolve: resolve$2,
-  reject: reject$2,
+  resolve,
+  reject,
   map,
   async,
   filter
 };
 
-export default rsvp;
-export { EventTarget, Promise, all$1 as all, allSettled, asap, async, cast, configure, defer, denodeify, filter, hash, hashSettled, map, off, on, race$1 as race, reject$2 as reject, resolve$2 as resolve, rethrow };
+export { EventTarget, Promise$2 as Promise, all, allSettled, asap, async, cast, configure, rsvp as default, defer, denodeify, filter, hash, hashSettled, map, off, on, race, reject, resolve, rethrow };