@cendarsoss/pusher-js 8.4.11

package/src/core/events/callback_table.ts

@@ -0,0 +1,7 @@
+import Callback from './callback';
+
+interface CallbackTable {
+  [index: string]: Callback[];
+}
+
+export default CallbackTable;

package/src/core/events/dispatcher.ts

@@ -0,0 +1,84 @@
+import * as Collections from '../utils/collections';
+import Callback from './callback';
+import Metadata from '../channels/metadata';
+import CallbackRegistry from './callback_registry';
+
+/** Manages callback bindings and event emitting.
+ *
+ * @param Function failThrough called when no listeners are bound to an event
+ */
+export default class Dispatcher {
+  callbacks: CallbackRegistry;
+  global_callbacks: Function[];
+  failThrough: Function;
+
+  constructor(failThrough?: Function) {
+    this.callbacks = new CallbackRegistry();
+    this.global_callbacks = [];
+    this.failThrough = failThrough;
+  }
+
+  bind(eventName: string, callback: Function, context?: any) {
+    this.callbacks.add(eventName, callback, context);
+    return this;
+  }
+
+  bind_global(callback: Function) {
+    this.global_callbacks.push(callback);
+    return this;
+  }
+
+  unbind(eventName?: string, callback?: Function, context?: any) {
+    this.callbacks.remove(eventName, callback, context);
+    return this;
+  }
+
+  unbind_global(callback?: Function) {
+    if (!callback) {
+      this.global_callbacks = [];
+      return this;
+    }
+
+    this.global_callbacks = Collections.filter(
+      this.global_callbacks || [],
+      (c) => c !== callback,
+    );
+
+    return this;
+  }
+
+  unbind_all() {
+    this.unbind();
+    this.unbind_global();
+    return this;
+  }
+
+  emit(eventName: string, data?: any, metadata?: Metadata): Dispatcher {
+    for (var i = 0; i < this.global_callbacks.length; i++) {
+      this.global_callbacks[i](eventName, data);
+    }
+
+    var callbacks = this.callbacks.get(eventName);
+    var args = [];
+
+    if (metadata) {
+      // if there's a metadata argument, we need to call the callback with both
+      // data and metadata regardless of whether data is undefined
+      args.push(data, metadata);
+    } else if (data) {
+      // metadata is undefined, so we only need to call the callback with data
+      // if data exists
+      args.push(data);
+    }
+
+    if (callbacks && callbacks.length > 0) {
+      for (var i = 0; i < callbacks.length; i++) {
+        callbacks[i].fn.apply(callbacks[i].context || global, args);
+      }
+    } else if (this.failThrough) {
+      this.failThrough(eventName, data);
+    }
+
+    return this;
+  }
+}

package/src/core/http/ajax.ts

@@ -0,0 +1,24 @@
+interface Ajax {
+  open(
+    method: string,
+    url: string,
+    async?: boolean,
+    user?: string,
+    password?: string,
+  ): void;
+  send(payload?: any): void;
+  setRequestHeader(key: string, value: string): void;
+  onreadystatechange: Function;
+  readyState: number;
+  responseText: string;
+  status: number;
+  withCredentials?: boolean;
+
+  ontimeout: Function;
+  onerror: Function;
+  onprogress: Function;
+  onload: Function;
+  abort: Function;
+}
+
+export default Ajax;

package/src/core/http/http_factory.ts

@@ -0,0 +1,16 @@
+import HTTPSocket from './http_socket';
+import SocketHooks from './socket_hooks';
+import HTTPRequest from './http_request';
+import RequestHooks from './request_hooks';
+import Ajax from './ajax';
+
+interface HTTPFactory {
+  createStreamingSocket(url: string): HTTPSocket;
+  createPollingSocket(url: string): HTTPSocket;
+  createSocket(hooks: SocketHooks, url: string): HTTPSocket;
+  createXHR(method: string, url: string): HTTPRequest;
+  createXDR?(method: string, url: string): HTTPRequest;
+  createRequest(hooks: RequestHooks, method: string, url: string): HTTPRequest;
+}
+
+export default HTTPFactory;

package/src/core/http/http_polling_socket.ts

@@ -0,0 +1,24 @@
+import SocketHooks from './socket_hooks';
+import URLLocation from './url_location';
+import HTTPSocket from './http_socket';
+
+var hooks: SocketHooks = {
+  getReceiveURL: function (url: URLLocation, session: string): string {
+    return url.base + '/' + session + '/xhr' + url.queryString;
+  },
+  onHeartbeat: function () {
+    // next HTTP request will reset server's activity timer
+  },
+  sendHeartbeat: function (socket) {
+    socket.sendRaw('[]');
+  },
+  onFinished: function (socket, status) {
+    if (status === 200) {
+      socket.reconnect();
+    } else {
+      socket.onClose(1006, 'Connection interrupted (' + status + ')', false);
+    }
+  },
+};
+
+export default hooks;

package/src/core/http/http_request.ts

@@ -0,0 +1,81 @@
+import Runtime from 'runtime';
+import RequestHooks from './request_hooks';
+import Ajax from './ajax';
+import { default as EventsDispatcher } from '../events/dispatcher';
+
+const MAX_BUFFER_LENGTH = 256 * 1024;
+
+export default class HTTPRequest extends EventsDispatcher {
+  hooks: RequestHooks;
+  method: string;
+  url: string;
+  position: number;
+  xhr: Ajax;
+  unloader: Function;
+
+  constructor(hooks: RequestHooks, method: string, url: string) {
+    super();
+    this.hooks = hooks;
+    this.method = method;
+    this.url = url;
+  }
+
+  start(payload?: any) {
+    this.position = 0;
+    this.xhr = this.hooks.getRequest(this);
+
+    this.unloader = () => {
+      this.close();
+    };
+    Runtime.addUnloadListener(this.unloader);
+
+    this.xhr.open(this.method, this.url, true);
+
+    if (this.xhr.setRequestHeader) {
+      this.xhr.setRequestHeader('Content-Type', 'application/json'); // ReactNative doesn't set this header by default.
+    }
+    this.xhr.send(payload);
+  }
+
+  close() {
+    if (this.unloader) {
+      Runtime.removeUnloadListener(this.unloader);
+      this.unloader = null;
+    }
+    if (this.xhr) {
+      this.hooks.abortRequest(this.xhr);
+      this.xhr = null;
+    }
+  }
+
+  onChunk(status: number, data: any) {
+    while (true) {
+      var chunk = this.advanceBuffer(data);
+      if (chunk) {
+        this.emit('chunk', { status: status, data: chunk });
+      } else {
+        break;
+      }
+    }
+    if (this.isBufferTooLong(data)) {
+      this.emit('buffer_too_long');
+    }
+  }
+
+  private advanceBuffer(buffer: any[]): any {
+    var unreadData = buffer.slice(this.position);
+    var endOfLinePosition = unreadData.indexOf('\n');
+
+    if (endOfLinePosition !== -1) {
+      this.position += endOfLinePosition + 1;
+      return unreadData.slice(0, endOfLinePosition);
+    } else {
+      // chunk is not finished yet, don't move the buffer pointer
+      return null;
+    }
+  }
+
+  private isBufferTooLong(buffer: any): boolean {
+    return this.position === buffer.length && buffer.length > MAX_BUFFER_LENGTH;
+  }
+}

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,66 @@
+import { stringify } from './utils/collections';
+
+// Logger configuration - can be set by Pusher class
+export interface LoggerConfig {
+  log?: (message: string) => void;
+  logToConsole?: boolean;
+}
+
+let config: LoggerConfig = {
+  logToConsole: false,
+};
+
+export function setLoggerConfig(newConfig: LoggerConfig) {
+  config = { ...config, ...newConfig };
+}
+
+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 (config.log) {
+      config.log(message);
+    } else if (config.logToConsole) {
+      const log = defaultLoggingFunction.bind(this);
+      log(message);
+    }
+  }
+}
+
+export default new Logger();

package/src/core/options.ts

@@ -0,0 +1,61 @@
+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';
+import { DeltaOptions } from './delta/types';
+
+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;
+  deltaCompression?: DeltaOptions;
+  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 Pusher from './pusher';
+import { Options, validateOptions } from './options';
+import * as nacl from 'tweetnacl';
+
+export default class PusherWithEncryption extends Pusher {
+  constructor(app_key: string, options: Options) {
+    Pusher.logToConsole = PusherWithEncryption.logToConsole;
+    Pusher.log = PusherWithEncryption.log;
+
+    validateOptions(options);
+    options.nacl = nacl;
+    super(app_key, options);
+  }
+}

package/src/core/pusher.js

@@ -0,0 +1,10 @@
+// required so we don't have to do require('pusher').default etc.
+const Pusher = require('./pusher').default;
+
+// Re-export Filter utilities for easy access
+Pusher.Filter = require('./pusher').Filter;
+Pusher.FilterNode = require('./pusher').FilterNode;
+Pusher.validateFilter = require('./pusher').validateFilter;
+Pusher.FilterExamples = require('./pusher').FilterExamples;
+
+module.exports = Pusher;