pingerchips-js 1.0.0-a

package/src/core/transports/transport_connection_options.ts

@@ -0,0 +1,8 @@
+import Timeline from '../timeline/timeline';
+
+interface TransportConnectionOptions {
+  timeline: Timeline;
+  activityTimeout: number;
+}
+
+export default TransportConnectionOptions;

package/src/core/transports/transport_hooks.ts

@@ -0,0 +1,16 @@
+import Factory from '../utils/factory';
+import URLScheme from './url_scheme';
+import Socket from '../socket';
+
+interface TransportHooks {
+  file?: string;
+  urls: URLScheme;
+  handlesActivityChecks: boolean;
+  supportsPing: boolean;
+  isInitialized(): boolean;
+  isSupported(environment?: any): boolean;
+  getSocket(url: string, options?: any): Socket;
+  beforeOpen?: Function;
+}
+
+export default TransportHooks;

package/src/core/transports/transport_manager.ts

@@ -0,0 +1,52 @@
+import AssistantToTheTransportManager from './assistant_to_the_transport_manager';
+import Transport from './transport';
+import PingDelayOptions from './ping_delay_options';
+import Factory from '../utils/factory';
+
+export interface TransportManagerOptions extends PingDelayOptions {
+  lives?: number;
+}
+
+/** Keeps track of the number of lives left for a transport.
+ *
+ * In the beginning of a session, transports may be assigned a number of
+ * lives. When an AssistantToTheTransportManager instance reports a transport
+ * connection closed uncleanly, the transport loses a life. When the number
+ * of lives drops to zero, the transport gets disabled by its manager.
+ *
+ * @param {Object} options
+ */
+export default class TransportManager {
+  options: TransportManagerOptions;
+  livesLeft: number;
+
+  constructor(options: TransportManagerOptions) {
+    this.options = options || {};
+    this.livesLeft = this.options.lives || Infinity;
+  }
+
+  /** Creates a assistant for the transport.
+   *
+   * @param {Transport} transport
+   * @returns {AssistantToTheTransportManager}
+   */
+  getAssistant(transport: Transport): AssistantToTheTransportManager {
+    return Factory.createAssistantToTheTransportManager(this, transport, {
+      minPingDelay: this.options.minPingDelay,
+      maxPingDelay: this.options.maxPingDelay
+    });
+  }
+
+  /** Returns whether the transport has any lives left.
+   *
+   * @returns {Boolean}
+   */
+  isAlive(): boolean {
+    return this.livesLeft > 0;
+  }
+
+  /** Takes one life from the transport. */
+  reportDeath() {
+    this.livesLeft -= 1;
+  }
+}

package/src/core/transports/transports_table.ts

@@ -0,0 +1,12 @@
+import Transport from './transport';
+
+interface TransportsTable {
+  ws: Transport;
+  xhr_streaming: Transport;
+  xdr_streaming?: Transport;
+  xhr_polling: Transport;
+  xdr_polling?: Transport;
+  sockjs?: Transport;
+}
+
+export default TransportsTable;

package/src/core/transports/url_scheme.ts

@@ -0,0 +1,13 @@
+export interface URLSchemeParams {
+  useTLS: boolean;
+  hostTLS: string;
+  hostNonTLS: string;
+  httpPath: string;
+}
+
+interface URLScheme {
+  getInitial(key: string, params: any): string;
+  getPath?(key: string, options: any): string;
+}
+
+export default URLScheme;

package/src/core/transports/url_schemes.ts

@@ -0,0 +1,47 @@
+import Defaults from '../defaults';
+import { default as URLScheme, URLSchemeParams } from './url_scheme';
+
+function getGenericURL(
+  baseScheme: string,
+  params: URLSchemeParams,
+  path: string
+): string {
+  var scheme = baseScheme + (params.useTLS ? 's' : '');
+  var host = params.useTLS ? params.hostTLS : params.hostNonTLS;
+  return scheme + '://' + host + path;
+}
+
+function getGenericPath(key: string, queryString?: string): string {
+  var path = '/app/' + key;
+  var query =
+    '?protocol=' +
+    Defaults.PROTOCOL +
+    '&client=js' +
+    '&version=' +
+    Defaults.VERSION +
+    (queryString ? '&' + queryString : '');
+  return path + query;
+}
+
+export var ws: URLScheme = {
+  getInitial: function(key: string, params: URLSchemeParams): string {
+    var path = (params.httpPath || '') + getGenericPath(key, 'flash=false');
+    return getGenericURL('ws', params, path);
+  }
+};
+
+export var http: URLScheme = {
+  getInitial: function(key: string, params: URLSchemeParams): string {
+    var path = (params.httpPath || '/pusher') + getGenericPath(key);
+    return getGenericURL('http', params, path);
+  }
+};
+
+export var sockjs: URLScheme = {
+  getInitial: function(key: string, params: URLSchemeParams): string {
+    return getGenericURL('http', params, params.httpPath || '/pusher');
+  },
+  getPath: function(key: string, params: URLSchemeParams): string {
+    return getGenericPath(key);
+  }
+};

package/src/core/user.ts

@@ -0,0 +1,186 @@
+import {
+    UserAuthenticationCallback,
+    UserAuthenticationData
+} from './auth/options';
+import Channel from './channels/channel';
+import EventsDispatcher from './events/dispatcher';
+import Logger from './logger';
+import Pingerchips from './pusher';
+import flatPromise from './utils/flat_promise';
+import WatchlistFacade from './watchlist';
+
+export default class UserFacade extends EventsDispatcher {
+  pusher: Pingerchips;
+  signin_requested: boolean = false;
+  user_data: any = null;
+  serverToUserChannel: Channel = null;
+  signinDonePromise: Promise<any> = null;
+  watchlist: WatchlistFacade;
+  private _signinDoneResolve: Function = null;
+
+  public constructor(pusher: Pingerchips) {
+    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;