@cendarsoss/pusher-js 8.4.11

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 Logger from './logger';
+import Pusher from './pusher';
+import EventsDispatcher from './events/dispatcher';
+
+export default class WatchlistFacade extends EventsDispatcher {
+  private pusher: Pusher;
+
+  public constructor(pusher: Pusher) {
+    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;
+}

package/src/filter.ts

@@ -0,0 +1,5 @@
+// Separate entry point for Filter exports
+// This allows clean imports: import { Filter } from 'pusher-js/filter'
+
+export { Filter, FilterExamples, validateFilter } from './core/channels/filter';
+export type { FilterNode } from './core/channels/filter';

package/src/index.ts

@@ -0,0 +1,8 @@
+// Main entry point for pusher-js
+// Only exports the Pusher class as default
+// For Filter imports, use: import { Filter } from 'pusher-js/filter'
+
+import PusherClass from './core/pusher.ts';
+
+// Export Pusher as default only
+export default PusherClass;

package/src/runtimes/interface.ts

@@ -0,0 +1,60 @@
+import { AuthTransports } from '../core/auth/auth_transports';
+import TimelineSender from '../core/timeline/timeline_sender';
+import TimelineTransport from '../core/timeline/timeline_transport';
+import Ajax from '../core/http/ajax';
+import Reachability from '../core/reachability';
+import TransportsTable from '../core/transports/transports_table';
+import Socket from '../core/socket';
+import HTTPFactory from '../core/http/http_factory';
+import HTTPRequest from '../core/http/http_request';
+import Pusher from '../core/pusher';
+import JSONPRequest from './web/dom/jsonp_request';
+import Strategy from '../core/strategies/strategy';
+import { Config } from '../core/config';
+import StrategyOptions from '../core/strategies/strategy_options';
+
+/*
+This interface is implemented in web/runtime, node/runtime, react-native/runtime
+and worker/runtime. Its job is to be the only point of contact to platform-specific
+code for the core library. When the core library imports "runtime", Webpack will
+look for src/runtimes/<platform>/runtime.ts. This is how PusherJS keeps
+core and platform-specific code separate.
+*/
+interface Runtime {
+  setup(PusherClass: {
+    new (key: string, options: any): Pusher;
+    ready(): void;
+  }): void;
+  getProtocol(): string;
+  getAuthorizers(): AuthTransports;
+  getLocalStorage(): any;
+  TimelineTransport: TimelineTransport;
+  createXHR(): Ajax;
+  createWebSocket(url: string): Socket;
+  getNetwork(): Reachability;
+  getDefaultStrategy(
+    config: Config,
+    options: StrategyOptions,
+    defineTransport: Function,
+  ): Strategy;
+  Transports: TransportsTable;
+  getWebSocketAPI(): new (url: string) => Socket;
+  getXHRAPI(): new () => Ajax;
+  addUnloadListener(listener: Function): void;
+  removeUnloadListener(listener: Function): void;
+  transportConnectionInitializer: Function;
+  HTTPFactory: HTTPFactory;
+  isXHRSupported(): boolean;
+  createSocketRequest(method: string, url: string): HTTPRequest;
+  randomInt(max: number): number;
+
+  // these methods/types are only implemented in the web Runtime, so they're
+  // optional but must be included in the interface
+  getDocument?(): Document;
+  createScriptRequest?(url: string): any;
+  createJSONPRequest?(url: string, data: any): JSONPRequest;
+  ScriptReceivers?: any;
+  isXDRSupported?(useTLS?: boolean): boolean;
+}
+
+export default Runtime;

package/src/runtimes/isomorphic/auth/xhr_auth.ts

@@ -0,0 +1,90 @@
+import TimelineSender from 'core/timeline/timeline_sender';
+import * as Collections from 'core/utils/collections';
+import Util from 'core/util';
+import Runtime from 'runtime';
+import { AuthTransport } from 'core/auth/auth_transports';
+import AbstractRuntime from 'runtimes/interface';
+import UrlStore from 'core/utils/url_store';
+import {
+  AuthRequestType,
+  AuthTransportCallback,
+  InternalAuthOptions,
+} from 'core/auth/options';
+import { HTTPAuthError } from 'core/errors';
+
+const ajax: AuthTransport = function (
+  context: AbstractRuntime,
+  query: string,
+  authOptions: InternalAuthOptions,
+  authRequestType: AuthRequestType,
+  callback: AuthTransportCallback,
+) {
+  const xhr = Runtime.createXHR();
+  xhr.open('POST', authOptions.endpoint, true);
+
+  // add request headers
+  xhr.setRequestHeader('Content-Type', 'application/x-www-form-urlencoded');
+  for (var headerName in authOptions.headers) {
+    xhr.setRequestHeader(headerName, authOptions.headers[headerName]);
+  }
+  if (authOptions.headersProvider != null) {
+    let dynamicHeaders = authOptions.headersProvider();
+    for (var headerName in dynamicHeaders) {
+      xhr.setRequestHeader(headerName, dynamicHeaders[headerName]);
+    }
+  }
+
+  xhr.onreadystatechange = function () {
+    if (xhr.readyState === 4) {
+      if (xhr.status === 200) {
+        let data;
+        let parsed = false;
+
+        try {
+          data = JSON.parse(xhr.responseText);
+          parsed = true;
+        } catch (e) {
+          callback(
+            new HTTPAuthError(
+              200,
+              `JSON returned from ${authRequestType.toString()} endpoint was invalid, yet status code was 200. Data was: ${
+                xhr.responseText
+              }`,
+            ),
+            null,
+          );
+        }
+
+        if (parsed) {
+          // prevents double execution.
+          callback(null, data);
+        }
+      } else {
+        let suffix = '';
+        switch (authRequestType) {
+          case AuthRequestType.UserAuthentication:
+            suffix = UrlStore.buildLogSuffix('authenticationEndpoint');
+            break;
+          case AuthRequestType.ChannelAuthorization:
+            suffix = `Clients must be authorized to join private or presence channels. ${UrlStore.buildLogSuffix(
+              'authorizationEndpoint',
+            )}`;
+            break;
+        }
+        callback(
+          new HTTPAuthError(
+            xhr.status,
+            `Unable to retrieve auth string from ${authRequestType.toString()} endpoint - ` +
+              `received status: ${xhr.status} from ${authOptions.endpoint}. ${suffix}`,
+          ),
+          null,
+        );
+      }
+    }
+  };
+
+  xhr.send(query);
+  return xhr;
+};
+
+export default ajax;

package/src/runtimes/isomorphic/default_strategy.ts

@@ -0,0 +1,155 @@
+import * as Collections from 'core/utils/collections';
+import TransportManager from 'core/transports/transport_manager';
+import Strategy from 'core/strategies/strategy';
+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';
+import StrategyOptions from 'core/strategies/strategy_options';
+
+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 = Collections.extend({}, ws_options, {
+    useTLS: true,
+  });
+  var http_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 xhr_streaming_transport = defineTransportStrategy(
+    'xhr_streaming',
+    'xhr_streaming',
+    1,
+    http_options,
+    streaming_manager,
+  );
+  var xhr_polling_transport = defineTransportStrategy(
+    'xhr_polling',
+    'xhr_polling',
+    1,
+    http_options,
+  );
+
+  var ws_loop = new SequentialStrategy([ws_transport], timeouts);
+  var wss_loop = new SequentialStrategy([wss_transport], timeouts);
+  var streaming_loop = new SequentialStrategy(
+    [xhr_streaming_transport],
+    timeouts,
+  );
+  var polling_loop = new SequentialStrategy([xhr_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 wsStrategy;
+  if (baseOptions.useTLS) {
+    wsStrategy = new BestConnectedEverStrategy([
+      ws_loop,
+      new DelayedStrategy(http_loop, { delay: 2000 }),
+    ]);
+  } else {
+    wsStrategy = new BestConnectedEverStrategy([
+      ws_loop,
+      new DelayedStrategy(wss_loop, { delay: 2000 }),
+      new DelayedStrategy(http_loop, { delay: 5000 }),
+    ]);
+  }
+
+  return new WebSocketPrioritizedCachedStrategy(
+    new FirstConnectedStrategy(
+      new IfStrategy(testSupportsStrategy(ws_transport), wsStrategy, http_loop),
+    ),
+    definedTransports,
+    {
+      ttl: 1800000,
+      timeline: baseOptions.timeline,
+      useTLS: baseOptions.useTLS,
+    },
+  );
+};
+
+export default getDefaultStrategy;

package/src/runtimes/isomorphic/http/http.ts

@@ -0,0 +1,32 @@
+import HTTPRequest from 'core/http/http_request';
+import HTTPSocket from 'core/http/http_socket';
+import SocketHooks from 'core/http/socket_hooks';
+import RequestHooks from 'core/http/request_hooks';
+import streamingHooks from 'core/http/http_streaming_socket';
+import pollingHooks from 'core/http/http_polling_socket';
+import xhrHooks from './http_xhr_request';
+import HTTPFactory from 'core/http/http_factory';
+
+var HTTP: HTTPFactory = {
+  createStreamingSocket(url: string): HTTPSocket {
+    return this.createSocket(streamingHooks, url);
+  },
+
+  createPollingSocket(url: string): HTTPSocket {
+    return this.createSocket(pollingHooks, url);
+  },
+
+  createSocket(hooks: SocketHooks, url: string): HTTPSocket {
+    return new HTTPSocket(hooks, url);
+  },
+
+  createXHR(method: string, url: string): HTTPRequest {
+    return this.createRequest(xhrHooks, method, url);
+  },
+
+  createRequest(hooks: RequestHooks, method: string, url: string): HTTPRequest {
+    return new HTTPRequest(hooks, method, url);
+  },
+};
+
+export default HTTP;

package/src/runtimes/isomorphic/http/http_xhr_request.ts

@@ -0,0 +1,35 @@
+import HTTPRequest from 'core/http/http_request';
+import RequestHooks from 'core/http/request_hooks';
+import Ajax from 'core/http/ajax';
+import Runtime from 'runtime';
+
+var hooks: RequestHooks = {
+  getRequest: function (socket: HTTPRequest): Ajax {
+    var Constructor = Runtime.getXHRAPI();
+    var xhr = new Constructor();
+    xhr.onreadystatechange = xhr.onprogress = function () {
+      switch (xhr.readyState) {
+        case 3:
+          if (xhr.responseText && xhr.responseText.length > 0) {
+            socket.onChunk(xhr.status, xhr.responseText);
+          }
+          break;
+        case 4:
+          // this happens only on errors, never after calling close
+          if (xhr.responseText && xhr.responseText.length > 0) {
+            socket.onChunk(xhr.status, xhr.responseText);
+          }
+          socket.emit('finished', xhr.status);
+          socket.close();
+          break;
+      }
+    };
+    return xhr;
+  },
+  abortRequest: function (xhr: Ajax) {
+    xhr.onreadystatechange = null;
+    xhr.abort();
+  },
+};
+
+export default hooks;

package/src/runtimes/isomorphic/runtime.ts

@@ -0,0 +1,62 @@
+import * as Collections from 'core/utils/collections';
+import Transports from 'isomorphic/transports/transports';
+import TimelineSender from 'core/timeline/timeline_sender';
+import Ajax from 'core/http/ajax';
+import getDefaultStrategy from './default_strategy';
+import TransportsTable from 'core/transports/transports_table';
+import transportConnectionInitializer from './transports/transport_connection_initializer';
+import HTTPFactory from './http/http';
+
+var Isomorphic: any = {
+  getDefaultStrategy,
+  Transports: <TransportsTable>Transports,
+  transportConnectionInitializer,
+  HTTPFactory,
+
+  setup(PusherClass): void {
+    PusherClass.ready();
+  },
+
+  getLocalStorage(): any {
+    return undefined;
+  },
+
+  getClientFeatures(): any[] {
+    return Collections.keys(
+      Collections.filterObject({ ws: Transports.ws }, function (t) {
+        return t.isSupported({});
+      }),
+    );
+  },
+
+  getProtocol(): string {
+    return 'http:';
+  },
+
+  isXHRSupported(): boolean {
+    return true;
+  },
+
+  createSocketRequest(method: string, url: string) {
+    if (this.isXHRSupported()) {
+      return this.HTTPFactory.createXHR(method, url);
+    } else {
+      throw 'Cross-origin HTTP requests are not supported';
+    }
+  },
+
+  createXHR(): Ajax {
+    var Constructor = this.getXHRAPI();
+    return new Constructor();
+  },
+
+  createWebSocket(url: string): any {
+    var Constructor = this.getWebSocketAPI();
+    return new Constructor(url);
+  },
+
+  addUnloadListener(listener: any) {},
+  removeUnloadListener(listener: any) {},
+};
+
+export default Isomorphic;