@cendarsoss/pusher-js 8.4.11

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

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

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

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

@@ -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/node/runtime.ts

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

package/src/runtimes/react-native/net_info.ts

@@ -0,0 +1,42 @@
+import { default as NativeNetInfo } from '@react-native-community/netinfo';
+import EventsDispatcher from 'core/events/dispatcher';
+import Util from 'core/util';
+import Reachability from 'core/reachability';
+
+function hasOnlineConnectionState(connectionState): boolean {
+  return connectionState.type.toLowerCase() !== 'none';
+}
+
+export class NetInfo extends EventsDispatcher implements Reachability {
+  online: boolean;
+
+  constructor() {
+    super();
+    this.online = true;
+
+    NativeNetInfo.fetch().then((connectionState) => {
+      this.online = hasOnlineConnectionState(connectionState);
+    });
+
+    NativeNetInfo.addEventListener((connectionState) => {
+      var isNowOnline = hasOnlineConnectionState(connectionState);
+
+      // React Native counts the switch from Wi-Fi to Cellular
+      // as a state change. Return if current and previous states
+      // are both online/offline
+      if (this.online === isNowOnline) return;
+      this.online = isNowOnline;
+      if (this.online) {
+        this.emit('online');
+      } else {
+        this.emit('offline');
+      }
+    });
+  }
+
+  isOnline(): boolean {
+    return this.online;
+  }
+}
+
+export var Network = new NetInfo();

package/src/runtimes/react-native/runtime.ts

@@ -0,0 +1,65 @@
+import Isomorphic from 'isomorphic/runtime';
+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';
+
+// 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 ReactNative: Runtime = {
+  getDefaultStrategy,
+  Transports,
+  setup,
+  getProtocol,
+  isXHRSupported,
+  getLocalStorage,
+  createXHR,
+  createWebSocket,
+  addUnloadListener,
+  removeUnloadListener,
+  transportConnectionInitializer,
+  createSocketRequest,
+  HTTPFactory,
+
+  TimelineTransport: xhrTimeline,
+
+  getAuthorizers(): AuthTransports {
+    return { ajax: xhrAuth };
+  },
+
+  getWebSocketAPI() {
+    return WebSocket;
+  },
+
+  getXHRAPI() {
+    return XMLHttpRequest;
+  },
+
+  getNetwork() {
+    return Network;
+  },
+
+  randomInt(max: number): number {
+    return Math.floor(Math.random() * max);
+  },
+};
+
+export default ReactNative;

package/src/runtimes/web/auth/jsonp_auth.ts

@@ -0,0 +1,51 @@
+import Browser from '../browser';
+import Logger from 'core/logger';
+import JSONPRequest from '../dom/jsonp_request';
+import { ScriptReceivers } from '../dom/script_receiver_factory';
+import { AuthTransport } from 'core/auth/auth_transports';
+import {
+  AuthRequestType,
+  AuthTransportCallback,
+  InternalAuthOptions,
+} from 'core/auth/options';
+
+var jsonp: AuthTransport = function (
+  context: Browser,
+  query: string,
+  authOptions: InternalAuthOptions,
+  authRequestType: AuthRequestType,
+  callback: AuthTransportCallback,
+) {
+  if (
+    authOptions.headers !== undefined ||
+    authOptions.headersProvider != null
+  ) {
+    Logger.warn(
+      `To send headers with the ${authRequestType.toString()} request, you must use AJAX, rather than JSONP.`,
+    );
+  }
+
+  var callbackName = context.nextAuthCallbackID.toString();
+  context.nextAuthCallbackID++;
+
+  var document = context.getDocument();
+  var script = document.createElement('script');
+  // Hacked wrapper.
+  context.auth_callbacks[callbackName] = function (data) {
+    callback(null, data);
+  };
+
+  var callback_name = "Pusher.auth_callbacks['" + callbackName + "']";
+  script.src =
+    authOptions.endpoint +
+    '?callback=' +
+    encodeURIComponent(callback_name) +
+    '&' +
+    query;
+
+  var head =
+    document.getElementsByTagName('head')[0] || document.documentElement;
+  head.insertBefore(script, head.firstChild);
+};
+
+export default jsonp;

package/src/runtimes/web/browser.ts

@@ -0,0 +1,24 @@
+import AbstractRuntime from 'runtimes/interface';
+import { ScriptReceiverFactory } from './dom/script_receiver_factory';
+import ScriptRequest from './dom/script_request';
+import JSONPRequest from './dom/jsonp_request';
+import Ajax from 'core/http/ajax';
+
+interface Browser extends AbstractRuntime {
+  // for jsonp auth
+  nextAuthCallbackID: number;
+  auth_callbacks: any;
+  ScriptReceivers: ScriptReceiverFactory;
+  DependenciesReceivers: ScriptReceiverFactory;
+  onDocumentBody(callback: Function);
+  getDocument(): any;
+
+  createJSONPRequest(url: string, data: any): JSONPRequest;
+  createScriptRequest(src: string): ScriptRequest;
+
+  isXDRSupported(useTLS?: boolean): boolean;
+  createXMLHttpRequest(): Ajax;
+  createMicrosoftXHR(): Ajax;
+}
+
+export default Browser;

package/src/runtimes/web/default_strategy.ts

@@ -0,0 +1,201 @@
+import * as Collections from 'core/utils/collections';
+import TransportManager from 'core/transports/transport_manager';
+import Strategy from 'core/strategies/strategy';
+import StrategyOptions from 'core/strategies/strategy_options';
+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';
+
+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 = Object.assign({}, ws_options, {
+    useTLS: true,
+  });
+  var sockjs_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 sockjs_transport = defineTransportStrategy(
+    'sockjs',
+    'sockjs',
+    1,
+    sockjs_options,
+  );
+  var xhr_streaming_transport = defineTransportStrategy(
+    'xhr_streaming',
+    'xhr_streaming',
+    1,
+    sockjs_options,
+    streaming_manager,
+  );
+  var xdr_streaming_transport = defineTransportStrategy(
+    'xdr_streaming',
+    'xdr_streaming',
+    1,
+    sockjs_options,
+    streaming_manager,
+  );
+  var xhr_polling_transport = defineTransportStrategy(
+    'xhr_polling',
+    'xhr_polling',
+    1,
+    sockjs_options,
+  );
+  var xdr_polling_transport = defineTransportStrategy(
+    'xdr_polling',
+    'xdr_polling',
+    1,
+    sockjs_options,
+  );
+
+  var ws_loop = new SequentialStrategy([ws_transport], timeouts);
+  var wss_loop = new SequentialStrategy([wss_transport], timeouts);
+  var sockjs_loop = new SequentialStrategy([sockjs_transport], timeouts);
+  var streaming_loop = new SequentialStrategy(
+    [
+      new IfStrategy(
+        testSupportsStrategy(xhr_streaming_transport),
+        xhr_streaming_transport,
+        xdr_streaming_transport,
+      ),
+    ],
+    timeouts,
+  );
+  var polling_loop = new SequentialStrategy(
+    [
+      new IfStrategy(
+        testSupportsStrategy(xhr_polling_transport),
+        xhr_polling_transport,
+        xdr_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 http_fallback_loop = new IfStrategy(
+    testSupportsStrategy(http_loop),
+    http_loop,
+    sockjs_loop,
+  );
+
+  var wsStrategy;
+  if (baseOptions.useTLS) {
+    wsStrategy = new BestConnectedEverStrategy([
+      ws_loop,
+      new DelayedStrategy(http_fallback_loop, { delay: 2000 }),
+    ]);
+  } else {
+    wsStrategy = new BestConnectedEverStrategy([
+      ws_loop,
+      new DelayedStrategy(wss_loop, { delay: 2000 }),
+      new DelayedStrategy(http_fallback_loop, { delay: 5000 }),
+    ]);
+  }
+
+  return new WebSocketPrioritizedCachedStrategy(
+    new FirstConnectedStrategy(
+      new IfStrategy(
+        testSupportsStrategy(ws_transport),
+        wsStrategy,
+        http_fallback_loop,
+      ),
+    ),
+    definedTransports,
+    {
+      ttl: 1800000,
+      timeline: baseOptions.timeline,
+      useTLS: baseOptions.useTLS,
+    },
+  );
+};
+
+export default getDefaultStrategy;

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

@@ -0,0 +1,16 @@
+import { ScriptReceiverFactory } from './script_receiver_factory';
+import Defaults from 'core/defaults';
+import DependencyLoader from './dependency_loader';
+
+export var DependenciesReceivers = new ScriptReceiverFactory(
+  '_pusher_dependencies',
+  'Pusher.DependenciesReceivers',
+);
+
+export var Dependencies = new DependencyLoader({
+  cdn_http: Defaults.cdn_http,
+  cdn_https: Defaults.cdn_https,
+  version: Defaults.VERSION,
+  suffix: Defaults.dependency_suffix,
+  receivers: DependenciesReceivers,
+});