pingerchips-js 1.0.0-a

package/src/runtimes/web/transports/transports.ts

@@ -0,0 +1,65 @@
+import {
+  default as Transports,
+  streamingConfiguration,
+  pollingConfiguration
+} from 'isomorphic/transports/transports';
+import Transport from 'core/transports/transport';
+import TransportHooks from 'core/transports/transport_hooks';
+import * as URLSchemes from 'core/transports/url_schemes';
+import Runtime from 'runtime';
+import { Dependencies } from '../dom/dependencies';
+import * as Collections from 'core/utils/collections';
+
+var SockJSTransport = new Transport(<TransportHooks>{
+  file: 'sockjs',
+  urls: URLSchemes.sockjs,
+  handlesActivityChecks: true,
+  supportsPing: false,
+
+  isSupported: function() {
+    return true;
+  },
+  isInitialized: function() {
+    return window.SockJS !== undefined;
+  },
+  getSocket: function(url, options) {
+    return new window.SockJS(url, null, {
+      js_path: Dependencies.getPath('sockjs', {
+        useTLS: options.useTLS
+      }),
+      ignore_null_origin: options.ignoreNullOrigin
+    });
+  },
+  beforeOpen: function(socket, path) {
+    socket.send(
+      JSON.stringify({
+        path: path
+      })
+    );
+  }
+});
+
+var xdrConfiguration = {
+  isSupported: function(environment): boolean {
+    var yes = Runtime.isXDRSupported(environment.useTLS);
+    return yes;
+  }
+};
+
+/** HTTP streaming transport using XDomainRequest (IE 8,9). */
+var XDRStreamingTransport = new Transport(
+  <TransportHooks>(
+    Collections.extend({}, streamingConfiguration, xdrConfiguration)
+  )
+);
+
+/** HTTP long-polling transport using XDomainRequest (IE 8,9). */
+var XDRPollingTransport = new Transport(
+  <TransportHooks>Collections.extend({}, pollingConfiguration, xdrConfiguration)
+);
+
+Transports.xdr_streaming = XDRStreamingTransport;
+Transports.xdr_polling = XDRPollingTransport;
+Transports.sockjs = SockJSTransport;
+
+export default Transports;

package/src/runtimes/worker/auth/fetch_auth.ts

@@ -0,0 +1,69 @@
+import AbstractRuntime from 'runtimes/interface';
+import { AuthTransport } from 'core/auth/auth_transports';
+import {
+  AuthRequestType,
+  AuthTransportCallback,
+  InternalAuthOptions
+} from 'core/auth/options';
+import { HTTPAuthError } from 'core/errors';
+
+var fetchAuth: AuthTransport = function(
+  context: AbstractRuntime,
+  query: string,
+  authOptions: InternalAuthOptions,
+  authRequestType: AuthRequestType,
+  callback: AuthTransportCallback
+) {
+  var headers = new Headers();
+  headers.set('Content-Type', 'application/x-www-form-urlencoded');
+
+  for (var headerName in authOptions.headers) {
+    headers.set(headerName, authOptions.headers[headerName]);
+  }
+
+  if (authOptions.headersProvider != null) {
+    const dynamicHeaders = authOptions.headersProvider();
+    for (var headerName in dynamicHeaders) {
+      headers.set(headerName, dynamicHeaders[headerName]);
+    }
+  }
+
+  var body = query;
+  var request = new Request(authOptions.endpoint, {
+    headers,
+    body,
+    credentials: 'same-origin',
+    method: 'POST'
+  });
+
+  return fetch(request)
+    .then(response => {
+      let { status } = response;
+      if (status === 200) {
+        // manually parse the json so we can provide a more helpful error in
+        // failure case
+        return response.text();
+      }
+      throw new HTTPAuthError(
+        status,
+        `Could not get ${authRequestType.toString()} info from your auth endpoint, status: ${status}`
+      );
+    })
+    .then(data => {
+      let parsedData;
+      try {
+        parsedData = JSON.parse(data);
+      } catch (e) {
+        throw new HTTPAuthError(
+          200,
+          `JSON returned from ${authRequestType.toString()} endpoint was invalid, yet status code was 200. Data was: ${data}`
+        );
+      }
+      callback(null, parsedData);
+    })
+    .catch(err => {
+      callback(err, null);
+    });
+};
+
+export default fetchAuth;

package/src/runtimes/worker/net_info.ts

@@ -0,0 +1,10 @@
+import { default as EventsDispatcher } from 'core/events/dispatcher';
+import Reachability from 'core/reachability';
+
+export class NetInfo extends EventsDispatcher implements Reachability {
+  isOnline(): boolean {
+    return true;
+  }
+}
+
+export var Network = new NetInfo();

package/src/runtimes/worker/runtime.ts

@@ -0,0 +1,75 @@
+import Isomorphic from 'isomorphic/runtime';
+import Runtime from '../interface';
+import { Network } from './net_info';
+import fetchAuth from './auth/fetch_auth';
+import { AuthTransports } from 'core/auth/auth_transports';
+import fetchTimeline from './timeline/fetch_timeline';
+
+// Very verbose but until unavoidable until
+// TypeScript 2.1, when spread attributes will be
+// supported
+const {
+  getDefaultStrategy,
+  Transports,
+  setup,
+  getProtocol,
+  isXHRSupported,
+  getLocalStorage,
+  createXHR,
+  createWebSocket,
+  addUnloadListener,
+  removeUnloadListener,
+  transportConnectionInitializer,
+  createSocketRequest,
+  HTTPFactory
+} = Isomorphic;
+
+const Worker: Runtime = {
+  getDefaultStrategy,
+  Transports,
+  setup,
+  getProtocol,
+  isXHRSupported,
+  getLocalStorage,
+  createXHR,
+  createWebSocket,
+  addUnloadListener,
+  removeUnloadListener,
+  transportConnectionInitializer,
+  createSocketRequest,
+  HTTPFactory,
+
+  TimelineTransport: fetchTimeline,
+
+  getAuthorizers(): AuthTransports {
+    return { ajax: fetchAuth };
+  },
+
+  getWebSocketAPI() {
+    return WebSocket;
+  },
+
+  getXHRAPI() {
+    return XMLHttpRequest;
+  },
+
+  getNetwork() {
+    return Network;
+  },
+
+  randomInt(max: number): number {
+    /**
+     * Return values in the range of [0, 1[
+     */
+    const random = function() {
+      const crypto = globalThis.crypto || globalThis['msCrypto'];
+      const random = crypto.getRandomValues(new Uint32Array(1))[0];
+
+      return random / 2 ** 32;
+    };
+
+    return Math.floor(random() * max);
+  }
+};
+
+export default Worker;

package/src/runtimes/worker/timeline/fetch_timeline.ts

@@ -0,0 +1,39 @@
+import Logger from 'core/logger';
+import TimelineSender from 'core/timeline/timeline_sender';
+import * as Collections from 'core/utils/collections';
+import Util from 'core/util';
+import Runtime from 'runtime';
+import TimelineTransport from 'core/timeline/timeline_transport';
+
+var getAgent = function(sender: TimelineSender, useTLS: boolean) {
+  return function(data: any, callback: Function) {
+    var scheme = 'http' + (useTLS ? 's' : '') + '://';
+    var url =
+      scheme + (sender.host || sender.options.host) + sender.options.path;
+    var query = Collections.buildQueryString(data);
+    url += '/' + 2 + '?' + query;
+
+    fetch(url)
+      .then(response => {
+        if (response.status !== 200) {
+          throw `received ${response.status} from stats.pusher.com`;
+        }
+        return response.json();
+      })
+      .then(({ host }) => {
+        if (host) {
+          sender.host = host;
+        }
+      })
+      .catch(err => {
+        Logger.debug('TimelineSender Error: ', err);
+      });
+  };
+};
+
+var fetchTimeline = {
+  name: 'xhr',
+  getAgent
+};
+
+export default fetchTimeline;

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "sourceMap": true,
+    "module": "es6",
+    "declaration": true,
+    "declarationDir": "types",
+    "target": "ES6",
+    "removeComments": true,
+    "moduleResolution": "node",
+    "baseUrl": "src",
+    "paths": {
+      "*": [
+        "*",
+        "runtimes/*"
+      ]
+    },
+    "lib": [
+      "ScriptHost",
+      "DOM",
+      "ES5"
+    ]
+  },
+  "exclude": [
+    "node_modules"
+  ]
+}

package/types/spec/javascripts/helpers/node/mock-dom-dependencies.d.ts

@@ -0,0 +1 @@
+export declare var Dependencies: {};

package/types/spec/javascripts/helpers/pusher_integration_class.d.ts

@@ -0,0 +1,4 @@
+import Pingerchips from '../../../src/core/pusher';
+export default class PusherIntegration extends Pingerchips {
+    static Integration: any;
+}

package/types/src/core/auth/auth_transports.d.ts

@@ -0,0 +1,9 @@
+import AbstractRuntime from '../../runtimes/interface';
+import { AuthRequestType, InternalAuthOptions } from './options';
+interface AuthTransport {
+    (context: AbstractRuntime, query: string, authOptions: InternalAuthOptions, authRequestType: AuthRequestType, callback: Function): void;
+}
+interface AuthTransports {
+    [index: string]: AuthTransport;
+}
+export { AuthTransport, AuthTransports };

package/types/src/core/auth/channel_authorizer.d.ts

@@ -0,0 +1,3 @@
+import { InternalAuthOptions, ChannelAuthorizationHandler } from './options';
+declare const ChannelAuthorizer: (authOptions: InternalAuthOptions) => ChannelAuthorizationHandler;
+export default ChannelAuthorizer;

package/types/src/core/auth/deprecated_channel_authorizer.d.ts

@@ -0,0 +1,18 @@
+import Channel from '../channels/channel';
+import { ChannelAuthorizationCallback, ChannelAuthorizationHandler, InternalAuthOptions } from './options';
+export interface DeprecatedChannelAuthorizer {
+    authorize(socketId: string, callback: ChannelAuthorizationCallback): void;
+}
+export interface ChannelAuthorizerGenerator {
+    (channel: Channel, options: DeprecatedAuthorizerOptions): DeprecatedChannelAuthorizer;
+}
+export interface DeprecatedAuthOptions {
+    params?: any;
+    headers?: any;
+}
+export interface DeprecatedAuthorizerOptions {
+    authTransport: 'ajax' | 'jsonp';
+    authEndpoint: string;
+    auth?: DeprecatedAuthOptions;
+}
+export declare const ChannelAuthorizerProxy: (pusher: any, authOptions: InternalAuthOptions, channelAuthorizerGenerator: ChannelAuthorizerGenerator) => ChannelAuthorizationHandler;

package/types/src/core/auth/options.d.ts

@@ -0,0 +1,48 @@
+export declare enum AuthRequestType {
+    UserAuthentication = "user-authentication",
+    ChannelAuthorization = "channel-authorization"
+}
+export interface ChannelAuthorizationData {
+    auth: string;
+    channel_data?: string;
+    shared_secret?: string;
+}
+export type ChannelAuthorizationCallback = (error: Error | null, authData: ChannelAuthorizationData | null) => void;
+export interface ChannelAuthorizationRequestParams {
+    socketId: string;
+    channelName: string;
+}
+export interface ChannelAuthorizationHandler {
+    (params: ChannelAuthorizationRequestParams, callback: ChannelAuthorizationCallback): void;
+}
+export interface UserAuthenticationData {
+    auth: string;
+    user_data: string;
+}
+export type UserAuthenticationCallback = (error: Error | null, authData: UserAuthenticationData | null) => void;
+export interface UserAuthenticationRequestParams {
+    socketId: string;
+}
+export interface UserAuthenticationHandler {
+    (params: UserAuthenticationRequestParams, callback: UserAuthenticationCallback): void;
+}
+export type AuthTransportCallback = ChannelAuthorizationCallback | UserAuthenticationCallback;
+export interface AuthOptionsT<AuthHandler> {
+    transport: 'ajax' | 'jsonp';
+    endpoint: string;
+    params?: any;
+    headers?: any;
+    paramsProvider?: () => any;
+    headersProvider?: () => any;
+    customHandler?: AuthHandler;
+}
+export declare type UserAuthenticationOptions = AuthOptionsT<UserAuthenticationHandler>;
+export declare type ChannelAuthorizationOptions = AuthOptionsT<ChannelAuthorizationHandler>;
+export interface InternalAuthOptions {
+    transport: 'ajax' | 'jsonp';
+    endpoint: string;
+    params?: any;
+    headers?: any;
+    paramsProvider?: () => any;
+    headersProvider?: () => any;
+}

package/types/src/core/auth/user_authenticator.d.ts

@@ -0,0 +1,3 @@
+import { InternalAuthOptions, UserAuthenticationHandler } from './options';
+declare const UserAuthenticator: (authOptions: InternalAuthOptions) => UserAuthenticationHandler;
+export default UserAuthenticator;

package/types/src/core/base64.d.ts

@@ -0,0 +1 @@
+export default function encode(s: any): string;

package/types/src/core/channels/channel.d.ts

@@ -0,0 +1,23 @@
+import { ChannelAuthorizationCallback } from '../auth/options';
+import { PusherEvent } from '../connection/protocol/message-types';
+import { default as EventsDispatcher } from '../events/dispatcher';
+import Pingerchips from '../pusher';
+export default class Channel extends EventsDispatcher {
+    name: string;
+    pusher: Pingerchips;
+    subscribed: boolean;
+    subscriptionPending: boolean;
+    subscriptionCancelled: boolean;
+    subscriptionCount: null;
+    constructor(name: string, pusher: Pingerchips);
+    authorize(socketId: string, callback: ChannelAuthorizationCallback): void;
+    trigger(event: string, data: any): boolean;
+    disconnect(): void;
+    handleEvent(event: PusherEvent): void;
+    handleSubscriptionSucceededEvent(event: PusherEvent): void;
+    handleSubscriptionCountEvent(event: PusherEvent): void;
+    subscribe(): void;
+    unsubscribe(): void;
+    cancelSubscription(): void;
+    reinstateSubscription(): void;
+}

package/types/src/core/channels/channel_table.d.ts

@@ -0,0 +1,5 @@
+import Channel from './channel';
+interface ChannelTable {
+    [index: string]: Channel;
+}
+export default ChannelTable;

package/types/src/core/channels/channels.d.ts

@@ -0,0 +1,12 @@
+import Pingerchips from '../pusher';
+import Channel from './channel';
+import ChannelTable from './channel_table';
+export default class Channels {
+    channels: ChannelTable;
+    constructor();
+    add(name: string, pusher: Pingerchips): Channel;
+    all(): Channel[];
+    find(name: string): Channel;
+    remove(name: string): Channel;
+    disconnect(): void;
+}

package/types/src/core/channels/encrypted_channel.d.ts

@@ -0,0 +1,15 @@
+import * as nacl from 'tweetnacl';
+import { ChannelAuthorizationCallback } from '../auth/options';
+import { PusherEvent } from '../connection/protocol/message-types';
+import Pingerchips from '../pusher';
+import PrivateChannel from './private_channel';
+export default class EncryptedChannel extends PrivateChannel {
+    key: Uint8Array;
+    nacl: nacl;
+    constructor(name: string, pusher: Pingerchips, nacl: nacl);
+    authorize(socketId: string, callback: ChannelAuthorizationCallback): void;
+    trigger(event: string, data: any): boolean;
+    handleEvent(event: PusherEvent): void;
+    private handleEncryptedEvent;
+    getDataToEmit(bytes: Uint8Array): string;
+}

package/types/src/core/channels/members.d.ts

@@ -0,0 +1,14 @@
+export default class Members {
+    members: any;
+    count: number;
+    myID: any;
+    me: any;
+    constructor();
+    get(id: string): any;
+    each(callback: Function): void;
+    setMyID(id: string): void;
+    onSubscription(subscriptionData: any): void;
+    addMember(memberData: any): any;
+    removeMember(memberData: any): any;
+    reset(): void;
+}

package/types/src/core/channels/metadata.d.ts

@@ -0,0 +1,4 @@
+interface Metadata {
+    user_id?: string;
+}
+export default Metadata;

package/types/src/core/channels/presence_channel.d.ts

@@ -0,0 +1,13 @@
+import { PusherEvent } from '../connection/protocol/message-types';
+import Pingerchips from '../pusher';
+import Members from './members';
+import PrivateChannel from './private_channel';
+export default class PresenceChannel extends PrivateChannel {
+    members: Members;
+    constructor(name: string, pusher: Pingerchips);
+    authorize(socketId: string, callback: Function): void;
+    handleEvent(event: PusherEvent): void;
+    handleInternalEvent(event: PusherEvent): void;
+    handleSubscriptionSucceededEvent(event: PusherEvent): void;
+    disconnect(): void;
+}

package/types/src/core/channels/private_channel.d.ts

@@ -0,0 +1,5 @@
+import Channel from './channel';
+import { ChannelAuthorizationCallback } from '../auth/options';
+export default class PrivateChannel extends Channel {
+    authorize(socketId: string, callback: ChannelAuthorizationCallback): void;
+}

package/types/src/core/config.d.ts

@@ -0,0 +1,31 @@
+import { Options } from './options';
+import { ChannelAuthorizationHandler, UserAuthenticationHandler } from './auth/options';
+import * as nacl from 'tweetnacl';
+export type AuthTransport = 'ajax' | 'jsonp';
+export type Transport = 'ws' | 'wss' | 'xhr_streaming' | 'xhr_polling' | 'sockjs';
+export interface Config {
+    activityTimeout: number;
+    enableStats: boolean;
+    httpHost: string;
+    httpPath: string;
+    httpPort: number;
+    httpsPort: number;
+    pongTimeout: number;
+    statsHost: string;
+    unavailableTimeout: number;
+    useTLS: boolean;
+    wsHost: string;
+    wsPath: string;
+    wsPort: number;
+    wssPort: number;
+    userAuthenticator: UserAuthenticationHandler;
+    channelAuthorizer: ChannelAuthorizationHandler;
+    forceTLS?: boolean;
+    cluster?: string;
+    disabledTransports?: Transport[];
+    enabledTransports?: Transport[];
+    ignoreNullOrigin?: boolean;
+    nacl?: nacl;
+    timelineParams?: any;
+}
+export declare function getConfig(opts: Options, pusher: any): Config;

package/types/src/core/connection/callbacks.d.ts

@@ -0,0 +1,18 @@
+import HandshakePayload from './handshake/handshake_payload';
+import Action from './protocol/action';
+export interface ErrorCallbacks {
+    tls_only: (result: Action | HandshakePayload) => void;
+    refused: (result: Action | HandshakePayload) => void;
+    backoff: (result: Action | HandshakePayload) => void;
+    retry: (result: Action | HandshakePayload) => void;
+}
+export interface HandshakeCallbacks {
+    connected: (handshake: HandshakePayload) => void;
+}
+export interface ConnectionCallbacks {
+    message: (message: any) => void;
+    ping: () => void;
+    activity: () => void;
+    error: (error: any) => void;
+    closed: () => void;
+}

package/types/src/core/connection/connection.d.ts

@@ -0,0 +1,16 @@
+import { default as EventsDispatcher } from '../events/dispatcher';
+import TransportConnection from '../transports/transport_connection';
+import Socket from '../socket';
+export default class Connection extends EventsDispatcher implements Socket {
+    id: string;
+    transport: TransportConnection;
+    activityTimeout: number;
+    constructor(id: string, transport: TransportConnection);
+    handlesActivityChecks(): boolean;
+    send(data: any): boolean;
+    send_event(name: string, data: any, channel?: string): boolean;
+    ping(): void;
+    close(): void;
+    private bindListeners;
+    private handleCloseEvent;
+}

package/types/src/core/connection/connection_manager.d.ts

@@ -0,0 +1,50 @@
+import { default as EventsDispatcher } from '../events/dispatcher';
+import { OneOffTimer as Timer } from '../utils/timers';
+import Connection from './connection';
+import Strategy from '../strategies/strategy';
+import StrategyRunner from '../strategies/strategy_runner';
+import Timeline from '../timeline/timeline';
+import ConnectionManagerOptions from './connection_manager_options';
+import { ErrorCallbacks, HandshakeCallbacks, ConnectionCallbacks } from './callbacks';
+export default class ConnectionManager extends EventsDispatcher {
+    key: string;
+    options: ConnectionManagerOptions;
+    state: string;
+    connection: Connection;
+    usingTLS: boolean;
+    timeline: Timeline;
+    socket_id: string;
+    unavailableTimer: Timer;
+    activityTimer: Timer;
+    retryTimer: Timer;
+    activityTimeout: number;
+    strategy: Strategy;
+    runner: StrategyRunner;
+    errorCallbacks: ErrorCallbacks;
+    handshakeCallbacks: HandshakeCallbacks;
+    connectionCallbacks: ConnectionCallbacks;
+    constructor(key: string, options: ConnectionManagerOptions);
+    connect(): void;
+    send(data: any): boolean;
+    send_event(name: string, data: any, channel?: string): boolean;
+    disconnect(): void;
+    isUsingTLS(): boolean;
+    private startConnecting;
+    private abortConnecting;
+    private disconnectInternally;
+    private updateStrategy;
+    private retryIn;
+    private clearRetryTimer;
+    private setUnavailableTimer;
+    private clearUnavailableTimer;
+    private sendActivityCheck;
+    private resetActivityCheck;
+    private stopActivityCheck;
+    private buildConnectionCallbacks;
+    private buildHandshakeCallbacks;
+    private buildErrorCallbacks;
+    private setConnection;
+    private abandonConnection;
+    private updateState;
+    private shouldRetry;
+}

package/types/src/core/connection/connection_manager_options.d.ts

@@ -0,0 +1,11 @@
+import Timeline from '../timeline/timeline';
+import Strategy from '../strategies/strategy';
+interface ConnectionManagerOptions {
+    timeline: Timeline;
+    getStrategy: (StrategyOptions: any) => Strategy;
+    unavailableTimeout: number;
+    pongTimeout: number;
+    activityTimeout: number;
+    useTLS: boolean;
+}
+export default ConnectionManagerOptions;

package/types/src/core/connection/handshake/handshake_payload.d.ts

@@ -0,0 +1,8 @@
+import TransportConnection from '../../transports/transport_connection';
+import Action from '../protocol/action';
+import Connection from '../connection';
+interface HandshakePayload extends Action {
+    transport: TransportConnection;
+    connection?: Connection;
+}
+export default HandshakePayload;

package/types/src/core/connection/handshake/index.d.ts

@@ -0,0 +1,12 @@
+import TransportConnection from '../../transports/transport_connection';
+export default class Handshake {
+    transport: TransportConnection;
+    callback: (HandshakePayload: any) => void;
+    onMessage: Function;
+    onClosed: Function;
+    constructor(transport: TransportConnection, callback: (HandshakePayload: any) => void);
+    close(): void;
+    private bindListeners;
+    private unbindListeners;
+    private finish;
+}

package/types/src/core/connection/protocol/action.d.ts

@@ -0,0 +1,7 @@
+interface Action {
+    action: string;
+    id?: string;
+    activityTimeout?: number;
+    error?: any;
+}
+export default Action;

package/types/src/core/connection/protocol/message-types.d.ts

@@ -0,0 +1,7 @@
+interface PusherEvent {
+    event: string;
+    channel?: string;
+    data?: any;
+    user_id?: string;
+}
+export { PusherEvent };