pingerchips-js 1.0.0 → 2.0.0

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

@@ -1,154 +0,0 @@
-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

@@ -1,66 +0,0 @@
-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

@@ -1,69 +0,0 @@
-/** 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

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

package/src/core/events/callback_registry.ts

@@ -1,75 +0,0 @@
-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

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

package/src/core/events/dispatcher.ts

@@ -1,84 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,16 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,81 +0,0 @@
-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;
-  }
-}