chore(helpers) drop custom createDeferred() for Promise.withResolvers()

package.json

     "optional-require": "1.0.3",
     "pixelmatch": "5.3.0",
     "promise.allsettled": "1.0.4",
+    "promise.withresolvers": "1.0.3",
     "punycode": "2.3.0",
     "react": "18.2.0",
     "react-dom": "18.2.0",

react/features/app/components/AbstractApp.ts

  */
 export class AbstractApp<P extends IProps = IProps> extends BaseApp<P> {
     /**
-     * The deferred for the initialisation {{promise, resolve, reject}}.
+     * The deferred for the initialization {{promise, resolve, reject}}.
      */
-    _init: {
-        promise: Promise<any>;
-    };
+    _init: PromiseWithResolvers<any>;
 
     /**
      * Initializes the app.

react/features/base/app/components/BaseApp.tsx

 import ReducerRegistry from '../../redux/ReducerRegistry';
 import StateListenerRegistry from '../../redux/StateListenerRegistry';
 import SoundCollection from '../../sounds/components/SoundCollection';
-import { createDeferred } from '../../util/helpers';
 import { appWillMount, appWillUnmount } from '../actions';
 import logger from '../logger';
 
     /**
      * The deferred for the initialisation {{promise, resolve, reject}}.
      */
-    _init: {
-        promise: Promise<any>;
-    };
+    _init: PromiseWithResolvers<any>
 
     /**
      * Initializes a new {@code BaseApp} instance.
          * @see {@link #_initStorage}
          * @type {Promise}
          */
-        this._init = createDeferred<void>();
+        this._init = Promise.withResolvers();
 
         try {
             await this._initStorage();

react/features/base/media/reducer.ts

 import { CONFERENCE_FAILED, CONFERENCE_LEFT } from '../conference/actionTypes';
 import ReducerRegistry from '../redux/ReducerRegistry';
 import { TRACK_REMOVED } from '../tracks/actionTypes';
-import { DefferedPromise, createDeferred } from '../util/helpers';
 
 import {
     GUM_PENDING,
 // initial track creation haven't been started we would wait for it to finish before starting to join the room.
 // NOTE: The previous implementation was using the GUM promise from conference.init. But it turned out that connect
 // may finish even before conference.init is executed.
-const DEFAULT_INITIAL_PROMISE_STATE = createDeferred<IInitialGUMPromiseResult>();
+const DEFAULT_INITIAL_PROMISE_STATE = Promise.withResolvers<IInitialGUMPromiseResult>();
 
 /**
  * Reducer for the common properties in media state.
  * @param {string} action.type - Type of action.
  * @returns {ICommonState}
  */
-function _initialGUMPromise(state: DefferedPromise<IInitialGUMPromiseResult> | null = DEFAULT_INITIAL_PROMISE_STATE,
+function _initialGUMPromise(state: PromiseWithResolvers<IInitialGUMPromiseResult> | null = DEFAULT_INITIAL_PROMISE_STATE,
         action: AnyAction) {
     if (action.type === SET_INITIAL_GUM_PROMISE) {
         return action.promise ?? null;
 
 export interface IMediaState {
     audio: IAudioState;
-    initialGUMPromise: DefferedPromise<IInitialGUMPromiseResult> | null;
+    initialGUMPromise: PromiseWithResolvers<IInitialGUMPromiseResult> | null;
     screenshare: IScreenshareState;
     video: IVideoState;
 }

react/features/base/participants/functions.ts

 import { MEDIA_TYPE, MediaType, VIDEO_TYPE } from '../media/constants';
 import { toState } from '../redux/functions';
 import { getScreenShareTrack, isLocalTrackMuted } from '../tracks/functions.any';
-import { createDeferred } from '../util/helpers';
 
 import {
     JIGASI_PARTICIPANT_ICON,
  * @returns {Promise}
  */
 export function getFirstLoadableAvatarUrl(participant: IParticipant, store: IStore) {
-    const deferred: any = createDeferred();
+    const deferred: any = Promise.withResolvers();
     const fullPromise = deferred.promise
         .then(() => _getFirstLoadableAvatarUrl(participant, store))
         .then((result: any) => {

react/features/base/util/helpers.ts

     return to;
 }
 
-export type DefferedPromise<T> = {
-    promise: Promise<T>;
-    reject: (reason?: any) => void;
-    resolve: (value: T) => void;
-};
-
-/**
- * Creates a deferred object.
- *
- * @returns {{promise, resolve, reject}}
- */
-export function createDeferred<T>() {
-    const deferred = {} as DefferedPromise<T>;
-
-    deferred.promise = new Promise<T>((resolve, reject) => {
-        deferred.resolve = resolve;
-        deferred.reject = reject;
-    });
-
-    return deferred;
-}
 
 const MATCH_OPERATOR_REGEXP = /[|\\{}()[\]^$+*?.-]/g;
 

react/features/calendar-sync/web/microsoftCalendar.ts

 import { findWindows } from 'windows-iana';
 import { IanaName } from 'windows-iana/dist/enums';
 
-// @ts-expect-error
-import { createDeferred } from '../../../../modules/util/helpers';
 import { IStore } from '../../app/types';
 import { parseURLParams } from '../../base/util/parseURLParams';
 import { parseStandardURIString } from '../../base/util/uri';
                 return Promise.reject('Sign in already in progress.');
             }
 
-            const signInDeferred = createDeferred();
-
+            const signInDeferred = Promise.withResolvers();
             const guids = {
                 authState: uuidV4(),
                 authNonce: uuidV4()
                     userSigninName: tokenParts.userSigninName
                 }));
 
-                signInDeferred.resolve();
+                signInDeferred.resolve(undefined);
             }
 
             window.addEventListener('message', handleAuth);

react/features/mobile/polyfills/browser.js

 import { TextDecoder, TextEncoder } from 'text-encoding';
 
 import 'promise.allsettled/auto'; // Promise.allSettled.
+import 'promise.withresolvers/auto'; // Promise.withResolvers.
 import 'react-native-url-polyfill/auto'; // Complete URL polyfill.
 
 import Storage from './Storage';

tsconfig.native.json

         "allowSyntheticDefaultImports": true,
         "target": "es2020",
         "jsx": "react-native",
-        "lib": [ "es2020"],
+        "lib": [ "ES2020", "ES2024.Promise" ],
         "types": [ "react-native" ],
         "skipLibCheck": true,
         "moduleResolution": "Node",

tsconfig.web.json

         "module": "es2020",
         "target": "es2020",
         "jsx": "react",
-        "lib": [ "ES2020", "DOM" ],
+        "lib": [ "ES2020", "ES2024.Promise", "DOM" ],
         "skipLibCheck": true,
         "moduleResolution": "Node",
         "strict": true,