pingerchips-js 1.0.0 → 2.0.0

package/src/core/strategies/best_connected_ever_strategy.ts

@@ -1,81 +0,0 @@
-import * as Collections from '../utils/collections';
-import Util from '../util';
-import Strategy from './strategy';
-
-/** Launches all substrategies and emits prioritized connected transports.
- *
- * @param {Array} strategies
- */
-export default class BestConnectedEverStrategy implements Strategy {
-  strategies: Strategy[];
-
-  constructor(strategies: Strategy[]) {
-    this.strategies = strategies;
-  }
-
-  isSupported(): boolean {
-    return Collections.any(this.strategies, Util.method('isSupported'));
-  }
-
-  connect(minPriority: number, callback: Function) {
-    return connect(this.strategies, minPriority, function(i, runners) {
-      return function(error, handshake) {
-        runners[i].error = error;
-        if (error) {
-          if (allRunnersFailed(runners)) {
-            callback(true);
-          }
-          return;
-        }
-        Collections.apply(runners, function(runner) {
-          runner.forceMinPriority(handshake.transport.priority);
-        });
-        callback(null, handshake);
-      };
-    });
-  }
-}
-
-/** Connects to all strategies in parallel.
- *
- * Callback builder should be a function that takes two arguments: index
- * and a list of runners. It should return another function that will be
- * passed to the substrategy with given index. Runners can be aborted using
- * abortRunner(s) functions from this class.
- *
- * @param  {Array} strategies
- * @param  {Function} callbackBuilder
- * @return {Object} strategy runner
- */
-function connect(
-  strategies: Strategy[],
-  minPriority: number,
-  callbackBuilder: Function
-) {
-  var runners = Collections.map(strategies, function(strategy, i, _, rs) {
-    return strategy.connect(minPriority, callbackBuilder(i, rs));
-  });
-  return {
-    abort: function() {
-      Collections.apply(runners, abortRunner);
-    },
-    forceMinPriority: function(p) {
-      Collections.apply(runners, function(runner) {
-        runner.forceMinPriority(p);
-      });
-    }
-  };
-}
-
-function allRunnersFailed(runners): boolean {
-  return Collections.all(runners, function(runner) {
-    return Boolean(runner.error);
-  });
-}
-
-function abortRunner(runner) {
-  if (!runner.error && !runner.aborted) {
-    runner.abort();
-    runner.aborted = true;
-  }
-}

package/src/core/strategies/delayed_strategy.ts

@@ -1,48 +0,0 @@
-import { OneOffTimer as Timer } from '../utils/timers';
-import Strategy from './strategy';
-import StrategyOptions from './strategy_options';
-
-/** Runs substrategy after specified delay.
- *
- * Options:
- * - delay - time in miliseconds to delay the substrategy attempt
- *
- * @param {Strategy} strategy
- * @param {Object} options
- */
-export default class DelayedStrategy implements Strategy {
-  strategy: Strategy;
-  options: { delay: number };
-
-  constructor(strategy: Strategy, { delay: number }) {
-    this.strategy = strategy;
-    this.options = { delay: number };
-  }
-
-  isSupported(): boolean {
-    return this.strategy.isSupported();
-  }
-
-  connect(minPriority: number, callback: Function) {
-    var strategy = this.strategy;
-    var runner;
-    var timer = new Timer(this.options.delay, function() {
-      runner = strategy.connect(minPriority, callback);
-    });
-
-    return {
-      abort: function() {
-        timer.ensureAborted();
-        if (runner) {
-          runner.abort();
-        }
-      },
-      forceMinPriority: function(p) {
-        minPriority = p;
-        if (runner) {
-          runner.forceMinPriority(p);
-        }
-      }
-    };
-  }
-}

package/src/core/strategies/first_connected_strategy.ts

@@ -1,28 +0,0 @@
-import Strategy from './strategy';
-import StrategyRunner from './strategy_runner';
-
-/** Launches the substrategy and terminates on the first open connection.
- *
- * @param {Strategy} strategy
- */
-export default class FirstConnectedStrategy implements Strategy {
-  strategy: Strategy;
-
-  constructor(strategy: Strategy) {
-    this.strategy = strategy;
-  }
-
-  isSupported(): boolean {
-    return this.strategy.isSupported();
-  }
-
-  connect(minPriority: number, callback: Function): StrategyRunner {
-    var runner = this.strategy.connect(minPriority, function(error, handshake) {
-      if (handshake) {
-        runner.abort();
-      }
-      callback(error, handshake);
-    });
-    return runner;
-  }
-}

package/src/core/strategies/if_strategy.ts

@@ -1,34 +0,0 @@
-import Strategy from './strategy';
-import StrategyRunner from './strategy_runner';
-
-/** Proxies method calls to one of substrategies basing on the test function.
- *
- * @param {Function} test
- * @param {Strategy} trueBranch strategy used when test returns true
- * @param {Strategy} falseBranch strategy used when test returns false
- */
-export default class IfStrategy implements Strategy {
-  test: () => boolean;
-  trueBranch: Strategy;
-  falseBranch: Strategy;
-
-  constructor(
-    test: () => boolean,
-    trueBranch: Strategy,
-    falseBranch: Strategy
-  ) {
-    this.test = test;
-    this.trueBranch = trueBranch;
-    this.falseBranch = falseBranch;
-  }
-
-  isSupported(): boolean {
-    var branch = this.test() ? this.trueBranch : this.falseBranch;
-    return branch.isSupported();
-  }
-
-  connect(minPriority: number, callback: Function): StrategyRunner {
-    var branch = this.test() ? this.trueBranch : this.falseBranch;
-    return branch.connect(minPriority, callback);
-  }
-}

package/src/core/strategies/sequential_strategy.ts

@@ -1,129 +0,0 @@
-import * as Collections from '../utils/collections';
-import Util from '../util';
-import { OneOffTimer as Timer } from '../utils/timers';
-import Strategy from './strategy';
-import StrategyOptions from './strategy_options';
-
-/** Loops through strategies with optional timeouts.
- *
- * Options:
- * - loop - whether it should loop through the substrategy list
- * - timeout - initial timeout for a single substrategy
- * - timeoutLimit - maximum timeout
- *
- * @param {Strategy[]} strategies
- * @param {Object} options
- */
-export default class SequentialStrategy implements Strategy {
-  strategies: Strategy[];
-  loop: boolean;
-  failFast: boolean;
-  timeout: number;
-  timeoutLimit: number;
-
-  constructor(strategies: Strategy[], options: StrategyOptions) {
-    this.strategies = strategies;
-    this.loop = Boolean(options.loop);
-    this.failFast = Boolean(options.failFast);
-    this.timeout = options.timeout;
-    this.timeoutLimit = options.timeoutLimit;
-  }
-
-  isSupported(): boolean {
-    return Collections.any(this.strategies, Util.method('isSupported'));
-  }
-
-  connect(minPriority: number, callback: Function) {
-    var strategies = this.strategies;
-    var current = 0;
-    var timeout = this.timeout;
-    var runner = null;
-
-    var tryNextStrategy = (error, handshake) => {
-      if (handshake) {
-        callback(null, handshake);
-      } else {
-        current = current + 1;
-        if (this.loop) {
-          current = current % strategies.length;
-        }
-
-        if (current < strategies.length) {
-          if (timeout) {
-            timeout = timeout * 2;
-            if (this.timeoutLimit) {
-              timeout = Math.min(timeout, this.timeoutLimit);
-            }
-          }
-          runner = this.tryStrategy(
-            strategies[current],
-            minPriority,
-            { timeout, failFast: this.failFast },
-            tryNextStrategy
-          );
-        } else {
-          callback(true);
-        }
-      }
-    };
-
-    runner = this.tryStrategy(
-      strategies[current],
-      minPriority,
-      { timeout: timeout, failFast: this.failFast },
-      tryNextStrategy
-    );
-
-    return {
-      abort: function() {
-        runner.abort();
-      },
-      forceMinPriority: function(p) {
-        minPriority = p;
-        if (runner) {
-          runner.forceMinPriority(p);
-        }
-      }
-    };
-  }
-
-  private tryStrategy(
-    strategy: Strategy,
-    minPriority: number,
-    options: StrategyOptions,
-    callback: Function
-  ) {
-    var timer = null;
-    var runner = null;
-
-    if (options.timeout > 0) {
-      timer = new Timer(options.timeout, function() {
-        runner.abort();
-        callback(true);
-      });
-    }
-
-    runner = strategy.connect(minPriority, function(error, handshake) {
-      if (error && timer && timer.isRunning() && !options.failFast) {
-        // advance to the next strategy after the timeout
-        return;
-      }
-      if (timer) {
-        timer.ensureAborted();
-      }
-      callback(error, handshake);
-    });
-
-    return {
-      abort: function() {
-        if (timer) {
-          timer.ensureAborted();
-        }
-        runner.abort();
-      },
-      forceMinPriority: function(p) {
-        runner.forceMinPriority(p);
-      }
-    };
-  }
-}

package/src/core/strategies/strategy.ts

@@ -1,8 +0,0 @@
-import StrategyRunner from './strategy_runner';
-
-interface Strategy {
-  isSupported(): boolean;
-  connect(minPriority: number, callback: Function): StrategyRunner;
-}
-
-export default Strategy;

package/src/core/strategies/strategy_builder.ts

@@ -1,67 +0,0 @@
-import * as Collections from '../utils/collections';
-import Util from '../util';
-import TransportManager from '../transports/transport_manager';
-import * as Errors from '../errors';
-import Strategy from './strategy';
-import TransportStrategy from './transport_strategy';
-import StrategyOptions from '../strategies/strategy_options';
-import { Config } from '../config';
-import Runtime from 'runtime';
-
-const { Transports } = Runtime;
-
-export var defineTransport = function(
-  config: Config,
-  name: string,
-  type: string,
-  priority: number,
-  options: StrategyOptions,
-  manager?: TransportManager
-): Strategy {
-  var transportClass = Transports[type];
-  if (!transportClass) {
-    throw new Errors.UnsupportedTransport(type);
-  }
-
-  var enabled =
-    (!config.enabledTransports ||
-      Collections.arrayIndexOf(config.enabledTransports, name) !== -1) &&
-    (!config.disabledTransports ||
-      Collections.arrayIndexOf(config.disabledTransports, name) === -1);
-
-  var transport;
-  if (enabled) {
-    options = Object.assign(
-      { ignoreNullOrigin: config.ignoreNullOrigin },
-      options
-    );
-
-    transport = new TransportStrategy(
-      name,
-      priority,
-      manager ? manager.getAssistant(transportClass) : transportClass,
-      options
-    );
-  } else {
-    transport = UnsupportedStrategy;
-  }
-
-  return transport;
-};
-
-var UnsupportedStrategy: Strategy = {
-  isSupported: function() {
-    return false;
-  },
-  connect: function(_, callback) {
-    var deferred = Util.defer(function() {
-      callback(new Errors.UnsupportedStrategy());
-    });
-    return {
-      abort: function() {
-        deferred.ensureAborted();
-      },
-      forceMinPriority: function() {}
-    };
-  }
-};

package/src/core/strategies/strategy_options.ts

@@ -1,18 +0,0 @@
-import Timeline from '../timeline/timeline';
-
-interface StrategyOptions {
-  failFast?: boolean;
-  hostNonTLS?: string;
-  hostTLS?: string;
-  httpPath?: string;
-  ignoreNullOrigin?: boolean;
-  key?: string;
-  loop?: boolean;
-  timeline?: Timeline;
-  timeout?: number;
-  timeoutLimit?: number;
-  ttl?: number;
-  useTLS?: boolean;
-}
-
-export default StrategyOptions;

package/src/core/strategies/strategy_runner.ts

@@ -1,6 +0,0 @@
-interface StrategyRunner {
-  forceMinPriority: (number) => void;
-  abort: () => void;
-}
-
-export default StrategyRunner;

package/src/core/strategies/transport_strategy.ts

@@ -1,144 +0,0 @@
-import Factory from '../utils/factory';
-import Util from '../util';
-import * as Errors from '../errors';
-import * as Collections from '../utils/collections';
-import Strategy from './strategy';
-import Transport from '../transports/transport';
-import StrategyOptions from './strategy_options';
-import Handshake from '../connection/handshake';
-
-/** Provides a strategy interface for transports.
- *
- * @param {String} name
- * @param {Number} priority
- * @param {Class} transport
- * @param {Object} options
- */
-export default class TransportStrategy implements Strategy {
-  name: string;
-  priority: number;
-  transport: Transport;
-  options: StrategyOptions;
-
-  constructor(
-    name: string,
-    priority: number,
-    transport: Transport,
-    options: StrategyOptions
-  ) {
-    this.name = name;
-    this.priority = priority;
-    this.transport = transport;
-    this.options = options || {};
-  }
-
-  /** Returns whether the transport is supported in the browser.
-   *
-   * @returns {Boolean}
-   */
-  isSupported(): boolean {
-    return this.transport.isSupported({
-      useTLS: this.options.useTLS
-    });
-  }
-
-  /** Launches a connection attempt and returns a strategy runner.
-   *
-   * @param  {Function} callback
-   * @return {Object} strategy runner
-   */
-  connect(minPriority: number, callback: Function) {
-    if (!this.isSupported()) {
-      return failAttempt(new Errors.UnsupportedStrategy(), callback);
-    } else if (this.priority < minPriority) {
-      return failAttempt(new Errors.TransportPriorityTooLow(), callback);
-    }
-
-    var connected = false;
-    var transport = this.transport.createConnection(
-      this.name,
-      this.priority,
-      this.options.key,
-      this.options
-    );
-    var handshake = null;
-
-    var onInitialized = function() {
-      transport.unbind('initialized', onInitialized);
-      transport.connect();
-    };
-    var onOpen = function() {
-      handshake = Factory.createHandshake(transport, function(result) {
-        connected = true;
-        unbindListeners();
-        callback(null, result);
-      });
-    };
-    var onError = function(error) {
-      unbindListeners();
-      callback(error);
-    };
-    var onClosed = function() {
-      unbindListeners();
-      var serializedTransport;
-
-      // The reason for this try/catch block is that on React Native
-      // the WebSocket object is circular. Therefore transport.socket will
-      // throw errors upon stringification. Collections.safeJSONStringify
-      // discards circular references when serializing.
-      serializedTransport = Collections.safeJSONStringify(transport);
-      callback(new Errors.TransportClosed(serializedTransport));
-    };
-
-    var unbindListeners = function() {
-      transport.unbind('initialized', onInitialized);
-      transport.unbind('open', onOpen);
-      transport.unbind('error', onError);
-      transport.unbind('closed', onClosed);
-    };
-
-    transport.bind('initialized', onInitialized);
-    transport.bind('open', onOpen);
-    transport.bind('error', onError);
-    transport.bind('closed', onClosed);
-
-    // connect will be called automatically after initialization
-    transport.initialize();
-
-    return {
-      abort: () => {
-        if (connected) {
-          return;
-        }
-        unbindListeners();
-        if (handshake) {
-          handshake.close();
-        } else {
-          transport.close();
-        }
-      },
-      forceMinPriority: p => {
-        if (connected) {
-          return;
-        }
-        if (this.priority < p) {
-          if (handshake) {
-            handshake.close();
-          } else {
-            transport.close();
-          }
-        }
-      }
-    };
-  }
-}
-
-function failAttempt(error: Error, callback: Function) {
-  Util.defer(function() {
-    callback(error);
-  });
-  return {
-    abort: function() {},
-    forceMinPriority: function() {}
-  };
-}