@cendarsoss/pusher-js 8.4.11

package/src/runtimes/web/dom/script_request.ts

@@ -0,0 +1,85 @@
+import ScriptReceiver from './script_receiver';
+
+/** Sends a generic HTTP GET request using a script tag.
+ *
+ * By constructing URL in a specific way, it can be used for loading
+ * JavaScript resources or JSONP requests. It can notify about errors, but
+ * only in certain environments. Please take care of monitoring the state of
+ * the request yourself.
+ *
+ * @param {String} src
+ */
+export default class ScriptRequest {
+  src: string;
+  script: any;
+  errorScript: any;
+
+  constructor(src: string) {
+    this.src = src;
+  }
+
+  send(receiver: ScriptReceiver) {
+    var self = this;
+    var errorString = 'Error loading ' + self.src;
+
+    self.script = document.createElement('script');
+    self.script.id = receiver.id;
+    self.script.src = self.src;
+    self.script.type = 'text/javascript';
+    self.script.charset = 'UTF-8';
+
+    if (self.script.addEventListener) {
+      self.script.onerror = function () {
+        receiver.callback(errorString);
+      };
+      self.script.onload = function () {
+        receiver.callback(null);
+      };
+    } else {
+      self.script.onreadystatechange = function () {
+        if (
+          self.script.readyState === 'loaded' ||
+          self.script.readyState === 'complete'
+        ) {
+          receiver.callback(null);
+        }
+      };
+    }
+
+    // Opera<11.6 hack for missing onerror callback
+    if (
+      self.script.async === undefined &&
+      (<any>document).attachEvent &&
+      /opera/i.test(navigator.userAgent)
+    ) {
+      self.errorScript = document.createElement('script');
+      self.errorScript.id = receiver.id + '_error';
+      self.errorScript.text = receiver.name + "('" + errorString + "');";
+      self.script.async = self.errorScript.async = false;
+    } else {
+      self.script.async = true;
+    }
+
+    var head = document.getElementsByTagName('head')[0];
+    head.insertBefore(self.script, head.firstChild);
+    if (self.errorScript) {
+      head.insertBefore(self.errorScript, self.script.nextSibling);
+    }
+  }
+
+  /** Cleans up the DOM remains of the script request. */
+  cleanup() {
+    if (this.script) {
+      this.script.onload = this.script.onerror = null;
+      this.script.onreadystatechange = null;
+    }
+    if (this.script && this.script.parentNode) {
+      this.script.parentNode.removeChild(this.script);
+    }
+    if (this.errorScript && this.errorScript.parentNode) {
+      this.errorScript.parentNode.removeChild(this.errorScript);
+    }
+    this.script = null;
+    this.errorScript = null;
+  }
+}

package/src/runtimes/web/http/http.ts

@@ -0,0 +1,8 @@
+import xdrHooks from './http_xdomain_request';
+import HTTP from 'isomorphic/http/http';
+
+HTTP.createXDR = function (method, url) {
+  return this.createRequest(xdrHooks, method, url);
+};
+
+export default HTTP;

package/src/runtimes/web/http/http_xdomain_request.ts

@@ -0,0 +1,37 @@
+import HTTPRequest from 'core/http/http_request';
+import RequestHooks from 'core/http/request_hooks';
+import Ajax from 'core/http/ajax';
+import * as Errors from 'core/errors';
+
+var hooks: RequestHooks = {
+  getRequest: function (socket: HTTPRequest): Ajax {
+    var xdr = new (<any>window).XDomainRequest();
+    xdr.ontimeout = function () {
+      socket.emit('error', new Errors.RequestTimedOut());
+      socket.close();
+    };
+    xdr.onerror = function (e) {
+      socket.emit('error', e);
+      socket.close();
+    };
+    xdr.onprogress = function () {
+      if (xdr.responseText && xdr.responseText.length > 0) {
+        socket.onChunk(200, xdr.responseText);
+      }
+    };
+    xdr.onload = function () {
+      if (xdr.responseText && xdr.responseText.length > 0) {
+        socket.onChunk(200, xdr.responseText);
+      }
+      socket.emit('finished', 200);
+      socket.close();
+    };
+    return xdr;
+  },
+  abortRequest: function (xdr: Ajax) {
+    xdr.ontimeout = xdr.onerror = xdr.onprogress = xdr.onload = null;
+    xdr.abort();
+  },
+};
+
+export default hooks;

package/src/runtimes/web/net_info.ts

@@ -0,0 +1,50 @@
+import Reachability from 'core/reachability';
+import { default as EventsDispatcher } from 'core/events/dispatcher';
+
+/** Really basic interface providing network availability info.
+ *
+ * Emits:
+ * - online - when browser goes online
+ * - offline - when browser goes offline
+ */
+export class NetInfo extends EventsDispatcher implements Reachability {
+  constructor() {
+    super();
+    var self = this;
+    // This is okay, as IE doesn't support this stuff anyway.
+    if (window.addEventListener !== undefined) {
+      window.addEventListener(
+        'online',
+        function () {
+          self.emit('online');
+        },
+        false,
+      );
+      window.addEventListener(
+        'offline',
+        function () {
+          self.emit('offline');
+        },
+        false,
+      );
+    }
+  }
+
+  /** Returns whether browser is online or not
+   *
+   * Offline means definitely offline (no connection to router).
+   * Inverse does NOT mean definitely online (only currently supported in Safari
+   * and even there only means the device has a connection to the router).
+   *
+   * @return {Boolean}
+   */
+  isOnline(): boolean {
+    if (window.navigator.onLine === undefined) {
+      return true;
+    } else {
+      return window.navigator.onLine;
+    }
+  }
+}
+
+export var Network = new NetInfo();

package/src/runtimes/web/runtime.ts

@@ -0,0 +1,174 @@
+import Browser from './browser';
+import { Dependencies, DependenciesReceivers } from './dom/dependencies';
+import { AuthTransport, AuthTransports } from 'core/auth/auth_transports';
+import xhrAuth from 'isomorphic/auth/xhr_auth';
+import jsonpAuth from './auth/jsonp_auth';
+import TimelineTransport from 'core/timeline/timeline_transport';
+import TimelineSender from 'core/timeline/timeline_sender';
+import ScriptRequest from './dom/script_request';
+import JSONPRequest from './dom/jsonp_request';
+import * as Collections from 'core/utils/collections';
+import { ScriptReceivers } from './dom/script_receiver_factory';
+import jsonpTimeline from './timeline/jsonp_timeline';
+import Transports from './transports/transports';
+import Ajax from 'core/http/ajax';
+import { Network } from './net_info';
+import getDefaultStrategy from './default_strategy';
+import transportConnectionInitializer from './transports/transport_connection_initializer';
+import HTTPFactory from './http/http';
+import HTTPRequest from 'core/http/http_request';
+
+var Runtime: Browser = {
+  // for jsonp auth
+  nextAuthCallbackID: 1,
+  auth_callbacks: {},
+  ScriptReceivers,
+  DependenciesReceivers,
+  getDefaultStrategy,
+  Transports,
+  transportConnectionInitializer,
+  HTTPFactory,
+
+  TimelineTransport: jsonpTimeline,
+
+  getXHRAPI() {
+    return window.XMLHttpRequest;
+  },
+
+  getWebSocketAPI() {
+    return window.WebSocket || window.MozWebSocket;
+  },
+
+  setup(PusherClass): void {
+    (<any>window).Pusher = PusherClass; // JSONp requires Pusher to be in the global scope.
+    var initializeOnDocumentBody = () => {
+      this.onDocumentBody(PusherClass.ready);
+    };
+    if (!(<any>window).JSON) {
+      Dependencies.load('json2', {}, initializeOnDocumentBody);
+    } else {
+      initializeOnDocumentBody();
+    }
+  },
+
+  getDocument(): Document {
+    return document;
+  },
+
+  getProtocol(): string {
+    return this.getDocument().location.protocol;
+  },
+
+  getAuthorizers(): AuthTransports {
+    return { ajax: xhrAuth, jsonp: jsonpAuth };
+  },
+
+  onDocumentBody(callback: Function) {
+    if (document.body) {
+      callback();
+    } else {
+      setTimeout(() => {
+        this.onDocumentBody(callback);
+      }, 0);
+    }
+  },
+
+  createJSONPRequest(url: string, data: any): JSONPRequest {
+    return new JSONPRequest(url, data);
+  },
+
+  createScriptRequest(src: string): ScriptRequest {
+    return new ScriptRequest(src);
+  },
+
+  getLocalStorage() {
+    try {
+      return window.localStorage;
+    } catch (e) {
+      return undefined;
+    }
+  },
+
+  createXHR(): Ajax {
+    if (this.getXHRAPI()) {
+      return this.createXMLHttpRequest();
+    } else {
+      return this.createMicrosoftXHR();
+    }
+  },
+
+  createXMLHttpRequest(): Ajax {
+    var Constructor = this.getXHRAPI();
+    return new Constructor();
+  },
+
+  createMicrosoftXHR(): Ajax {
+    return new ActiveXObject('Microsoft.XMLHTTP');
+  },
+
+  getNetwork() {
+    return Network;
+  },
+
+  createWebSocket(url: string): any {
+    var Constructor = this.getWebSocketAPI();
+    return new Constructor(url);
+  },
+
+  createSocketRequest(method: string, url: string): HTTPRequest {
+    if (this.isXHRSupported()) {
+      return this.HTTPFactory.createXHR(method, url);
+    } else if (this.isXDRSupported(url.indexOf('https:') === 0)) {
+      return this.HTTPFactory.createXDR(method, url);
+    } else {
+      throw 'Cross-origin HTTP requests are not supported';
+    }
+  },
+
+  isXHRSupported(): boolean {
+    var Constructor = this.getXHRAPI();
+    return (
+      Boolean(Constructor) && new Constructor().withCredentials !== undefined
+    );
+  },
+
+  isXDRSupported(useTLS?: boolean): boolean {
+    var protocol = useTLS ? 'https:' : 'http:';
+    var documentProtocol = this.getProtocol();
+    return (
+      Boolean(<any>window['XDomainRequest']) && documentProtocol === protocol
+    );
+  },
+
+  addUnloadListener(listener: any) {
+    if (window.addEventListener !== undefined) {
+      window.addEventListener('unload', listener, false);
+    } else if (window.attachEvent !== undefined) {
+      window.attachEvent('onunload', listener);
+    }
+  },
+
+  removeUnloadListener(listener: any) {
+    if (window.addEventListener !== undefined) {
+      window.removeEventListener('unload', listener, false);
+    } else if (window.detachEvent !== undefined) {
+      window.detachEvent('onunload', listener);
+    }
+  },
+
+  randomInt(max: number): number {
+    /**
+     * Return values in the range of [0, 1[
+     */
+    const random = function () {
+      const crypto = window.crypto || window['msCrypto'];
+      const random = crypto.getRandomValues(new Uint32Array(1))[0];
+
+      return random / 2 ** 32;
+    };
+
+    return Math.floor(random() * max);
+  },
+};
+
+export default Runtime;

package/src/runtimes/web/timeline/jsonp_timeline.ts

@@ -0,0 +1,34 @@
+import TimelineSender from 'core/timeline/timeline_sender';
+import TimelineTransport from 'core/timeline/timeline_transport';
+import Browser from 'runtime';
+import { AuthTransport } from 'core/auth/auth_transports';
+import { ScriptReceivers } from '../dom/script_receiver_factory';
+
+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 request = Browser.createJSONPRequest(url, data);
+
+    var receiver = Browser.ScriptReceivers.create(function (error, result) {
+      ScriptReceivers.remove(receiver);
+      request.cleanup();
+
+      if (result && result.host) {
+        sender.host = result.host;
+      }
+      if (callback) {
+        callback(error, result);
+      }
+    });
+    request.send(receiver);
+  };
+};
+
+var jsonp = {
+  name: 'jsonp',
+  getAgent,
+};
+
+export default jsonp;

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

@@ -0,0 +1,39 @@
+import { Dependencies } from '../dom/dependencies';
+
+/** 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 if (self.hooks.file) {
+    self.changeState('initializing');
+    Dependencies.load(
+      self.hooks.file,
+      { useTLS: self.options.useTLS },
+      function (error, callback) {
+        if (self.hooks.isInitialized()) {
+          self.changeState('initialized');
+          callback(true);
+        } else {
+          if (error) {
+            self.onError(error);
+          }
+          self.onClose();
+          callback(false);
+        }
+      },
+    );
+  } else {
+    self.onClose();
+  }
+}

package/src/runtimes/web/transports/transports.ts

@@ -0,0 +1,67 @@
+import {
+  default as Transports,
+  streamingConfiguration,
+  pollingConfiguration,
+} from 'isomorphic/transports/transports';
+import Transport from 'core/transports/transport';
+import TransportHooks from 'core/transports/transport_hooks';
+import * as URLSchemes from 'core/transports/url_schemes';
+import Runtime from 'runtime';
+import { Dependencies } from '../dom/dependencies';
+import * as Collections from 'core/utils/collections';
+
+var SockJSTransport = new Transport(<TransportHooks>{
+  file: 'sockjs',
+  urls: URLSchemes.sockjs,
+  handlesActivityChecks: true,
+  supportsPing: false,
+
+  isSupported: function () {
+    return true;
+  },
+  isInitialized: function () {
+    return window.SockJS !== undefined;
+  },
+  getSocket: function (url, options) {
+    return new window.SockJS(url, null, {
+      js_path: Dependencies.getPath('sockjs', {
+        useTLS: options.useTLS,
+      }),
+      ignore_null_origin: options.ignoreNullOrigin,
+    });
+  },
+  beforeOpen: function (socket, path) {
+    socket.send(
+      JSON.stringify({
+        path: path,
+      }),
+    );
+  },
+});
+
+var xdrConfiguration = {
+  isSupported: function (environment): boolean {
+    var yes = Runtime.isXDRSupported(environment.useTLS);
+    return yes;
+  },
+};
+
+/** HTTP streaming transport using XDomainRequest (IE 8,9). */
+var XDRStreamingTransport = new Transport(
+  <TransportHooks>(
+    Collections.extend({}, streamingConfiguration, xdrConfiguration)
+  ),
+);
+
+/** HTTP long-polling transport using XDomainRequest (IE 8,9). */
+var XDRPollingTransport = new Transport(
+  <TransportHooks>(
+    Collections.extend({}, pollingConfiguration, xdrConfiguration)
+  ),
+);
+
+Transports.xdr_streaming = XDRStreamingTransport;
+Transports.xdr_polling = XDRPollingTransport;
+Transports.sockjs = SockJSTransport;
+
+export default Transports;

package/src/runtimes/worker/auth/fetch_auth.ts

@@ -0,0 +1,69 @@
+import AbstractRuntime from 'runtimes/interface';
+import { AuthTransport } from 'core/auth/auth_transports';
+import {
+  AuthRequestType,
+  AuthTransportCallback,
+  InternalAuthOptions,
+} from 'core/auth/options';
+import { HTTPAuthError } from 'core/errors';
+
+var fetchAuth: AuthTransport = function (
+  context: AbstractRuntime,
+  query: string,
+  authOptions: InternalAuthOptions,
+  authRequestType: AuthRequestType,
+  callback: AuthTransportCallback,
+) {
+  var headers = new Headers();
+  headers.set('Content-Type', 'application/x-www-form-urlencoded');
+
+  for (var headerName in authOptions.headers) {
+    headers.set(headerName, authOptions.headers[headerName]);
+  }
+
+  if (authOptions.headersProvider != null) {
+    const dynamicHeaders = authOptions.headersProvider();
+    for (var headerName in dynamicHeaders) {
+      headers.set(headerName, dynamicHeaders[headerName]);
+    }
+  }
+
+  var body = query;
+  var request = new Request(authOptions.endpoint, {
+    headers,
+    body,
+    credentials: 'same-origin',
+    method: 'POST',
+  });
+
+  return fetch(request)
+    .then((response) => {
+      let { status } = response;
+      if (status === 200) {
+        // manually parse the json so we can provide a more helpful error in
+        // failure case
+        return response.text();
+      }
+      throw new HTTPAuthError(
+        status,
+        `Could not get ${authRequestType.toString()} info from your auth endpoint, status: ${status}`,
+      );
+    })
+    .then((data) => {
+      let parsedData;
+      try {
+        parsedData = JSON.parse(data);
+      } catch (e) {
+        throw new HTTPAuthError(
+          200,
+          `JSON returned from ${authRequestType.toString()} endpoint was invalid, yet status code was 200. Data was: ${data}`,
+        );
+      }
+      callback(null, parsedData);
+    })
+    .catch((err) => {
+      callback(err, null);
+    });
+};
+
+export default fetchAuth;

package/src/runtimes/worker/net_info.ts

@@ -0,0 +1,10 @@
+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/worker/runtime.ts

@@ -0,0 +1,75 @@
+import Isomorphic from 'isomorphic/runtime';
+import Runtime from '../interface';
+import { Network } from './net_info';
+import fetchAuth from './auth/fetch_auth';
+import { AuthTransports } from 'core/auth/auth_transports';
+import fetchTimeline from './timeline/fetch_timeline';
+
+// 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 Worker: Runtime = {
+  getDefaultStrategy,
+  Transports,
+  setup,
+  getProtocol,
+  isXHRSupported,
+  getLocalStorage,
+  createXHR,
+  createWebSocket,
+  addUnloadListener,
+  removeUnloadListener,
+  transportConnectionInitializer,
+  createSocketRequest,
+  HTTPFactory,
+
+  TimelineTransport: fetchTimeline,
+
+  getAuthorizers(): AuthTransports {
+    return { ajax: fetchAuth };
+  },
+
+  getWebSocketAPI() {
+    return WebSocket;
+  },
+
+  getXHRAPI() {
+    return XMLHttpRequest;
+  },
+
+  getNetwork() {
+    return Network;
+  },
+
+  randomInt(max: number): number {
+    /**
+     * Return values in the range of [0, 1[
+     */
+    const random = function () {
+      const crypto = globalThis.crypto || globalThis['msCrypto'];
+      const random = crypto.getRandomValues(new Uint32Array(1))[0];
+
+      return random / 2 ** 32;
+    };
+
+    return Math.floor(random() * max);
+  },
+};
+
+export default Worker;

package/src/runtimes/worker/timeline/fetch_timeline.ts

@@ -0,0 +1,39 @@
+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;
+
+    fetch(url)
+      .then((response) => {
+        if (response.status !== 200) {
+          throw `received ${response.status} from stats.pusher.com`;
+        }
+        return response.json();
+      })
+      .then(({ host }) => {
+        if (host) {
+          sender.host = host;
+        }
+      })
+      .catch((err) => {
+        Logger.debug('TimelineSender Error: ', err);
+      });
+  };
+};
+
+var fetchTimeline = {
+  name: 'xhr',
+  getAgent,
+};
+
+export default fetchTimeline;