pingerchips-js 1.0.0-a

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
+});

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

@@ -0,0 +1,93 @@
+import {
+  ScriptReceivers,
+  ScriptReceiverFactory
+} from './script_receiver_factory';
+import Runtime from 'runtime';
+import ScriptRequest from './script_request';
+
+/** Handles loading dependency files.
+ *
+ * Dependency loaders don't remember whether a resource has been loaded or
+ * not. It is caller's responsibility to make sure the resource is not loaded
+ * twice. This is because it's impossible to detect resource loading status
+ * without knowing its content.
+ *
+ * Options:
+ * - cdn_http - url to HTTP CND
+ * - cdn_https - url to HTTPS CDN
+ * - version - version of pusher-js
+ * - suffix - suffix appended to all names of dependency files
+ *
+ * @param {Object} options
+ */
+export default class DependencyLoader {
+  options: any;
+  receivers: ScriptReceiverFactory;
+  loading: any;
+
+  constructor(options: any) {
+    this.options = options;
+    this.receivers = options.receivers || ScriptReceivers;
+    this.loading = {};
+  }
+
+  /** Loads the dependency from CDN.
+   *
+   * @param  {String} name
+   * @param  {Function} callback
+   */
+  load(name: string, options: any, callback: Function) {
+    var self = this;
+
+    if (self.loading[name] && self.loading[name].length > 0) {
+      self.loading[name].push(callback);
+    } else {
+      self.loading[name] = [callback];
+
+      var request = Runtime.createScriptRequest(self.getPath(name, options));
+      var receiver = self.receivers.create(function(error) {
+        self.receivers.remove(receiver);
+
+        if (self.loading[name]) {
+          var callbacks = self.loading[name];
+          delete self.loading[name];
+
+          var successCallback = function(wasSuccessful) {
+            if (!wasSuccessful) {
+              request.cleanup();
+            }
+          };
+          for (var i = 0; i < callbacks.length; i++) {
+            callbacks[i](error, successCallback);
+          }
+        }
+      });
+      request.send(receiver);
+    }
+  }
+
+  /** Returns a root URL for pusher-js CDN.
+   *
+   * @returns {String}
+   */
+  getRoot(options: any): string {
+    var cdn;
+    var protocol = Runtime.getDocument().location.protocol;
+    if ((options && options.useTLS) || protocol === 'https:') {
+      cdn = this.options.cdn_https;
+    } else {
+      cdn = this.options.cdn_http;
+    }
+    // make sure there are no double slashes
+    return cdn.replace(/\/*$/, '') + '/' + this.options.version;
+  }
+
+  /** Returns a full path to a dependency file.
+   *
+   * @param {String} name
+   * @returns {String}
+   */
+  getPath(name: string, options: any): string {
+    return this.getRoot(options) + '/' + name + this.options.suffix + '.js';
+  }
+}