quickblox 2.17.2-beta.2-logger → 2.17.3-logger

package/strophejs-1.6.1/src/builder.js

@@ -0,0 +1,239 @@
+import { NS } from './constants.js';
+import { copyElement, createHtml, serialize, xmlElement, xmlGenerator, xmlTextNode } from './utils.js';
+
+/** Class: Strophe.Builder
+ *  XML DOM builder.
+ *
+ *  This object provides an interface similar to JQuery but for building
+ *  DOM elements easily and rapidly.  All the functions except for toString()
+ *  and tree() return the object, so calls can be chained.  Here's an
+ *  example using the $iq() builder helper.
+ *  > $iq({to: 'you', from: 'me', type: 'get', id: '1'})
+ *  >     .c('query', {xmlns: 'strophe:example'})
+ *  >     .c('example')
+ *  >     .toString()
+ *
+ *  The above generates this XML fragment
+ *  > <iq to='you' from='me' type='get' id='1'>
+ *  >   <query xmlns='strophe:example'>
+ *  >     <example/>
+ *  >   </query>
+ *  > </iq>
+ *  The corresponding DOM manipulations to get a similar fragment would be
+ *  a lot more tedious and probably involve several helper variables.
+ *
+ *  Since adding children makes new operations operate on the child, up()
+ *  is provided to traverse up the tree.  To add two children, do
+ *  > builder.c('child1', ...).up().c('child2', ...)
+ *  The next operation on the Builder will be relative to the second child.
+ */
+
+/** Constructor: Strophe.Builder
+ *  Create a Strophe.Builder object.
+ *
+ *  The attributes should be passed in object notation.  For example
+ *  > let b = new Builder('message', {to: 'you', from: 'me'});
+ *  or
+ *  > let b = new Builder('messsage', {'xml:lang': 'en'});
+ *
+ *  Parameters:
+ *    (String) name - The name of the root element.
+ *    (Object) attrs - The attributes for the root element in object notation.
+ *
+ *  Returns:
+ *    A new Strophe.Builder.
+ */
+
+export default class Builder {
+
+    constructor (name, attrs) {
+        // Set correct namespace for jabber:client elements
+        if (name === 'presence' || name === 'message' || name === 'iq') {
+            if (attrs && !attrs.xmlns) {
+                attrs.xmlns = NS.CLIENT;
+            } else if (!attrs) {
+                attrs = { xmlns: NS.CLIENT };
+            }
+        }
+        // Holds the tree being built.
+        this.nodeTree = xmlElement(name, attrs);
+        // Points to the current operation node.
+        this.node = this.nodeTree;
+    }
+
+    /** Function: tree
+     *  Return the DOM tree.
+     *
+     *  This function returns the current DOM tree as an element object.  This
+     *  is suitable for passing to functions like Strophe.Connection.send().
+     *
+     *  Returns:
+     *    The DOM tree as a element object.
+     */
+    tree () {
+        return this.nodeTree;
+    }
+
+    /** Function: toString
+     *  Serialize the DOM tree to a String.
+     *
+     *  This function returns a string serialization of the current DOM
+     *  tree.  It is often used internally to pass data to a
+     *  Strophe.Request object.
+     *
+     *  Returns:
+     *    The serialized DOM tree in a String.
+     */
+    toString () {
+        return serialize(this.nodeTree);
+    }
+
+    /** Function: up
+     *  Make the current parent element the new current element.
+     *
+     *  This function is often used after c() to traverse back up the tree.
+     *  For example, to add two children to the same element
+     *  > builder.c('child1', {}).up().c('child2', {});
+     *
+     *  Returns:
+     *    The Stophe.Builder object.
+     */
+    up () {
+        this.node = this.node.parentNode;
+        return this;
+    }
+
+    /** Function: root
+     *  Make the root element the new current element.
+     *
+     *  When at a deeply nested element in the tree, this function can be used
+     *  to jump back to the root of the tree, instead of having to repeatedly
+     *  call up().
+     *
+     *  Returns:
+     *    The Stophe.Builder object.
+     */
+    root () {
+        this.node = this.nodeTree;
+        return this;
+    }
+
+    /** Function: attrs
+     *  Add or modify attributes of the current element.
+     *
+     *  The attributes should be passed in object notation.  This function
+     *  does not move the current element pointer.
+     *
+     *  Parameters:
+     *    (Object) moreattrs - The attributes to add/modify in object notation.
+     *
+     *  Returns:
+     *    The Strophe.Builder object.
+     */
+    attrs (moreattrs) {
+        for (const k in moreattrs) {
+            if (Object.prototype.hasOwnProperty.call(moreattrs, k)) {
+                if (moreattrs[k] === undefined) {
+                    this.node.removeAttribute(k);
+                } else {
+                    this.node.setAttribute(k, moreattrs[k]);
+                }
+            }
+        }
+        return this;
+    }
+
+    /** Function: c
+     *  Add a child to the current element and make it the new current
+     *  element.
+     *
+     *  This function moves the current element pointer to the child,
+     *  unless text is provided.  If you need to add another child, it
+     *  is necessary to use up() to go back to the parent in the tree.
+     *
+     *  Parameters:
+     *    (String) name - The name of the child.
+     *    (Object) attrs - The attributes of the child in object notation.
+     *    (String) text - The text to add to the child.
+     *
+     *  Returns:
+     *    The Strophe.Builder object.
+     */
+    c (name, attrs, text) {
+        const child = xmlElement(name, attrs, text);
+        this.node.appendChild(child);
+        if (typeof text !== 'string' && typeof text !== 'number') {
+            this.node = child;
+        }
+        return this;
+    }
+
+    /** Function: cnode
+     *  Add a child to the current element and make it the new current
+     *  element.
+     *
+     *  This function is the same as c() except that instead of using a
+     *  name and an attributes object to create the child it uses an
+     *  existing DOM element object.
+     *
+     *  Parameters:
+     *    (XMLElement) elem - A DOM element.
+     *
+     *  Returns:
+     *    The Strophe.Builder object.
+     */
+    cnode (elem) {
+        let impNode;
+        const xmlGen = xmlGenerator();
+        try {
+            impNode = xmlGen.importNode !== undefined;
+        } catch (e) {
+            impNode = false;
+        }
+        const newElem = impNode ? xmlGen.importNode(elem, true) : copyElement(elem);
+        this.node.appendChild(newElem);
+        this.node = newElem;
+        return this;
+    }
+
+    /** Function: t
+     *  Add a child text element.
+     *
+     *  This *does not* make the child the new current element since there
+     *  are no children of text elements.
+     *
+     *  Parameters:
+     *    (String) text - The text data to append to the current element.
+     *
+     *  Returns:
+     *    The Strophe.Builder object.
+     */
+    t (text) {
+        const child = xmlTextNode(text);
+        this.node.appendChild(child);
+        return this;
+    }
+
+    /** Function: h
+     *  Replace current element contents with the HTML passed in.
+     *
+     *  This *does not* make the child the new current element
+     *
+     *  Parameters:
+     *    (String) html - The html to insert as contents of current element.
+     *
+     *  Returns:
+     *    The Strophe.Builder object.
+     */
+    h (html) {
+        const fragment = xmlGenerator().createElement('body');
+        // force the browser to try and fix any invalid HTML tags
+        fragment.innerHTML = html;
+        // copy cleaned html into an xml dom
+        const xhtml = createHtml(fragment);
+        while (xhtml.childNodes.length > 0) {
+            this.node.appendChild(xhtml.childNodes[0]);
+        }
+        return this;
+    }
+}

package/strophejs-1.6.1/src/constants.js

@@ -0,0 +1,155 @@
+/** Constants: XMPP Namespace Constants
+ *  Common namespace constants from the XMPP RFCs and XEPs.
+ *
+ *  Strophe.NS.HTTPBIND - HTTP BIND namespace from XEP 124.
+ *  Strophe.NS.BOSH - BOSH namespace from XEP 206.
+ *  Strophe.NS.CLIENT - Main XMPP client namespace.
+ *  Strophe.NS.AUTH - Legacy authentication namespace.
+ *  Strophe.NS.ROSTER - Roster operations namespace.
+ *  Strophe.NS.PROFILE - Profile namespace.
+ *  Strophe.NS.DISCO_INFO - Service discovery info namespace from XEP 30.
+ *  Strophe.NS.DISCO_ITEMS - Service discovery items namespace from XEP 30.
+ *  Strophe.NS.MUC - Multi-User Chat namespace from XEP 45.
+ *  Strophe.NS.SASL - XMPP SASL namespace from RFC 3920.
+ *  Strophe.NS.STREAM - XMPP Streams namespace from RFC 3920.
+ *  Strophe.NS.BIND - XMPP Binding namespace from RFC 3920 and RFC 6120.
+ *  Strophe.NS.SESSION - XMPP Session namespace from RFC 3920.
+ *  Strophe.NS.XHTML_IM - XHTML-IM namespace from XEP 71.
+ *  Strophe.NS.XHTML - XHTML body namespace from XEP 71.
+ */
+export const NS = {
+    HTTPBIND: "http://jabber.org/protocol/httpbind",
+    BOSH: "urn:xmpp:xbosh",
+    CLIENT: "jabber:client",
+    AUTH: "jabber:iq:auth",
+    ROSTER: "jabber:iq:roster",
+    PROFILE: "jabber:iq:profile",
+    DISCO_INFO: "http://jabber.org/protocol/disco#info",
+    DISCO_ITEMS: "http://jabber.org/protocol/disco#items",
+    MUC: "http://jabber.org/protocol/muc",
+    SASL: "urn:ietf:params:xml:ns:xmpp-sasl",
+    STREAM: "http://etherx.jabber.org/streams",
+    FRAMING: "urn:ietf:params:xml:ns:xmpp-framing",
+    BIND: "urn:ietf:params:xml:ns:xmpp-bind",
+    SESSION: "urn:ietf:params:xml:ns:xmpp-session",
+    VERSION: "jabber:iq:version",
+    STANZAS: "urn:ietf:params:xml:ns:xmpp-stanzas",
+    XHTML_IM: "http://jabber.org/protocol/xhtml-im",
+    XHTML: "http://www.w3.org/1999/xhtml",
+}
+
+/** Constants: XHTML_IM Namespace
+ *  contains allowed tags, tag attributes, and css properties.
+ *  Used in the createHtml function to filter incoming html into the allowed XHTML-IM subset.
+ *  See http://xmpp.org/extensions/xep-0071.html#profile-summary for the list of recommended
+ *  allowed tags and their attributes.
+ */
+export const XHTML = {
+    tags: ['a','blockquote','br','cite','em','img','li','ol','p','span','strong','ul','body'],
+    attributes: {
+        'a':          ['href'],
+        'blockquote': ['style'],
+        'br':         [],
+        'cite':       ['style'],
+        'em':         [],
+        'img':        ['src', 'alt', 'style', 'height', 'width'],
+        'li':         ['style'],
+        'ol':         ['style'],
+        'p':          ['style'],
+        'span':       ['style'],
+        'strong':     [],
+        'ul':         ['style'],
+        'body':       []
+    },
+    css: ['background-color','color','font-family','font-size','font-style','font-weight','margin-left','margin-right','text-align','text-decoration'],
+}
+
+/** Constants: Connection Status Constants
+ *  Connection status constants for use by the connection handler
+ *  callback.
+ *
+ *  Strophe.Status.ERROR - An error has occurred
+ *  Strophe.Status.CONNECTING - The connection is currently being made
+ *  Strophe.Status.CONNFAIL - The connection attempt failed
+ *  Strophe.Status.AUTHENTICATING - The connection is authenticating
+ *  Strophe.Status.AUTHFAIL - The authentication attempt failed
+ *  Strophe.Status.CONNECTED - The connection has succeeded
+ *  Strophe.Status.DISCONNECTED - The connection has been terminated
+ *  Strophe.Status.DISCONNECTING - The connection is currently being terminated
+ *  Strophe.Status.ATTACHED - The connection has been attached
+ *  Strophe.Status.REDIRECT - The connection has been redirected
+ *  Strophe.Status.CONNTIMEOUT - The connection has timed out
+ */
+export const Status = {
+    ERROR: 0,
+    CONNECTING: 1,
+    CONNFAIL: 2,
+    AUTHENTICATING: 3,
+    AUTHFAIL: 4,
+    CONNECTED: 5,
+    DISCONNECTED: 6,
+    DISCONNECTING: 7,
+    ATTACHED: 8,
+    REDIRECT: 9,
+    CONNTIMEOUT: 10,
+    BINDREQUIRED: 11,
+    ATTACHFAIL: 12
+}
+
+export const ErrorCondition = {
+    BAD_FORMAT: "bad-format",
+    CONFLICT: "conflict",
+    MISSING_JID_NODE: "x-strophe-bad-non-anon-jid",
+    NO_AUTH_MECH: "no-auth-mech",
+    UNKNOWN_REASON: "unknown",
+}
+
+
+/** Constants: Log Level Constants
+ *  Logging level indicators.
+ *
+ *  Strophe.LogLevel.DEBUG - Debug output
+ *  Strophe.LogLevel.INFO - Informational output
+ *  Strophe.LogLevel.WARN - Warnings
+ *  Strophe.LogLevel.ERROR - Errors
+ *  Strophe.LogLevel.FATAL - Fatal errors
+ */
+export const LogLevel = {
+    DEBUG: 0,
+    INFO: 1,
+    WARN: 2,
+    ERROR: 3,
+    FATAL: 4
+}
+
+/** PrivateConstants: DOM Element Type Constants
+ *  DOM element types.
+ *
+ *  ElementType.NORMAL - Normal element.
+ *  ElementType.TEXT - Text data element.
+ *  ElementType.FRAGMENT - XHTML fragment element.
+ */
+export const ElementType = {
+    NORMAL: 1,
+    TEXT: 3,
+    CDATA: 4,
+    FRAGMENT: 11,
+}
+
+
+/** PrivateConstants: Timeout Values
+ *  Timeout values for error states.  These values are in seconds.
+ *  These should not be changed unless you know exactly what you are
+ *  doing.
+ *
+ *  TIMEOUT - Timeout multiplier. A waiting request will be considered
+ *      failed after Math.floor(TIMEOUT * wait) seconds have elapsed.
+ *      This defaults to 1.1, and with default wait, 66 seconds.
+ *  SECONDARY_TIMEOUT - Secondary timeout multiplier. In cases where
+ *      Strophe can detect early failure, it will consider the request
+ *      failed if it doesn't return after
+ *      Math.floor(SECONDARY_TIMEOUT * wait) seconds have elapsed.
+ *      This defaults to 0.1, and with default wait, 6 seconds.
+ */
+export const TIMEOUT = 1.1;
+export const SECONDARY_TIMEOUT = 0.1;