pingerchips-js 1.0.0-a

package/src/core/http/http_socket.ts

@@ -0,0 +1,220 @@
+import URLLocation from './url_location';
+import State from './state';
+import Socket from '../socket';
+import SocketHooks from './socket_hooks';
+import Util from '../util';
+import Ajax from './ajax';
+import HTTPRequest from './http_request';
+import Runtime from 'runtime';
+
+var autoIncrement = 1;
+
+class HTTPSocket implements Socket {
+  hooks: SocketHooks;
+  session: string;
+  location: URLLocation;
+  readyState: State;
+  stream: HTTPRequest;
+
+  onopen: () => void;
+  onerror: (error: any) => void;
+  onclose: (closeEvent: any) => void;
+  onmessage: (message: any) => void;
+  onactivity: () => void;
+
+  constructor(hooks: SocketHooks, url: string) {
+    this.hooks = hooks;
+    this.session = randomNumber(1000) + '/' + randomString(8);
+    this.location = getLocation(url);
+    this.readyState = State.CONNECTING;
+    this.openStream();
+  }
+
+  send(payload: any) {
+    return this.sendRaw(JSON.stringify([payload]));
+  }
+
+  ping() {
+    this.hooks.sendHeartbeat(this);
+  }
+
+  close(code: any, reason: any) {
+    this.onClose(code, reason, true);
+  }
+
+  /** For internal use only */
+  sendRaw(payload: any): boolean {
+    if (this.readyState === State.OPEN) {
+      try {
+        Runtime.createSocketRequest(
+          'POST',
+          getUniqueURL(getSendURL(this.location, this.session))
+        ).start(payload);
+        return true;
+      } catch (e) {
+        return false;
+      }
+    } else {
+      return false;
+    }
+  }
+
+  /** For internal use only */
+  reconnect() {
+    this.closeStream();
+    this.openStream();
+  }
+
+  /** For internal use only */
+  onClose(code, reason, wasClean) {
+    this.closeStream();
+    this.readyState = State.CLOSED;
+    if (this.onclose) {
+      this.onclose({
+        code: code,
+        reason: reason,
+        wasClean: wasClean
+      });
+    }
+  }
+
+  private onChunk(chunk) {
+    if (chunk.status !== 200) {
+      return;
+    }
+    if (this.readyState === State.OPEN) {
+      this.onActivity();
+    }
+
+    var payload;
+    var type = chunk.data.slice(0, 1);
+    switch (type) {
+      case 'o':
+        payload = JSON.parse(chunk.data.slice(1) || '{}');
+        this.onOpen(payload);
+        break;
+      case 'a':
+        payload = JSON.parse(chunk.data.slice(1) || '[]');
+        for (var i = 0; i < payload.length; i++) {
+          this.onEvent(payload[i]);
+        }
+        break;
+      case 'm':
+        payload = JSON.parse(chunk.data.slice(1) || 'null');
+        this.onEvent(payload);
+        break;
+      case 'h':
+        this.hooks.onHeartbeat(this);
+        break;
+      case 'c':
+        payload = JSON.parse(chunk.data.slice(1) || '[]');
+        this.onClose(payload[0], payload[1], true);
+        break;
+    }
+  }
+
+  private onOpen(options) {
+    if (this.readyState === State.CONNECTING) {
+      if (options && options.hostname) {
+        this.location.base = replaceHost(this.location.base, options.hostname);
+      }
+      this.readyState = State.OPEN;
+
+      if (this.onopen) {
+        this.onopen();
+      }
+    } else {
+      this.onClose(1006, 'Server lost session', true);
+    }
+  }
+
+  private onEvent(event) {
+    if (this.readyState === State.OPEN && this.onmessage) {
+      this.onmessage({ data: event });
+    }
+  }
+
+  private onActivity() {
+    if (this.onactivity) {
+      this.onactivity();
+    }
+  }
+
+  private onError(error) {
+    if (this.onerror) {
+      this.onerror(error);
+    }
+  }
+
+  private openStream() {
+    this.stream = Runtime.createSocketRequest(
+      'POST',
+      getUniqueURL(this.hooks.getReceiveURL(this.location, this.session))
+    );
+
+    this.stream.bind('chunk', chunk => {
+      this.onChunk(chunk);
+    });
+    this.stream.bind('finished', status => {
+      this.hooks.onFinished(this, status);
+    });
+    this.stream.bind('buffer_too_long', () => {
+      this.reconnect();
+    });
+
+    try {
+      this.stream.start();
+    } catch (error) {
+      Util.defer(() => {
+        this.onError(error);
+        this.onClose(1006, 'Could not start streaming', false);
+      });
+    }
+  }
+
+  private closeStream() {
+    if (this.stream) {
+      this.stream.unbind_all();
+      this.stream.close();
+      this.stream = null;
+    }
+  }
+}
+
+function getLocation(url): URLLocation {
+  var parts = /([^\?]*)\/*(\??.*)/.exec(url);
+  return {
+    base: parts[1],
+    queryString: parts[2]
+  };
+}
+
+function getSendURL(url: URLLocation, session: string): string {
+  return url.base + '/' + session + '/xhr_send';
+}
+
+function getUniqueURL(url: string): string {
+  var separator = url.indexOf('?') === -1 ? '?' : '&';
+  return url + separator + 't=' + +new Date() + '&n=' + autoIncrement++;
+}
+
+function replaceHost(url: string, hostname: string): string {
+  var urlParts = /(https?:\/\/)([^\/:]+)((\/|:)?.*)/.exec(url);
+  return urlParts[1] + hostname + urlParts[3];
+}
+
+function randomNumber(max: number): number {
+  return Runtime.randomInt(max);
+}
+
+function randomString(length: number): string {
+  var result = [];
+
+  for (var i = 0; i < length; i++) {
+    result.push(randomNumber(32).toString(32));
+  }
+
+  return result.join('');
+}
+
+export default HTTPSocket;

package/src/core/http/http_streaming_socket.ts

@@ -0,0 +1,19 @@
+import SocketHooks from './socket_hooks';
+import HTTPSocket from './http_socket';
+
+var hooks: SocketHooks = {
+  getReceiveURL: function(url, session) {
+    return url.base + '/' + session + '/xhr_streaming' + url.queryString;
+  },
+  onHeartbeat: function(socket) {
+    socket.sendRaw('[]');
+  },
+  sendHeartbeat: function(socket) {
+    socket.sendRaw('[]');
+  },
+  onFinished: function(socket, status) {
+    socket.onClose(1006, 'Connection interrupted (' + status + ')', false);
+  }
+};
+
+export default hooks;

package/src/core/http/request_hooks.ts

@@ -0,0 +1,9 @@
+import HTTPRequest from './http_request';
+import Ajax from './ajax';
+
+interface RequestHooks {
+  getRequest(HTTPRequest): Ajax;
+  abortRequest(HTTPRequest): void;
+}
+
+export default RequestHooks;

package/src/core/http/socket_hooks.ts

@@ -0,0 +1,11 @@
+import Socket from '../socket';
+import URLLocation from './url_location';
+
+interface SocketHooks {
+  getReceiveURL(url: URLLocation, session: string): string;
+  onHeartbeat(Socket): void;
+  sendHeartbeat(Socket): void;
+  onFinished(Socket, Status): void;
+}
+
+export default SocketHooks;

package/src/core/http/state.ts

@@ -0,0 +1,7 @@
+enum State {
+  CONNECTING = 0,
+  OPEN = 1,
+  CLOSED = 3
+}
+
+export default State;

package/src/core/http/url_location.ts

@@ -0,0 +1,6 @@
+interface URLLocation {
+  base: string;
+  queryString: string;
+}
+
+export default URLLocation;

package/src/core/logger.ts

@@ -0,0 +1,53 @@
+import Pingerchips from './pusher';
+import { stringify } from './utils/collections';
+
+class Logger {
+  debug(...args: any[]) {
+    this.log(this.globalLog, args);
+  }
+
+  warn(...args: any[]) {
+    this.log(this.globalLogWarn, args);
+  }
+
+  error(...args: any[]) {
+    this.log(this.globalLogError, args);
+  }
+
+  private globalLog = (message: string) => {
+    if (global.console && global.console.log) {
+      global.console.log(message);
+    }
+  };
+
+  private globalLogWarn(message: string) {
+    if (global.console && global.console.warn) {
+      global.console.warn(message);
+    } else {
+      this.globalLog(message);
+    }
+  }
+
+  private globalLogError(message: string) {
+    if (global.console && global.console.error) {
+      global.console.error(message);
+    } else {
+      this.globalLogWarn(message);
+    }
+  }
+
+  private log(
+    defaultLoggingFunction: (message: string) => void,
+    ...args: any[]
+  ) {
+    var message = stringify.apply(this, arguments);
+    if (Pingerchips.log) {
+      Pingerchips.log(message);
+    } else if (Pingerchips.logToConsole) {
+      const log = defaultLoggingFunction.bind(this);
+      log(message);
+    }
+  }
+}
+
+export default new Logger();

package/src/core/options.ts

@@ -0,0 +1,59 @@
+import ConnectionManager from './connection/connection_manager';
+import {
+  ChannelAuthorizationOptions,
+  UserAuthenticationOptions
+} from './auth/options';
+import {
+  ChannelAuthorizerGenerator,
+  DeprecatedAuthOptions
+} from './auth/deprecated_channel_authorizer';
+import { AuthTransport, Transport } from './config';
+import * as nacl from 'tweetnacl';
+import Logger from './logger';
+
+export interface Options {
+  activityTimeout?: number;
+
+  auth?: DeprecatedAuthOptions; // DEPRECATED use channelAuthorization instead
+  authEndpoint?: string; // DEPRECATED use channelAuthorization instead
+  authTransport?: AuthTransport; // DEPRECATED use channelAuthorization instead
+  authorizer?: ChannelAuthorizerGenerator; // DEPRECATED use channelAuthorization instead
+
+  channelAuthorization?: ChannelAuthorizationOptions;
+  userAuthentication?: UserAuthenticationOptions;
+
+  cluster: string;
+  enableStats?: boolean;
+  disableStats?: boolean;
+  disabledTransports?: Transport[];
+  enabledTransports?: Transport[];
+  forceTLS?: boolean;
+  httpHost?: string;
+  httpPath?: string;
+  httpPort?: number;
+  httpsPort?: number;
+  ignoreNullOrigin?: boolean;
+  nacl?: nacl;
+  pongTimeout?: number;
+  statsHost?: string;
+  timelineParams?: any;
+  unavailableTimeout?: number;
+  wsHost?: string;
+  wsPath?: string;
+  wsPort?: number;
+  wssPort?: number;
+}
+
+export function validateOptions(options) {
+  if (options == null) {
+    throw 'You must pass an options object';
+  }
+  if (options.cluster == null) {
+    throw 'Options object must provide a cluster';
+  }
+  if ('disableStats' in options) {
+    Logger.warn(
+      'The disableStats option is deprecated in favor of enableStats'
+    );
+  }
+}

package/src/core/pusher-licence.js

@@ -0,0 +1,7 @@
+/*!
+ * Pusher JavaScript Library v<VERSION>
+ * https://pusher.com/
+ *
+ * Copyright 2020, Pusher
+ * Released under the MIT licence.
+ */

package/src/core/pusher-with-encryption.js

@@ -0,0 +1 @@
+module.exports = require('./pusher-with-encryption').default;

package/src/core/pusher-with-encryption.ts

@@ -0,0 +1,14 @@
+import * as nacl from 'tweetnacl';
+import { Options, validateOptions } from './options';
+import Pingerchips from './pusher';
+
+export default class PusherWithEncryption extends Pingerchips {
+  constructor(app_key: string, options: Options) {
+    Pingerchips.logToConsole = PusherWithEncryption.logToConsole;
+    Pingerchips.log = PusherWithEncryption.log;
+
+    validateOptions(options);
+    options.nacl = nacl;
+    super(app_key, options);
+  }
+}

package/src/core/pusher.js

@@ -0,0 +1,2 @@
+// required so we don't have to do require('pusher').default etc.
+module.exports = require('./pusher').default;

package/src/core/pusher.ts

@@ -0,0 +1,249 @@
+import Runtime from 'runtime';
+import AbstractRuntime from '../runtimes/interface';
+import Channel from './channels/channel';
+import Channels from './channels/channels';
+import { Config, getConfig } from './config';
+import ConnectionManager from './connection/connection_manager';
+import Defaults from './defaults';
+import { default as EventsDispatcher } from './events/dispatcher';
+import Logger from './logger';
+import { Options, validateOptions } from './options';
+import { defineTransport } from './strategies/strategy_builder';
+import StrategyOptions from './strategies/strategy_options';
+import TimelineLevel from './timeline/level';
+import Timeline from './timeline/timeline';
+import TimelineSender from './timeline/timeline_sender';
+import UserFacade from './user';
+import * as Collections from './utils/collections';
+import Factory from './utils/factory';
+import { PeriodicTimer } from './utils/timers';
+
+export default class Pingerchips {
+  /*  STATIC PROPERTIES */
+  static instances: Pingerchips[] = [];
+  static isReady: boolean = false;
+  static logToConsole: boolean = false;
+
+  // for jsonp
+  static Runtime: AbstractRuntime = Runtime;
+  static ScriptReceivers: any = (<any>Runtime).ScriptReceivers;
+  static DependenciesReceivers: any = (<any>Runtime).DependenciesReceivers;
+  static auth_callbacks: any = (<any>Runtime).auth_callbacks;
+
+  static ready() {
+    Pingerchips.isReady = true;
+    for (var i = 0, l = Pingerchips.instances.length; i < l; i++) {
+      Pingerchips.instances[i].connect();
+    }
+  }
+
+  static log: (message: any) => void;
+
+  private static getClientFeatures(): string[] {
+    return Collections.keys(
+      Collections.filterObject({ ws: Runtime.Transports.ws }, function(t) {
+        return t.isSupported({});
+      })
+    );
+  }
+
+  /* INSTANCE PROPERTIES */
+  key: string;
+  config: Config;
+  channels: Channels;
+  global_emitter: EventsDispatcher;
+  sessionID: number;
+  timeline: Timeline;
+  timelineSender: TimelineSender;
+  connection: ConnectionManager;
+  timelineSenderTimer: PeriodicTimer;
+  user: UserFacade;
+  constructor(app_key: string, options: Options) {
+    checkAppKey(app_key);
+    validateOptions(options);
+    this.key = app_key;
+    this.config = getConfig(options, this);
+
+    this.channels = Factory.createChannels();
+    this.global_emitter = new EventsDispatcher();
+    this.sessionID = Runtime.randomInt(1000000000);
+
+    this.timeline = new Timeline(this.key, this.sessionID, {
+      cluster: this.config.cluster,
+      features: Pingerchips.getClientFeatures(),
+      params: this.config.timelineParams || {},
+      limit: 50,
+      level: TimelineLevel.INFO,
+      version: Defaults.VERSION
+    });
+    if (this.config.enableStats) {
+      this.timelineSender = Factory.createTimelineSender(this.timeline, {
+        host: this.config.statsHost,
+        path: '/timeline/v2/' + Runtime.TimelineTransport.name
+      });
+    }
+
+    var getStrategy = (options: StrategyOptions) => {
+      return Runtime.getDefaultStrategy(this.config, options, defineTransport);
+    };
+
+    this.connection = Factory.createConnectionManager(this.key, {
+      getStrategy: getStrategy,
+      timeline: this.timeline,
+      activityTimeout: this.config.activityTimeout,
+      pongTimeout: this.config.pongTimeout,
+      unavailableTimeout: this.config.unavailableTimeout,
+      useTLS: Boolean(this.config.useTLS)
+    });
+
+    this.connection.bind('connected', () => {
+      this.subscribeAll();
+      if (this.timelineSender) {
+        this.timelineSender.send(this.connection.isUsingTLS());
+      }
+    });
+
+    this.connection.bind('message', event => {
+      var eventName = event.event;
+      var internal = eventName.indexOf('pusher_internal:') === 0;
+      if (event.channel) {
+        var channel = this.channel(event.channel);
+        if (channel) {
+          channel.handleEvent(event);
+        }
+      }
+      // Emit globally [deprecated]
+      if (!internal) {
+        this.global_emitter.emit(event.event, event.data);
+      }
+    });
+    this.connection.bind('connecting', () => {
+      this.channels.disconnect();
+    });
+    this.connection.bind('disconnected', () => {
+      this.channels.disconnect();
+    });
+    this.connection.bind('error', err => {
+      Logger.warn(err);
+    });
+
+    Pingerchips.instances.push(this);
+    this.timeline.info({ instances: Pingerchips.instances.length });
+
+    this.user = new UserFacade(this);
+
+    if (Pingerchips.isReady) {
+      this.connect();
+    }
+  }
+
+  channel(name: string): Channel {
+    return this.channels.find(name);
+  }
+
+  allChannels(): Channel[] {
+    return this.channels.all();
+  }
+
+  connect() {
+    this.connection.connect();
+
+    if (this.timelineSender) {
+      if (!this.timelineSenderTimer) {
+        var usingTLS = this.connection.isUsingTLS();
+        var timelineSender = this.timelineSender;
+        this.timelineSenderTimer = new PeriodicTimer(60000, function() {
+          timelineSender.send(usingTLS);
+        });
+      }
+    }
+  }
+
+  disconnect() {
+    this.connection.disconnect();
+
+    if (this.timelineSenderTimer) {
+      this.timelineSenderTimer.ensureAborted();
+      this.timelineSenderTimer = null;
+    }
+  }
+
+  bind(event_name: string, callback: Function, context?: any): Pingerchips {
+    this.global_emitter.bind(event_name, callback, context);
+    return this;
+  }
+
+  unbind(event_name?: string, callback?: Function, context?: any): Pingerchips {
+    this.global_emitter.unbind(event_name, callback, context);
+    return this;
+  }
+
+  bind_global(callback: Function): Pingerchips {
+    this.global_emitter.bind_global(callback);
+    return this;
+  }
+
+  unbind_global(callback?: Function): Pingerchips {
+    this.global_emitter.unbind_global(callback);
+    return this;
+  }
+
+  unbind_all(callback?: Function): Pingerchips {
+    this.global_emitter.unbind_all();
+    return this;
+  }
+
+  subscribeAll() {
+    var channelName;
+    for (channelName in this.channels.channels) {
+      if (this.channels.channels.hasOwnProperty(channelName)) {
+        this.subscribe(channelName);
+      }
+    }
+  }
+
+  subscribe(channel_name: string) {
+    var channel = this.channels.add(channel_name, this);
+    if (channel.subscriptionPending && channel.subscriptionCancelled) {
+      channel.reinstateSubscription();
+    } else if (
+      !channel.subscriptionPending &&
+      this.connection.state === 'connected'
+    ) {
+      channel.subscribe();
+    }
+    return channel;
+  }
+
+  unsubscribe(channel_name: string) {
+    var channel = this.channels.find(channel_name);
+    if (channel && channel.subscriptionPending) {
+      channel.cancelSubscription();
+    } else {
+      channel = this.channels.remove(channel_name);
+      if (channel && channel.subscribed) {
+        channel.unsubscribe();
+      }
+    }
+  }
+
+  send_event(event_name: string, data: any, channel?: string) {
+    return this.connection.send_event(event_name, data, channel);
+  }
+
+  shouldUseTLS(): boolean {
+    return this.config.useTLS;
+  }
+
+  signin() {
+    this.user.signin();
+  }
+}
+
+function checkAppKey(key) {
+  if (key === null || key === undefined) {
+    throw 'You must pass your app key when you instantiate Pusher.';
+  }
+}
+
+Runtime.setup(Pingerchips);

package/src/core/reachability.ts

@@ -0,0 +1,7 @@
+import { default as EventsDispatcher } from './events/dispatcher';
+
+interface Reachability extends EventsDispatcher {
+  isOnline(): boolean;
+}
+
+export default Reachability;

package/src/core/socket.ts

@@ -0,0 +1,14 @@
+interface Socket {
+  send(payload: any): void;
+  ping?(): void;
+  close(code?: any, reason?: any);
+  sendRaw?(payload: any): boolean;
+
+  onopen?(evt?: any): void;
+  onerror?(error: any): void;
+  onclose?(closeEvent: any): void;
+  onmessage?(message: any): void;
+  onactivity?(): void;
+}
+
+export default Socket;