feat: Moves jquery import in a common place.

JitsiConference.js

 import { getLogger } from '@jitsi/logger';
-import $ from 'jquery';
 import { isEqual } from 'lodash-es';
 import { Strophe } from 'strophe.js';
 
 import { isValidNumber, safeSubtract } from './modules/util/MathUtil';
 import RandomUtil from './modules/util/RandomUtil';
 import { getJitterDelay } from './modules/util/Retry';
+import $ from './modules/util/XMLParser';
 import ComponentsVersions from './modules/version/ComponentsVersions';
 import VideoSIPGW from './modules/videosipgw/VideoSIPGW';
 import * as VideoSIPGWConstants from './modules/videosipgw/VideoSIPGWConstants';
     /**
      * Callback called by the Jingle plugin when 'session-answer' is received.
      * @param {JingleSessionPC} session - The Jingle session for which an answer was received.
-     * @param {jQuery} answer - A jQuery selector pointing to 'jingle' IQ element.
+     * @param {Object} answer - An element pointing to 'jingle' IQ element.
      */
     onCallAccepted(session, answer) {
         if (this.p2pJingleSession === session) {
     /**
      * Callback called by the Jingle plugin when 'transport-info' is received.
      * @param {JingleSessionPC} session - The Jingle session for which the IQ was received.
-     * @param {jQuery} transportInfo - A jQuery selector pointing to 'jingle' IQ element.
+     * @param {Object} transportInfo - An element pointing to 'jingle' IQ element.
      */
     onTransportInfo(session, transportInfo) {
         if (this.p2pJingleSession === session) {
     /**
      * Handles an incoming call event for the P2P Jingle session.
      * @param {JingleSessionPC} jingleSession - The Jingle session for the incoming call.
-     * @param {jQuery} jingleOffer - A jQuery selector pointing to 'jingle' IQ element containing the offer.
+     * @param {Object} jingleOffer - An element pointing to 'jingle' IQ element containing the offer.
      * @private
      */
     _onIncomingCallP2P(jingleSession, jingleOffer) {
     /**
      * Handles an incoming call event.
      * @param {JingleSessionPC} jingleSession - The Jingle session for the incoming call.
-     * @param {jQuery} jingleOffer - A jQuery selector pointing to 'jingle' IQ element containing the offer.
+     * @param {Object} jingleOffer - An element pointing to 'jingle' IQ element containing the offer.
      * @param {number} now - The timestamp when the call was received.
      */
     onIncomingCall(jingleSession, jingleOffer, now) {
     /**
      * Accepts an incoming call event for the JVB Jingle session.
      * @param {JingleSessionPC} jingleSession - The Jingle session for the incoming call.
-     * @param {jQuery} jingleOffer - A jQuery selector pointing to 'jingle' IQ element containing the offer.
+     * @param {Object} jingleOffer - An element pointing to 'jingle' IQ element containing the offer.
      * @param {number} now - The timestamp when the call was received.
      * @private
      */
     /**
      * Sets the BridgeChannel.
      *
-     * @param {jQuery} offerIq - A jQuery selector pointing to the jingle element of
+     * @param {Object} offerIq - An element pointing to the jingle element of
      * the offer IQ which may carry the WebSocket URL for the 'websocket'
      * BridgeChannel mode.
      * @param {TraceablePeerConnection} pc - The peer connection which will be used
     /**
      * Accepts an incoming P2P Jingle call.
      * @param {JingleSessionPC} jingleSession - The Jingle session instance.
-     * @param {jQuery} jingleOffer - A jQuery selector pointing to 'jingle' IQ element containing the offer.
+     * @param {Object} jingleOffer - An element pointing to 'jingle' IQ element containing the offer.
      * @private
      */
     _acceptP2PIncomingCall(jingleSession, jingleOffer) {

modules/proxyconnection/ProxyConnectionPC.js

      * The passed in jingle element should contain an SDP answer to a previously
      * sent SDP offer.
      *
-     * @param {Object} $jingle - The jingle element wrapped in jQuery.
+     * @param {Object} $jingle - The jingle element.
      * @private
      * @returns {void}
      */
      * Callback invoked in response to a request to start a proxy connection.
      * The passed in jingle element should contain an SDP offer.
      *
-     * @param {Object} $jingle - The jingle element wrapped in jQuery.
+     * @param {Object} $jingle - The jingle element.
      * @private
      * @returns {void}
      */
      * Callback invoked in response to ICE candidates from the remote peer.
      * The passed in jingle element should contain an ICE candidate.
      *
-     * @param {Object} $jingle - The jingle element wrapped in jQuery.
+     * @param {Object} $jingle - The jingle element.
      * @private
      * @returns {void}
      */

modules/proxyconnection/ProxyConnectionService.js

 import { getLogger } from '@jitsi/logger';
-import $ from 'jquery';
 import { $iq } from 'strophe.js';
 
+import $ from '../../modules/util/XMLParser';
 import { MediaType } from '../../service/RTC/MediaType';
 import { getSourceNameForJitsiTrack } from '../../service/RTC/SignalingLayer';
 import { VideoType } from '../../service/RTC/VideoType';
     }
 
     /**
-     * Transforms a stringified xML into a XML wrapped in jQuery.
+     * Transforms a stringified xML into a XML element.
      *
      * @param {string} xml - The XML in string form.
      * @private
-     * @returns {Object|null} A jQuery version of the xml. Null will be returned
+     * @returns {Object|null} An element version of the xml. Null will be returned
      * if an error is encountered during transformation.
      */
     _convertStringToXML(xml) {

modules/sdp/SDP.js

-import $ from 'jquery';
+
 import { cloneDeep } from 'lodash-es';
 import transform from 'sdp-transform';
 import { Strophe } from 'strophe.js';
 import { SSRC_GROUP_SEMANTICS } from '../../service/RTC/StandardVideoQualitySettings';
 import { XEP } from '../../service/xmpp/XMPPExtensioProtocols';
 import browser from '../browser';
+import $ from '../util/XMLParser';
 
 import SDPUtil from './SDPUtil';
 

modules/sdp/SDP.spec.js

-import $ from 'jquery';
 import { $iq } from 'strophe.js';
 
 import FeatureFlags from '../flags/FeatureFlags';
 import { expandSourcesFromJson } from '../xmpp/JingleHelperFunctions';
+import $ from '../util/XMLParser';
 
 import SDP from './SDP';
 

modules/util/XMLParser.ts

+import $ from 'jquery';
+
+export default $;

modules/xmpp/Caps.js

-import $ from 'jquery';
 import { Strophe } from 'strophe.js'; // eslint-disable-line camelcase
 
 import { XMPPEvents } from '../../service/xmpp/XMPPEvents';
 import Listenable from '../util/Listenable';
+import $ from '../util/XMLParser';
 
 import sha1 from './sha1';
 

modules/xmpp/ChatRoom.js

 import { getLogger } from '@jitsi/logger';
 import emojiRegex from 'emoji-regex';
-import $ from 'jquery';
 import { isEqual } from 'lodash-es';
 import { $iq, $msg, $pres, Strophe } from 'strophe.js';
 import { v4 as uuidv4 } from 'uuid';
 import EventEmitterForwarder from '../util/EventEmitterForwarder';
 import Listenable from '../util/Listenable';
 import { getJitterDelay } from '../util/Retry';
+import $ from '../util/XMLParser';
 
 import AVModeration from './AVModeration';
 import BreakoutRooms from './BreakoutRooms';

modules/xmpp/JingleHelperFunctions.ts

 import { safeJsonParse } from '@jitsi/js-utils/json';
 import { getLogger } from '@jitsi/logger';
-import $ from 'jquery';
 import { $build } from 'strophe.js';
 
 import { MediaType } from '../../service/RTC/MediaType';
 import { SSRC_GROUP_SEMANTICS } from '../../service/RTC/StandardVideoQualitySettings';
 import { VideoType } from '../../service/RTC/VideoType';
 import { XEP } from '../../service/xmpp/XMPPExtensioProtocols';
+import $ from '../util/XMLParser';
 
 const logger = getLogger('modules/xmpp/JingleHelperFunctions');
 

modules/xmpp/JingleSessionPC.js

 import { getLogger } from '@jitsi/logger';
-import $ from 'jquery';
 import { isEqual } from 'lodash-es';
 import { $build, $iq, Strophe } from 'strophe.js';
 
 import SDPUtil from '../sdp/SDPUtil';
 import Statistics from '../statistics/statistics';
 import AsyncQueue, { ClearedQueueError } from '../util/AsyncQueue';
+import $ from '../util/XMLParser';
 
 import browser from './../browser';
 import JingleSession from './JingleSession';
 export default class JingleSessionPC extends JingleSession {
     /**
      * Parses 'senders' attribute of the video content.
-     * @param {jQuery} jingleContents
+     * @param {Object} jingleContents
      * @return {string|null} one of the values of content "senders" attribute
      * defined by Jingle. If there is no "senders" attribute or if the value is
      * invalid then <tt>null</tt> will be returned.
      * Parses the source-name and max frame height value of the 'content-modify' IQ when source-name signaling
      * is enabled.
      *
-     * @param {jQuery} jingleContents - A jQuery selector pointing to the '>jingle' element.
+     * @param {Object} jingleContents - An element pointing to the '>jingle' element.
      * @returns {Object|null}
      */
     static parseSourceMaxFrameHeight(jingleContents) {
      * Takes in a jingle offer iq, returns the new sdp offer that can be set as remote description in the
      * peerconnection.
      *
-     * @param {jquery xml element} offerIq the incoming offer.
+     * @param {Object} offerIq the incoming offer.
      * @returns {SDP object} the jingle offer translated to SDP.
      * @private
      */
     /**
      * Parses the SSRC information from the source-add/source-remove element passed and updates the SSRC owners.
      *
-     * @param {jquery xml element} sourceElement the source-add/source-remove element from jingle.
+     * @param {Object} sourceElement the source-add/source-remove element from jingle.
      * @param {boolean} isAdd true if the sources are being added, false if they are to be removed.
      * @returns {Map<string, Object>} - The map of source name to ssrcs, msid and groups.
      */
     /**
      * Accepts incoming Jingle 'session-initiate' and should send 'session-accept' in result.
      *
-     * @param jingleOffer jQuery selector pointing to the jingle element of the offer IQ
+     * @param jingleOffer element pointing to the jingle element of the offer IQ
      * @param success callback called when we accept incoming session successfully and receive RESULT packet to
      * 'session-accept' sent.
      * @param failure function(error) called if for any reason we fail to accept the incoming offer. 'error' argument
      * This is a setRemoteDescription/setLocalDescription cycle which starts at converting Strophe Jingle IQ into
      * remote offer SDP. Once converted, setRemoteDescription, createAnswer and setLocalDescription calls follow.
      *
-     * @param jingleOfferAnswerIq jQuery selector pointing to the jingle element of the offer (or answer) IQ
+     * @param jingleOfferAnswerIq element pointing to the jingle element of the offer (or answer) IQ
      * @param success callback called when sRD/sLD cycle finishes successfully.
      * @param failure callback called with an error object as an argument if we fail at any point during setRD,
      * createAnswer, setLD.

modules/xmpp/JingleSessionPC.spec.js

-import $ from 'jquery';
-
 import { MockRTC } from '../RTC/MockClasses';
+import $ from '../util/XMLParser';
 
 import JingleSessionPC from './JingleSessionPC';
 import * as JingleSessionState from './JingleSessionState';
 
 /**
  * Creates 'content-modify' Jingle IQ.
- * @returns {jQuery}
+ * @returns {Object}
  */
 function createContentModifyForSourceNames() {
     const modifyContentsIq = $.parseXML(

modules/xmpp/moderator.js

 /* eslint-disable newline-per-chained-call */
 import { getLogger } from '@jitsi/logger';
-import $ from 'jquery';
 import { $iq } from 'strophe.js';
 
 import { CONFERENCE_REQUEST_FAILED, NOT_LIVE_ERROR } from '../../JitsiConnectionErrors';
 import { CONNECTION_FAILED, CONNECTION_REDIRECTED } from '../../JitsiConnectionEvents';
 import Settings from '../settings/Settings';
 import Listenable from '../util/Listenable';
+import $ from '../util/XMLParser';
 
 const AuthenticationEvents
     = require('../../service/authentication/AuthenticationEvents');

modules/xmpp/strophe.emuc.js

 import { getLogger } from '@jitsi/logger';
-import $ from 'jquery';
 import { Strophe } from 'strophe.js';
 
 import { CONNECTION_REDIRECTED } from '../../JitsiConnectionEvents';
 import { XMPPEvents } from '../../service/xmpp/XMPPEvents';
+import $ from '../util/XMLParser';
 
 import ChatRoom from './ChatRoom';
 import { ConnectionPluginListenable } from './ConnectionPlugin';

modules/xmpp/strophe.jingle.js

 import { getLogger } from '@jitsi/logger';
-import $ from 'jquery';
 import { cloneDeep } from 'lodash-es';
 import { $iq, Strophe } from 'strophe.js';
 
 import { XMPPEvents } from '../../service/xmpp/XMPPEvents';
 import RandomUtil from '../util/RandomUtil';
+import $ from '../util/XMLParser';
 
 import ConnectionPlugin from './ConnectionPlugin';
 import { expandSourcesFromJson } from './JingleHelperFunctions';

modules/xmpp/strophe.rayo.ts

 import { getLogger } from '@jitsi/logger';
-import $ from 'jquery';
 import { $iq, type Connection } from 'strophe.js';
 
+import $ from '../util/XMLParser';
+
 import ConnectionPlugin from './ConnectionPlugin';
 
 const logger = getLogger('modules/xmpp/strophe.rayo');

modules/xmpp/xmpp.js

 import { safeJsonParse } from '@jitsi/js-utils/json';
 import { getLogger } from '@jitsi/logger';
-import $ from 'jquery';
 import { unescape } from 'lodash-es';
 import { $msg, Strophe } from 'strophe.js';
 
 import Statistics from '../statistics/statistics';
 import Listenable from '../util/Listenable';
 import RandomUtil from '../util/RandomUtil';
+import $ from '../util/XMLParser';
 
 import Caps, { parseDiscoInfo } from './Caps';
 import { IDENTITY_TYPE as FILE_SHARING_IDENTITY_TYPE } from './FileSharing';

types/hand-crafted/JitsiConference.d.ts

   onUserRoleChanged: ( jid: string, role: string ) => void;
   onDisplayNameChanged: ( jid: string, displayName: string ) => void;
   onRemoteTrackAdded: ( track: JitsiRemoteTrack ) => void;
-  onCallAccepted: ( session: unknown, answer: JQuery ) => void; // TODO: answer is a jQuery object, unknown = JingleSessionPC which doesn't exist
-  onTransportInfo: ( session: unknown, transportInfo: JQuery ) => void; // TODO: transportInfo is a jQuery object, unknown = JingleSessionPC which doesn't exist
+  onCallAccepted: ( session: unknown, answer: Object ) => void; // TODO: answer is an element object, unknown = JingleSessionPC which doesn't exist
+  onTransportInfo: ( session: unknown, transportInfo: Object ) => void; // TODO: transportInfo is an element object, unknown = JingleSessionPC which doesn't exist
   onRemoteTrackRemoved: ( removedTrack: JitsiRemoteTrack ) => void;
   onIncomingCall: ( jingleSession: unknown, jingleOffer: unknown, now: unknown ) => void; // TODO: unknown = JingleSessionPC which doesn't exist
   onCallEnded: ( jingleSession: unknown, reasonCondition: string, reasonText: string ) => void; // TODO: unknown = JingleSessionPC which doesn't exist

types/hand-crafted/modules/proxyconnection/ProxyConnectionPC.d.ts

     onSendMessage: ( params: unknown ) => unknown; // TODO:
   } );
   getPeerJid: () => string;
-  processMessage: ( $jingle: JQuery ) => void; // TODO: surely there shouldn't be a dependency on jQuery
+  processMessage: ( $jingle: Object ) => void;
   start: ( localTracks?: JitsiLocalTrack[] ) => void;
   stop: () => void;
 }

types/hand-crafted/modules/xmpp/Caps.d.ts

 
 export default class Caps extends Listenable {
   constructor( connection?: Strophe.Connection, node?: string );
-  parseDiscoInfo: ( node: string ) => { features: Set<string>, identities: Set<{ type: string, name: string, category: string }> }; // TODO: (string here is a jquery selector)
+  parseDiscoInfo: ( node: string ) => { features: Set<string>, identities: Set<{ type: string, name: string, category: string }> }; // TODO: (string here is an element)
   addFeature: ( feature: string, submit?: boolean, external?: boolean ) => void;
   removeFeature: ( feature: string, submit?: boolean, external?: boolean ) => void;
   submit: () => void;

types/hand-crafted/modules/xmpp/JingleSession.d.ts

   addSources: ( contents: unknown ) => void; // TODO:
   removeSources: ( contents: unknown ) => void; // TODO:
   terminate: ( success: ( params: unknown ) => unknown, failure: ( params: unknown ) => unknown, options: { reason: string, reasonDescription: string, requestRestart?: boolean, sendSessionTerminate?: boolean } ) => void; // TODO:
-  acceptOffer: ( jingle: JQuery, success: ( params: unknown ) => unknown, failure: ( params: unknown ) => unknown ) => void; // TODO:
+  acceptOffer: ( jingle: Object, success: ( params: unknown ) => unknown, failure: ( params: unknown ) => unknown ) => void; // TODO:
 }

types/hand-crafted/modules/xmpp/JingleSessionPC.d.ts

 import JitsiRemoteTrack from '../RTC/JitsiRemoteTrack';
 
 export default class JingleSessionPC extends JingleSession {
-  static parseVideoSenders: ( jingleContents: JQuery ) => string | null;
+  static parseVideoSenders: ( jingleContents: Object ) => string | null;
   constructor( sid: string, localJid: string, remoteJid: string, connection: XmppConnection, mediaConstraints: unknown, iceConfig: unknown, isP2P: boolean, isInitiator: boolean ); // TODO:
   doInitialize: ( options: {} ) => void;
   sendIceCandidate: ( candidate: RTCIceCandidate ) => void;
   sendIceCandidates: ( candidates: RTCIceCandidate[] ) => void;
   addIceCandidates: ( elem: unknown ) => void; // TODO:
   getConfiguredVideoCodec: () => CodecMimeType;
-  acceptOffer: ( jingleOffer: JQuery, success: ( params: unknown ) => unknown, failure: ( params: unknown ) => unknown, localTracks?: JitsiLocalTrack[] ) => void; // TODO:
+  acceptOffer: ( jingleOffer: Object, success: ( params: unknown ) => unknown, failure: ( params: unknown ) => unknown, localTracks?: JitsiLocalTrack[] ) => void; // TODO:
   invite: ( localTracks?: JitsiLocalTrack[] ) => void;
   sendSessionInitiate: ( offerSdp: string ) => void;
   setAnswer: ( jingleAnswer: unknown ) => void; // TODO:
-  setOfferAnswerCycle: ( jingleOfferAnswerIq: JQuery, success: ( params: unknown ) => unknown, failure: ( params: unknown ) => unknown, localTracks?: JitsiLocalTrack[] ) => void; // TODO:
+  setOfferAnswerCycle: ( jingleOfferAnswerIq: Object, success: ( params: unknown ) => unknown, failure: ( params: unknown ) => unknown, localTracks?: JitsiLocalTrack[] ) => void; // TODO:
   setVideoCodecs: ( preferred?: CodecMimeType, disabled?: CodecMimeType ) => void;
   setReceiverVideoConstraint: ( maxFrameHeight: number ) => void;
   setSenderMaxBitrates: () => Promise<void>;
   addTrackAsUnmute: ( track: JitsiLocalTrack ) => Promise<unknown>; // TODO:
   removeTrackAsMute: ( track: JitsiLocalTrack ) => Promise<unknown>; // TODO:
   setMediaTransferActive: ( videoActive: boolean ) => Promise<unknown>; // TODO:
-  modifyContents: ( jingleContents: JQuery ) => void;
+  modifyContents: ( jingleContents: Object ) => void;
   notifyMySSRCUpdate: ( oldSDP: unknown, newSDP: unknown ) => void; // TODO:
   newJingleErrorHandler: ( request: unknown, failureCb: ( error: Error ) => void ) => ( this: JingleSessionPC ) => unknown; // TODO:
   getIceConnectionState: () => unknown; // TODO: