pingerchips-js 1.0.0 → 2.0.0

package/src/runtimes/interface.ts

@@ -1,59 +0,0 @@
-import { AuthTransports } from '../core/auth/auth_transports';
-import { Config } from '../core/config';
-import Ajax from '../core/http/ajax';
-import HTTPFactory from '../core/http/http_factory';
-import HTTPRequest from '../core/http/http_request';
-import Pingerchips from '../core/pusher';
-import Reachability from '../core/reachability';
-import Socket from '../core/socket';
-import Strategy from '../core/strategies/strategy';
-import StrategyOptions from '../core/strategies/strategy_options';
-import TimelineTransport from '../core/timeline/timeline_transport';
-import TransportsTable from '../core/transports/transports_table';
-import JSONPRequest from './web/dom/jsonp_request';
-
-/*
-This interface is implemented in web/runtime, node/runtime, react-native/runtime
-and worker/runtime. Its job is to be the only point of contact to platform-specific
-code for the core library. When the core library imports "runtime", Webpack will
-look for src/runtimes/<platform>/runtime.ts. This is how PusherJS keeps
-core and platform-specific code separate.
-*/
-interface Runtime {
-  setup(PusherClass: {
-    new (key: string, options: any): Pingerchips;
-    ready(): void;
-  }): void;
-  getProtocol(): string;
-  getAuthorizers(): AuthTransports;
-  getLocalStorage(): any;
-  TimelineTransport: TimelineTransport;
-  createXHR(): Ajax;
-  createWebSocket(url: string): Socket;
-  getNetwork(): Reachability;
-  getDefaultStrategy(
-    config: Config,
-    options: StrategyOptions,
-    defineTransport: Function
-  ): Strategy;
-  Transports: TransportsTable;
-  getWebSocketAPI(): new (url: string) => Socket;
-  getXHRAPI(): new () => Ajax;
-  addUnloadListener(listener: Function): void;
-  removeUnloadListener(listener: Function): void;
-  transportConnectionInitializer: Function;
-  HTTPFactory: HTTPFactory;
-  isXHRSupported(): boolean;
-  createSocketRequest(method: string, url: string): HTTPRequest;
-  randomInt(max: number): number;
-
-  // these methods/types are only implemented in the web Runtime, so they're
-  // optional but must be included in the interface
-  getDocument?(): Document;
-  createScriptRequest?(url: string): any;
-  createJSONPRequest?(url: string, data: any): JSONPRequest;
-  ScriptReceivers?: any;
-  isXDRSupported?(useTLS?: boolean): boolean;
-}
-
-export default Runtime;

package/src/runtimes/isomorphic/auth/xhr_auth.ts

@@ -1,90 +0,0 @@
-import TimelineSender from 'core/timeline/timeline_sender';
-import * as Collections from 'core/utils/collections';
-import Util from 'core/util';
-import Runtime from 'runtime';
-import { AuthTransport } from 'core/auth/auth_transports';
-import AbstractRuntime from 'runtimes/interface';
-import UrlStore from 'core/utils/url_store';
-import {
-  AuthRequestType,
-  AuthTransportCallback,
-  InternalAuthOptions
-} from 'core/auth/options';
-import { HTTPAuthError } from 'core/errors';
-
-const ajax: AuthTransport = function(
-  context: AbstractRuntime,
-  query: string,
-  authOptions: InternalAuthOptions,
-  authRequestType: AuthRequestType,
-  callback: AuthTransportCallback
-) {
-  const xhr = Runtime.createXHR();
-  xhr.open('POST', authOptions.endpoint, true);
-
-  // add request headers
-  xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
-  for (var headerName in authOptions.headers) {
-    xhr.setRequestHeader(headerName, authOptions.headers[headerName]);
-  }
-  if (authOptions.headersProvider != null) {
-    let dynamicHeaders = authOptions.headersProvider();
-    for (var headerName in dynamicHeaders) {
-      xhr.setRequestHeader(headerName, dynamicHeaders[headerName]);
-    }
-  }
-
-  xhr.onreadystatechange = function() {
-    if (xhr.readyState === 4) {
-      if (xhr.status === 200) {
-        let data;
-        let parsed = false;
-
-        try {
-          data = JSON.parse(xhr.responseText);
-          parsed = true;
-        } catch (e) {
-          callback(
-            new HTTPAuthError(
-              200,
-              `JSON returned from ${authRequestType.toString()} endpoint was invalid, yet status code was 200. Data was: ${
-                xhr.responseText
-              }`
-            ),
-            null
-          );
-        }
-
-        if (parsed) {
-          // prevents double execution.
-          callback(null, data);
-        }
-      } else {
-        let suffix = '';
-        switch (authRequestType) {
-          case AuthRequestType.UserAuthentication:
-            suffix = UrlStore.buildLogSuffix('authenticationEndpoint');
-            break;
-          case AuthRequestType.ChannelAuthorization:
-            suffix = `Clients must be authorized to join private or presence channels. ${UrlStore.buildLogSuffix(
-              'authorizationEndpoint'
-            )}`;
-            break;
-        }
-        callback(
-          new HTTPAuthError(
-            xhr.status,
-            `Unable to retrieve auth string from ${authRequestType.toString()} endpoint - ` +
-              `received status: ${xhr.status} from ${authOptions.endpoint}. ${suffix}`
-          ),
-          null
-        );
-      }
-    }
-  };
-
-  xhr.send(query);
-  return xhr;
-};
-
-export default ajax;

package/src/runtimes/isomorphic/default_strategy.ts

@@ -1,155 +0,0 @@
-import * as Collections from 'core/utils/collections';
-import TransportManager from 'core/transports/transport_manager';
-import Strategy from 'core/strategies/strategy';
-import SequentialStrategy from 'core/strategies/sequential_strategy';
-import BestConnectedEverStrategy from 'core/strategies/best_connected_ever_strategy';
-import WebSocketPrioritizedCachedStrategy, {
-  TransportStrategyDictionary
-} from 'core/strategies/websocket_prioritized_cached_strategy';
-import DelayedStrategy from 'core/strategies/delayed_strategy';
-import IfStrategy from 'core/strategies/if_strategy';
-import FirstConnectedStrategy from 'core/strategies/first_connected_strategy';
-import { Config } from 'core/config';
-import StrategyOptions from 'core/strategies/strategy_options';
-
-function testSupportsStrategy(strategy: Strategy) {
-  return function() {
-    return strategy.isSupported();
-  };
-}
-
-var getDefaultStrategy = function(
-  config: Config,
-  baseOptions: StrategyOptions,
-  defineTransport: Function
-): Strategy {
-  var definedTransports = <TransportStrategyDictionary>{};
-
-  function defineTransportStrategy(
-    name: string,
-    type: string,
-    priority: number,
-    options: StrategyOptions,
-    manager?: TransportManager
-  ) {
-    var transport = defineTransport(
-      config,
-      name,
-      type,
-      priority,
-      options,
-      manager
-    );
-
-    definedTransports[name] = transport;
-
-    return transport;
-  }
-
-  var ws_options: StrategyOptions = Object.assign({}, baseOptions, {
-    hostNonTLS: config.wsHost + ':' + config.wsPort,
-    hostTLS: config.wsHost + ':' + config.wssPort,
-    httpPath: config.wsPath
-  });
-  var wss_options: StrategyOptions = Collections.extend({}, ws_options, {
-    useTLS: true
-  });
-  var http_options: StrategyOptions = Object.assign({}, baseOptions, {
-    hostNonTLS: config.httpHost + ':' + config.httpPort,
-    hostTLS: config.httpHost + ':' + config.httpsPort,
-    httpPath: config.httpPath
-  });
-  var timeouts = {
-    loop: true,
-    timeout: 15000,
-    timeoutLimit: 60000
-  };
-
-  var ws_manager = new TransportManager({
-    minPingDelay: 10000,
-    maxPingDelay: config.activityTimeout
-  });
-  var streaming_manager = new TransportManager({
-    lives: 2,
-    minPingDelay: 10000,
-    maxPingDelay: config.activityTimeout
-  });
-
-  var ws_transport = defineTransportStrategy(
-    'ws',
-    'ws',
-    3,
-    ws_options,
-    ws_manager
-  );
-  var wss_transport = defineTransportStrategy(
-    'wss',
-    'ws',
-    3,
-    wss_options,
-    ws_manager
-  );
-  var xhr_streaming_transport = defineTransportStrategy(
-    'xhr_streaming',
-    'xhr_streaming',
-    1,
-    http_options,
-    streaming_manager
-  );
-  var xhr_polling_transport = defineTransportStrategy(
-    'xhr_polling',
-    'xhr_polling',
-    1,
-    http_options
-  );
-
-  var ws_loop = new SequentialStrategy([ws_transport], timeouts);
-  var wss_loop = new SequentialStrategy([wss_transport], timeouts);
-  var streaming_loop = new SequentialStrategy(
-    [xhr_streaming_transport],
-    timeouts
-  );
-  var polling_loop = new SequentialStrategy([xhr_polling_transport], timeouts);
-
-  var http_loop = new SequentialStrategy(
-    [
-      new IfStrategy(
-        testSupportsStrategy(streaming_loop),
-        new BestConnectedEverStrategy([
-          streaming_loop,
-          new DelayedStrategy(polling_loop, { delay: 4000 })
-        ]),
-        polling_loop
-      )
-    ],
-    timeouts
-  );
-
-  var wsStrategy;
-  if (baseOptions.useTLS) {
-    wsStrategy = new BestConnectedEverStrategy([
-      ws_loop,
-      new DelayedStrategy(http_loop, { delay: 2000 })
-    ]);
-  } else {
-    wsStrategy = new BestConnectedEverStrategy([
-      ws_loop,
-      new DelayedStrategy(wss_loop, { delay: 2000 }),
-      new DelayedStrategy(http_loop, { delay: 5000 })
-    ]);
-  }
-
-  return new WebSocketPrioritizedCachedStrategy(
-    new FirstConnectedStrategy(
-      new IfStrategy(testSupportsStrategy(ws_transport), wsStrategy, http_loop)
-    ),
-    definedTransports,
-    {
-      ttl: 1800000,
-      timeline: baseOptions.timeline,
-      useTLS: baseOptions.useTLS
-    }
-  );
-};
-
-export default getDefaultStrategy;

package/src/runtimes/isomorphic/http/http.ts

@@ -1,32 +0,0 @@
-import HTTPRequest from 'core/http/http_request';
-import HTTPSocket from 'core/http/http_socket';
-import SocketHooks from 'core/http/socket_hooks';
-import RequestHooks from 'core/http/request_hooks';
-import streamingHooks from 'core/http/http_streaming_socket';
-import pollingHooks from 'core/http/http_polling_socket';
-import xhrHooks from './http_xhr_request';
-import HTTPFactory from 'core/http/http_factory';
-
-var HTTP: HTTPFactory = {
-  createStreamingSocket(url: string): HTTPSocket {
-    return this.createSocket(streamingHooks, url);
-  },
-
-  createPollingSocket(url: string): HTTPSocket {
-    return this.createSocket(pollingHooks, url);
-  },
-
-  createSocket(hooks: SocketHooks, url: string): HTTPSocket {
-    return new HTTPSocket(hooks, url);
-  },
-
-  createXHR(method: string, url: string): HTTPRequest {
-    return this.createRequest(xhrHooks, method, url);
-  },
-
-  createRequest(hooks: RequestHooks, method: string, url: string): HTTPRequest {
-    return new HTTPRequest(hooks, method, url);
-  }
-};
-
-export default HTTP;

package/src/runtimes/isomorphic/http/http_xhr_request.ts

@@ -1,35 +0,0 @@
-import HTTPRequest from 'core/http/http_request';
-import RequestHooks from 'core/http/request_hooks';
-import Ajax from 'core/http/ajax';
-import Runtime from 'runtime';
-
-var hooks: RequestHooks = {
-  getRequest: function(socket: HTTPRequest): Ajax {
-    var Constructor = Runtime.getXHRAPI();
-    var xhr = new Constructor();
-    xhr.onreadystatechange = xhr.onprogress = function() {
-      switch (xhr.readyState) {
-        case 3:
-          if (xhr.responseText && xhr.responseText.length > 0) {
-            socket.onChunk(xhr.status, xhr.responseText);
-          }
-          break;
-        case 4:
-          // this happens only on errors, never after calling close
-          if (xhr.responseText && xhr.responseText.length > 0) {
-            socket.onChunk(xhr.status, xhr.responseText);
-          }
-          socket.emit('finished', xhr.status);
-          socket.close();
-          break;
-      }
-    };
-    return xhr;
-  },
-  abortRequest: function(xhr: Ajax) {
-    xhr.onreadystatechange = null;
-    xhr.abort();
-  }
-};
-
-export default hooks;

package/src/runtimes/isomorphic/runtime.ts

@@ -1,62 +0,0 @@
-import * as Collections from 'core/utils/collections';
-import Transports from 'isomorphic/transports/transports';
-import TimelineSender from 'core/timeline/timeline_sender';
-import Ajax from 'core/http/ajax';
-import getDefaultStrategy from './default_strategy';
-import TransportsTable from 'core/transports/transports_table';
-import transportConnectionInitializer from './transports/transport_connection_initializer';
-import HTTPFactory from './http/http';
-
-var Isomorphic: any = {
-  getDefaultStrategy,
-  Transports: <TransportsTable>Transports,
-  transportConnectionInitializer,
-  HTTPFactory,
-
-  setup(PusherClass): void {
-    PusherClass.ready();
-  },
-
-  getLocalStorage(): any {
-    return undefined;
-  },
-
-  getClientFeatures(): any[] {
-    return Collections.keys(
-      Collections.filterObject({ ws: Transports.ws }, function(t) {
-        return t.isSupported({});
-      })
-    );
-  },
-
-  getProtocol(): string {
-    return 'http:';
-  },
-
-  isXHRSupported(): boolean {
-    return true;
-  },
-
-  createSocketRequest(method: string, url: string) {
-    if (this.isXHRSupported()) {
-      return this.HTTPFactory.createXHR(method, url);
-    } else {
-      throw 'Cross-origin HTTP requests are not supported';
-    }
-  },
-
-  createXHR(): Ajax {
-    var Constructor = this.getXHRAPI();
-    return new Constructor();
-  },
-
-  createWebSocket(url: string): any {
-    var Constructor = this.getWebSocketAPI();
-    return new Constructor(url);
-  },
-
-  addUnloadListener(listener: any) {},
-  removeUnloadListener(listener: any) {}
-};
-
-export default Isomorphic;

package/src/runtimes/isomorphic/timeline/xhr_timeline.ts

@@ -1,50 +0,0 @@
-import Logger from 'core/logger';
-import TimelineSender from 'core/timeline/timeline_sender';
-import * as Collections from 'core/utils/collections';
-import Util from 'core/util';
-import Runtime from 'runtime';
-import TimelineTransport from 'core/timeline/timeline_transport';
-
-var getAgent = function(sender: TimelineSender, useTLS: boolean) {
-  return function(data: any, callback: Function) {
-    var scheme = 'http' + (useTLS ? 's' : '') + '://';
-    var url =
-      scheme + (sender.host || sender.options.host) + sender.options.path;
-    var query = Collections.buildQueryString(data);
-
-    url += '/' + 2 + '?' + query;
-
-    var xhr = Runtime.createXHR();
-    xhr.open('GET', url, true);
-
-    xhr.onreadystatechange = function() {
-      if (xhr.readyState === 4) {
-        let { status, responseText } = xhr;
-        if (status !== 200) {
-          Logger.debug(
-            `TimelineSender Error: received ${status} from stats.pusher.com`
-          );
-          return;
-        }
-
-        try {
-          var { host } = JSON.parse(responseText);
-        } catch (e) {
-          Logger.debug(`TimelineSenderError: invalid response ${responseText}`);
-        }
-        if (host) {
-          sender.host = host;
-        }
-      }
-    };
-
-    xhr.send();
-  };
-};
-
-var xhr = {
-  name: 'xhr',
-  getAgent
-};
-
-export default xhr;

package/src/runtimes/isomorphic/transports/transport_connection_initializer.ts

@@ -1,19 +0,0 @@
-/** Initializes the transport.
- *
- * Fetches resources if needed and then transitions to initialized.
- */
-export default function() {
-  var self = this;
-
-  self.timeline.info(
-    self.buildTimelineMessage({
-      transport: self.name + (self.options.useTLS ? 's' : '')
-    })
-  );
-
-  if (self.hooks.isInitialized()) {
-    self.changeState('initialized');
-  } else {
-    self.onClose();
-  }
-}

package/src/runtimes/isomorphic/transports/transports.ts

@@ -1,81 +0,0 @@
-import * as URLSchemes from 'core/transports/url_schemes';
-import URLScheme from 'core/transports/url_scheme';
-import Transport from 'core/transports/transport';
-import Util from 'core/util';
-import * as Collections from 'core/utils/collections';
-import TransportHooks from 'core/transports/transport_hooks';
-import TransportsTable from 'core/transports/transports_table';
-import Runtime from 'runtime';
-
-/** WebSocket transport.
- *
- * Uses native WebSocket implementation, including MozWebSocket supported by
- * earlier Firefox versions.
- */
-var WSTransport = new Transport(<TransportHooks>{
-  urls: URLSchemes.ws,
-  handlesActivityChecks: false,
-  supportsPing: false,
-
-  isInitialized: function() {
-    return Boolean(Runtime.getWebSocketAPI());
-  },
-  isSupported: function(): boolean {
-    return Boolean(Runtime.getWebSocketAPI());
-  },
-  getSocket: function(url) {
-    return Runtime.createWebSocket(url);
-  }
-});
-
-var httpConfiguration = {
-  urls: URLSchemes.http,
-  handlesActivityChecks: false,
-  supportsPing: true,
-  isInitialized: function() {
-    return true;
-  }
-};
-
-export var streamingConfiguration = Collections.extend(
-  {
-    getSocket: function(url) {
-      return Runtime.HTTPFactory.createStreamingSocket(url);
-    }
-  },
-  httpConfiguration
-);
-export var pollingConfiguration = Collections.extend(
-  {
-    getSocket: function(url) {
-      return Runtime.HTTPFactory.createPollingSocket(url);
-    }
-  },
-  httpConfiguration
-);
-
-var xhrConfiguration = {
-  isSupported: function(): boolean {
-    return Runtime.isXHRSupported();
-  }
-};
-
-/** HTTP streaming transport using CORS-enabled XMLHttpRequest. */
-var XHRStreamingTransport = new Transport(
-  <TransportHooks>(
-    Collections.extend({}, streamingConfiguration, xhrConfiguration)
-  )
-);
-
-/** HTTP long-polling transport using CORS-enabled XMLHttpRequest. */
-var XHRPollingTransport = new Transport(
-  <TransportHooks>Collections.extend({}, pollingConfiguration, xhrConfiguration)
-);
-
-var Transports: TransportsTable = {
-  ws: WSTransport,
-  xhr_streaming: XHRStreamingTransport,
-  xhr_polling: XHRPollingTransport
-};
-
-export default Transports;

package/src/runtimes/node/net_info.ts

@@ -1,10 +0,0 @@
-import { default as EventsDispatcher } from 'core/events/dispatcher';
-import Reachability from 'core/reachability';
-
-export class NetInfo extends EventsDispatcher implements Reachability {
-  isOnline(): boolean {
-    return true;
-  }
-}
-
-export var Network = new NetInfo();

package/src/runtimes/node/runtime.ts

@@ -1,68 +0,0 @@
-import Isomorphic from 'isomorphic/runtime';
-import { Client as WebSocket } from 'faye-websocket';
-import { XMLHttpRequest } from 'xmlhttprequest';
-import Runtime from '../interface';
-import { Network } from './net_info';
-import xhrAuth from 'isomorphic/auth/xhr_auth';
-import { AuthTransports } from 'core/auth/auth_transports';
-import xhrTimeline from 'isomorphic/timeline/xhr_timeline';
-import { randomInt } from 'crypto';
-
-// Very verbose but until unavoidable until
-// TypeScript 2.1, when spread attributes will be
-// supported
-const {
-  getDefaultStrategy,
-  Transports,
-  setup,
-  getProtocol,
-  isXHRSupported,
-  getLocalStorage,
-  createXHR,
-  createWebSocket,
-  addUnloadListener,
-  removeUnloadListener,
-  transportConnectionInitializer,
-  createSocketRequest,
-  HTTPFactory
-} = Isomorphic;
-
-const NodeJS: Runtime = {
-  getDefaultStrategy,
-  Transports,
-  setup,
-  getProtocol,
-  isXHRSupported,
-  createSocketRequest,
-  getLocalStorage,
-  createXHR,
-  createWebSocket,
-  addUnloadListener,
-  removeUnloadListener,
-  transportConnectionInitializer,
-  HTTPFactory,
-
-  TimelineTransport: xhrTimeline,
-
-  getAuthorizers(): AuthTransports {
-    return { ajax: xhrAuth };
-  },
-
-  getWebSocketAPI() {
-    return WebSocket;
-  },
-
-  getXHRAPI() {
-    return XMLHttpRequest;
-  },
-
-  getNetwork() {
-    return Network;
-  },
-
-  randomInt(max: number): number {
-    return randomInt(max);
-  }
-};
-
-export default NodeJS;