pingerchips-js 1.0.0-a

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

@@ -0,0 +1,10 @@
+import Action from './action';
+import { PusherEvent } from './message-types';
+declare const Protocol: {
+    decodeMessage: (messageEvent: MessageEvent) => PusherEvent;
+    encodeMessage: (event: PusherEvent) => string;
+    processHandshake: (messageEvent: MessageEvent) => Action;
+    getCloseAction: (closeEvent: any) => string;
+    getCloseError: (closeEvent: any) => any;
+};
+export default Protocol;

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

@@ -0,0 +1,26 @@
+import { ChannelAuthorizationOptions, UserAuthenticationOptions } from './auth/options';
+import { AuthTransport } from './config';
+export interface DefaultConfig {
+    VERSION: string;
+    PROTOCOL: number;
+    wsPort: number;
+    wssPort: number;
+    wsPath: string;
+    httpHost: string;
+    httpPort: number;
+    httpsPort: number;
+    httpPath: string;
+    stats_host: string;
+    authEndpoint: string;
+    authTransport: AuthTransport;
+    activityTimeout: number;
+    pongTimeout: number;
+    unavailableTimeout: number;
+    userAuthentication: UserAuthenticationOptions;
+    channelAuthorization: ChannelAuthorizationOptions;
+    cdn_http?: string;
+    cdn_https?: string;
+    dependency_suffix?: string;
+}
+declare var Defaults: DefaultConfig;
+export default Defaults;

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

@@ -0,0 +1,28 @@
+export declare class BadEventName extends Error {
+    constructor(msg?: string);
+}
+export declare class BadChannelName extends Error {
+    constructor(msg?: string);
+}
+export declare class RequestTimedOut extends Error {
+    constructor(msg?: string);
+}
+export declare class TransportPriorityTooLow extends Error {
+    constructor(msg?: string);
+}
+export declare class TransportClosed extends Error {
+    constructor(msg?: string);
+}
+export declare class UnsupportedFeature extends Error {
+    constructor(msg?: string);
+}
+export declare class UnsupportedTransport extends Error {
+    constructor(msg?: string);
+}
+export declare class UnsupportedStrategy extends Error {
+    constructor(msg?: string);
+}
+export declare class HTTPAuthError extends Error {
+    status: number;
+    constructor(status: number, msg?: string);
+}

package/types/src/core/events/callback.d.ts

@@ -0,0 +1,5 @@
+interface Callback {
+    fn: Function;
+    context: any;
+}
+export default Callback;

package/types/src/core/events/callback_registry.d.ts

@@ -0,0 +1,11 @@
+import Callback from './callback';
+import CallbackTable from './callback_table';
+export default class CallbackRegistry {
+    _callbacks: CallbackTable;
+    constructor();
+    get(name: string): Callback[];
+    add(name: string, callback: Function, context: any): void;
+    remove(name?: string, callback?: Function, context?: any): void;
+    private removeCallback;
+    private removeAllCallbacks;
+}

package/types/src/core/events/callback_table.d.ts

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

package/types/src/core/events/dispatcher.d.ts

@@ -0,0 +1,14 @@
+import Metadata from '../channels/metadata';
+import CallbackRegistry from './callback_registry';
+export default class Dispatcher {
+    callbacks: CallbackRegistry;
+    global_callbacks: Function[];
+    failThrough: Function;
+    constructor(failThrough?: Function);
+    bind(eventName: string, callback: Function, context?: any): this;
+    bind_global(callback: Function): this;
+    unbind(eventName?: string, callback?: Function, context?: any): this;
+    unbind_global(callback?: Function): this;
+    unbind_all(): this;
+    emit(eventName: string, data?: any, metadata?: Metadata): Dispatcher;
+}

package/types/src/core/http/ajax.d.ts

@@ -0,0 +1,16 @@
+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/types/src/core/http/http_factory.d.ts

@@ -0,0 +1,13 @@
+import HTTPSocket from './http_socket';
+import SocketHooks from './socket_hooks';
+import HTTPRequest from './http_request';
+import RequestHooks from './request_hooks';
+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/types/src/core/http/http_polling_socket.d.ts

@@ -0,0 +1,3 @@
+import SocketHooks from './socket_hooks';
+declare var hooks: SocketHooks;
+export default hooks;

package/types/src/core/http/http_request.d.ts

@@ -0,0 +1,17 @@
+import RequestHooks from './request_hooks';
+import Ajax from './ajax';
+import { default as EventsDispatcher } from '../events/dispatcher';
+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);
+    start(payload?: any): void;
+    close(): void;
+    onChunk(status: number, data: any): void;
+    private advanceBuffer;
+    private isBufferTooLong;
+}

package/types/src/core/http/http_socket.d.ts

@@ -0,0 +1,32 @@
+import URLLocation from './url_location';
+import State from './state';
+import Socket from '../socket';
+import SocketHooks from './socket_hooks';
+import HTTPRequest from './http_request';
+declare 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);
+    send(payload: any): boolean;
+    ping(): void;
+    close(code: any, reason: any): void;
+    sendRaw(payload: any): boolean;
+    reconnect(): void;
+    onClose(code: any, reason: any, wasClean: any): void;
+    private onChunk;
+    private onOpen;
+    private onEvent;
+    private onActivity;
+    private onError;
+    private openStream;
+    private closeStream;
+}
+export default HTTPSocket;

package/types/src/core/http/http_streaming_socket.d.ts

@@ -0,0 +1,3 @@
+import SocketHooks from './socket_hooks';
+declare var hooks: SocketHooks;
+export default hooks;

package/types/src/core/http/request_hooks.d.ts

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

package/types/src/core/http/socket_hooks.d.ts

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

package/types/src/core/http/state.d.ts

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

package/types/src/core/http/url_location.d.ts

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

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

@@ -0,0 +1,11 @@
+declare class Logger {
+    debug(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    private globalLog;
+    private globalLogWarn;
+    private globalLogError;
+    private log;
+}
+declare const _default: Logger;
+export default _default;

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

@@ -0,0 +1,34 @@
+import { ChannelAuthorizationOptions, UserAuthenticationOptions } from './auth/options';
+import { ChannelAuthorizerGenerator, DeprecatedAuthOptions } from './auth/deprecated_channel_authorizer';
+import { AuthTransport, Transport } from './config';
+import * as nacl from 'tweetnacl';
+export interface Options {
+    activityTimeout?: number;
+    auth?: DeprecatedAuthOptions;
+    authEndpoint?: string;
+    authTransport?: AuthTransport;
+    authorizer?: ChannelAuthorizerGenerator;
+    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 declare function validateOptions(options: any): void;

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

@@ -0,0 +1,5 @@
+import { Options } from './options';
+import Pingerchips from './pusher';
+export default class PusherWithEncryption extends Pingerchips {
+    constructor(app_key: string, options: Options);
+}

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

@@ -0,0 +1,49 @@
+import AbstractRuntime from '../runtimes/interface';
+import Channel from './channels/channel';
+import Channels from './channels/channels';
+import { Config } from './config';
+import ConnectionManager from './connection/connection_manager';
+import { default as EventsDispatcher } from './events/dispatcher';
+import { Options } from './options';
+import Timeline from './timeline/timeline';
+import TimelineSender from './timeline/timeline_sender';
+import UserFacade from './user';
+import { PeriodicTimer } from './utils/timers';
+export default class Pingerchips {
+    static instances: Pingerchips[];
+    static isReady: boolean;
+    static logToConsole: boolean;
+    static Runtime: AbstractRuntime;
+    static ScriptReceivers: any;
+    static DependenciesReceivers: any;
+    static auth_callbacks: any;
+    static ready(): void;
+    static log: (message: any) => void;
+    private static getClientFeatures;
+    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);
+    channel(name: string): Channel;
+    allChannels(): Channel[];
+    connect(): void;
+    disconnect(): void;
+    bind(event_name: string, callback: Function, context?: any): Pingerchips;
+    unbind(event_name?: string, callback?: Function, context?: any): Pingerchips;
+    bind_global(callback: Function): Pingerchips;
+    unbind_global(callback?: Function): Pingerchips;
+    unbind_all(callback?: Function): Pingerchips;
+    subscribeAll(): void;
+    subscribe(channel_name: string): Channel;
+    unsubscribe(channel_name: string): void;
+    send_event(event_name: string, data: any, channel?: string): boolean;
+    shouldUseTLS(): boolean;
+    signin(): void;
+}

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

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

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

@@ -0,0 +1,12 @@
+interface Socket {
+    send(payload: any): void;
+    ping?(): void;
+    close(code?: any, reason?: any): 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;

package/types/src/core/strategies/best_connected_ever_strategy.d.ts

@@ -0,0 +1,10 @@
+import Strategy from './strategy';
+export default class BestConnectedEverStrategy implements Strategy {
+    strategies: Strategy[];
+    constructor(strategies: Strategy[]);
+    isSupported(): boolean;
+    connect(minPriority: number, callback: Function): {
+        abort: () => void;
+        forceMinPriority: (p: any) => void;
+    };
+}

package/types/src/core/strategies/delayed_strategy.d.ts

@@ -0,0 +1,15 @@
+import Strategy from './strategy';
+export default class DelayedStrategy implements Strategy {
+    strategy: Strategy;
+    options: {
+        delay: number;
+    };
+    constructor(strategy: Strategy, { delay: number }: {
+        delay: any;
+    });
+    isSupported(): boolean;
+    connect(minPriority: number, callback: Function): {
+        abort: () => void;
+        forceMinPriority: (p: any) => void;
+    };
+}

package/types/src/core/strategies/first_connected_strategy.d.ts

@@ -0,0 +1,8 @@
+import Strategy from './strategy';
+import StrategyRunner from './strategy_runner';
+export default class FirstConnectedStrategy implements Strategy {
+    strategy: Strategy;
+    constructor(strategy: Strategy);
+    isSupported(): boolean;
+    connect(minPriority: number, callback: Function): StrategyRunner;
+}

package/types/src/core/strategies/if_strategy.d.ts

@@ -0,0 +1,10 @@
+import Strategy from './strategy';
+import StrategyRunner from './strategy_runner';
+export default class IfStrategy implements Strategy {
+    test: () => boolean;
+    trueBranch: Strategy;
+    falseBranch: Strategy;
+    constructor(test: () => boolean, trueBranch: Strategy, falseBranch: Strategy);
+    isSupported(): boolean;
+    connect(minPriority: number, callback: Function): StrategyRunner;
+}

package/types/src/core/strategies/sequential_strategy.d.ts

@@ -0,0 +1,16 @@
+import Strategy from './strategy';
+import StrategyOptions from './strategy_options';
+export default class SequentialStrategy implements Strategy {
+    strategies: Strategy[];
+    loop: boolean;
+    failFast: boolean;
+    timeout: number;
+    timeoutLimit: number;
+    constructor(strategies: Strategy[], options: StrategyOptions);
+    isSupported(): boolean;
+    connect(minPriority: number, callback: Function): {
+        abort: () => void;
+        forceMinPriority: (p: any) => void;
+    };
+    private tryStrategy;
+}

package/types/src/core/strategies/strategy.d.ts

@@ -0,0 +1,6 @@
+import StrategyRunner from './strategy_runner';
+interface Strategy {
+    isSupported(): boolean;
+    connect(minPriority: number, callback: Function): StrategyRunner;
+}
+export default Strategy;

package/types/src/core/strategies/strategy_builder.d.ts

@@ -0,0 +1,5 @@
+import TransportManager from '../transports/transport_manager';
+import Strategy from './strategy';
+import StrategyOptions from '../strategies/strategy_options';
+import { Config } from '../config';
+export declare var defineTransport: (config: Config, name: string, type: string, priority: number, options: StrategyOptions, manager?: TransportManager) => Strategy;

package/types/src/core/strategies/strategy_options.d.ts

@@ -0,0 +1,16 @@
+import Timeline from '../timeline/timeline';
+interface StrategyOptions {
+    failFast?: boolean;
+    hostNonTLS?: string;
+    hostTLS?: string;
+    httpPath?: string;
+    ignoreNullOrigin?: boolean;
+    key?: string;
+    loop?: boolean;
+    timeline?: Timeline;
+    timeout?: number;
+    timeoutLimit?: number;
+    ttl?: number;
+    useTLS?: boolean;
+}
+export default StrategyOptions;

package/types/src/core/strategies/strategy_runner.d.ts

@@ -0,0 +1,5 @@
+interface StrategyRunner {
+    forceMinPriority: (number: any) => void;
+    abort: () => void;
+}
+export default StrategyRunner;

package/types/src/core/strategies/transport_strategy.d.ts

@@ -0,0 +1,15 @@
+import Strategy from './strategy';
+import Transport from '../transports/transport';
+import StrategyOptions from './strategy_options';
+export default class TransportStrategy implements Strategy {
+    name: string;
+    priority: number;
+    transport: Transport;
+    options: StrategyOptions;
+    constructor(name: string, priority: number, transport: Transport, options: StrategyOptions);
+    isSupported(): boolean;
+    connect(minPriority: number, callback: Function): {
+        abort: () => void;
+        forceMinPriority: (p: any) => void;
+    };
+}

package/types/src/core/strategies/websocket_prioritized_cached_strategy.d.ts

@@ -0,0 +1,20 @@
+import Strategy from './strategy';
+import StrategyOptions from './strategy_options';
+import TransportStrategy from './transport_strategy';
+import Timeline from '../timeline/timeline';
+export interface TransportStrategyDictionary {
+    [key: string]: TransportStrategy;
+}
+export default class WebSocketPrioritizedCachedStrategy implements Strategy {
+    strategy: Strategy;
+    transports: TransportStrategyDictionary;
+    ttl: number;
+    usingTLS: boolean;
+    timeline: Timeline;
+    constructor(strategy: Strategy, transports: TransportStrategyDictionary, options: StrategyOptions);
+    isSupported(): boolean;
+    connect(minPriority: number, callback: Function): {
+        abort: () => void;
+        forceMinPriority: (p: any) => void;
+    };
+}

package/types/src/core/timeline/level.d.ts

@@ -0,0 +1,6 @@
+declare enum TimelineLevel {
+    ERROR = 3,
+    INFO = 6,
+    DEBUG = 7
+}
+export default TimelineLevel;

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

@@ -0,0 +1,25 @@
+import { default as Level } from './level';
+export interface TimelineOptions {
+    level?: Level;
+    limit?: number;
+    version?: string;
+    cluster?: string;
+    features?: string[];
+    params?: any;
+}
+export default class Timeline {
+    key: string;
+    session: number;
+    events: any[];
+    options: TimelineOptions;
+    sent: number;
+    uniqueID: number;
+    constructor(key: string, session: number, options: TimelineOptions);
+    log(level: any, event: any): void;
+    error(event: any): void;
+    info(event: any): void;
+    debug(event: any): void;
+    isEmpty(): boolean;
+    send(sendfn: any, callback: any): boolean;
+    generateUniqueID(): number;
+}

package/types/src/core/timeline/timeline_sender.d.ts

@@ -0,0 +1,13 @@
+import Timeline from './timeline';
+export interface TimelineSenderOptions {
+    host?: string;
+    port?: number;
+    path?: string;
+}
+export default class TimelineSender {
+    timeline: Timeline;
+    options: TimelineSenderOptions;
+    host: string;
+    constructor(timeline: Timeline, options: TimelineSenderOptions);
+    send(useTLS: boolean, callback?: Function): void;
+}

package/types/src/core/timeline/timeline_transport.d.ts

@@ -0,0 +1,6 @@
+import TimelineSender from '../timeline/timeline_sender';
+interface TimelineTransport {
+    name: string;
+    getAgent: (sender: TimelineSender, useTLS: boolean) => (data: any, callback: Function) => void;
+}
+export default TimelineTransport;

package/types/src/core/transports/assistant_to_the_transport_manager.d.ts

@@ -0,0 +1,14 @@
+import TransportManager from './transport_manager';
+import TransportConnection from './transport_connection';
+import Transport from './transport';
+import PingDelayOptions from './ping_delay_options';
+export default class AssistantToTheTransportManager {
+    manager: TransportManager;
+    transport: Transport;
+    minPingDelay: number;
+    maxPingDelay: number;
+    pingDelay: number;
+    constructor(manager: TransportManager, transport: Transport, options: PingDelayOptions);
+    createConnection(name: string, priority: number, key: string, options: Object): TransportConnection;
+    isSupported(environment: string): boolean;
+}

package/types/src/core/transports/ping_delay_options.d.ts

@@ -0,0 +1,6 @@
+interface PingDelayOptions {
+    minPingDelay?: number;
+    maxPingDelay?: number;
+    pingDelay?: number;
+}
+export default PingDelayOptions;

package/types/src/core/transports/transport.d.ts

@@ -0,0 +1,8 @@
+import TransportHooks from './transport_hooks';
+import TransportConnection from './transport_connection';
+export default class Transport {
+    hooks: TransportHooks;
+    constructor(hooks: TransportHooks);
+    isSupported(environment: any): boolean;
+    createConnection(name: string, priority: number, key: string, options: any): TransportConnection;
+}

package/types/src/core/transports/transport_connection.d.ts

@@ -0,0 +1,35 @@
+import { default as EventsDispatcher } from '../events/dispatcher';
+import TransportHooks from './transport_hooks';
+import Socket from '../socket';
+import Timeline from '../timeline/timeline';
+import TransportConnectionOptions from './transport_connection_options';
+export default class TransportConnection extends EventsDispatcher {
+    hooks: TransportHooks;
+    name: string;
+    priority: number;
+    key: string;
+    options: TransportConnectionOptions;
+    state: string;
+    timeline: Timeline;
+    activityTimeout: number;
+    id: number;
+    socket: Socket;
+    beforeOpen: Function;
+    initialize: Function;
+    constructor(hooks: TransportHooks, name: string, priority: number, key: string, options: TransportConnectionOptions);
+    handlesActivityChecks(): boolean;
+    supportsPing(): boolean;
+    connect(): boolean;
+    close(): boolean;
+    send(data: any): boolean;
+    ping(): void;
+    private onOpen;
+    private onError;
+    private onClose;
+    private onMessage;
+    private onActivity;
+    private bindListeners;
+    private unbindListeners;
+    private changeState;
+    buildTimelineMessage(message: any): any;
+}

package/types/src/core/transports/transport_connection_options.d.ts

@@ -0,0 +1,6 @@
+import Timeline from '../timeline/timeline';
+interface TransportConnectionOptions {
+    timeline: Timeline;
+    activityTimeout: number;
+}
+export default TransportConnectionOptions;

package/types/src/core/transports/transport_hooks.d.ts

@@ -0,0 +1,13 @@
+import URLScheme from './url_scheme';
+import Socket from '../socket';
+interface TransportHooks {
+    file?: string;
+    urls: URLScheme;
+    handlesActivityChecks: boolean;
+    supportsPing: boolean;
+    isInitialized(): boolean;
+    isSupported(environment?: any): boolean;
+    getSocket(url: string, options?: any): Socket;
+    beforeOpen?: Function;
+}
+export default TransportHooks;