pingerchips-js 1.0.0-a

package/src/core/utils/collections.ts

@@ -0,0 +1,353 @@
+import base64encode from '../base64';
+import Util from '../util';
+
+/** Merges multiple objects into the target argument.
+ *
+ * For properties that are plain Objects, performs a deep-merge. For the
+ * rest it just copies the value of the property.
+ *
+ * To extend prototypes use it as following:
+ *   Pusher.Util.extend(Target.prototype, Base.prototype)
+ *
+ * You can also use it to merge objects without altering them:
+ *   Pusher.Util.extend({}, object1, object2)
+ *
+ * @param  {Object} target
+ * @return {Object} the target argument
+ */
+export function extend<T>(target: any, ...sources: any[]): T {
+  for (var i = 0; i < sources.length; i++) {
+    var extensions = sources[i];
+    for (var property in extensions) {
+      if (
+        extensions[property] &&
+        extensions[property].constructor &&
+        extensions[property].constructor === Object
+      ) {
+        target[property] = extend(target[property] || {}, extensions[property]);
+      } else {
+        target[property] = extensions[property];
+      }
+    }
+  }
+  return target;
+}
+
+export function stringify(): string {
+  var m = ['Pusher'];
+  for (var i = 0; i < arguments.length; i++) {
+    if (typeof arguments[i] === 'string') {
+      m.push(arguments[i]);
+    } else {
+      m.push(safeJSONStringify(arguments[i]));
+    }
+  }
+  return m.join(' : ');
+}
+
+export function arrayIndexOf(array: any[], item: any): number {
+  // MSIE doesn't have array.indexOf
+  var nativeIndexOf = Array.prototype.indexOf;
+  if (array === null) {
+    return -1;
+  }
+  if (nativeIndexOf && array.indexOf === nativeIndexOf) {
+    return array.indexOf(item);
+  }
+  for (var i = 0, l = array.length; i < l; i++) {
+    if (array[i] === item) {
+      return i;
+    }
+  }
+  return -1;
+}
+
+/** Applies a function f to all properties of an object.
+ *
+ * Function f gets 3 arguments passed:
+ * - element from the object
+ * - key of the element
+ * - reference to the object
+ *
+ * @param {Object} object
+ * @param {Function} f
+ */
+export function objectApply(object: any, f: Function) {
+  for (var key in object) {
+    if (Object.prototype.hasOwnProperty.call(object, key)) {
+      f(object[key], key, object);
+    }
+  }
+}
+
+/** Return a list of objects own proerty keys
+ *
+ * @param {Object} object
+ * @returns {Array}
+ */
+export function keys(object: any): string[] {
+  var keys = [];
+  objectApply(object, function(_, key) {
+    keys.push(key);
+  });
+  return keys;
+}
+
+/** Return a list of object's own property values
+ *
+ * @param {Object} object
+ * @returns {Array}
+ */
+export function values(object: any): any[] {
+  var values = [];
+  objectApply(object, function(value) {
+    values.push(value);
+  });
+  return values;
+}
+
+/** Applies a function f to all elements of an array.
+ *
+ * Function f gets 3 arguments passed:
+ * - element from the array
+ * - index of the element
+ * - reference to the array
+ *
+ * @param {Array} array
+ * @param {Function} f
+ */
+export function apply(array: any[], f: Function, context?: any) {
+  for (var i = 0; i < array.length; i++) {
+    f.call(context || global, array[i], i, array);
+  }
+}
+
+/** Maps all elements of the array and returns the result.
+ *
+ * Function f gets 4 arguments passed:
+ * - element from the array
+ * - index of the element
+ * - reference to the source array
+ * - reference to the destination array
+ *
+ * @param {Array} array
+ * @param {Function} f
+ */
+export function map(array: any[], f: Function): any[] {
+  var result = [];
+  for (var i = 0; i < array.length; i++) {
+    result.push(f(array[i], i, array, result));
+  }
+  return result;
+}
+
+/** Maps all elements of the object and returns the result.
+ *
+ * Function f gets 4 arguments passed:
+ * - element from the object
+ * - key of the element
+ * - reference to the source object
+ * - reference to the destination object
+ *
+ * @param {Object} object
+ * @param {Function} f
+ */
+export function mapObject(object: any, f: Function): any {
+  var result = {};
+  objectApply(object, function(value, key) {
+    result[key] = f(value);
+  });
+  return result;
+}
+
+/** Filters elements of the array using a test function.
+ *
+ * Function test gets 4 arguments passed:
+ * - element from the array
+ * - index of the element
+ * - reference to the source array
+ * - reference to the destination array
+ *
+ * @param {Array} array
+ * @param {Function} f
+ */
+export function filter(array: any[], test: Function): any[] {
+  test =
+    test ||
+    function(value) {
+      return !!value;
+    };
+
+  var result = [];
+  for (var i = 0; i < array.length; i++) {
+    if (test(array[i], i, array, result)) {
+      result.push(array[i]);
+    }
+  }
+  return result;
+}
+
+/** Filters properties of the object using a test function.
+ *
+ * Function test gets 4 arguments passed:
+ * - element from the object
+ * - key of the element
+ * - reference to the source object
+ * - reference to the destination object
+ *
+ * @param {Object} object
+ * @param {Function} f
+ */
+export function filterObject(object: Object, test: Function) {
+  var result = {};
+  objectApply(object, function(value, key) {
+    if ((test && test(value, key, object, result)) || Boolean(value)) {
+      result[key] = value;
+    }
+  });
+  return result;
+}
+
+/** Flattens an object into a two-dimensional array.
+ *
+ * @param  {Object} object
+ * @return {Array} resulting array of [key, value] pairs
+ */
+export function flatten(object: Object): any[] {
+  var result = [];
+  objectApply(object, function(value, key) {
+    result.push([key, value]);
+  });
+  return result;
+}
+
+/** Checks whether any element of the array passes the test.
+ *
+ * Function test gets 3 arguments passed:
+ * - element from the array
+ * - index of the element
+ * - reference to the source array
+ *
+ * @param {Array} array
+ * @param {Function} f
+ */
+export function any(array: any[], test: Function): boolean {
+  for (var i = 0; i < array.length; i++) {
+    if (test(array[i], i, array)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/** Checks whether all elements of the array pass the test.
+ *
+ * Function test gets 3 arguments passed:
+ * - element from the array
+ * - index of the element
+ * - reference to the source array
+ *
+ * @param {Array} array
+ * @param {Function} f
+ */
+export function all(array: any[], test: Function): boolean {
+  for (var i = 0; i < array.length; i++) {
+    if (!test(array[i], i, array)) {
+      return false;
+    }
+  }
+  return true;
+}
+
+export function encodeParamsObject(data): string {
+  return mapObject(data, function(value) {
+    if (typeof value === 'object') {
+      value = safeJSONStringify(value);
+    }
+    return encodeURIComponent(base64encode(value.toString()));
+  });
+}
+
+export function buildQueryString(data: any): string {
+  var params = filterObject(data, function(value) {
+    return value !== undefined;
+  });
+
+  var query = map(
+    flatten(encodeParamsObject(params)),
+    Util.method('join', '=')
+  ).join('&');
+
+  return query;
+}
+
+/**
+ * See https://github.com/douglascrockford/JSON-js/blob/master/cycle.js
+ *
+ * Remove circular references from an object. Required for JSON.stringify in
+ * React Native, which tends to blow up a lot.
+ *
+ * @param  {any} object
+ * @return {any}        Decycled object
+ */
+export function decycleObject(object: any): any {
+  var objects = [],
+    paths = [];
+
+  return (function derez(value, path) {
+    var i, name, nu;
+
+    switch (typeof value) {
+      case 'object':
+        if (!value) {
+          return null;
+        }
+        for (i = 0; i < objects.length; i += 1) {
+          if (objects[i] === value) {
+            return { $ref: paths[i] };
+          }
+        }
+
+        objects.push(value);
+        paths.push(path);
+
+        if (Object.prototype.toString.apply(value) === '[object Array]') {
+          nu = [];
+          for (i = 0; i < value.length; i += 1) {
+            nu[i] = derez(value[i], path + '[' + i + ']');
+          }
+        } else {
+          nu = {};
+          for (name in value) {
+            if (Object.prototype.hasOwnProperty.call(value, name)) {
+              nu[name] = derez(
+                value[name],
+                path + '[' + JSON.stringify(name) + ']'
+              );
+            }
+          }
+        }
+        return nu;
+      case 'number':
+      case 'string':
+      case 'boolean':
+        return value;
+    }
+  })(object, '$');
+}
+
+/**
+ * Provides a cross-browser and cross-platform way to safely stringify objects
+ * into JSON. This is particularly necessary for ReactNative, where circular JSON
+ * structures throw an exception.
+ *
+ * @param  {any}    source The object to stringify
+ * @return {string}        The serialized output.
+ */
+export function safeJSONStringify(source: any): string {
+  try {
+    return JSON.stringify(source);
+  } catch (e) {
+    return JSON.stringify(decycleObject(source));
+  }
+}

package/src/core/utils/factory.ts

@@ -0,0 +1,75 @@
+import Handshake from '../connection/handshake';
+import AssistantToTheTransportManager from '../transports/assistant_to_the_transport_manager';
+import PingDelayOptions from '../transports/ping_delay_options';
+import Transport from '../transports/transport';
+import TransportConnection from '../transports/transport_connection';
+import TransportManager from '../transports/transport_manager';
+
+import * as nacl from 'tweetnacl';
+import Channel from '../channels/channel';
+import Channels from '../channels/channels';
+import EncryptedChannel from '../channels/encrypted_channel';
+import PresenceChannel from '../channels/presence_channel';
+import PrivateChannel from '../channels/private_channel';
+import ConnectionManager from '../connection/connection_manager';
+import ConnectionManagerOptions from '../connection/connection_manager_options';
+import Pingerchips from '../pusher';
+import Timeline from '../timeline/timeline';
+import {
+    default as TimelineSender,
+    TimelineSenderOptions
+} from '../timeline/timeline_sender';
+
+var Factory = {
+  createChannels(): Channels {
+    return new Channels();
+  },
+
+  createConnectionManager(
+    key: string,
+    options: ConnectionManagerOptions
+  ): ConnectionManager {
+    return new ConnectionManager(key, options);
+  },
+
+  createChannel(name: string, pusher: Pingerchips): Channel {
+    return new Channel(name, pusher);
+  },
+
+  createPrivateChannel(name: string, pusher: Pingerchips): PrivateChannel {
+    return new PrivateChannel(name, pusher);
+  },
+
+  createPresenceChannel(name: string, pusher: Pingerchips): PresenceChannel {
+    return new PresenceChannel(name, pusher);
+  },
+
+  createEncryptedChannel(
+    name: string,
+    pusher: Pingerchips,
+    nacl: nacl
+  ): EncryptedChannel {
+    return new EncryptedChannel(name, pusher, nacl);
+  },
+
+  createTimelineSender(timeline: Timeline, options: TimelineSenderOptions) {
+    return new TimelineSender(timeline, options);
+  },
+
+  createHandshake(
+    transport: TransportConnection,
+    callback: (HandshakePayload) => void
+  ): Handshake {
+    return new Handshake(transport, callback);
+  },
+
+  createAssistantToTheTransportManager(
+    manager: TransportManager,
+    transport: Transport,
+    options: PingDelayOptions
+  ): AssistantToTheTransportManager {
+    return new AssistantToTheTransportManager(manager, transport, options);
+  }
+};
+
+export default Factory;

package/src/core/utils/flat_promise.ts

@@ -0,0 +1,10 @@
+function flatPromise() {
+  let resolve, reject;
+  const promise = new Promise((res, rej) => {
+    resolve = res;
+    reject = rej;
+  });
+  return { promise, resolve, reject };
+}
+
+export default flatPromise;

package/src/core/utils/timers/abstract_timer.ts

@@ -0,0 +1,39 @@
+import TimedCallback from './timed_callback';
+import { Delay, Scheduler, Canceller } from './scheduling';
+
+abstract class Timer {
+  protected clear: Canceller;
+  protected timer: number | void;
+
+  constructor(
+    set: Scheduler,
+    clear: Canceller,
+    delay: Delay,
+    callback: TimedCallback
+  ) {
+    this.clear = clear;
+    this.timer = set(() => {
+      if (this.timer) {
+        this.timer = callback(this.timer);
+      }
+    }, delay);
+  }
+
+  /** Returns whether the timer is still running.
+   *
+   * @return {Boolean}
+   */
+  isRunning(): boolean {
+    return this.timer !== null;
+  }
+
+  /** Aborts a timer when it's running. */
+  ensureAborted() {
+    if (this.timer) {
+      this.clear(this.timer);
+      this.timer = null;
+    }
+  }
+}
+
+export default Timer;

package/src/core/utils/timers/index.ts

@@ -0,0 +1,39 @@
+import Timer from './abstract_timer';
+import TimedCallback from './timed_callback';
+import { Delay } from './scheduling';
+
+// We need to bind clear functions this way to avoid exceptions on IE8
+function clearTimeout(timer) {
+  global.clearTimeout(timer);
+}
+function clearInterval(timer) {
+  global.clearInterval(timer);
+}
+
+/** Cross-browser compatible one-off timer abstraction.
+ *
+ * @param {Number} delay
+ * @param {Function} callback
+ */
+export class OneOffTimer extends Timer {
+  constructor(delay: Delay, callback: TimedCallback) {
+    super(setTimeout, clearTimeout, delay, function(timer) {
+      callback();
+      return null;
+    });
+  }
+}
+
+/** Cross-browser compatible periodic timer abstraction.
+ *
+ * @param {Number} delay
+ * @param {Function} callback
+ */
+export class PeriodicTimer extends Timer {
+  constructor(delay: Delay, callback: TimedCallback) {
+    super(setInterval, clearInterval, delay, function(timer) {
+      callback();
+      return timer;
+    });
+  }
+}

package/src/core/utils/timers/scheduling.ts

@@ -0,0 +1,11 @@
+interface Scheduler {
+  (TimedCallback, number): number;
+}
+
+interface Canceller {
+  (number): void;
+}
+
+type Delay = number;
+
+export { Scheduler, Canceller, Delay };

package/src/core/utils/timers/timed_callback.ts

@@ -0,0 +1,5 @@
+interface TimedCallback {
+  (number?): number | void;
+}
+
+export default TimedCallback;

package/src/core/utils/url_store.ts

@@ -0,0 +1,48 @@
+/**
+ * A place to store help URLs for error messages etc
+ */
+
+const urlStore = {
+  baseUrl: 'https://pusher.com',
+  urls: {
+    authenticationEndpoint: {
+      path: '/docs/channels/server_api/authenticating_users'
+    },
+    authorizationEndpoint: {
+      path: '/docs/channels/server_api/authorizing-users/'
+    },
+    javascriptQuickStart: {
+      path: '/docs/javascript_quick_start'
+    },
+    triggeringClientEvents: {
+      path: '/docs/client_api_guide/client_events#trigger-events'
+    },
+    encryptedChannelSupport: {
+      fullUrl:
+        'https://github.com/pusher/pusher-js/tree/cc491015371a4bde5743d1c87a0fbac0feb53195#encrypted-channel-support'
+    }
+  }
+};
+
+/** Builds a consistent string with links to pusher documentation
+ *
+ * @param {string} key - relevant key in the url_store.urls object
+ * @return {string} suffix string to append to log message
+ */
+const buildLogSuffix = function(key: string): string {
+  const urlPrefix = 'See:';
+  const urlObj = urlStore.urls[key];
+  if (!urlObj) return '';
+
+  let url;
+  if (urlObj.fullUrl) {
+    url = urlObj.fullUrl;
+  } else if (urlObj.path) {
+    url = urlStore.baseUrl + urlObj.path;
+  }
+
+  if (!url) return '';
+  return `${urlPrefix} ${url}`;
+};
+
+export default { buildLogSuffix };

package/src/core/watchlist.ts

@@ -0,0 +1,31 @@
+import EventsDispatcher from './events/dispatcher';
+import Logger from './logger';
+import Pingerchips from './pusher';
+
+export default class WatchlistFacade extends EventsDispatcher {
+  private pusher: Pingerchips;
+
+  public constructor(pusher: Pingerchips) {
+    super(function(eventName, data) {
+      Logger.debug(`No callbacks on watchlist events for ${eventName}`);
+    });
+
+    this.pusher = pusher;
+    this.bindWatchlistInternalEvent();
+  }
+
+  handleEvent(pusherEvent) {
+    pusherEvent.data.events.forEach(watchlistEvent => {
+      this.emit(watchlistEvent.name, watchlistEvent);
+    });
+  }
+
+  private bindWatchlistInternalEvent() {
+    this.pusher.connection.bind('message', pusherEvent => {
+      var eventName = pusherEvent.event;
+      if (eventName === 'pusher_internal:watchlist_events') {
+        this.handleEvent(pusherEvent);
+      }
+    });
+  }
+}

package/src/d.ts/constants/index.d.ts

@@ -0,0 +1,5 @@
+declare var VERSION;
+declare var CDN_HTTP;
+declare var CDN_HTTPS;
+declare var DEPENDENCY_SUFFIX;
+declare var RUNTIME;

package/src/d.ts/faye-websocket/faye-websocket.d.ts

@@ -0,0 +1,21 @@
+declare module 'faye-websocket' {
+  interface MessageEvent {
+    data: any;
+  }
+
+  interface CloseEvent {
+    code: number;
+    reason: string;
+    wasClean: boolean;
+  }
+
+  export class Client {
+    public onopen: () => void;
+    public onmessage: (event: MessageEvent) => void;
+    public onclose: (event: CloseEvent) => void;
+
+    constructor(url: string);
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+  }
+}

package/src/d.ts/global/global.d.ts

@@ -0,0 +1 @@
+declare const global: any;

package/src/d.ts/module/module.d.ts

@@ -0,0 +1,12 @@
+declare var module: {
+  exports: any;
+};
+
+declare var require: {
+  <T>(path: string): T;
+  (paths: string[], callback: (...modules: any[]) => void): void;
+  ensure: (
+    paths: string[],
+    callback: (require: <T>(path: string) => T) => void
+  ) => void;
+};

package/src/d.ts/tweetnacl-util/index.d.ts

@@ -0,0 +1,6 @@
+declare module 'tweetnacl-util' {
+  export function encodeUTF8(data: Uint8Array): string;
+  export function decodeUTF8(data: string): Uint8Array;
+  export function encodeBase64(data: Uint8Array): string;
+  export function decodeBase64(data: string): Uint8Array;
+}

package/src/d.ts/window/events.d.ts

@@ -0,0 +1,4 @@
+interface Window {
+  attachEvent: any;
+  detachEvent: any;
+}

package/src/d.ts/window/sockjs.d.ts

@@ -0,0 +1,3 @@
+interface Window {
+  SockJS: any;
+}

package/src/d.ts/window/websocket.d.ts

@@ -0,0 +1,4 @@
+interface Window {
+  WebSocket: any;
+  MozWebSocket: any;
+}

package/src/d.ts/window/xmlhttprequest.d.ts

@@ -0,0 +1,3 @@
+interface Window {
+  XMLHttpRequest: any;
+}