alu/tra-analysis
1
0
Fork 0
mirror of https://github.com/titanscouting/tra-analysis.git synced 2025-09-07 23:37:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

push all website files

Browse Source
This commit is contained in:
Jacob Levine
2019-01-06 13:14:45 -06:00
parent 476d8c19cf
commit 0a9f515fae
335 changed files with 144108 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
functions/node_modules/@firebase/database/dist/packages/database/index.d.ts generated vendored Normal file
View File

@@ -0,0 +1,28 @@
import { FirebaseNamespace } from '@firebase/app-types';
import { Database } from './src/api/Database';
import { Query } from './src/api/Query';
import { Reference } from './src/api/Reference';
import { enableLogging } from './src/core/util/util';
import * as types from '@firebase/database-types';
declare const ServerValue: {
TIMESTAMP: {
'.sv': string;
};
};
export declare function registerDatabase(instance: FirebaseNamespace): void;
export { Database, Query, Reference, enableLogging, ServerValue };
export { DataSnapshot } from './src/api/DataSnapshot';
export { OnDisconnect } from './src/api/onDisconnect';
declare module '@firebase/app-types' {
interface FirebaseNamespace {
database?: {
(app?: FirebaseApp): types.FirebaseDatabase;
enableLogging: typeof types.enableLogging;
ServerValue: types.ServerValue;
Database: typeof types.FirebaseDatabase;
};
}
interface FirebaseApp {
database?(databaseURL?: string): types.FirebaseDatabase;
}
}

16
functions/node_modules/@firebase/database/dist/packages/database/src/api/internal.d.ts generated vendored Normal file
View File

@@ -0,0 +1,16 @@
import { Reference } from './Reference';
/**
* INTERNAL methods for internal-use only (tests, etc.).
*
* Customers shouldn't use these or else should be aware that they could break at any time.
*
* @const
*/
export declare const forceLongPolling: () => void;
export declare const forceWebSockets: () => void;
export declare const isWebSocketsAvailable: () => boolean;
export declare const setSecurityDebugCallback: (ref: Reference, callback: (a: Object) => void) => void;
export declare const stats: (ref: Reference, showDelta?: boolean) => void;
export declare const statsIncrementCounter: (ref: Reference, metric: string) => void;
export declare const dataUpdateCount: (ref: Reference) => number;
export declare const interceptServerData: (ref: Reference, callback: (a: string, b: any) => void) => void;

46
functions/node_modules/@firebase/database/dist/packages/database/src/api/test_access.d.ts generated vendored Normal file
View File

@@ -0,0 +1,46 @@
/**
* 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 { PersistentConnection } from '../core/PersistentConnection';
import { Connection } from '../realtime/Connection';
import { Query } from './Query';
export declare const DataConnection: typeof PersistentConnection;
export declare const RealTimeConnection: typeof Connection;
/**
* @param {function(): string} newHash
* @return {function()}
*/
export declare const hijackHash: (newHash: () => string) => () => void;
/**
* @type {function(new:RepoInfo, !string, boolean, !string, boolean): undefined}
*/
export declare const ConnectionTarget: typeof RepoInfo;
/**
* @param {!Query} query
* @return {!string}
*/
export declare const queryIdentifier: (query: Query) => string;
/**
* @param {!Query} firebaseRef
* @return {!Object}
*/
export declare const listens: (firebaseRef: Query) => any;
/**
* Forces the RepoManager to create Repos that use ReadonlyRestClient instead of PersistentConnection.
*
* @param {boolean} forceRestClient
*/
export declare const forceRestClient: (forceRestClient: boolean) => void;

194
functions/node_modules/@firebase/database/dist/packages/database/src/core/PersistentConnection.d.ts generated vendored Normal file
View File

@@ -0,0 +1,194 @@
import { ServerActions } from './ServerActions';
import { AuthTokenProvider } from './AuthTokenProvider';
import { RepoInfo } from './RepoInfo';
import { Query } from '../api/Query';
/**
* Firebase connection. Abstracts wire protocol and handles reconnecting.
*
* NOTE: All JSON objects sent to the realtime connection must have property names enclosed
* in quotes to make sure the closure compiler does not minify them.
*/
export declare class PersistentConnection extends ServerActions {
private repoInfo_;
private onDataUpdate_;
private onConnectStatus_;
private onServerInfoUpdate_;
private authTokenProvider_;
private authOverride_;
id: number;
private log_;
/** @private {Object} */
private interruptReasons_;
private listens_;
private outstandingPuts_;
private outstandingPutCount_;
private onDisconnectRequestQueue_;
private connected_;
private reconnectDelay_;
private maxReconnectDelay_;
private securityDebugCallback_;
lastSessionId: string | null;
/** @private {number|null} */
private establishConnectionTimer_;
/** @private {boolean} */
private visible_;
private requestCBHash_;
private requestNumber_;
/** @private {?{
* sendRequest(Object),
* close()
* }} */
private realtime_;
/** @private {string|null} */
private authToken_;
private forceTokenRefresh_;
private invalidAuthTokenCount_;
private firstConnection_;
private lastConnectionAttemptTime_;
private lastConnectionEstablishedTime_;
/**
* @private
*/
private static nextPersistentConnectionId_;
/**
* Counter for number of connections created. Mainly used for tagging in the logs
* @type {number}
* @private
*/
private static nextConnectionId_;
/**
* @implements {ServerActions}
* @param {!RepoInfo} repoInfo_ Data about the namespace we are connecting to
* @param {function(string, *, boolean, ?number)} onDataUpdate_ A callback for new data from the server
* @param onConnectStatus_
* @param onServerInfoUpdate_
* @param authTokenProvider_
* @param authOverride_
*/
constructor(repoInfo_: RepoInfo, onDataUpdate_: (a: string, b: any, c: boolean, d: number | null) => void, onConnectStatus_: (a: boolean) => void, onServerInfoUpdate_: (a: any) => void, authTokenProvider_: AuthTokenProvider, authOverride_?: Object | null);
/**
* @param {!string} action
* @param {*} body
* @param {function(*)=} onResponse
* @protected
*/
protected sendRequest(action: string, body: any, onResponse?: (a: any) => void): void;
/**
* @inheritDoc
*/
listen(query: Query, currentHashFn: () => string, tag: number | null, onComplete: (a: string, b: any) => void): void;
/**
* @param {!{onComplete(),
* hashFn():!string,
* query: !Query,
* tag: ?number}} listenSpec
* @private
*/
private sendListen_(listenSpec);
/**
* @param {*} payload
* @param {!Query} query
* @private
*/
private static warnOnListenWarnings_(payload, query);
/**
* @inheritDoc
*/
refreshAuthToken(token: string): void;
/**
* @param {!string} credential
* @private
*/
private reduceReconnectDelayIfAdminCredential_(credential);
/**
* Attempts to authenticate with the given credentials. If the authentication attempt fails, it's triggered like
* a auth revoked (the connection is closed).
*/
tryAuth(): void;
/**
* @inheritDoc
*/
unlisten(query: Query, tag: number | null): void;
private sendUnlisten_(pathString, queryId, queryObj, tag);
/**
* @inheritDoc
*/
onDisconnectPut(pathString: string, data: any, onComplete?: (a: string, b: string) => void): void;
/**
* @inheritDoc
*/
onDisconnectMerge(pathString: string, data: any, onComplete?: (a: string, b: string) => void): void;
/**
* @inheritDoc
*/
onDisconnectCancel(pathString: string, onComplete?: (a: string, b: string) => void): void;
private sendOnDisconnect_(action, pathString, data, onComplete);
/**
* @inheritDoc
*/
put(pathString: string, data: any, onComplete?: (a: string, b: string) => void, hash?: string): void;
/**
* @inheritDoc
*/
merge(pathString: string, data: any, onComplete: (a: string, b: string | null) => void, hash?: string): void;
putInternal(action: string, pathString: string, data: any, onComplete: (a: string, b: string | null) => void, hash?: string): void;
private sendPut_(index);
/**
* @inheritDoc
*/
reportStats(stats: {
[k: string]: any;
}): void;
/**
* @param {*} message
* @private
*/
private onDataMessage_(message);
private onDataPush_(action, body);
private onReady_(timestamp, sessionId);
private scheduleConnect_(timeout);
/**
* @param {boolean} visible
* @private
*/
private onVisible_(visible);
private onOnline_(online);
private onRealtimeDisconnect_();
private establishConnection_();
/**
* @param {string} reason
*/
interrupt(reason: string): void;
/**
* @param {string} reason
*/
resume(reason: string): void;
private handleTimestamp_(timestamp);
private cancelSentTransactions_();
/**
* @param {!string} pathString
* @param {Array.<*>=} query
* @private
*/
private onListenRevoked_(pathString, query?);
/**
* @param {!string} pathString
* @param {!string} queryId
* @return {{queries:Array.<Query>, onComplete:function(string)}}
* @private
*/
private removeListen_(pathString, queryId);
private onAuthRevoked_(statusCode, explanation);
private onSecurityDebugPacket_(body);
private restoreState_();
/**
* Sends client stats for first connection
* @private
*/
private sendConnectStats_();
/**
* @return {boolean}
* @private
*/
private shouldReconnect_();
}

56
functions/node_modules/@firebase/database/dist/packages/database/src/core/ReadonlyRestClient.d.ts generated vendored Normal file
View File

@@ -0,0 +1,56 @@
import { ServerActions } from './ServerActions';
import { RepoInfo } from './RepoInfo';
import { AuthTokenProvider } from './AuthTokenProvider';
import { Query } from '../api/Query';
/**
* An implementation of ServerActions that communicates with the server via REST requests.
* This is mostly useful for compatibility with crawlers, where we don't want to spin up a full
* persistent connection (using WebSockets or long-polling)
*/
export declare class ReadonlyRestClient extends ServerActions {
private repoInfo_;
private onDataUpdate_;
private authTokenProvider_;
reportStats(stats: {
[k: string]: any;
}): void;
/** @private {function(...[*])} */
private log_;
/**
* We don't actually need to track listens, except to prevent us calling an onComplete for a listen
* that's been removed. :-/
*
* @private {!Object.<string, !Object>}
*/
private listens_;
/**
* @param {!Query} query
* @param {?number=} tag
* @return {string}
* @private
*/
static getListenId_(query: Query, tag?: number | null): string;
/**
* @param {!RepoInfo} repoInfo_ Data about the namespace we are connecting to
* @param {function(string, *, boolean, ?number)} onDataUpdate_ A callback for new data from the server
* @param {AuthTokenProvider} authTokenProvider_
* @implements {ServerActions}
*/
constructor(repoInfo_: RepoInfo, onDataUpdate_: (a: string, b: any, c: boolean, d: number | null) => void, authTokenProvider_: AuthTokenProvider);
/** @inheritDoc */
listen(query: Query, currentHashFn: () => string, tag: number | null, onComplete: (a: string, b: any) => void): void;
/** @inheritDoc */
unlisten(query: Query, tag: number | null): void;
/** @inheritDoc */
refreshAuthToken(token: string): void;
/**
* Performs a REST request to the given path, with the provided query string parameters,
* and any auth credentials we have.
*
* @param {!string} pathString
* @param {!Object.<string, *>} queryStringParameters
* @param {?function(?number, *=)} callback
* @private
*/
private restRequest_(pathString, queryStringParameters, callback);
}

64
functions/node_modules/@firebase/database/dist/packages/database/src/core/RepoManager.d.ts generated vendored Normal file
View File

@@ -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 { FirebaseApp } from '@firebase/app-types';
import { Repo } from './Repo';
import './Repo_transaction';
import { Database } from '../api/Database';
import { RepoInfo } from './RepoInfo';
/**
* Creates and caches Repo instances.
*/
export declare class RepoManager {
/**
* @private {!Object.<string, Object<string, !fb.core.Repo>>}
*/
private repos_;
/**
* If true, new Repos will be created to use ReadonlyRestClient (for testing purposes).
* @private {boolean}
*/
private useRestClient_;
static getInstance(): RepoManager;
interrupt(): void;
resume(): void;
/**
* This function should only ever be called to CREATE a new database instance.
*
* @param {!FirebaseApp} app
* @return {!Database}
*/
databaseFromApp(app: FirebaseApp, url?: string): Database;
/**
* Remove the repo and make sure it is disconnected.
*
* @param {!Repo} repo
*/
deleteRepo(repo: Repo): void;
/**
* Ensures a repo doesn't already exist and then creates one using the
* provided app.
*
* @param {!RepoInfo} repoInfo The metadata about the Repo
* @param {!FirebaseApp} app
* @return {!Repo} The Repo object for the specified server / repoName.
*/
createRepo(repoInfo: RepoInfo, app: FirebaseApp): Repo;
/**
* Forces us to use ReadonlyRestClient instead of PersistentConnection for new Repos.
* @param {boolean} forceRestClient
*/
forceRestClient(forceRestClient: boolean): void;
}

17
functions/node_modules/@firebase/database/dist/packages/database/src/core/Repo_transaction.d.ts generated vendored Normal file
View File

@@ -0,0 +1,17 @@
import { DataSnapshot } from '../api/DataSnapshot';
import { Path } from './util/Path';
/**
* @enum {number}
*/
export declare enum TransactionStatus {
RUN = 0,
SENT = 1,
COMPLETED = 2,
SENT_NEEDS_ABORT = 3,
NEEDS_ABORT = 4,
}
declare module './Repo' {
interface Repo {
startTransaction(path: Path, transactionUpdate: (a: any) => void, onComplete: ((a: Error, b: boolean, c: DataSnapshot) => void) | null, applyLocally: boolean): void;
}
}

80
functions/node_modules/@firebase/database/dist/packages/database/src/core/ServerActions.d.ts generated vendored Normal file
View File

@@ -0,0 +1,80 @@
/**
* 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 { Query } from '../api/Query';
/**
* Interface defining the set of actions that can be performed against the Firebase server
* (basically corresponds to our wire protocol).
*
* @interface
*/
export declare abstract class ServerActions {
/**
* @param {!Query} query
* @param {function():string} currentHashFn
* @param {?number} tag
* @param {function(string, *)} onComplete
*/
abstract listen(query: Query, currentHashFn: () => string, tag: number | null, onComplete: (a: string, b: any) => void): void;
/**
* Remove a listen.
*
* @param {!Query} query
* @param {?number} tag
*/
abstract unlisten(query: Query, tag: number | null): void;
/**
* @param {string} pathString
* @param {*} data
* @param {function(string, string)=} onComplete
* @param {string=} hash
*/
put(pathString: string, data: any, onComplete?: (a: string, b: string) => void, hash?: string): void;
/**
* @param {string} pathString
* @param {*} data
* @param {function(string, ?string)} onComplete
* @param {string=} hash
*/
merge(pathString: string, data: any, onComplete: (a: string, b: string | null) => void, hash?: string): void;
/**
* Refreshes the auth token for the current connection.
* @param {string} token The authentication token
*/
refreshAuthToken(token: string): void;
/**
* @param {string} pathString
* @param {*} data
* @param {function(string, string)=} onComplete
*/
onDisconnectPut(pathString: string, data: any, onComplete?: (a: string, b: string) => void): void;
/**
* @param {string} pathString
* @param {*} data
* @param {function(string, string)=} onComplete
*/
onDisconnectMerge(pathString: string, data: any, onComplete?: (a: string, b: string) => void): void;
/**
* @param {string} pathString
* @param {function(string, string)=} onComplete
*/
onDisconnectCancel(pathString: string, onComplete?: (a: string, b: string) => void): void;
/**
* @param {Object.<string, *>} stats
*/
reportStats(stats: {
[k: string]: any;
}): void;
}

29
functions/node_modules/@firebase/database/dist/packages/database/src/core/util/EventEmitter.d.ts generated vendored Normal file
View File

@@ -0,0 +1,29 @@
/**
* Base class to be used if you want to emit events. Call the constructor with
* the set of allowed event names.
*/
export declare abstract class EventEmitter {
private allowedEvents_;
private listeners_;
/**
* @param {!Array.<string>} allowedEvents_
*/
constructor(allowedEvents_: Array<string>);
/**
* To be overridden by derived classes in order to fire an initial event when
* somebody subscribes for data.
*
* @param {!string} eventType
* @return {Array.<*>} Array of parameters to trigger initial event with.
*/
abstract getInitialEvent(eventType: string): any[];
/**
* To be called by derived classes to trigger events.
* @param {!string} eventType
* @param {...*} var_args
*/
protected trigger(eventType: string, ...var_args: any[]): void;
on(eventType: string, callback: (a: any) => void, context: any): void;
off(eventType: string, callback: (a: any) => void, context: any): void;
private validateEventType_(eventType);
}

24
functions/node_modules/@firebase/database/dist/packages/database/src/core/util/OnlineMonitor.d.ts generated vendored Normal file
View File

@@ -0,0 +1,24 @@
import { EventEmitter } from './EventEmitter';
/**
* Monitors online state (as reported by window.online/offline events).
*
* The expectation is that this could have many false positives (thinks we are online
* when we're not), but no false negatives. So we can safely use it to determine when
* we definitely cannot reach the internet.
*
* @extends {EventEmitter}
*/
export declare class OnlineMonitor extends EventEmitter {
private online_;
static getInstance(): OnlineMonitor;
constructor();
/**
* @param {!string} eventType
* @return {Array.<boolean>}
*/
getInitialEvent(eventType: string): boolean[];
/**
* @return {boolean}
*/
currentlyOnline(): boolean;
}

118
functions/node_modules/@firebase/database/dist/packages/database/src/core/util/Tree.d.ts generated vendored Normal file
View File

@@ -0,0 +1,118 @@
import { Path } from './Path';
/**
* Node in a Tree.
*/
export declare class TreeNode<T> {
children: {
[name: string]: TreeNode<T>;
};
childCount: number;
value: T | null;
}
/**
* A light-weight tree, traversable by path. Nodes can have both values and children.
* Nodes are not enumerated (by forEachChild) unless they have a value or non-empty
* children.
*/
export declare class Tree<T> {
private name_;
private parent_;
private node_;
/**
* @template T
* @param {string=} name_ Optional name of the node.
* @param {Tree=} parent_ Optional parent node.
* @param {TreeNode=} node_ Optional node to wrap.
*/
constructor(name_?: string, parent_?: Tree<T> | null, node_?: TreeNode<T>);
/**
* Returns a sub-Tree for the given path.
*
* @param {!(string|Path)} pathObj Path to look up.
* @return {!Tree.<T>} Tree for path.
*/
subTree(pathObj: string | Path): Tree<T>;
/**
* Returns the data associated with this tree node.
*
* @return {?T} The data or null if no data exists.
*/
getValue(): T | null;
/**
* Sets data to this tree node.
*
* @param {!T} value Value to set.
*/
setValue(value: T): void;
/**
* Clears the contents of the tree node (its value and all children).
*/
clear(): void;
/**
* @return {boolean} Whether the tree has any children.
*/
hasChildren(): boolean;
/**
* @return {boolean} Whether the tree is empty (no value or children).
*/
isEmpty(): boolean;
/**
* Calls action for each child of this tree node.
*
* @param {function(!Tree.<T>)} action Action to be called for each child.
*/
forEachChild(action: (tree: Tree<T>) => void): void;
/**
* Does a depth-first traversal of this node's descendants, calling action for each one.
*
* @param {function(!Tree.<T>)} action Action to be called for each child.
* @param {boolean=} includeSelf Whether to call action on this node as well. Defaults to
* false.
* @param {boolean=} childrenFirst Whether to call action on children before calling it on
* parent.
*/
forEachDescendant(action: (tree: Tree<T>) => void, includeSelf?: boolean, childrenFirst?: boolean): void;
/**
* Calls action on each ancestor node.
*
* @param {function(!Tree.<T>)} action Action to be called on each parent; return
* true to abort.
* @param {boolean=} includeSelf Whether to call action on this node as well.
* @return {boolean} true if the action callback returned true.
*/
forEachAncestor(action: (tree: Tree<T>) => void, includeSelf?: boolean): boolean;
/**
* Does a depth-first traversal of this node's descendants. When a descendant with a value
* is found, action is called on it and traversal does not continue inside the node.
* Action is *not* called on this node.
*
* @param {function(!Tree.<T>)} action Action to be called for each child.
*/
forEachImmediateDescendantWithValue(action: (tree: Tree<T>) => void): void;
/**
* @return {!Path} The path of this tree node, as a Path.
*/
path(): Path;
/**
* @return {string} The name of the tree node.
*/
name(): string;
/**
* @return {?Tree} The parent tree node, or null if this is the root of the tree.
*/
parent(): Tree<T> | null;
/**
* Adds or removes this child from its parent based on whether it's empty or not.
*
* @private
*/
private updateParents_();
/**
* Adds or removes the passed child to this tree node, depending on whether it's empty.
*
* @param {string} childName The name of the child to update.
* @param {!Tree.<T>} child The child to update.
* @private
*/
private updateChild_(childName, child);
}

29
functions/node_modules/@firebase/database/dist/packages/database/src/core/util/VisibilityMonitor.d.ts generated vendored Normal file
View File

@@ -0,0 +1,29 @@
/**
* 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 { EventEmitter } from './EventEmitter';
/**
* @extends {EventEmitter}
*/
export declare class VisibilityMonitor extends EventEmitter {
private visible_;
static getInstance(): VisibilityMonitor;
constructor();
/**
* @param {!string} eventType
* @return {Array.<boolean>}
*/
getInitialEvent(eventType: string): boolean[];
}

154
functions/node_modules/@firebase/database/dist/packages/database/src/core/view/QueryParams.d.ts generated vendored Normal file
View File

@@ -0,0 +1,154 @@
import { NodeFilter } from './filter/NodeFilter';
import { Index } from '../snap/indexes/Index';
/**
* This class is an immutable-from-the-public-api struct containing a set of query parameters defining a
* range to be returned for a particular location. It is assumed that validation of parameters is done at the
* user-facing API level, so it is not done here.
* @constructor
*/
export declare class QueryParams {
private limitSet_;
private startSet_;
private startNameSet_;
private endSet_;
private endNameSet_;
private limit_;
private viewFrom_;
private indexStartValue_;
private indexStartName_;
private indexEndValue_;
private indexEndName_;
private index_;
/**
* Wire Protocol Constants
* @const
* @enum {string}
* @private
*/
private static readonly WIRE_PROTOCOL_CONSTANTS_;
/**
* REST Query Constants
* @const
* @enum {string}
* @private
*/
private static readonly REST_QUERY_CONSTANTS_;
/**
* Default, empty query parameters
* @type {!QueryParams}
* @const
*/
static readonly DEFAULT: QueryParams;
/**
* @return {boolean}
*/
hasStart(): boolean;
/**
* @return {boolean} True if it would return from left.
*/
isViewFromLeft(): boolean;
/**
* Only valid to call if hasStart() returns true
* @return {*}
*/
getIndexStartValue(): any;
/**
* Only valid to call if hasStart() returns true.
* Returns the starting key name for the range defined by these query parameters
* @return {!string}
*/
getIndexStartName(): string;
/**
* @return {boolean}
*/
hasEnd(): boolean;
/**
* Only valid to call if hasEnd() returns true.
* @return {*}
*/
getIndexEndValue(): any;
/**
* Only valid to call if hasEnd() returns true.
* Returns the end key name for the range defined by these query parameters
* @return {!string}
*/
getIndexEndName(): string;
/**
* @return {boolean}
*/
hasLimit(): boolean;
/**
* @return {boolean} True if a limit has been set and it has been explicitly anchored
*/
hasAnchoredLimit(): boolean;
/**
* Only valid to call if hasLimit() returns true
* @return {!number}
*/
getLimit(): number;
/**
* @return {!Index}
*/
getIndex(): Index;
/**
* @return {!QueryParams}
* @private
*/
private copy_();
/**
* @param {!number} newLimit
* @return {!QueryParams}
*/
limit(newLimit: number): QueryParams;
/**
* @param {!number} newLimit
* @return {!QueryParams}
*/
limitToFirst(newLimit: number): QueryParams;
/**
* @param {!number} newLimit
* @return {!QueryParams}
*/
limitToLast(newLimit: number): QueryParams;
/**
* @param {*} indexValue
* @param {?string=} key
* @return {!QueryParams}
*/
startAt(indexValue: any, key?: string | null): QueryParams;
/**
* @param {*} indexValue
* @param {?string=} key
* @return {!QueryParams}
*/
endAt(indexValue: any, key?: string | null): QueryParams;
/**
* @param {!Index} index
* @return {!QueryParams}
*/
orderBy(index: Index): QueryParams;
/**
* @return {!Object}
*/
getQueryObject(): Object;
/**
* @return {boolean}
*/
loadsAllData(): boolean;
/**
* @return {boolean}
*/
isDefault(): boolean;
/**
* @return {!NodeFilter}
*/
getNodeFilter(): NodeFilter;
/**
* Returns a set of REST query string parameters representing this query.
*
* @return {!Object.<string,*>} query string parameters
*/
toRestQueryStringParameters(): {
[k: string]: any;
};
}

78
functions/node_modules/@firebase/database/dist/packages/database/src/core/view/filter/LimitedFilter.d.ts generated vendored Normal file
View File

@@ -0,0 +1,78 @@
import { Node } from '../../snap/Node';
import { NodeFilter } from './NodeFilter';
import { Index } from '../../snap/indexes/Index';
import { IndexedFilter } from './IndexedFilter';
import { QueryParams } from '../QueryParams';
import { Path } from '../../util/Path';
import { CompleteChildSource } from '../CompleteChildSource';
import { ChildChangeAccumulator } from '../ChildChangeAccumulator';
/**
* Applies a limit and a range to a node and uses RangedFilter to do the heavy lifting where possible
*
* @constructor
* @implements {NodeFilter}
*/
export declare class LimitedFilter implements NodeFilter {
/**
* @const
* @type {RangedFilter}
* @private
*/
private readonly rangedFilter_;
/**
* @const
* @type {!Index}
* @private
*/
private readonly index_;
/**
* @const
* @type {number}
* @private
*/
private readonly limit_;
/**
* @const
* @type {boolean}
* @private
*/
private readonly reverse_;
/**
* @param {!QueryParams} params
*/
constructor(params: QueryParams);
/**
* @inheritDoc
*/
updateChild(snap: Node, key: string, newChild: Node, affectedPath: Path, source: CompleteChildSource, optChangeAccumulator: ChildChangeAccumulator | null): Node;
/**
* @inheritDoc
*/
updateFullNode(oldSnap: Node, newSnap: Node, optChangeAccumulator: ChildChangeAccumulator | null): Node;
/**
* @inheritDoc
*/
updatePriority(oldSnap: Node, newPriority: Node): Node;
/**
* @inheritDoc
*/
filtersNodes(): boolean;
/**
* @inheritDoc
*/
getIndexedFilter(): IndexedFilter;
/**
* @inheritDoc
*/
getIndex(): Index;
/**
* @param {!Node} snap
* @param {string} childKey
* @param {!Node} childSnap
* @param {!CompleteChildSource} source
* @param {?ChildChangeAccumulator} changeAccumulator
* @return {!Node}
* @private
*/
private fullLimitUpdateChild_(snap, childKey, childSnap, source, changeAccumulator);
}

74
functions/node_modules/@firebase/database/dist/packages/database/src/core/view/filter/NodeFilter.d.ts generated vendored Normal file
View File

@@ -0,0 +1,74 @@
/**
* 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 { Node } from '../../snap/Node';
import { Path } from '../../util/Path';
import { CompleteChildSource } from '../CompleteChildSource';
import { ChildChangeAccumulator } from '../ChildChangeAccumulator';
import { Index } from '../../snap/indexes/Index';
/**
* NodeFilter is used to update nodes and complete children of nodes while applying queries on the fly and keeping
* track of any child changes. This class does not track value changes as value changes depend on more
* than just the node itself. Different kind of queries require different kind of implementations of this interface.
* @interface
*/
export interface NodeFilter {
/**
* Update a single complete child in the snap. If the child equals the old child in the snap, this is a no-op.
* The method expects an indexed snap.
*
* @param {!Node} snap
* @param {string} key
* @param {!Node} newChild
* @param {!Path} affectedPath
* @param {!CompleteChildSource} source
* @param {?ChildChangeAccumulator} optChangeAccumulator
* @return {!Node}
*/
updateChild(snap: Node, key: string, newChild: Node, affectedPath: Path, source: CompleteChildSource, optChangeAccumulator: ChildChangeAccumulator | null): Node;
/**
* Update a node in full and output any resulting change from this complete update.
*
* @param {!Node} oldSnap
* @param {!Node} newSnap
* @param {?ChildChangeAccumulator} optChangeAccumulator
* @return {!Node}
*/
updateFullNode(oldSnap: Node, newSnap: Node, optChangeAccumulator: ChildChangeAccumulator | null): Node;
/**
* Update the priority of the root node
*
* @param {!Node} oldSnap
* @param {!Node} newPriority
* @return {!Node}
*/
updatePriority(oldSnap: Node, newPriority: Node): Node;
/**
* Returns true if children might be filtered due to query criteria
*
* @return {boolean}
*/
filtersNodes(): boolean;
/**
* Returns the index filter that this filter uses to get a NodeFilter that doesn't filter any children.
* @return {!NodeFilter}
*/
getIndexedFilter(): NodeFilter;
/**
* Returns the index that this filter uses
* @return {!Index}
*/
getIndex(): Index;
}

108
functions/node_modules/@firebase/database/dist/packages/database/src/core/view/filter/RangedFilter.d.ts generated vendored Normal file
View File

@@ -0,0 +1,108 @@
/**
* 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 { IndexedFilter } from './IndexedFilter';
import { NamedNode, Node } from '../../../core/snap/Node';
import { NodeFilter } from './NodeFilter';
import { QueryParams } from '../QueryParams';
import { Index } from '../../snap/indexes/Index';
import { Path } from '../../util/Path';
import { CompleteChildSource } from '../CompleteChildSource';
import { ChildChangeAccumulator } from '../ChildChangeAccumulator';
/**
* Filters nodes by range and uses an IndexFilter to track any changes after filtering the node
*
* @constructor
* @implements {NodeFilter}
*/
export declare class RangedFilter implements NodeFilter {
/**
* @type {!IndexedFilter}
* @const
* @private
*/
private indexedFilter_;
/**
* @const
* @type {!Index}
* @private
*/
private index_;
/**
* @const
* @type {!NamedNode}
* @private
*/
private startPost_;
/**
* @const
* @type {!NamedNode}
* @private
*/
private endPost_;
/**
* @param {!QueryParams} params
*/
constructor(params: QueryParams);
/**
* @return {!NamedNode}
*/
getStartPost(): NamedNode;
/**
* @return {!NamedNode}
*/
getEndPost(): NamedNode;
/**
* @param {!NamedNode} node
* @return {boolean}
*/
matches(node: NamedNode): boolean;
/**
* @inheritDoc
*/
updateChild(snap: Node, key: string, newChild: Node, affectedPath: Path, source: CompleteChildSource, optChangeAccumulator: ChildChangeAccumulator | null): Node;
/**
* @inheritDoc
*/
updateFullNode(oldSnap: Node, newSnap: Node, optChangeAccumulator: ChildChangeAccumulator | null): Node;
/**
* @inheritDoc
*/
updatePriority(oldSnap: Node, newPriority: Node): Node;
/**
* @inheritDoc
*/
filtersNodes(): boolean;
/**
* @inheritDoc
*/
getIndexedFilter(): IndexedFilter;
/**
* @inheritDoc
*/
getIndex(): Index;
/**
* @param {!QueryParams} params
* @return {!NamedNode}
* @private
*/
private static getStartPost_(params);
/**
* @param {!QueryParams} params
* @return {!NamedNode}
* @private
*/
private static getEndPost_(params);
}

1
functions/node_modules/@firebase/database/dist/packages/database/src/nodePatches.d.ts generated vendored Normal file
View File

@@ -0,0 +1 @@
export {};

194
functions/node_modules/@firebase/database/dist/packages/database/src/realtime/BrowserPollConnection.d.ts generated vendored Normal file
View File

@@ -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;
}

101
functions/node_modules/@firebase/database/dist/packages/database/src/realtime/Connection.d.ts generated vendored Normal file
View File

@@ -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_();
}

64
functions/node_modules/@firebase/database/dist/packages/database/src/realtime/Transport.d.ts generated vendored Normal file
View File

@@ -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;
}

54
functions/node_modules/@firebase/database/dist/packages/database/src/realtime/TransportManager.d.ts generated vendored Normal file
View File

@@ -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;
}

129
functions/node_modules/@firebase/database/dist/packages/database/src/realtime/WebSocketConnection.d.ts generated vendored Normal file
View File

@@ -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);
}

25
functions/node_modules/@firebase/database/dist/packages/database/src/realtime/polling/PacketReceiver.d.ts generated vendored Normal file
View File

@@ -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;
}

1
functions/node_modules/@firebase/database/dist/packages/database/test/browser/crawler_support.test.d.ts generated vendored Normal file
View File

@@ -0,0 +1 @@
export {};

1
functions/node_modules/@firebase/database/dist/packages/database/test/compound_write.test.d.ts generated vendored Normal file
View File

@@ -0,0 +1 @@
export {};

1
functions/node_modules/@firebase/database/dist/packages/database/test/connection.test.d.ts generated vendored Normal file
View File

@@ -0,0 +1 @@
export {};

1
functions/node_modules/@firebase/database/dist/packages/database/test/database.test.d.ts generated vendored Normal file
View File

@@ -0,0 +1 @@
import '../index';

1
functions/node_modules/@firebase/database/dist/packages/database/test/datasnapshot.test.d.ts generated vendored Normal file
View File

@@ -0,0 +1 @@
export {};

33
functions/node_modules/@firebase/database/dist/packages/database/test/helpers/EventAccumulator.d.ts generated vendored Normal file
View File

@@ -0,0 +1,33 @@
/**
* 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 EventAccumulatorFactory: {
waitsForCount: (maxCount: any) => EventAccumulator;
};
export declare class EventAccumulator {
condition: Function;
eventData: any[];
promise: any;
resolve: any;
reject: any;
private onResetFxn;
private onEventFxn;
constructor(condition: Function);
addEvent(eventData?: any): void;
reset(condition?: Function): void;
onEvent(cb: Function): void;
onReset(cb: Function): void;
_testCondition(): any;
}

21
functions/node_modules/@firebase/database/dist/packages/database/test/helpers/events.d.ts generated vendored Normal file
View File

@@ -0,0 +1,21 @@
/**
* A set of functions to clean up event handlers.
* @type {function()}
*/
export declare let eventCleanupHandlers: any[];
/** Clean up outstanding event handlers */
export declare function eventCleanup(): void;
/**
* Creates a struct which waits for many events.
* @param {Array<Array>} pathAndEvents an array of tuples of [Firebase, [event type strings]]
* @param {string=} helperName
* @return {{waiter: waiter, watchesInitializedWaiter: watchesInitializedWaiter, unregister: unregister, addExpectedEvents: addExpectedEvents}}
*/
export declare function eventTestHelper(pathAndEvents: any, helperName?: any): {
promise: Promise<{}>;
initPromise: Promise<{}>;
waiter: () => boolean;
watchesInitializedWaiter: () => boolean;
unregister: () => void;
addExpectedEvents: (moreEvents: any) => void;
};

44
functions/node_modules/@firebase/database/dist/packages/database/test/helpers/util.d.ts generated vendored Normal file
View File

@@ -0,0 +1,44 @@
import '../../index';
import { Reference } from '../../src/api/Reference';
import { Query } from '../../src/api/Query';
export declare const TEST_PROJECT: any;
export declare const DATABASE_ADDRESS: any;
export declare const DATABASE_URL: any;
/**
* Fake Firebase App Authentication functions for testing.
* @param {!FirebaseApp} app
* @return {!FirebaseApp}
*/
export declare function patchFakeAuthFunctions(app: any): any;
export declare function createTestApp(): FirebaseApp;
/**
* Gets or creates a root node to the test namespace. All calls sharing the
* value of opt_i will share an app context.
* @param {number=} i
* @param {string=} ref
* @return {Reference}
*/
export declare function getRootNode(i?: number, ref?: string): any;
/**
* Create multiple refs to the same top level
* push key - each on it's own Firebase.Context.
* @param {int=} numNodes
* @return {Reference|Array<Reference>}
*/
export declare function getRandomNode(numNodes?: any): Reference | Array<Reference>;
export declare function getQueryValue(query: Query): Promise<any>;
export declare function pause(milliseconds: number): Promise<{}>;
export declare function getPath(query: Query): string;
export declare function shuffle(arr: any, randFn?: () => number): void;
export declare function testAuthTokenProvider(app: any): {
setToken: (token: any) => Promise<void>;
setNextToken: (token: any) => void;
};
export declare function getFreshRepo(path: any): any;
export declare function getFreshRepoFromReference(ref: any): any;
export declare function getSnap(path: any): any;
export declare function getVal(path: any): any;
export declare function canCreateExtraConnections(): boolean;
export declare function buildObjFromKey(key: any): {};
export declare function testRepoInfo(url: any): RepoInfo;
export declare function repoInfoForConnectionTest(): RepoInfo;

1
functions/node_modules/@firebase/database/dist/packages/database/test/info.test.d.ts generated vendored Normal file
View File

@@ -0,0 +1 @@
export {};

1
functions/node_modules/@firebase/database/dist/packages/database/test/node.test.d.ts generated vendored Normal file
View File

@@ -0,0 +1 @@
export {};

1
functions/node_modules/@firebase/database/dist/packages/database/test/order.test.d.ts generated vendored Normal file
View File

@@ -0,0 +1 @@
export {};

1
functions/node_modules/@firebase/database/dist/packages/database/test/order_by.test.d.ts generated vendored Normal file
View File

@@ -0,0 +1 @@
export {};

1
functions/node_modules/@firebase/database/dist/packages/database/test/path.test.d.ts generated vendored Normal file
View File

@@ -0,0 +1 @@
export {};

1
functions/node_modules/@firebase/database/dist/packages/database/test/promise.test.d.ts generated vendored Normal file
View File

@@ -0,0 +1 @@
export {};

1
functions/node_modules/@firebase/database/dist/packages/database/test/query.test.d.ts generated vendored Normal file
View File

@@ -0,0 +1 @@
import '../src/core/snap/ChildrenNode';

1
functions/node_modules/@firebase/database/dist/packages/database/test/repoinfo.test.d.ts generated vendored Normal file
View File

@@ -0,0 +1 @@
export {};

1
functions/node_modules/@firebase/database/dist/packages/database/test/sortedmap.test.d.ts generated vendored Normal file
View File

@@ -0,0 +1 @@
export {};

1
functions/node_modules/@firebase/database/dist/packages/database/test/sparsesnapshottree.test.d.ts generated vendored Normal file
View File

@@ -0,0 +1 @@
export {};

1
functions/node_modules/@firebase/database/dist/packages/database/test/transaction.test.d.ts generated vendored Normal file
View File

@@ -0,0 +1 @@
import '../index';