pingerchips-js 1.0.0-a

package/src/core/connection/protocol/protocol.ts

@@ -0,0 +1,154 @@
+import Action from './action';
+import { PusherEvent } from './message-types';
+/**
+ * Provides functions for handling Pusher protocol-specific messages.
+ */
+
+const Protocol = {
+  /**
+   * Decodes a message in a Pusher format.
+   *
+   * The MessageEvent we receive from the transport should contain a pusher event
+   * (https://pusher.com/docs/pusher_protocol#events) serialized as JSON in the
+   * data field
+   *
+   * The pusher event may contain a data field too, and it may also be
+   * serialised as JSON
+   *
+   * Throws errors when messages are not parse'able.
+   *
+   * @param  {MessageEvent} messageEvent
+   * @return {PusherEvent}
+   */
+  decodeMessage: function(messageEvent: MessageEvent): PusherEvent {
+    try {
+      var messageData = JSON.parse(messageEvent.data);
+      var pusherEventData = messageData.data;
+      if (typeof pusherEventData === 'string') {
+        try {
+          pusherEventData = JSON.parse(messageData.data);
+        } catch (e) {}
+      }
+      var pusherEvent: PusherEvent = {
+        event: messageData.event,
+        channel: messageData.channel,
+        data: pusherEventData
+      };
+      if (messageData.user_id) {
+        pusherEvent.user_id = messageData.user_id;
+      }
+      return pusherEvent;
+    } catch (e) {
+      throw { type: 'MessageParseError', error: e, data: messageEvent.data };
+    }
+  },
+
+  /**
+   * Encodes a message to be sent.
+   *
+   * @param  {PusherEvent} event
+   * @return {String}
+   */
+  encodeMessage: function(event: PusherEvent): string {
+    return JSON.stringify(event);
+  },
+
+  /**
+   * Processes a handshake message and returns appropriate actions.
+   *
+   * Returns an object with an 'action' and other action-specific properties.
+   *
+   * There are three outcomes when calling this function. First is a successful
+   * connection attempt, when pusher:connection_established is received, which
+   * results in a 'connected' action with an 'id' property. When passed a
+   * pusher:error event, it returns a result with action appropriate to the
+   * close code and an error. Otherwise, it raises an exception.
+   *
+   * @param {String} message
+   * @result Object
+   */
+  processHandshake: function(messageEvent: MessageEvent): Action {
+    var message = Protocol.decodeMessage(messageEvent);
+
+    if (message.event === 'pusher:connection_established') {
+      if (!message.data.activity_timeout) {
+        throw 'No activity timeout specified in handshake';
+      }
+      return {
+        action: 'connected',
+        id: message.data.socket_id,
+        activityTimeout: message.data.activity_timeout * 1000
+      };
+    } else if (message.event === 'pusher:error') {
+      // From protocol 6 close codes are sent only once, so this only
+      // happens when connection does not support close codes
+      return {
+        action: this.getCloseAction(message.data),
+        error: this.getCloseError(message.data)
+      };
+    } else {
+      throw 'Invalid handshake';
+    }
+  },
+
+  /**
+   * Dispatches the close event and returns an appropriate action name.
+   *
+   * See:
+   * 1. https://developer.mozilla.org/en-US/docs/WebSockets/WebSockets_reference/CloseEvent
+   * 2. http://pusher.com/docs/pusher_protocol
+   *
+   * @param  {CloseEvent} closeEvent
+   * @return {String} close action name
+   */
+  getCloseAction: function(closeEvent): string {
+    if (closeEvent.code < 4000) {
+      // ignore 1000 CLOSE_NORMAL, 1001 CLOSE_GOING_AWAY,
+      //        1005 CLOSE_NO_STATUS, 1006 CLOSE_ABNORMAL
+      // ignore 1007...3999
+      // handle 1002 CLOSE_PROTOCOL_ERROR, 1003 CLOSE_UNSUPPORTED,
+      //        1004 CLOSE_TOO_LARGE
+      if (closeEvent.code >= 1002 && closeEvent.code <= 1004) {
+        return 'backoff';
+      } else {
+        return null;
+      }
+    } else if (closeEvent.code === 4000) {
+      return 'tls_only';
+    } else if (closeEvent.code < 4100) {
+      return 'refused';
+    } else if (closeEvent.code < 4200) {
+      return 'backoff';
+    } else if (closeEvent.code < 4300) {
+      return 'retry';
+    } else {
+      // unknown error
+      return 'refused';
+    }
+  },
+
+  /**
+   * Returns an error or null basing on the close event.
+   *
+   * Null is returned when connection was closed cleanly. Otherwise, an object
+   * with error details is returned.
+   *
+   * @param  {CloseEvent} closeEvent
+   * @return {Object} error object
+   */
+  getCloseError: function(closeEvent): any {
+    if (closeEvent.code !== 1000 && closeEvent.code !== 1001) {
+      return {
+        type: 'PusherError',
+        data: {
+          code: closeEvent.code,
+          message: closeEvent.reason || closeEvent.message
+        }
+      };
+    } else {
+      return null;
+    }
+  }
+};
+
+export default Protocol;

package/src/core/defaults.ts

@@ -0,0 +1,66 @@
+import {
+  ChannelAuthorizationOptions,
+  UserAuthenticationOptions
+} from './auth/options';
+import { AuthTransport } from './config';
+
+export interface DefaultConfig {
+  VERSION: string;
+  PROTOCOL: number;
+  wsPort: number;
+  wssPort: number;
+  wsPath: string;
+  httpHost: string;
+  httpPort: number;
+  httpsPort: number;
+  httpPath: string;
+  stats_host: string;
+  authEndpoint: string;
+  authTransport: AuthTransport;
+  activityTimeout: number;
+  pongTimeout: number;
+  unavailableTimeout: number;
+  userAuthentication: UserAuthenticationOptions;
+  channelAuthorization: ChannelAuthorizationOptions;
+
+  cdn_http?: string;
+  cdn_https?: string;
+  dependency_suffix?: string;
+}
+
+var Defaults: DefaultConfig = {
+  VERSION: VERSION,
+  PROTOCOL: 7,
+
+  wsPort: 80,
+  wssPort: 443,
+  wsPath: '',
+  // DEPRECATED: SockJS fallback parameters
+  httpHost: 'sockjs.pusher.com',
+  httpPort: 80,
+  httpsPort: 443,
+  httpPath: '/pusher',
+  // DEPRECATED: Stats
+  stats_host: 'stats.pusher.com',
+  // DEPRECATED: Other settings
+  authEndpoint: '/pusher/auth',
+  authTransport: 'ajax',
+  activityTimeout: 120000,
+  pongTimeout: 30000,
+  unavailableTimeout: 10000,
+  userAuthentication: {
+    endpoint: '/pusher/user-auth',
+    transport: 'ajax'
+  },
+  channelAuthorization: {
+    endpoint: '/pusher/auth',
+    transport: 'ajax'
+  },
+
+  // CDN configuration
+  cdn_http: CDN_HTTP,
+  cdn_https: CDN_HTTPS,
+  dependency_suffix: DEPENDENCY_SUFFIX
+};
+
+export default Defaults;

package/src/core/errors.ts

@@ -0,0 +1,69 @@
+/** Error classes used throughout the library. */
+// https://github.com/Microsoft/TypeScript-wiki/blob/master/Breaking-Changes.md#extending-built-ins-like-error-array-and-map-may-no-longer-work
+export class BadEventName extends Error {
+  constructor(msg?: string) {
+    super(msg);
+
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+export class BadChannelName extends Error {
+  constructor(msg?: string) {
+    super(msg);
+
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+
+export class RequestTimedOut extends Error {
+  constructor(msg?: string) {
+    super(msg);
+
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+export class TransportPriorityTooLow extends Error {
+  constructor(msg?: string) {
+    super(msg);
+
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+export class TransportClosed extends Error {
+  constructor(msg?: string) {
+    super(msg);
+
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+export class UnsupportedFeature extends Error {
+  constructor(msg?: string) {
+    super(msg);
+
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+export class UnsupportedTransport extends Error {
+  constructor(msg?: string) {
+    super(msg);
+
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+export class UnsupportedStrategy extends Error {
+  constructor(msg?: string) {
+    super(msg);
+
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}
+export class HTTPAuthError extends Error {
+  status: number;
+  constructor(status: number, msg?: string) {
+    super(msg);
+    this.status = status;
+
+    Object.setPrototypeOf(this, new.target.prototype);
+  }
+}

package/src/core/events/callback.ts

@@ -0,0 +1,6 @@
+interface Callback {
+  fn: Function;
+  context: any;
+}
+
+export default Callback;

package/src/core/events/callback_registry.ts

@@ -0,0 +1,75 @@
+import Callback from './callback';
+import * as Collections from '../utils/collections';
+import CallbackTable from './callback_table';
+
+export default class CallbackRegistry {
+  _callbacks: CallbackTable;
+
+  constructor() {
+    this._callbacks = {};
+  }
+
+  get(name: string): Callback[] {
+    return this._callbacks[prefix(name)];
+  }
+
+  add(name: string, callback: Function, context: any) {
+    var prefixedEventName = prefix(name);
+    this._callbacks[prefixedEventName] =
+      this._callbacks[prefixedEventName] || [];
+    this._callbacks[prefixedEventName].push({
+      fn: callback,
+      context: context
+    });
+  }
+
+  remove(name?: string, callback?: Function, context?: any) {
+    if (!name && !callback && !context) {
+      this._callbacks = {};
+      return;
+    }
+
+    var names = name ? [prefix(name)] : Collections.keys(this._callbacks);
+
+    if (callback || context) {
+      this.removeCallback(names, callback, context);
+    } else {
+      this.removeAllCallbacks(names);
+    }
+  }
+
+  private removeCallback(names: string[], callback: Function, context: any) {
+    Collections.apply(
+      names,
+      function(name) {
+        this._callbacks[name] = Collections.filter(
+          this._callbacks[name] || [],
+          function(binding) {
+            return (
+              (callback && callback !== binding.fn) ||
+              (context && context !== binding.context)
+            );
+          }
+        );
+        if (this._callbacks[name].length === 0) {
+          delete this._callbacks[name];
+        }
+      },
+      this
+    );
+  }
+
+  private removeAllCallbacks(names: string[]) {
+    Collections.apply(
+      names,
+      function(name) {
+        delete this._callbacks[name];
+      },
+      this
+    );
+  }
+}
+
+function prefix(name: string): string {
+  return '_' + name;
+}

package/src/core/events/callback_table.ts

@@ -0,0 +1,7 @@
+import Callback from './callback';
+
+interface CallbackTable {
+  [index: string]: Callback[];
+}
+
+export default CallbackTable;

package/src/core/events/dispatcher.ts

@@ -0,0 +1,84 @@
+import * as Collections from '../utils/collections';
+import Callback from './callback';
+import Metadata from '../channels/metadata';
+import CallbackRegistry from './callback_registry';
+
+/** Manages callback bindings and event emitting.
+ *
+ * @param Function failThrough called when no listeners are bound to an event
+ */
+export default class Dispatcher {
+  callbacks: CallbackRegistry;
+  global_callbacks: Function[];
+  failThrough: Function;
+
+  constructor(failThrough?: Function) {
+    this.callbacks = new CallbackRegistry();
+    this.global_callbacks = [];
+    this.failThrough = failThrough;
+  }
+
+  bind(eventName: string, callback: Function, context?: any) {
+    this.callbacks.add(eventName, callback, context);
+    return this;
+  }
+
+  bind_global(callback: Function) {
+    this.global_callbacks.push(callback);
+    return this;
+  }
+
+  unbind(eventName?: string, callback?: Function, context?: any) {
+    this.callbacks.remove(eventName, callback, context);
+    return this;
+  }
+
+  unbind_global(callback?: Function) {
+    if (!callback) {
+      this.global_callbacks = [];
+      return this;
+    }
+
+    this.global_callbacks = Collections.filter(
+      this.global_callbacks || [],
+      c => c !== callback
+    );
+
+    return this;
+  }
+
+  unbind_all() {
+    this.unbind();
+    this.unbind_global();
+    return this;
+  }
+
+  emit(eventName: string, data?: any, metadata?: Metadata): Dispatcher {
+    for (var i = 0; i < this.global_callbacks.length; i++) {
+      this.global_callbacks[i](eventName, data);
+    }
+
+    var callbacks = this.callbacks.get(eventName);
+    var args = [];
+
+    if (metadata) {
+      // if there's a metadata argument, we need to call the callback with both
+      // data and metadata regardless of whether data is undefined
+      args.push(data, metadata);
+    } else if (data) {
+      // metadata is undefined, so we only need to call the callback with data
+      // if data exists
+      args.push(data);
+    }
+
+    if (callbacks && callbacks.length > 0) {
+      for (var i = 0; i < callbacks.length; i++) {
+        callbacks[i].fn.apply(callbacks[i].context || global, args);
+      }
+    } else if (this.failThrough) {
+      this.failThrough(eventName, data);
+    }
+
+    return this;
+  }
+}

package/src/core/http/ajax.ts

@@ -0,0 +1,24 @@
+interface Ajax {
+  open(
+    method: string,
+    url: string,
+    async?: boolean,
+    user?: string,
+    password?: string
+  ): void;
+  send(payload?: any): void;
+  setRequestHeader(key: string, value: string): void;
+  onreadystatechange: Function;
+  readyState: number;
+  responseText: string;
+  status: number;
+  withCredentials?: boolean;
+
+  ontimeout: Function;
+  onerror: Function;
+  onprogress: Function;
+  onload: Function;
+  abort: Function;
+}
+
+export default Ajax;

package/src/core/http/http_factory.ts

@@ -0,0 +1,16 @@
+import HTTPSocket from './http_socket';
+import SocketHooks from './socket_hooks';
+import HTTPRequest from './http_request';
+import RequestHooks from './request_hooks';
+import Ajax from './ajax';
+
+interface HTTPFactory {
+  createStreamingSocket(url: string): HTTPSocket;
+  createPollingSocket(url: string): HTTPSocket;
+  createSocket(hooks: SocketHooks, url: string): HTTPSocket;
+  createXHR(method: string, url: string): HTTPRequest;
+  createXDR?(method: string, url: string): HTTPRequest;
+  createRequest(hooks: RequestHooks, method: string, url: string): HTTPRequest;
+}
+
+export default HTTPFactory;

package/src/core/http/http_polling_socket.ts

@@ -0,0 +1,24 @@
+import SocketHooks from './socket_hooks';
+import URLLocation from './url_location';
+import HTTPSocket from './http_socket';
+
+var hooks: SocketHooks = {
+  getReceiveURL: function(url: URLLocation, session: string): string {
+    return url.base + '/' + session + '/xhr' + url.queryString;
+  },
+  onHeartbeat: function() {
+    // next HTTP request will reset server's activity timer
+  },
+  sendHeartbeat: function(socket) {
+    socket.sendRaw('[]');
+  },
+  onFinished: function(socket, status) {
+    if (status === 200) {
+      socket.reconnect();
+    } else {
+      socket.onClose(1006, 'Connection interrupted (' + status + ')', false);
+    }
+  }
+};
+
+export default hooks;

package/src/core/http/http_request.ts

@@ -0,0 +1,81 @@
+import Runtime from 'runtime';
+import RequestHooks from './request_hooks';
+import Ajax from './ajax';
+import { default as EventsDispatcher } from '../events/dispatcher';
+
+const MAX_BUFFER_LENGTH = 256 * 1024;
+
+export default class HTTPRequest extends EventsDispatcher {
+  hooks: RequestHooks;
+  method: string;
+  url: string;
+  position: number;
+  xhr: Ajax;
+  unloader: Function;
+
+  constructor(hooks: RequestHooks, method: string, url: string) {
+    super();
+    this.hooks = hooks;
+    this.method = method;
+    this.url = url;
+  }
+
+  start(payload?: any) {
+    this.position = 0;
+    this.xhr = this.hooks.getRequest(this);
+
+    this.unloader = () => {
+      this.close();
+    };
+    Runtime.addUnloadListener(this.unloader);
+
+    this.xhr.open(this.method, this.url, true);
+
+    if (this.xhr.setRequestHeader) {
+      this.xhr.setRequestHeader('Content-Type', 'application/json'); // ReactNative doesn't set this header by default.
+    }
+    this.xhr.send(payload);
+  }
+
+  close() {
+    if (this.unloader) {
+      Runtime.removeUnloadListener(this.unloader);
+      this.unloader = null;
+    }
+    if (this.xhr) {
+      this.hooks.abortRequest(this.xhr);
+      this.xhr = null;
+    }
+  }
+
+  onChunk(status: number, data: any) {
+    while (true) {
+      var chunk = this.advanceBuffer(data);
+      if (chunk) {
+        this.emit('chunk', { status: status, data: chunk });
+      } else {
+        break;
+      }
+    }
+    if (this.isBufferTooLong(data)) {
+      this.emit('buffer_too_long');
+    }
+  }
+
+  private advanceBuffer(buffer: any[]): any {
+    var unreadData = buffer.slice(this.position);
+    var endOfLinePosition = unreadData.indexOf('\n');
+
+    if (endOfLinePosition !== -1) {
+      this.position += endOfLinePosition + 1;
+      return unreadData.slice(0, endOfLinePosition);
+    } else {
+      // chunk is not finished yet, don't move the buffer pointer
+      return null;
+    }
+  }
+
+  private isBufferTooLong(buffer: any): boolean {
+    return this.position === buffer.length && buffer.length > MAX_BUFFER_LENGTH;
+  }
+}