Converse converse.js

API Documentation

Source: headless/shared/api/send.js

  1. import _converse from '../../shared/_converse.js';
  2. import log from '../../log.js';
  3. import { Strophe } from 'strophe.js';
  4. import { TimeoutError } from '../errors.js';
  5. import { toStanza } from '../../utils/stanza.js';
  7. export default {
  8.     /**
  9.      * Allows you to send XML stanzas.
  10.      * @method _converse.api.send
  11.      * @param { Element | Stanza } stanza
  12.      * @return { void }
  13.      * @example
  14.      * const msg = converse.env.$msg({
  15.      *     'from': 'juliet@example.com/balcony',
  16.      *     'to': 'romeo@example.net',
  17.      *     'type':'chat'
  18.      * });
  19.      * _converse.api.send(msg);
  20.      */
  21.     send (stanza) {
  22.         const { api } = _converse;
  23.         if (!api.connection.connected()) {
  24.             log.warn("Not sending stanza because we're not connected!");
  25.             log.warn(Strophe.serialize(stanza));
  26.             return;
  27.         }
  28.         if (typeof stanza === 'string') {
  29.             stanza = toStanza(stanza);
  30.         } else if (stanza?.tree) {
  31.             stanza = stanza.tree();
  32.         }
  34.         if (stanza.tagName === 'iq') {
  35.             return api.sendIQ(stanza);
  36.         } else {
  37.             _converse.connection.send(stanza);
  38.             api.trigger('send', stanza);
  39.         }
  40.     },
  42.     /**
  43.      * Send an IQ stanza
  44.      * @method _converse.api.sendIQ
  45.      * @param { Element } stanza
  46.      * @param { number } [timeout] - The default timeout value is taken from
  47.      *  the `stanza_timeout` configuration setting.
  48.      * @param { Boolean } [reject=true] - Whether an error IQ should cause the promise
  49.      *  to be rejected. If `false`, the promise will resolve instead of being rejected.
  50.      * @returns { Promise } A promise which resolves (or potentially rejected) once we
  51.      *  receive a `result` or `error` stanza or once a timeout is reached.
  52.      *  If the IQ stanza being sent is of type `result` or `error`, there's
  53.      *  nothing to wait for, so an already resolved promise is returned.
  54.      */
  55.     sendIQ (stanza, timeout, reject=true) {
  56.         const { api, connection } = _converse;
  58.         let promise;
  59.         stanza = stanza.tree?.() ?? stanza;
  60.         if (['get', 'set'].includes(stanza.getAttribute('type'))) {
  61.             timeout = timeout || api.settings.get('stanza_timeout');
  62.             if (reject) {
  63.                 promise = new Promise((resolve, reject) => connection.sendIQ(stanza, resolve, reject, timeout));
  64.                 promise.catch((e) => {
  65.                     if (e === null) {
  66.                         throw new TimeoutError(
  67.                             `Timeout error after ${timeout}ms for the following IQ stanza: ${Strophe.serialize(stanza)}`
  68.                         );
  69.                     }
  70.                 });
  71.             } else {
  72.                 promise = new Promise((resolve) => connection.sendIQ(stanza, resolve, resolve, timeout));
  73.             }
  74.         } else {
  75.             _converse.connection.sendIQ(stanza);
  76.             promise = Promise.resolve();
  77.         }
  78.         api.trigger('send', stanza);
  79.         return promise;
  80.     }
  81. }