Remove RSVP from internal code

packages/@ember/-internals/glimmer/lib/renderer.ts

@@ -48,7 +48,6 @@ import { dict } from '@glimmer/util';
 import { unwrapTemplate } from './component-managers/unwrap-template';
 import { CURRENT_TAG, validateTag, valueForTag } from '@glimmer/validator';
 import type { SimpleDocument, SimpleElement, SimpleNode } from '@simple-dom/interface';
-import RSVP from 'rsvp';
 import type Component from './component';
 import { hasDOM } from '../../browser-environment';
 import type ClassicComponent from './component';
@@ -297,7 +296,8 @@ function loopBegin(): void {
   }
 }
 
-let renderSettledDeferred: RSVP.Deferred<void> | null = null;
+let renderSettledPromise: Promise<void> | null = null;
+let renderSettledResolve: (() => void) | null = null;
 /*
   Returns a promise which will resolve when rendering has settled. Settled in
   this context is defined as when all of the tags in use are "current" (e.g.
@@ -308,8 +308,10 @@ let renderSettledDeferred: RSVP.Deferred<void> | null = null;
   @returns {Promise<void>} a promise which fulfills when rendering has settled
 */
 export function renderSettled() {
-  if (renderSettledDeferred === null) {
-    renderSettledDeferred = RSVP.defer();
+  if (renderSettledPromise === null) {
+    renderSettledPromise = new Promise<void>((resolve) => {
+      renderSettledResolve = resolve;
+    });
     // if there is no current runloop, the promise created above will not have
     // a chance to resolve (because its resolved in backburner's "end" event)
     if (!_getCurrentRunLoop()) {
@@ -318,13 +320,14 @@ export function renderSettled() {
     }
   }
 
-  return renderSettledDeferred.promise;
+  return renderSettledPromise;
 }
 
 function resolveRenderPromise() {
-  if (renderSettledDeferred !== null) {
-    let resolve = renderSettledDeferred.resolve;
-    renderSettledDeferred = null;
+  if (renderSettledResolve !== null) {
+    let resolve = renderSettledResolve;
+    renderSettledPromise = null;
+    renderSettledResolve = null;
 
     _backburner.join(null, resolve);
   }

packages/@ember/application/index.ts

@@ -10,7 +10,6 @@ import { assert } from '@ember/debug';
 import { DEBUG } from '@glimmer/env';
 import { join, once, run, schedule } from '@ember/runloop';
 import { libraries } from '@ember/-internals/metal';
-import { RSVP } from '@ember/-internals/runtime';
 import { EventDispatcher } from '@ember/-internals/views';
 import Route from '@ember/routing/route';
 import Router from '@ember/routing/router';
@@ -681,7 +680,10 @@ class Application extends Engine {
     return this._bootPromise;
   }
 
-  _bootResolver: ReturnType<(typeof RSVP)['defer']> | null = null;
+  _bootResolver: {
+    resolve: (value: Application) => void;
+    reject: (reason?: unknown) => void;
+  } | null = null;
 
   /**
     Unfortunately, a lot of existing code assumes the booting process is
@@ -705,16 +707,19 @@ class Application extends Engine {
     // boot promise exists for book-keeping purposes: if anything went wrong in
     // the boot process, we need to store the error as a rejection on the boot
     // promise so that a future caller of `boot()` can tell what failed.
-    let defer = (this._bootResolver = RSVP.defer());
-    this._bootPromise = defer.promise as Promise<this>;
+    let resolver!: { resolve: (value: Application) => void; reject: (reason?: unknown) => void };
+    this._bootPromise = new Promise<this>((resolve, reject) => {
+      resolver = { resolve: resolve as (value: Application) => void, reject };
+    });
+    this._bootResolver = resolver;
 
     try {
       this.runInitializers();
       this.advanceReadiness();
       // Continues to `didBecomeReady`
     } catch (error) {
       // For the asynchronous boot path
-      defer.reject(error);
+      resolver.reject(error);
 
       // For the synchronous boot path
       throw error;

packages/@ember/engine/instance.ts

@@ -3,7 +3,6 @@
 */
 
 import EmberObject from '@ember/object';
-import { RSVP } from '@ember/-internals/runtime';
 import { assert } from '@ember/debug';
 import { Registry, privatize as P } from '@ember/-internals/container';
 import { guidFor } from '@ember/-internals/utils';
@@ -101,7 +100,7 @@ class EngineInstance extends EmberObject.extend(RegistryProxyMixin, ContainerPro
     this._booted = false;
   }
 
-  _bootPromise: RSVP.Promise<this> | null = null;
+  _bootPromise: Promise<this> | null = null;
 
   /**
     Initialize the `EngineInstance` and return a promise that resolves
@@ -121,7 +120,7 @@ class EngineInstance extends EmberObject.extend(RegistryProxyMixin, ContainerPro
       return this._bootPromise;
     }
 
-    this._bootPromise = new RSVP.Promise((resolve) => {
+    this._bootPromise = new Promise((resolve) => {
       resolve(this._bootSync(options));
     });
 

packages/@ember/object/promise-proxy-mixin.ts

@@ -1,14 +1,13 @@
 import { get, setProperties, computed } from '@ember/object';
 import Mixin from '@ember/object/mixin';
 import type { AnyFn, MethodNamesOf } from '@ember/-internals/utility-types';
-import type RSVP from 'rsvp';
 import type CoreObject from '@ember/object/core';
 
 /**
   @module @ember/object/promise-proxy-mixin
 */
 
-function tap<T>(proxy: PromiseProxyMixin<T>, promise: RSVP.Promise<T>) {
+function tap<T>(proxy: PromiseProxyMixin<T>, promise: Promise<T>) {
   setProperties(proxy, {
     isFulfilled: false,
     isRejected: false,
@@ -38,24 +37,22 @@ function tap<T>(proxy: PromiseProxyMixin<T>, promise: RSVP.Promise<T>) {
         });
       }
       throw reason;
-    },
-    'Ember: PromiseProxy'
+    }
   );
 }
 
 /**
   A low level mixin making ObjectProxy promise-aware.
 
   ```javascript
-  import { resolve } from 'rsvp';
   import $ from 'jquery';
   import ObjectProxy from '@ember/object/proxy';
   import PromiseProxyMixin from '@ember/object/promise-proxy-mixin';
 
   let ObjectPromiseProxy = ObjectProxy.extend(PromiseProxyMixin);
 
   let proxy = ObjectPromiseProxy.create({
-    promise: resolve($.getJSON('/some/remote/data.json'))
+    promise: Promise.resolve($.getJSON('/some/remote/data.json'))
   });
 
   proxy.then(function(json){
@@ -78,7 +75,7 @@ function tap<T>(proxy: PromiseProxyMixin<T>, promise: RSVP.Promise<T>) {
   When the $.getJSON completes, and the promise is fulfilled
   with json, the life cycle attributes will update accordingly.
   Note that $.getJSON doesn't return an ECMA specified promise,
-  it is useful to wrap this with an `RSVP.resolve` so that it behaves
+  it is useful to wrap this with `Promise.resolve` so that it behaves
   as a spec compliant promise.
 
   ```javascript
@@ -176,34 +173,34 @@ interface PromiseProxyMixin<T> {
   /**
     An alias to the proxied promise's `then`.
 
-    See RSVP.Promise.then.
+    See Promise.prototype.then.
 
     @method then
     @param {Function} callback
-    @return {RSVP.Promise}
+    @return {Promise}
     @public
   */
   then: this['promise']['then'];
   /**
     An alias to the proxied promise's `catch`.
 
-    See RSVP.Promise.catch.
+    See Promise.prototype.catch.
 
     @method catch
     @param {Function} callback
-    @return {RSVP.Promise}
+    @return {Promise}
     @since 1.3.0
     @public
   */
   catch: this['promise']['catch'];
   /**
     An alias to the proxied promise's `finally`.
 
-    See RSVP.Promise.finally.
+    See Promise.prototype.finally.
 
     @method finally
     @param {Function} callback
-    @return {RSVP.Promise}
+    @return {Promise}
     @since 1.3.0
     @public
   */
@@ -228,7 +225,7 @@ const PromiseProxyMixin = Mixin.create({
     get() {
       throw new Error("PromiseProxy's promise must be set");
     },
-    set(_key, promise: RSVP.Promise<unknown>) {
+    set(_key, promise: Promise<unknown>) {
       return tap(this, promise);
     },
   }),

packages/@ember/routing/route.ts

@@ -198,7 +198,6 @@ interface Route<Model = unknown> extends IRoute<Model>, ActionHandler, Evented {
     as well as any unhandled errors from child routes:
 
     ```app/routes/admin.js
-    import { reject } from 'rsvp';
     import Route from '@ember/routing/route';
     import { action } from '@ember/object';
     import { service } from '@ember/service';
@@ -207,7 +206,7 @@ interface Route<Model = unknown> extends IRoute<Model>, ActionHandler, Evented {
       @service router;
 
       beforeModel() {
-        return reject('bad things!');
+        return Promise.reject('bad things!');
       }
 
       @action

packages/internal-test-helpers/lib/module-for.ts

@@ -2,7 +2,6 @@
 import { isEnabled } from '@ember/canary-features';
 import { assertDestroyablesDestroyed, enableDestroyableTracking } from '@glimmer/destroyable';
 import { DEBUG } from '@glimmer/env';
-import { all } from 'rsvp';
 import type { Generator, Mixin } from './apply-mixins';
 import applyMixins from './apply-mixins';
 import getAllPropertyNames from './get-all-property-names';
@@ -122,7 +121,7 @@ export function setupTestClass<T extends TestCase, G extends Generator>(
     // promise when it is not needed
     let filteredPromises = promises.filter(Boolean);
     if (filteredPromises.length > 0) {
-      return all(filteredPromises)
+      return Promise.all(filteredPromises)
         .finally(afterEachFinally)
         .then(() => {});
     }

packages/internal-test-helpers/lib/run.ts

@@ -1,8 +1,6 @@
 import { next, run, _getCurrentRunLoop, _hasScheduledTimers } from '@ember/runloop';
 import { destroy } from '@glimmer/destroyable';
 
-import { Promise } from 'rsvp';
-
 export function runAppend(view: any): void {
   run(view, 'appendTo', document.getElementById('qunit-fixture'));
 }

packages/router_js/lib/route-info.ts

@@ -1,5 +1,4 @@
 /* eslint-disable no-prototype-builtins */
-import { Promise } from 'rsvp';
 import type { Dict, Option } from './core';
 import type { SerializerFunc } from './router';
 import type Router from './router';
@@ -234,8 +233,8 @@ export default class InternalRouteInfo<R extends Route> {
     }
   }
 
-  getModel(_transition: InternalTransition<R>) {
-    return Promise.resolve(this.context);
+  getModel(_transition: InternalTransition<R>): Promise<ModelFor<R> | undefined> {
+    return Promise.resolve<ModelFor<R> | undefined>(this.context);
   }
 
   serialize(_context?: ModelFor<R> | null): Dict<unknown> | undefined {
@@ -477,7 +476,7 @@ export class UnresolvedRouteInfoByParam<R extends Route> extends InternalRouteIn
     }
   }
 
-  getModel(transition: InternalTransition<R>): Promise<ModelFor<R>> {
+  getModel(transition: InternalTransition<R>): Promise<ModelFor<R> | undefined> {
     let fullParams = this.params;
     if (transition && transition[QUERY_PARAMS_SYMBOL]) {
       fullParams = {};
@@ -506,7 +505,7 @@ export class UnresolvedRouteInfoByParam<R extends Route> extends InternalRouteIn
       result = undefined;
     }
 
-    return Promise.resolve(result);
+    return Promise.resolve<ModelFor<R> | undefined>(result);
   }
 }
 

packages/router_js/lib/router.ts

@@ -1,7 +1,6 @@
 /* eslint-disable no-prototype-builtins */
 import type { MatchCallback, Params, QueryParams } from 'route-recognizer';
 import RouteRecognizer from 'route-recognizer';
-import { Promise } from 'rsvp';
 import type { Dict, Maybe, Option } from './core';
 import type { ModelFor, Route, RouteInfo, RouteInfoWithAttributes } from './route-info';
 import type InternalRouteInfo from './route-info';
@@ -15,7 +14,7 @@ import URLTransitionIntent from './transition-intent/url-transition-intent';
 import type { TransitionError } from './transition-state';
 import TransitionState from './transition-state';
 import type { ChangeList, ModelsAndQueryParams } from './utils';
-import { extractQueryParams, forEach, getChangelist, log, merge, promiseLabel } from './utils';
+import { extractQueryParams, forEach, getChangelist, log, merge } from './utils';
 
 export interface SerializerFunc<T> {
   (model: T, params: string[]): Dict<unknown>;
@@ -132,9 +131,7 @@ export default abstract class Router<R extends Route> {
             this.routeDidChange(newTransition);
           }
           return result;
-        },
-        null,
-        promiseLabel('Transition complete')
+        }
       );
 
       return newTransition;
@@ -258,13 +255,9 @@ export default abstract class Router<R extends Route> {
     // Transition promises by default resolve with resolved state.
     // For our purposes, swap out the promise to resolve
     // after the transition has been finalized.
-    newTransition.promise = newTransition.promise!.then(
-      (result: TransitionState<R>) => {
-        return this.finalizeTransition(newTransition, result);
-      },
-      null,
-      promiseLabel('Settle transition promise when transition is finalized')
-    );
+    newTransition.promise = newTransition.promise!.then((result: TransitionState<R>) => {
+      return this.finalizeTransition(newTransition, result);
+    });
 
     if (!wasTransitioning) {
       this.notifyExistingHandlers(newState, newTransition);

packages/router_js/lib/transition-state.ts

@@ -1,4 +1,3 @@
-import { Promise } from 'rsvp';
 import type { Dict } from './core';
 import type { Route, ResolvedRouteInfo } from './route-info';
 import type InternalRouteInfo from './route-info';
@@ -47,7 +46,7 @@ function resolveOneRouteInfo<R extends Route>(
     resolvedRouteInfo: ResolvedRouteInfo<R>
   ) => void | Promise<void>;
 
-  return routeInfo.resolve(transition).then(callback, null, currentState.promiseLabel('Proceed'));
+  return routeInfo.resolve(transition).then(callback);
 }
 
 function proceed<R extends Route>(
@@ -112,10 +111,10 @@ export default class TransitionState<R extends Route> {
     let callback = resolveOneRouteInfo.bind(null, this, transition);
     let errorHandler = handleError.bind(null, this, transition);
 
-    // The prelude RSVP.resolve() async moves us into the promise land.
-    return Promise.resolve(null, this.promiseLabel('Start transition'))
-      .then(callback, null, this.promiseLabel('Resolve route'))
-      .catch(errorHandler, this.promiseLabel('Handle error'))
+    // The prelude Promise.resolve() async moves us into the promise land.
+    return Promise.resolve(null)
+      .then(callback)
+      .catch(errorHandler)
       .then(() => this);
   }
 }