@qikdev/sdk 0.1.164 → 0.1.166

package/src/api/qik.socket.js

@@ -1,4 +1,4 @@
-import { EventDispatcher } from './qik.utils.js';
+import { EventDispatcher } from "./qik.utils.js";
 
 ///////////////////////////////////////////////////
 
@@ -11,338 +11,348 @@ import { EventDispatcher } from './qik.utils.js';
  * @param {QikAPI} qik A reference to the parent instance of the QikCore module. This module is usually created by a QikCore instance that passes itself in as the first argument.
  */
 
-const QikSocket = function(qik, mode) {
-
-    mode = mode || 'production';
-
-    if (!qik.auth) {
-        throw new Error(`Can't Instantiate QikSocket before QikAuth exists`);
+const QikSocket = function (qik, mode) {
+  mode = mode || "production";
+
+  if (!qik.auth) {
+    throw new Error(`Can't Instantiate QikSocket before QikAuth exists`);
+  }
+
+  const windowID = qik.utils.guid();
+
+  ///////////////////////////////////////////////////
+
+  let service = {
+    debug: false,
+    url: `wss://iqtm6zjz3l.execute-api.ap-southeast-2.amazonaws.com/${mode}`,
+    connected: false,
+    windowID,
+    autoreconnect: true,
+  };
+
+  let socket;
+  let timer;
+  let buckets = {};
+  const channels = {};
+
+  //Create a new dispatcher
+  const dispatcher = new EventDispatcher();
+  dispatcher.bootstrap(service);
+
+  ///////////////////////////////////////////////////
+
+  function getSubscriptions() {
+    return Object.keys(buckets);
+  }
+
+  ///////////////////////////////////////////////////
+
+  /**
+   * @description Create an event dispatcher instance and subscribe to a new socket channel.
+   * This can then be used to receive socket events for this channel
+   * @alias socket.channel
+   * @param  {String} key The key or name of the channel to subscribe to
+   * @example
+   * const socketChannel = await sdk.socket.channel('awesome:notifications')
+   * socketChannel.addEventListener('message', function(message) {
+   *    console.log('Received a new message from the socket')
+   * })
+   *
+   * // Disconnect from this channel and remove all listeners
+   * socketChannel.destroy();
+   *
+   */
+  service.channel = async function (key) {
+    if (!buckets[key]) {
+      // Create a new channel instance
+      const bucket = new EventDispatcher();
+      buckets[key] = bucket;
+
+      // If the user isn't online
+      if (!service.connected) {
+        // Connect them now
+        await service.connect();
+      }
+
+      // Subscribe to this key
+      service.subscribe(key);
+
+      // Listen for all relevant events
+      service.addEventListener(key, dispatchMessage);
+
+      function dispatchMessage(message) {
+        bucket.dispatch("message", message);
+      }
+
+      // Destroy the service
+      bucket.destroy = function () {
+        service.unsubscribe(key);
+        buckets[key].removeAllListeners();
+        buckets[key] = null;
+      };
     }
 
+    // Return the channel instance
+    return buckets[key];
+  };
 
-    const windowID = qik.utils.guid();
+  ///////////////////////////////////////////////////
 
-    ///////////////////////////////////////////////////
+  function ping() {
+    broadcast({
+      action: "ping",
+    });
+  }
 
-    let service = {
-        debug: false,
-        url: `wss://iqtm6zjz3l.execute-api.ap-southeast-2.amazonaws.com/${mode}`,
-        connected: false,
-        windowID,
-        autoreconnect:true,
+  function startHeartbeat() {
+    if (timer) {
+      return;
     }
+    timer = setInterval(ping, 10000);
+  }
 
-    let socket;
-    let timer;
-    let buckets = {};
-    const channels = {};
-
-
-
-    //Create a new dispatcher
-    const dispatcher = new EventDispatcher();
-    dispatcher.bootstrap(service);
-
-    ///////////////////////////////////////////////////
-
-    function getSubscriptions() {
-        return Object.keys(buckets);
+  function stopHeartbeat() {
+    if (!timer) {
+      return;
     }
 
-    ///////////////////////////////////////////////////
-
-
-    /**
-     * @description Create an event dispatcher instance and subscribe to a new socket channel.
-     * This can then be used to receive socket events for this channel
-     * @alias socket.channel
-     * @param  {String} key The key or name of the channel to subscribe to
-     * @example
-     * const socketChannel = await sdk.socket.channel('awesome:notifications')
-     * socketChannel.addEventListener('message', function(message) {
-     *    console.log('Received a new message from the socket')
-     * })
-     *
-     * // Disconnect from this channel and remove all listeners
-     * socketChannel.destroy();
-     * 
-     */
-    service.channel = async function(key) {
-        if (buckets[key]) {
-            return buckets[key];
-        }
-
-        const bucket = new EventDispatcher();
-        buckets[key] = bucket;
-
-        if (!service.connected) {
-            // Return the socket
-            await service.connect();
-        }
-
-        // Subscribe to this channel
-        service.subscribe(key);
-
-        // Listen for all relevant events
-        service.addEventListener(key, dispatchMessage);
-
-        function dispatchMessage(message) {
-            bucket.dispatch('message', message);
-        }
-
-        // Destroy the service
-        bucket.destroy = function() {
-            service.removeAllListeners();
-            buckets[key] = null;
-        }
-
-        return buckets[key];
-    }
-
-    ///////////////////////////////////////////////////
-
-    function ping() {
-        broadcast({
-            action: 'ping',
-        })
-    }
-
-    function startHeartbeat() {
-        if (timer) {
-            return;
-        }
-        timer = setInterval(ping, 10000);
+    clearInterval(timer);
+    timer = null;
+  }
+
+  ///////////////////////////////////////////////////
+
+  function socketOpened(event) {
+    service.debug ? console.log("[socket] Connection open", event) : null;
+    service.connected = true;
+
+    dispatcher.dispatch("connected", event);
+
+    // startHeartbeat();
+  }
+
+  async function socketClosed(event) {
+    if (event.wasClean) {
+      service.debug
+        ? console.log(
+            `[socket] Connection closed cleanly, code=${event.code} reason=${event.reason}`,
+          )
+        : null;
+    } else {
+      // e.g. server process killed or network down
+      // event.code is usually 1006 in this case
+      service.debug
+        ? console.log("[socket] - connection closed due to error", event)
+        : null;
     }
 
-    function stopHeartbeat() {
-        if (!timer) {
-            return;
-        }
+    service.connected = false;
+    dispatcher.dispatch("disconnected", event);
+    socket = null;
 
-        clearInterval(timer)
-        timer = null;
+    if (service.autoreconnect) {
+      service.reconnect();
     }
+  }
 
-    ///////////////////////////////////////////////////
+  function socketError(error) {
+    console.log("[event] socketError", event);
+    service.debug ? console.log("[socket] Error", error) : null;
+    dispatcher.dispatch("error", error);
+  }
 
-    function socketOpened(event) {
-        service.debug ? console.log("[socket] Connection open", event) : null;
-        service.connected = true;
+  function socketMessageReceived(event) {
+    const eventData = JSON.parse(event.data);
+    service.debug ? console.log("[socket] message received", eventData) : null;
 
-        dispatcher.dispatch('connected', event);
+    // Dispatch a generic message
+    dispatcher.dispatch("message", eventData);
 
-        // startHeartbeat();
+    if (eventData.channel) {
+      dispatcher.dispatch(eventData.channel, eventData);
     }
+  }
 
-    async function socketClosed(event) {
-        if (event.wasClean) {
-            service.debug ? console.log(`[socket] Connection closed cleanly, code=${event.code} reason=${event.reason}`) : null;
-        } else {
-            // e.g. server process killed or network down
-            // event.code is usually 1006 in this case
-            service.debug ? console.log('[socket] - connection closed due to error', event) : null
-        }
+  async function broadcast(data) {
+    socket.send(JSON.stringify(data));
+  }
 
-        service.connected = false;
-        dispatcher.dispatch('disconnected', event);
-        socket = null;
+  ///////////////////////////////////////////////////
 
-        if(service.autoreconnect) {
-            service.reconnect();
+  function wait() {
+    return new Promise(function (resolve) {
+      function check() {
+        if (service.connected) {
+          return resolve(socket);
         }
-    }
-
-    function socketError(error) {
-        console.log('[event] socketError', event);
-        service.debug ? console.log("[socket] Error", error) : null;
-        dispatcher.dispatch('error', error);
-    }
 
-    function socketMessageReceived(event) {
-        const eventData = JSON.parse(event.data);
-        service.debug ? console.log("[socket] message received", eventData) : null;
-
-        // Dispatch a generic message
-        dispatcher.dispatch('message', eventData);
-
-        if (eventData.channel) {
-            dispatcher.dispatch(eventData.channel, eventData);
-        }
-    }
+        setTimeout(check, 1000);
+      }
+
+      check();
+    });
+  }
+
+  ///////////////////////////////////////////////////
+
+  /**
+   * @description Connect to the socket service
+   * @alias socket.connect
+   * @example
+   * const connected = await sdk.socket.connect()
+   *
+   */
+  service.connect = async function () {
+    if (socket) {
+      if (!socket.connected) {
+        return wait();
+      }
 
-    async function broadcast(data) {
-        socket.send(JSON.stringify(data));
+      console.log("[socket] - Socket is already connected");
+      return socket;
     }
 
-    ///////////////////////////////////////////////////
-
-    function wait() {
-        return new Promise(function(resolve) {
-            function check() {
-                if (service.connected) {
-                    return resolve(socket);
-                }
+    const accessToken = qik.auth.getCurrentToken();
 
-                setTimeout(check, 1000);
-            }
-
-            check();
-        })
+    if (!accessToken) {
+      service.debug
+        ? console.log("[socket] - Must be authenticated to connect to socket")
+        : null;
+      return;
     }
 
-    ///////////////////////////////////////////////////
-
-    /**
-     * @description Connect to the socket service
-     * @alias socket.connect
-     * @example
-     * const connected = await sdk.socket.connect()
-     * 
-     */
-    service.connect = async function() {
-        if (socket) {
-
-            if (!socket.connected) {
-                return wait();
-            }
-
-            console.log('[socket] - Socket is already connected');
-            return socket;
-        }
-
-        const accessToken = qik.auth.getCurrentToken();
-
-        if (!accessToken) {
-            service.debug ? console.log('[socket] - Must be authenticated to connect to socket') : null;
-            return;
-        }
-
-        socket = new WebSocket(`${service.url}?access_token=${accessToken}&windowid=${windowID}`);
-        socket.addEventListener('close', socketClosed);
-        socket.addEventListener('error', socketError);
-        socket.addEventListener('open', socketOpened);
-        socket.addEventListener('message', socketMessageReceived);
-        service.debug ? console.log('[socket] - Connected with event listeners') : null;
-
-        return wait();
+    socket = new WebSocket(
+      `${service.url}?access_token=${accessToken}&windowid=${windowID}`,
+    );
+    socket.addEventListener("close", socketClosed);
+    socket.addEventListener("error", socketError);
+    socket.addEventListener("open", socketOpened);
+    socket.addEventListener("message", socketMessageReceived);
+    service.debug
+      ? console.log("[socket] - Connected with event listeners")
+      : null;
+
+    return wait();
+  };
+
+  /**
+   * @description Reconnect to the socket service
+   * @alias socket.reconnect
+   * @example
+   * const connected = await sdk.socket.reconnect()
+   *
+   */
+  service.reconnect = async function () {
+    if (service.connected) {
+      return;
     }
 
-
-    /**
-     * @description Reconnect to the socket service
-     * @alias socket.reconnect
-     * @example
-     * const connected = await sdk.socket.reconnect()
-     * 
-     */
-    service.reconnect = async function() {
-        if(service.connected) {
-            return;
-        }
-        
-        service.debug ? console.log(`[socket] reconnecting...`) : null;
-        
-        // Reconnect all listeners
-        const result = await service.connect();
-
-        // Resubscribe to all previously connected channels
-        const subscribedChannels = Object.keys(channels);
-        subscribedChannels.forEach(function(channel) {
-            service.subscribe(channel);
-        })
-
-        return result;
+    service.debug ? console.log(`[socket] reconnecting...`) : null;
+
+    // Reconnect all listeners
+    const result = await service.connect();
+
+    // Resubscribe to all previously connected channels
+    const subscribedChannels = Object.keys(channels);
+    subscribedChannels.forEach(function (channel) {
+      service.subscribe(channel);
+    });
+
+    return result;
+  };
+
+  ///////////////////////////////////////////////////
+
+  /**
+   * @description Close the connection to the socket service
+   * @alias socket.close
+   * @example
+   * const closed = await sdk.socket.close()
+   *
+   */
+  service.close = async function () {
+    if (!socket) {
+      console.log("[socket] - Socket is not connected");
+      return;
     }
-    
-
-    ///////////////////////////////////////////////////
-
-    /**
-     * @description Close the connection to the socket service
-     * @alias socket.close
-     * @example
-     * const closed = await sdk.socket.close()
-     * 
-     */
-    service.close = async function() {
-        if (!socket) {
-            console.log('[socket] - Socket is not connected');
-            return;
-        }
 
-        const previousSetting = service.autoreconnect;
-        service.autoreconnect = false;
-        socket.close();
-        socket.removeEventListener('close', socketClosed);
-        socket.removeEventListener('error', socketError);
-        socket.removeEventListener('open', socketOpened);
-        socket.removeEventListener('message', socketMessageReceived);
-        socket = null;
-        socketClosed({ wasClean: true });
-        service.autoreconnect = previousSetting;
+    const previousSetting = service.autoreconnect;
+    service.autoreconnect = false;
+    socket.close();
+    socket.removeEventListener("close", socketClosed);
+    socket.removeEventListener("error", socketError);
+    socket.removeEventListener("open", socketOpened);
+    socket.removeEventListener("message", socketMessageReceived);
+    socket = null;
+    socketClosed({ wasClean: true });
+    service.autoreconnect = previousSetting;
+  };
+
+  service.disconnect = service.close;
+
+  ///////////////////////////////////////////////////
+
+  /**
+   * @description Subscribe to a socket channel
+   * @alias socket.subscribe
+   * @param  {String} key The name of the channel to subscribe to
+   * @example
+   * const subscribed = await sdk.socket.subscribe('some:cool:alert')
+   *
+   */
+  service.subscribe = async function (channel) {
+    if (!socket) {
+      console.log(
+        `[socket] - Can't subscribe to channel as socket is not connected`,
+      );
+      return;
     }
 
-    service.disconnect = service.close;
-
-    ///////////////////////////////////////////////////
-
-    /**
-     * @description Subscribe to a socket channel
-     * @alias socket.subscribe
-     * @param  {String} key The name of the channel to subscribe to
-     * @example
-     * const subscribed = await sdk.socket.subscribe('some:cool:alert')
-     * 
-     */
-    service.subscribe = async function(channel) {
-        if (!socket) {
-            console.log(`[socket] - Can't subscribe to channel as socket is not connected`);
-            return;
-        }
-
-        broadcast({
-            action: 'subscribe',
-            channel,
-        })
-
-        channels[channel] = true;
-
-        dispatcher.dispatch('subscribe', channel)
-        service.debug ? console.log(`[socket] - subscribed to ${channel}`) : null;
+    broadcast({
+      action: "subscribe",
+      channel,
+    });
+
+    channels[channel] = true;
+
+    dispatcher.dispatch("subscribe", channel);
+    service.debug ? console.log(`[socket] - subscribed to ${channel}`) : null;
+  };
+
+  ///////////////////////////////////////////////////
+
+  /**
+   * @description Unsubscribe from a socket channel
+   * @alias socket.unsubscribe
+   * @param  {String} key The name of the channel to unsubscribe from
+   * @example
+   * const unsubscribed = await sdk.socket.unsubscribe('some:cool:alert')
+   *
+   */
+  service.unsubscribe = async function (channel) {
+    if (!socket) {
+      console.log(
+        `[socket] - Can't unsubscribe from channel as socket is not connected`,
+      );
+      return;
     }
 
-    ///////////////////////////////////////////////////
-
-    /**
-     * @description Unsubscribe from a socket channel
-     * @alias socket.unsubscribe
-     * @param  {String} key The name of the channel to unsubscribe from
-     * @example
-     * const unsubscribed = await sdk.socket.unsubscribe('some:cool:alert')
-     * 
-     */
-    service.unsubscribe = async function(channel) {
-        if (!socket) {
-            console.log(`[socket] - Can't unsubscribe from channel as socket is not connected`);
-            return;
-        }
-
-        broadcast({
-            action: 'unsubscribe',
-            channel,
-        })
-
-        delete channels[channel];
-
-        dispatcher.dispatch('unsubscribe', channel)
-        service.debug ? console.log(`[socket] - unsubscribed from ${channel}`) : null;
-    }
+    broadcast({
+      action: "unsubscribe",
+      channel,
+    });
 
-    ///////////////////////////////////////////////////
+    delete channels[channel];
 
-    return service;
+    dispatcher.dispatch("unsubscribe", channel);
+    service.debug
+      ? console.log(`[socket] - unsubscribed from ${channel}`)
+      : null;
+  };
 
-}
+  ///////////////////////////////////////////////////
 
+  return service;
+};
 
-export default QikSocket;
+export default QikSocket;

package/src/version.js

@@ -1 +1 @@
-export const version = "0.1.164";
+export const version = "0.1.166";

package/.eslintcache

@@ -1 +0,0 @@
-[{"/Users/cadeembery/Code/qik/sdk/dist/main.js":"1","/Users/cadeembery/Code/qik/sdk/eslint.config.js":"2","/Users/cadeembery/Code/qik/sdk/src/version.js":"3"},{"size":154130,"mtime":1717379141890,"results":"4","hashOfConfig":"5"},{"size":103,"mtime":1717379186115,"results":"6","hashOfConfig":"5"},{"size":34,"mtime":1717379141891,"results":"7","hashOfConfig":"5"},{"filePath":"8","messages":"9","suppressedMessages":"10","errorCount":0,"fatalErrorCount":0,"warningCount":0,"fixableErrorCount":0,"fixableWarningCount":0},"1wo9pgp",{"filePath":"11","messages":"12","suppressedMessages":"13","errorCount":0,"fatalErrorCount":0,"warningCount":0,"fixableErrorCount":0,"fixableWarningCount":0},{"filePath":"14","messages":"15","suppressedMessages":"16","errorCount":0,"fatalErrorCount":0,"warningCount":0,"fixableErrorCount":0,"fixableWarningCount":0},"/Users/cadeembery/Code/qik/sdk/dist/main.js",[],[],"/Users/cadeembery/Code/qik/sdk/eslint.config.js",[],[],"/Users/cadeembery/Code/qik/sdk/src/version.js",[],[]]