@cendarsoss/pusher-js 8.4.11

package/src/core/user.ts

@@ -0,0 +1,186 @@
+import Pusher from './pusher';
+import Logger from './logger';
+import {
+  UserAuthenticationData,
+  UserAuthenticationCallback,
+} from './auth/options';
+import Channel from './channels/channel';
+import WatchlistFacade from './watchlist';
+import EventsDispatcher from './events/dispatcher';
+import flatPromise from './utils/flat_promise';
+
+export default class UserFacade extends EventsDispatcher {
+  pusher: Pusher;
+  signin_requested: boolean = false;
+  user_data: any = null;
+  serverToUserChannel: Channel = null;
+  signinDonePromise: Promise<any> = null;
+  watchlist: WatchlistFacade;
+  private _signinDoneResolve: Function = null;
+
+  public constructor(pusher: Pusher) {
+    super(function (eventName, data) {
+      Logger.debug('No callbacks on user for ' + eventName);
+    });
+    this.pusher = pusher;
+    this.pusher.connection.bind('state_change', ({ previous, current }) => {
+      if (previous !== 'connected' && current === 'connected') {
+        this._signin();
+      }
+      if (previous === 'connected' && current !== 'connected') {
+        this._cleanup();
+        this._newSigninPromiseIfNeeded();
+      }
+    });
+
+    this.watchlist = new WatchlistFacade(pusher);
+
+    this.pusher.connection.bind('message', (event) => {
+      var eventName = event.event;
+      if (eventName === 'pusher:signin_success') {
+        this._onSigninSuccess(event.data);
+      }
+      if (
+        this.serverToUserChannel &&
+        this.serverToUserChannel.name === event.channel
+      ) {
+        this.serverToUserChannel.handleEvent(event);
+      }
+    });
+  }
+
+  public signin() {
+    if (this.signin_requested) {
+      return;
+    }
+
+    this.signin_requested = true;
+    this._signin();
+  }
+
+  private _signin() {
+    if (!this.signin_requested) {
+      return;
+    }
+
+    this._newSigninPromiseIfNeeded();
+
+    if (this.pusher.connection.state !== 'connected') {
+      // Signin will be attempted when the connection is connected
+      return;
+    }
+
+    this.pusher.config.userAuthenticator(
+      {
+        socketId: this.pusher.connection.socket_id,
+      },
+      this._onAuthorize,
+    );
+  }
+
+  private _onAuthorize: UserAuthenticationCallback = (
+    err,
+    authData: UserAuthenticationData,
+  ) => {
+    if (err) {
+      Logger.warn(`Error during signin: ${err}`);
+      this._cleanup();
+      return;
+    }
+
+    this.pusher.send_event('pusher:signin', {
+      auth: authData.auth,
+      user_data: authData.user_data,
+    });
+
+    // Later when we get pusher:singin_success event, the user will be marked as signed in
+  };
+
+  private _onSigninSuccess(data: any) {
+    try {
+      this.user_data = JSON.parse(data.user_data);
+    } catch (e) {
+      Logger.error(`Failed parsing user data after signin: ${data.user_data}`);
+      this._cleanup();
+      return;
+    }
+
+    if (typeof this.user_data.id !== 'string' || this.user_data.id === '') {
+      Logger.error(
+        `user_data doesn't contain an id. user_data: ${this.user_data}`,
+      );
+      this._cleanup();
+      return;
+    }
+
+    // Signin succeeded
+    this._signinDoneResolve();
+    this._subscribeChannels();
+  }
+
+  private _subscribeChannels() {
+    const ensure_subscribed = (channel) => {
+      if (channel.subscriptionPending && channel.subscriptionCancelled) {
+        channel.reinstateSubscription();
+      } else if (
+        !channel.subscriptionPending &&
+        this.pusher.connection.state === 'connected'
+      ) {
+        channel.subscribe();
+      }
+    };
+
+    this.serverToUserChannel = new Channel(
+      `#server-to-user-${this.user_data.id}`,
+      this.pusher,
+    );
+    this.serverToUserChannel.bind_global((eventName, data) => {
+      if (
+        eventName.indexOf('pusher_internal:') === 0 ||
+        eventName.indexOf('pusher:') === 0
+      ) {
+        // ignore internal events
+        return;
+      }
+      this.emit(eventName, data);
+    });
+    ensure_subscribed(this.serverToUserChannel);
+  }
+
+  private _cleanup() {
+    this.user_data = null;
+    if (this.serverToUserChannel) {
+      this.serverToUserChannel.unbind_all();
+      this.serverToUserChannel.disconnect();
+      this.serverToUserChannel = null;
+    }
+
+    if (this.signin_requested) {
+      // If signin is in progress and cleanup is called,
+      // Mark the current signin process as done.
+      this._signinDoneResolve();
+    }
+  }
+
+  private _newSigninPromiseIfNeeded() {
+    if (!this.signin_requested) {
+      return;
+    }
+
+    // If there is a promise and it is not resolved, return without creating a new one.
+    if (this.signinDonePromise && !(this.signinDonePromise as any).done) {
+      return;
+    }
+
+    // This promise is never rejected.
+    // It gets resolved when the signin process is done whether it failed or succeeded
+    const { promise, resolve, reject: _ } = flatPromise();
+    (promise as any).done = false;
+    const setDone = () => {
+      (promise as any).done = true;
+    };
+    promise.then(setDone).catch(setDone);
+    this.signinDonePromise = promise;
+    this._signinDoneResolve = resolve;
+  }
+}

package/src/core/util.ts

@@ -0,0 +1,34 @@
+import * as Collections from './utils/collections';
+import TimedCallback from './utils/timers/timed_callback';
+import { OneOffTimer, PeriodicTimer } from './utils/timers';
+
+var Util = {
+  now(): number {
+    if (Date.now) {
+      return Date.now();
+    } else {
+      return new Date().valueOf();
+    }
+  },
+
+  defer(callback: TimedCallback): OneOffTimer {
+    return new OneOffTimer(0, callback);
+  },
+
+  /** Builds a function that will proxy a method call to its first argument.
+   *
+   * Allows partial application of arguments, so additional arguments are
+   * prepended to the argument list.
+   *
+   * @param  {String} name method name
+   * @return {Function} proxy function
+   */
+  method(name: string, ...args: any[]): Function {
+    var boundArguments = Array.prototype.slice.call(arguments, 1);
+    return function (object) {
+      return object[name].apply(object, boundArguments.concat(arguments));
+    };
+  },
+};
+
+export default Util;

package/src/core/utils/collections.ts

@@ -0,0 +1,353 @@
+import base64encode from '../base64';
+import Util from '../util';
+
+/** Merges multiple objects into the target argument.
+ *
+ * For properties that are plain Objects, performs a deep-merge. For the
+ * rest it just copies the value of the property.
+ *
+ * To extend prototypes use it as following:
+ *   Pusher.Util.extend(Target.prototype, Base.prototype)
+ *
+ * You can also use it to merge objects without altering them:
+ *   Pusher.Util.extend({}, object1, object2)
+ *
+ * @param  {Object} target
+ * @return {Object} the target argument
+ */
+export function extend<T>(target: any, ...sources: any[]): T {
+  for (var i = 0; i < sources.length; i++) {
+    var extensions = sources[i];
+    for (var property in extensions) {
+      if (
+        extensions[property] &&
+        extensions[property].constructor &&
+        extensions[property].constructor === Object
+      ) {
+        target[property] = extend(target[property] || {}, extensions[property]);
+      } else {
+        target[property] = extensions[property];
+      }
+    }
+  }
+  return target;
+}
+
+export function stringify(): string {
+  var m = ['Pusher'];
+  for (var i = 0; i < arguments.length; i++) {
+    if (typeof arguments[i] === 'string') {
+      m.push(arguments[i]);
+    } else {
+      m.push(safeJSONStringify(arguments[i]));
+    }
+  }
+  return m.join(' : ');
+}
+
+export function arrayIndexOf(array: any[], item: any): number {
+  // MSIE doesn't have array.indexOf
+  var nativeIndexOf = Array.prototype.indexOf;
+  if (array === null) {
+    return -1;
+  }
+  if (nativeIndexOf && array.indexOf === nativeIndexOf) {
+    return array.indexOf(item);
+  }
+  for (var i = 0, l = array.length; i < l; i++) {
+    if (array[i] === item) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+/** Applies a function f to all properties of an object.
+ *
+ * Function f gets 3 arguments passed:
+ * - element from the object
+ * - key of the element
+ * - reference to the object
+ *
+ * @param {Object} object
+ * @param {Function} f
+ */
+export function objectApply(object: any, f: Function) {
+  for (var key in object) {
+    if (Object.prototype.hasOwnProperty.call(object, key)) {
+      f(object[key], key, object);
+    }
+  }
+}
+
+/** Return a list of objects own proerty keys
+ *
+ * @param {Object} object
+ * @returns {Array}
+ */
+export function keys(object: any): string[] {
+  var keys = [];
+  objectApply(object, function (_, key) {
+    keys.push(key);
+  });
+  return keys;
+}
+
+/** Return a list of object's own property values
+ *
+ * @param {Object} object
+ * @returns {Array}
+ */
+export function values(object: any): any[] {
+  var values = [];
+  objectApply(object, function (value) {
+    values.push(value);
+  });
+  return values;
+}
+
+/** Applies a function f to all elements of an array.
+ *
+ * Function f gets 3 arguments passed:
+ * - element from the array
+ * - index of the element
+ * - reference to the array
+ *
+ * @param {Array} array
+ * @param {Function} f
+ */
+export function apply(array: any[], f: Function, context?: any) {
+  for (var i = 0; i < array.length; i++) {
+    f.call(context || global, array[i], i, array);
+  }
+}
+
+/** Maps all elements of the array and returns the result.
+ *
+ * Function f gets 4 arguments passed:
+ * - element from the array
+ * - index of the element
+ * - reference to the source array
+ * - reference to the destination array
+ *
+ * @param {Array} array
+ * @param {Function} f
+ */
+export function map(array: any[], f: Function): any[] {
+  var result = [];
+  for (var i = 0; i < array.length; i++) {
+    result.push(f(array[i], i, array, result));
+  }
+  return result;
+}
+
+/** Maps all elements of the object and returns the result.
+ *
+ * Function f gets 4 arguments passed:
+ * - element from the object
+ * - key of the element
+ * - reference to the source object
+ * - reference to the destination object
+ *
+ * @param {Object} object
+ * @param {Function} f
+ */
+export function mapObject(object: any, f: Function): any {
+  var result = {};
+  objectApply(object, function (value, key) {
+    result[key] = f(value);
+  });
+  return result;
+}
+
+/** Filters elements of the array using a test function.
+ *
+ * Function test gets 4 arguments passed:
+ * - element from the array
+ * - index of the element
+ * - reference to the source array
+ * - reference to the destination array
+ *
+ * @param {Array} array
+ * @param {Function} f
+ */
+export function filter(array: any[], test: Function): any[] {
+  test =
+    test ||
+    function (value) {
+      return !!value;
+    };
+
+  var result = [];
+  for (var i = 0; i < array.length; i++) {
+    if (test(array[i], i, array, result)) {
+      result.push(array[i]);
+    }
+  }
+  return result;
+}
+
+/** Filters properties of the object using a test function.
+ *
+ * Function test gets 4 arguments passed:
+ * - element from the object
+ * - key of the element
+ * - reference to the source object
+ * - reference to the destination object
+ *
+ * @param {Object} object
+ * @param {Function} f
+ */
+export function filterObject(object: Object, test: Function) {
+  var result = {};
+  objectApply(object, function (value, key) {
+    if ((test && test(value, key, object, result)) || Boolean(value)) {
+      result[key] = value;
+    }
+  });
+  return result;
+}
+
+/** Flattens an object into a two-dimensional array.
+ *
+ * @param  {Object} object
+ * @return {Array} resulting array of [key, value] pairs
+ */
+export function flatten(object: Object): any[] {
+  var result = [];
+  objectApply(object, function (value, key) {
+    result.push([key, value]);
+  });
+  return result;
+}
+
+/** Checks whether any element of the array passes the test.
+ *
+ * Function test gets 3 arguments passed:
+ * - element from the array
+ * - index of the element
+ * - reference to the source array
+ *
+ * @param {Array} array
+ * @param {Function} f
+ */
+export function any(array: any[], test: Function): boolean {
+  for (var i = 0; i < array.length; i++) {
+    if (test(array[i], i, array)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/** Checks whether all elements of the array pass the test.
+ *
+ * Function test gets 3 arguments passed:
+ * - element from the array
+ * - index of the element
+ * - reference to the source array
+ *
+ * @param {Array} array
+ * @param {Function} f
+ */
+export function all(array: any[], test: Function): boolean {
+  for (var i = 0; i < array.length; i++) {
+    if (!test(array[i], i, array)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export function encodeParamsObject(data): string {
+  return mapObject(data, function (value) {
+    if (typeof value === 'object') {
+      value = safeJSONStringify(value);
+    }
+    return encodeURIComponent(base64encode(value.toString()));
+  });
+}
+
+export function buildQueryString(data: any): string {
+  var params = filterObject(data, function (value) {
+    return value !== undefined;
+  });
+
+  var query = map(
+    flatten(encodeParamsObject(params)),
+    Util.method('join', '='),
+  ).join('&');
+
+  return query;
+}
+
+/**
+ * See https://github.com/douglascrockford/JSON-js/blob/master/cycle.js
+ *
+ * Remove circular references from an object. Required for JSON.stringify in
+ * React Native, which tends to blow up a lot.
+ *
+ * @param  {any} object
+ * @return {any}        Decycled object
+ */
+export function decycleObject(object: any): any {
+  var objects = [],
+    paths = [];
+
+  return (function derez(value, path) {
+    var i, name, nu;
+
+    switch (typeof value) {
+      case 'object':
+        if (!value) {
+          return null;
+        }
+        for (i = 0; i < objects.length; i += 1) {
+          if (objects[i] === value) {
+            return { $ref: paths[i] };
+          }
+        }
+
+        objects.push(value);
+        paths.push(path);
+
+        if (Object.prototype.toString.apply(value) === '[object Array]') {
+          nu = [];
+          for (i = 0; i < value.length; i += 1) {
+            nu[i] = derez(value[i], path + '[' + i + ']');
+          }
+        } else {
+          nu = {};
+          for (name in value) {
+            if (Object.prototype.hasOwnProperty.call(value, name)) {
+              nu[name] = derez(
+                value[name],
+                path + '[' + JSON.stringify(name) + ']',
+              );
+            }
+          }
+        }
+        return nu;
+      case 'number':
+      case 'string':
+      case 'boolean':
+        return value;
+    }
+  })(object, '$');
+}
+
+/**
+ * Provides a cross-browser and cross-platform way to safely stringify objects
+ * into JSON. This is particularly necessary for ReactNative, where circular JSON
+ * structures throw an exception.
+ *
+ * @param  {any}    source The object to stringify
+ * @return {string}        The serialized output.
+ */
+export function safeJSONStringify(source: any): string {
+  try {
+    return JSON.stringify(source);
+  } catch (e) {
+    return JSON.stringify(decycleObject(source));
+  }
+}

package/src/core/utils/factory.ts

@@ -0,0 +1,79 @@
+import AssistantToTheTransportManager from '../transports/assistant_to_the_transport_manager';
+import PingDelayOptions from '../transports/ping_delay_options';
+import Transport from '../transports/transport';
+import TransportManager from '../transports/transport_manager';
+import Handshake from '../connection/handshake';
+import TransportConnection from '../transports/transport_connection';
+import SocketHooks from '../http/socket_hooks';
+import HTTPSocket from '../http/http_socket';
+
+import Timeline from '../timeline/timeline';
+import {
+  default as TimelineSender,
+  TimelineSenderOptions,
+} from '../timeline/timeline_sender';
+import PresenceChannel from '../channels/presence_channel';
+import PrivateChannel from '../channels/private_channel';
+import EncryptedChannel from '../channels/encrypted_channel';
+import Channel from '../channels/channel';
+import ConnectionManager from '../connection/connection_manager';
+import ConnectionManagerOptions from '../connection/connection_manager_options';
+import Ajax from '../http/ajax';
+import Channels from '../channels/channels';
+import Pusher from '../pusher';
+import { Config } from '../config';
+import * as nacl from 'tweetnacl';
+
+var Factory = {
+  createChannels(): Channels {
+    return new Channels();
+  },
+
+  createConnectionManager(
+    key: string,
+    options: ConnectionManagerOptions,
+  ): ConnectionManager {
+    return new ConnectionManager(key, options);
+  },
+
+  createChannel(name: string, pusher: Pusher): Channel {
+    return new Channel(name, pusher);
+  },
+
+  createPrivateChannel(name: string, pusher: Pusher): PrivateChannel {
+    return new PrivateChannel(name, pusher);
+  },
+
+  createPresenceChannel(name: string, pusher: Pusher): PresenceChannel {
+    return new PresenceChannel(name, pusher);
+  },
+
+  createEncryptedChannel(
+    name: string,
+    pusher: Pusher,
+    nacl: nacl,
+  ): EncryptedChannel {
+    return new EncryptedChannel(name, pusher, nacl);
+  },
+
+  createTimelineSender(timeline: Timeline, options: TimelineSenderOptions) {
+    return new TimelineSender(timeline, options);
+  },
+
+  createHandshake(
+    transport: TransportConnection,
+    callback: (HandshakePayload) => void,
+  ): Handshake {
+    return new Handshake(transport, callback);
+  },
+
+  createAssistantToTheTransportManager(
+    manager: TransportManager,
+    transport: Transport,
+    options: PingDelayOptions,
+  ): AssistantToTheTransportManager {
+    return new AssistantToTheTransportManager(manager, transport, options);
+  },
+};
+
+export default Factory;

package/src/core/utils/flat_promise.ts

@@ -0,0 +1,10 @@
+function flatPromise() {
+  let resolve, reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+export default flatPromise;

package/src/core/utils/timers/abstract_timer.ts

@@ -0,0 +1,39 @@
+import TimedCallback from './timed_callback';
+import { Delay, Scheduler, Canceller } from './scheduling';
+
+abstract class Timer {
+  protected clear: Canceller;
+  protected timer: number | void;
+
+  constructor(
+    set: Scheduler,
+    clear: Canceller,
+    delay: Delay,
+    callback: TimedCallback,
+  ) {
+    this.clear = clear;
+    this.timer = set(() => {
+      if (this.timer) {
+        this.timer = callback(this.timer);
+      }
+    }, delay);
+  }
+
+  /** Returns whether the timer is still running.
+   *
+   * @return {Boolean}
+   */
+  isRunning(): boolean {
+    return this.timer !== null;
+  }
+
+  /** Aborts a timer when it's running. */
+  ensureAborted() {
+    if (this.timer) {
+      this.clear(this.timer);
+      this.timer = null;
+    }
+  }
+}
+
+export default Timer;