pingerchips-js 1.0.1-a → 2.0.0

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

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

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

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

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

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

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

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