push all website files

website/functions/node_modules/@firebase/database/dist/src/realtime/BrowserPollConnection.d.ts

@@ -0,0 +1,194 @@
+import { CountedSet } from '../core/util/CountedSet';
+import { PacketReceiver } from './polling/PacketReceiver';
+import { Transport } from './Transport';
+import { RepoInfo } from '../core/RepoInfo';
+export declare const FIREBASE_LONGPOLL_START_PARAM = "start";
+export declare const FIREBASE_LONGPOLL_CLOSE_COMMAND = "close";
+export declare const FIREBASE_LONGPOLL_COMMAND_CB_NAME = "pLPCommand";
+export declare const FIREBASE_LONGPOLL_DATA_CB_NAME = "pRTLPCB";
+export declare const FIREBASE_LONGPOLL_ID_PARAM = "id";
+export declare const FIREBASE_LONGPOLL_PW_PARAM = "pw";
+export declare const FIREBASE_LONGPOLL_SERIAL_PARAM = "ser";
+export declare const FIREBASE_LONGPOLL_CALLBACK_ID_PARAM = "cb";
+export declare const FIREBASE_LONGPOLL_SEGMENT_NUM_PARAM = "seg";
+export declare const FIREBASE_LONGPOLL_SEGMENTS_IN_PACKET = "ts";
+export declare const FIREBASE_LONGPOLL_DATA_PARAM = "d";
+export declare const FIREBASE_LONGPOLL_DISCONN_FRAME_PARAM = "disconn";
+export declare const FIREBASE_LONGPOLL_DISCONN_FRAME_REQUEST_PARAM = "dframe";
+/**
+ * This class manages a single long-polling connection.
+ *
+ * @constructor
+ * @implements {Transport}
+ */
+export declare class BrowserPollConnection implements Transport {
+    connId: string;
+    repoInfo: RepoInfo;
+    transportSessionId: string;
+    lastSessionId: string;
+    bytesSent: number;
+    bytesReceived: number;
+    urlFn: (params: object) => string;
+    scriptTagHolder: FirebaseIFrameScriptHolder;
+    myDisconnFrame: HTMLIFrameElement;
+    curSegmentNum: number;
+    myPacketOrderer: PacketReceiver;
+    id: string;
+    password: string;
+    private log_;
+    private stats_;
+    private everConnected_;
+    private isClosed_;
+    private connectTimeoutTimer_;
+    private onDisconnect_;
+    /**
+     * @param {string} connId An identifier for this connection, used for logging
+     * @param {RepoInfo} repoInfo The info for the endpoint to send data to.
+     * @param {string=} transportSessionId Optional transportSessionid if we are reconnecting for an existing
+     *                                         transport session
+     * @param {string=}  lastSessionId Optional lastSessionId if the PersistentConnection has already created a
+     *                                     connection previously
+     */
+    constructor(connId: string, repoInfo: RepoInfo, transportSessionId?: string, lastSessionId?: string);
+    /**
+     *
+     * @param {function(Object)} onMessage Callback when messages arrive
+     * @param {function()} onDisconnect Callback with connection lost.
+     */
+    open(onMessage: (msg: Object) => void, onDisconnect: (a?: boolean) => void): void;
+    /**
+     * Call this when a handshake has completed successfully and we want to consider the connection established
+     */
+    start(): void;
+    private static forceAllow_;
+    /**
+     * Forces long polling to be considered as a potential transport
+     */
+    static forceAllow(): void;
+    private static forceDisallow_;
+    /**
+     * Forces longpolling to not be considered as a potential transport
+     */
+    static forceDisallow(): void;
+    static isAvailable(): boolean;
+    /**
+     * No-op for polling
+     */
+    markConnectionHealthy(): void;
+    /**
+     * Stops polling and cleans up the iframe
+     * @private
+     */
+    private shutdown_();
+    /**
+     * Triggered when this transport is closed
+     * @private
+     */
+    private onClosed_();
+    /**
+     * External-facing close handler. RealTime has requested we shut down. Kill our connection and tell the server
+     * that we've left.
+     */
+    close(): void;
+    /**
+     * Send the JSON object down to the server. It will need to be stringified, base64 encoded, and then
+     * broken into chunks (since URLs have a small maximum length).
+     * @param {!Object} data The JSON data to transmit.
+     */
+    send(data: Object): void;
+    /**
+     * This is how we notify the server that we're leaving.
+     * We aren't able to send requests with DHTML on a window close event, but we can
+     * trigger XHR requests in some browsers (everything but Opera basically).
+     * @param {!string} id
+     * @param {!string} pw
+     */
+    addDisconnectPingFrame(id: string, pw: string): void;
+    /**
+     * Used to track the bytes received by this client
+     * @param {*} args
+     * @private
+     */
+    private incrementIncomingBytes_(args);
+}
+export interface IFrameElement extends HTMLIFrameElement {
+    doc: Document;
+}
+/*********************************************************************************************
+ * A wrapper around an iframe that is used as a long-polling script holder.
+ * @constructor
+ *********************************************************************************************/
+export declare class FirebaseIFrameScriptHolder {
+    onDisconnect: () => void;
+    urlFn: (a: object) => string;
+    /**
+     * @type {CountedSet.<number, number>}
+     */
+    outstandingRequests: CountedSet<number, number>;
+    pendingSegs: {
+        seg: number;
+        ts: number;
+        d: any;
+    }[];
+    currentSerial: number;
+    sendNewPolls: boolean;
+    uniqueCallbackIdentifier: number;
+    myIFrame: IFrameElement;
+    alive: boolean;
+    myID: string;
+    myPW: string;
+    commandCB: (command: string, ...args: any[]) => void;
+    onMessageCB: (...args: any[]) => void;
+    /**
+     * @param commandCB - The callback to be called when control commands are recevied from the server.
+     * @param onMessageCB - The callback to be triggered when responses arrive from the server.
+     * @param onDisconnect - The callback to be triggered when this tag holder is closed
+     * @param urlFn - A function that provides the URL of the endpoint to send data to.
+     */
+    constructor(commandCB: (command: string, ...args: any[]) => void, onMessageCB: (...args: any[]) => void, onDisconnect: () => void, urlFn: (a: object) => string);
+    /**
+     * Each browser has its own funny way to handle iframes. Here we mush them all together into one object that I can
+     * actually use.
+     * @private
+     * @return {Element}
+     */
+    private static createIFrame_();
+    /**
+     * Cancel all outstanding queries and remove the frame.
+     */
+    close(): void;
+    /**
+     * Actually start the long-polling session by adding the first script tag(s) to the iframe.
+     * @param {!string} id - The ID of this connection
+     * @param {!string} pw - The password for this connection
+     */
+    startLongPoll(id: string, pw: string): void;
+    /**
+     * This is called any time someone might want a script tag to be added. It adds a script tag when there aren't
+     * too many outstanding requests and we are still alive.
+     *
+     * If there are outstanding packet segments to send, it sends one. If there aren't, it sends a long-poll anyways if
+     * needed.
+     */
+    private newRequest_();
+    /**
+     * Queue a packet for transmission to the server.
+     * @param segnum - A sequential id for this packet segment used for reassembly
+     * @param totalsegs - The total number of segments in this packet
+     * @param data - The data for this segment.
+     */
+    enqueueSegment(segnum: number, totalsegs: number, data: any): void;
+    /**
+     * Add a script tag for a regular long-poll request.
+     * @param {!string} url - The URL of the script tag.
+     * @param {!number} serial - The serial number of the request.
+     * @private
+     */
+    private addLongPollTag_(url, serial);
+    /**
+     * Add an arbitrary script tag to the iframe.
+     * @param {!string} url - The URL for the script tag source.
+     * @param {!function()} loadCB - A callback to be triggered once the script has loaded.
+     */
+    addTag(url: string, loadCB: () => void): void;
+}

website/functions/node_modules/@firebase/database/dist/src/realtime/Connection.d.ts

@@ -0,0 +1,101 @@
+import { RepoInfo } from '../core/RepoInfo';
+/**
+ * Creates a new real-time connection to the server using whichever method works
+ * best in the current browser.
+ *
+ * @constructor
+ */
+export declare class Connection {
+    id: string;
+    private repoInfo_;
+    private onMessage_;
+    private onReady_;
+    private onDisconnect_;
+    private onKill_;
+    lastSessionId: string;
+    connectionCount: number;
+    pendingDataMessages: any[];
+    sessionId: string;
+    private conn_;
+    private healthyTimeout_;
+    private isHealthy_;
+    private log_;
+    private primaryResponsesRequired_;
+    private rx_;
+    private secondaryConn_;
+    private secondaryResponsesRequired_;
+    private state_;
+    private transportManager_;
+    private tx_;
+    /**
+     * @param {!string} id - an id for this connection
+     * @param {!RepoInfo} repoInfo_ - the info for the endpoint to connect to
+     * @param {function(Object)} onMessage_ - the callback to be triggered when a server-push message arrives
+     * @param {function(number, string)} onReady_ - the callback to be triggered when this connection is ready to send messages.
+     * @param {function()} onDisconnect_ - the callback to be triggered when a connection was lost
+     * @param {function(string)} onKill_ - the callback to be triggered when this connection has permanently shut down.
+     * @param {string=} lastSessionId - last session id in persistent connection. is used to clean up old session in real-time server
+     */
+    constructor(id: string, repoInfo_: RepoInfo, onMessage_: (a: Object) => void, onReady_: (a: number, b: string) => void, onDisconnect_: () => void, onKill_: (a: string) => void, lastSessionId?: string);
+    /**
+     * Starts a connection attempt
+     * @private
+     */
+    private start_();
+    /**
+     * @return {!string}
+     * @private
+     */
+    private nextTransportId_();
+    private disconnReceiver_(conn);
+    private connReceiver_(conn);
+    /**
+     *
+     * @param {Object} dataMsg An arbitrary data message to be sent to the server
+     */
+    sendRequest(dataMsg: object): void;
+    tryCleanupConnection(): void;
+    private onSecondaryControl_(controlData);
+    private onSecondaryMessageReceived_(parsedData);
+    private upgradeIfSecondaryHealthy_();
+    private proceedWithUpgrade_();
+    private onPrimaryMessageReceived_(parsedData);
+    private onDataMessage_(message);
+    private onPrimaryResponse_();
+    private onControl_(controlData);
+    /**
+     *
+     * @param {Object} handshake The handshake data returned from the server
+     * @private
+     */
+    private onHandshake_(handshake);
+    private tryStartUpgrade_();
+    private startUpgrade_(conn);
+    private onReset_(host);
+    private onConnectionEstablished_(conn, timestamp);
+    private sendPingOnPrimaryIfNecessary_();
+    private onSecondaryConnectionLost_();
+    /**
+     *
+     * @param {boolean} everConnected Whether or not the connection ever reached a server. Used to determine if
+     * we should flush the host cache
+     * @private
+     */
+    private onConnectionLost_(everConnected);
+    /**
+     *
+     * @param {string} reason
+     * @private
+     */
+    private onConnectionShutdown_(reason);
+    private sendData_(data);
+    /**
+     * Cleans up this connection, calling the appropriate callbacks
+     */
+    close(): void;
+    /**
+     *
+     * @private
+     */
+    private closeConnections_();
+}

website/functions/node_modules/@firebase/database/dist/src/realtime/Constants.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Copyright 2017 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+export declare const PROTOCOL_VERSION = "5";
+export declare const VERSION_PARAM = "v";
+export declare const TRANSPORT_SESSION_PARAM = "s";
+export declare const REFERER_PARAM = "r";
+export declare const FORGE_REF = "f";
+export declare const FORGE_DOMAIN = "firebaseio.com";
+export declare const LAST_SESSION_PARAM = "ls";
+export declare const WEBSOCKET = "websocket";
+export declare const LONG_POLLING = "long_polling";

website/functions/node_modules/@firebase/database/dist/src/realtime/Transport.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Copyright 2017 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { RepoInfo } from '../core/RepoInfo';
+export interface TransportConstructor {
+    new (connId: string, repoInfo: RepoInfo, transportSessionId?: string, lastSessionId?: string): Transport;
+    isAvailable: () => boolean;
+    responsesRequiredToBeHealthy?: number;
+    healthyTimeout?: number;
+}
+export declare abstract class Transport {
+    /**
+     * Bytes received since connection started.
+     * @type {number}
+     */
+    abstract bytesReceived: number;
+    /**
+     * Bytes sent since connection started.
+     * @type {number}
+     */
+    abstract bytesSent: number;
+    /**
+     * An identifier for this connection, used for logging
+     * @type {string}
+     */
+    abstract connId: string;
+    /**
+     *
+     * @param {string} connId An identifier for this connection, used for logging
+     * @param {RepoInfo} repoInfo The info for the endpoint to send data to.
+     * @param {string=} transportSessionId Optional transportSessionId if this is connecting to an existing transport session
+     * @param {string=} lastSessionId Optional lastSessionId if there was a previous connection
+     * @interface
+     */
+    constructor(connId: string, repoInfo: RepoInfo, transportSessionId?: string, lastSessionId?: string);
+    /**
+     * @param {function(Object)} onMessage Callback when messages arrive
+     * @param {function()} onDisconnect Callback with connection lost.
+     */
+    abstract open(onMessage: (a: Object) => void, onDisconnect: (a?: boolean) => void): void;
+    abstract start(): void;
+    abstract close(): void;
+    /**
+     * @param {!Object} data The JSON data to transmit
+     */
+    abstract send(data: Object): void;
+    abstract markConnectionHealthy(): void;
+    abstract markConnectionHealthy(): void;
+}
+export interface TransportConstructor {
+    new (connId: string, RepoInfo: any, transportSessionId?: string, lastSessionId?: string): any;
+}

website/functions/node_modules/@firebase/database/dist/src/realtime/TransportManager.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Copyright 2017 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { BrowserPollConnection } from './BrowserPollConnection';
+import { WebSocketConnection } from './WebSocketConnection';
+import { TransportConstructor } from './Transport';
+import { RepoInfo } from '../core/RepoInfo';
+/**
+ * Currently simplistic, this class manages what transport a Connection should use at various stages of its
+ * lifecycle.
+ *
+ * It starts with longpolling in a browser, and httppolling on node. It then upgrades to websockets if
+ * they are available.
+ * @constructor
+ */
+export declare class TransportManager {
+    private transports_;
+    /**
+     * @const
+     * @type {!Array.<function(new:Transport, string, RepoInfo, string=)>}
+     */
+    static readonly ALL_TRANSPORTS: (typeof BrowserPollConnection | typeof WebSocketConnection)[];
+    /**
+     * @param {!RepoInfo} repoInfo Metadata around the namespace we're connecting to
+     */
+    constructor(repoInfo: RepoInfo);
+    /**
+     * @param {!RepoInfo} repoInfo
+     * @private
+     */
+    private initTransports_(repoInfo);
+    /**
+     * @return {function(new:Transport, !string, !RepoInfo, string=, string=)} The constructor for the
+     * initial transport to use
+     */
+    initialTransport(): TransportConstructor;
+    /**
+     * @return {?function(new:Transport, function(),function(), string=)} The constructor for the next
+     * transport, or null
+     */
+    upgradeTransport(): TransportConstructor | null;
+}

website/functions/node_modules/@firebase/database/dist/src/realtime/WebSocketConnection.d.ts

@@ -0,0 +1,129 @@
+/**
+ * Copyright 2017 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { RepoInfo } from '../core/RepoInfo';
+import { Transport } from './Transport';
+export declare function setWebSocketImpl(impl: any): void;
+/**
+ * Create a new websocket connection with the given callbacks.
+ * @constructor
+ * @implements {Transport}
+ */
+export declare class WebSocketConnection implements Transport {
+    connId: string;
+    keepaliveTimer: number | null;
+    frames: string[] | null;
+    totalFrames: number;
+    bytesSent: number;
+    bytesReceived: number;
+    connURL: string;
+    onDisconnect: (a?: boolean) => void;
+    onMessage: (msg: Object) => void;
+    mySock: any | null;
+    private log_;
+    private stats_;
+    private everConnected_;
+    private isClosed_;
+    /**
+     * @param {string} connId identifier for this transport
+     * @param {RepoInfo} repoInfo The info for the websocket endpoint.
+     * @param {string=} transportSessionId Optional transportSessionId if this is connecting to an existing transport
+     *                                         session
+     * @param {string=} lastSessionId Optional lastSessionId if there was a previous connection
+     */
+    constructor(connId: string, repoInfo: RepoInfo, transportSessionId?: string, lastSessionId?: string);
+    /**
+     * @param {RepoInfo} repoInfo The info for the websocket endpoint.
+     * @param {string=} transportSessionId Optional transportSessionId if this is connecting to an existing transport
+     *                                         session
+     * @param {string=} lastSessionId Optional lastSessionId if there was a previous connection
+     * @return {string} connection url
+     * @private
+     */
+    private static connectionURL_(repoInfo, transportSessionId?, lastSessionId?);
+    /**
+     *
+     * @param onMessage Callback when messages arrive
+     * @param onDisconnect Callback with connection lost.
+     */
+    open(onMessage: (msg: Object) => void, onDisconnect: (a?: boolean) => void): void;
+    /**
+     * No-op for websockets, we don't need to do anything once the connection is confirmed as open
+     */
+    start(): void;
+    static forceDisallow_: Boolean;
+    static forceDisallow(): void;
+    static isAvailable(): boolean;
+    /**
+     * Number of response before we consider the connection "healthy."
+     * @type {number}
+     */
+    static responsesRequiredToBeHealthy: number;
+    /**
+     * Time to wait for the connection te become healthy before giving up.
+     * @type {number}
+     */
+    static healthyTimeout: number;
+    /**
+     * Returns true if we previously failed to connect with this transport.
+     * @return {boolean}
+     */
+    static previouslyFailed(): boolean;
+    markConnectionHealthy(): void;
+    private appendFrame_(data);
+    /**
+     * @param {number} frameCount The number of frames we are expecting from the server
+     * @private
+     */
+    private handleNewFrameCount_(frameCount);
+    /**
+     * Attempts to parse a frame count out of some text. If it can't, assumes a value of 1
+     * @param {!String} data
+     * @return {?String} Any remaining data to be process, or null if there is none
+     * @private
+     */
+    private extractFrameCount_(data);
+    /**
+     * Process a websocket frame that has arrived from the server.
+     * @param mess The frame data
+     */
+    handleIncomingFrame(mess: {
+        [k: string]: any;
+    }): void;
+    /**
+     * Send a message to the server
+     * @param {Object} data The JSON object to transmit
+     */
+    send(data: Object): void;
+    private shutdown_();
+    private onClosed_();
+    /**
+     * External-facing close handler.
+     * Close the websocket and kill the connection.
+     */
+    close(): void;
+    /**
+     * Kill the current keepalive timer and start a new one, to ensure that it always fires N seconds after
+     * the last activity.
+     */
+    resetKeepAlive(): void;
+    /**
+     * Send a string over the websocket.
+     *
+     * @param {string} str String to send.
+     * @private
+     */
+    private sendString_(str);
+}

website/functions/node_modules/@firebase/database/dist/src/realtime/polling/PacketReceiver.d.ts

@@ -0,0 +1,25 @@
+/**
+ * This class ensures the packets from the server arrive in order
+ * This class takes data from the server and ensures it gets passed into the callbacks in order.
+ * @constructor
+ */
+export declare class PacketReceiver {
+    private onMessage_;
+    pendingResponses: any[];
+    currentResponseNum: number;
+    closeAfterResponse: number;
+    onClose: (() => void) | null;
+    /**
+     * @param onMessage_
+     */
+    constructor(onMessage_: (a: Object) => void);
+    closeAfter(responseNum: number, callback: () => void): void;
+    /**
+     * Each message from the server comes with a response number, and an array of data. The responseNumber
+     * allows us to ensure that we process them in the right order, since we can't be guaranteed that all
+     * browsers will respond in the same order as the requests we sent
+     * @param {number} requestNum
+     * @param {Array} data
+     */
+    handleResponse(requestNum: number, data: any[]): void;
+}