@firebase/database 1.0.9 → 1.0.10

package/dist/node-esm/src/core/util/ImmutableTree.d.ts

@@ -1,117 +1,117 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * 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 { Path } from './Path';
-import { SortedMap } from './SortedMap';
-/**
- * A tree with immutable elements.
- */
-export declare class ImmutableTree<T> {
-    readonly value: T | null;
-    readonly children: SortedMap<string, ImmutableTree<T>>;
-    static fromObject<T>(obj: {
-        [k: string]: T;
-    }): ImmutableTree<T>;
-    constructor(value: T | null, children?: SortedMap<string, ImmutableTree<T>>);
-    /**
-     * True if the value is empty and there are no children
-     */
-    isEmpty(): boolean;
-    /**
-     * Given a path and predicate, return the first node and the path to that node
-     * where the predicate returns true.
-     *
-     * TODO Do a perf test -- If we're creating a bunch of `{path: value:}`
-     * objects on the way back out, it may be better to pass down a pathSoFar obj.
-     *
-     * @param relativePath - The remainder of the path
-     * @param predicate - The predicate to satisfy to return a node
-     */
-    findRootMostMatchingPathAndValue(relativePath: Path, predicate: (a: T) => boolean): {
-        path: Path;
-        value: T;
-    } | null;
-    /**
-     * Find, if it exists, the shortest subpath of the given path that points a defined
-     * value in the tree
-     */
-    findRootMostValueAndPath(relativePath: Path): {
-        path: Path;
-        value: T;
-    } | null;
-    /**
-     * @returns The subtree at the given path
-     */
-    subtree(relativePath: Path): ImmutableTree<T>;
-    /**
-     * Sets a value at the specified path.
-     *
-     * @param relativePath - Path to set value at.
-     * @param toSet - Value to set.
-     * @returns Resulting tree.
-     */
-    set(relativePath: Path, toSet: T | null): ImmutableTree<T>;
-    /**
-     * Removes the value at the specified path.
-     *
-     * @param relativePath - Path to value to remove.
-     * @returns Resulting tree.
-     */
-    remove(relativePath: Path): ImmutableTree<T>;
-    /**
-     * Gets a value from the tree.
-     *
-     * @param relativePath - Path to get value for.
-     * @returns Value at path, or null.
-     */
-    get(relativePath: Path): T | null;
-    /**
-     * Replace the subtree at the specified path with the given new tree.
-     *
-     * @param relativePath - Path to replace subtree for.
-     * @param newTree - New tree.
-     * @returns Resulting tree.
-     */
-    setTree(relativePath: Path, newTree: ImmutableTree<T>): ImmutableTree<T>;
-    /**
-     * Performs a depth first fold on this tree. Transforms a tree into a single
-     * value, given a function that operates on the path to a node, an optional
-     * current value, and a map of child names to folded subtrees
-     */
-    fold<V>(fn: (path: Path, value: T, children: {
-        [k: string]: V;
-    }) => V): V;
-    /**
-     * Recursive helper for public-facing fold() method
-     */
-    private fold_;
-    /**
-     * Find the first matching value on the given path. Return the result of applying f to it.
-     */
-    findOnPath<V>(path: Path, f: (path: Path, value: T) => V | null): V | null;
-    private findOnPath_;
-    foreachOnPath(path: Path, f: (path: Path, value: T) => void): ImmutableTree<T>;
-    private foreachOnPath_;
-    /**
-     * Calls the given function for each node in the tree that has a value.
-     *
-     * @param f - A function to be called with the path from the root of the tree to
-     * a node, and the value at that node. Called in depth-first order.
-     */
-    foreach(f: (path: Path, value: T) => void): void;
-    private foreach_;
-    foreachChild(f: (name: string, value: T) => void): void;
-}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * 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 { Path } from './Path';
+import { SortedMap } from './SortedMap';
+/**
+ * A tree with immutable elements.
+ */
+export declare class ImmutableTree<T> {
+    readonly value: T | null;
+    readonly children: SortedMap<string, ImmutableTree<T>>;
+    static fromObject<T>(obj: {
+        [k: string]: T;
+    }): ImmutableTree<T>;
+    constructor(value: T | null, children?: SortedMap<string, ImmutableTree<T>>);
+    /**
+     * True if the value is empty and there are no children
+     */
+    isEmpty(): boolean;
+    /**
+     * Given a path and predicate, return the first node and the path to that node
+     * where the predicate returns true.
+     *
+     * TODO Do a perf test -- If we're creating a bunch of `{path: value:}`
+     * objects on the way back out, it may be better to pass down a pathSoFar obj.
+     *
+     * @param relativePath - The remainder of the path
+     * @param predicate - The predicate to satisfy to return a node
+     */
+    findRootMostMatchingPathAndValue(relativePath: Path, predicate: (a: T) => boolean): {
+        path: Path;
+        value: T;
+    } | null;
+    /**
+     * Find, if it exists, the shortest subpath of the given path that points a defined
+     * value in the tree
+     */
+    findRootMostValueAndPath(relativePath: Path): {
+        path: Path;
+        value: T;
+    } | null;
+    /**
+     * @returns The subtree at the given path
+     */
+    subtree(relativePath: Path): ImmutableTree<T>;
+    /**
+     * Sets a value at the specified path.
+     *
+     * @param relativePath - Path to set value at.
+     * @param toSet - Value to set.
+     * @returns Resulting tree.
+     */
+    set(relativePath: Path, toSet: T | null): ImmutableTree<T>;
+    /**
+     * Removes the value at the specified path.
+     *
+     * @param relativePath - Path to value to remove.
+     * @returns Resulting tree.
+     */
+    remove(relativePath: Path): ImmutableTree<T>;
+    /**
+     * Gets a value from the tree.
+     *
+     * @param relativePath - Path to get value for.
+     * @returns Value at path, or null.
+     */
+    get(relativePath: Path): T | null;
+    /**
+     * Replace the subtree at the specified path with the given new tree.
+     *
+     * @param relativePath - Path to replace subtree for.
+     * @param newTree - New tree.
+     * @returns Resulting tree.
+     */
+    setTree(relativePath: Path, newTree: ImmutableTree<T>): ImmutableTree<T>;
+    /**
+     * Performs a depth first fold on this tree. Transforms a tree into a single
+     * value, given a function that operates on the path to a node, an optional
+     * current value, and a map of child names to folded subtrees
+     */
+    fold<V>(fn: (path: Path, value: T, children: {
+        [k: string]: V;
+    }) => V): V;
+    /**
+     * Recursive helper for public-facing fold() method
+     */
+    private fold_;
+    /**
+     * Find the first matching value on the given path. Return the result of applying f to it.
+     */
+    findOnPath<V>(path: Path, f: (path: Path, value: T) => V | null): V | null;
+    private findOnPath_;
+    foreachOnPath(path: Path, f: (path: Path, value: T) => void): ImmutableTree<T>;
+    private foreachOnPath_;
+    /**
+     * Calls the given function for each node in the tree that has a value.
+     *
+     * @param f - A function to be called with the path from the root of the tree to
+     * a node, and the value at that node. Called in depth-first order.
+     */
+    foreach(f: (path: Path, value: T) => void): void;
+    private foreach_;
+    foreachChild(f: (name: string, value: T) => void): void;
+}

package/dist/node-esm/src/core/util/NextPushId.d.ts

@@ -1,33 +1,33 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * 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.
- */
-/**
- * Fancy ID generator that creates 20-character string identifiers with the
- * following properties:
- *
- * 1. They're based on timestamp so that they sort *after* any existing ids.
- * 2. They contain 72-bits of random data after the timestamp so that IDs won't
- *    collide with other clients' IDs.
- * 3. They sort *lexicographically* (so the timestamp is converted to characters
- *    that will sort properly).
- * 4. They're monotonically increasing. Even if you generate more than one in
- *    the same timestamp, the latter ones will sort after the former ones. We do
- *    this by using the previous random bits but "incrementing" them by 1 (only
- *    in the case of a timestamp collision).
- */
-export declare const nextPushId: (now: number) => string;
-export declare const successor: (key: string) => string;
-export declare const predecessor: (key: string) => string;
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * 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.
+ */
+/**
+ * Fancy ID generator that creates 20-character string identifiers with the
+ * following properties:
+ *
+ * 1. They're based on timestamp so that they sort *after* any existing ids.
+ * 2. They contain 72-bits of random data after the timestamp so that IDs won't
+ *    collide with other clients' IDs.
+ * 3. They sort *lexicographically* (so the timestamp is converted to characters
+ *    that will sort properly).
+ * 4. They're monotonically increasing. Even if you generate more than one in
+ *    the same timestamp, the latter ones will sort after the former ones. We do
+ *    this by using the previous random bits but "incrementing" them by 1 (only
+ *    in the case of a timestamp collision).
+ */
+export declare const nextPushId: (now: number) => string;
+export declare const successor: (key: string) => string;
+export declare const predecessor: (key: string) => string;

package/dist/node-esm/src/core/util/OnlineMonitor.d.ts

@@ -1,31 +1,31 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * 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';
-/**
- * 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.
- */
-export declare class OnlineMonitor extends EventEmitter {
-    private online_;
-    static getInstance(): OnlineMonitor;
-    constructor();
-    getInitialEvent(eventType: string): boolean[];
-    currentlyOnline(): boolean;
-}
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * 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';
+/**
+ * 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.
+ */
+export declare class OnlineMonitor extends EventEmitter {
+    private online_;
+    static getInstance(): OnlineMonitor;
+    constructor();
+    getInitialEvent(eventType: string): boolean[];
+    currentlyOnline(): boolean;
+}

package/dist/node-esm/src/core/util/Path.d.ts

@@ -1,94 +1,94 @@
-/**
- * @license
- * Copyright 2017 Google LLC
- *
- * 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.
- */
-/**
- * An immutable object representing a parsed path.  It's immutable so that you
- * can pass them around to other functions without worrying about them changing
- * it.
- */
-export declare class Path {
-    pieces_: string[];
-    pieceNum_: number;
-    /**
-     * @param pathOrString - Path string to parse, or another path, or the raw
-     * tokens array
-     */
-    constructor(pathOrString: string | string[], pieceNum?: number);
-    toString(): string;
-}
-export declare function newEmptyPath(): Path;
-export declare function pathGetFront(path: Path): string | null;
-/**
- * @returns The number of segments in this path
- */
-export declare function pathGetLength(path: Path): number;
-export declare function pathPopFront(path: Path): Path;
-export declare function pathGetBack(path: Path): string | null;
-export declare function pathToUrlEncodedString(path: Path): string;
-/**
- * Shallow copy of the parts of the path.
- *
- */
-export declare function pathSlice(path: Path, begin?: number): string[];
-export declare function pathParent(path: Path): Path | null;
-export declare function pathChild(path: Path, childPathObj: string | Path): Path;
-/**
- * @returns True if there are no segments in this path
- */
-export declare function pathIsEmpty(path: Path): boolean;
-/**
- * @returns The path from outerPath to innerPath
- */
-export declare function newRelativePath(outerPath: Path, innerPath: Path): Path;
-/**
- * @returns -1, 0, 1 if left is less, equal, or greater than the right.
- */
-export declare function pathCompare(left: Path, right: Path): number;
-/**
- * @returns true if paths are the same.
- */
-export declare function pathEquals(path: Path, other: Path): boolean;
-/**
- * @returns True if this path is a parent of (or the same as) other
- */
-export declare function pathContains(path: Path, other: Path): boolean;
-/**
- * Dynamic (mutable) path used to count path lengths.
- *
- * This class is used to efficiently check paths for valid
- * length (in UTF8 bytes) and depth (used in path validation).
- *
- * Throws Error exception if path is ever invalid.
- *
- * The definition of a path always begins with '/'.
- */
-export declare class ValidationPath {
-    errorPrefix_: string;
-    parts_: string[];
-    /** Initialize to number of '/' chars needed in path. */
-    byteLength_: number;
-    /**
-     * @param path - Initial Path.
-     * @param errorPrefix_ - Prefix for any error messages.
-     */
-    constructor(path: Path, errorPrefix_: string);
-}
-export declare function validationPathPush(validationPath: ValidationPath, child: string): void;
-export declare function validationPathPop(validationPath: ValidationPath): void;
-/**
- * String for use in error messages - uses '.' notation for path.
- */
-export declare function validationPathToErrorString(validationPath: ValidationPath): string;
+/**
+ * @license
+ * Copyright 2017 Google LLC
+ *
+ * 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.
+ */
+/**
+ * An immutable object representing a parsed path.  It's immutable so that you
+ * can pass them around to other functions without worrying about them changing
+ * it.
+ */
+export declare class Path {
+    pieces_: string[];
+    pieceNum_: number;
+    /**
+     * @param pathOrString - Path string to parse, or another path, or the raw
+     * tokens array
+     */
+    constructor(pathOrString: string | string[], pieceNum?: number);
+    toString(): string;
+}
+export declare function newEmptyPath(): Path;
+export declare function pathGetFront(path: Path): string | null;
+/**
+ * @returns The number of segments in this path
+ */
+export declare function pathGetLength(path: Path): number;
+export declare function pathPopFront(path: Path): Path;
+export declare function pathGetBack(path: Path): string | null;
+export declare function pathToUrlEncodedString(path: Path): string;
+/**
+ * Shallow copy of the parts of the path.
+ *
+ */
+export declare function pathSlice(path: Path, begin?: number): string[];
+export declare function pathParent(path: Path): Path | null;
+export declare function pathChild(path: Path, childPathObj: string | Path): Path;
+/**
+ * @returns True if there are no segments in this path
+ */
+export declare function pathIsEmpty(path: Path): boolean;
+/**
+ * @returns The path from outerPath to innerPath
+ */
+export declare function newRelativePath(outerPath: Path, innerPath: Path): Path;
+/**
+ * @returns -1, 0, 1 if left is less, equal, or greater than the right.
+ */
+export declare function pathCompare(left: Path, right: Path): number;
+/**
+ * @returns true if paths are the same.
+ */
+export declare function pathEquals(path: Path, other: Path): boolean;
+/**
+ * @returns True if this path is a parent of (or the same as) other
+ */
+export declare function pathContains(path: Path, other: Path): boolean;
+/**
+ * Dynamic (mutable) path used to count path lengths.
+ *
+ * This class is used to efficiently check paths for valid
+ * length (in UTF8 bytes) and depth (used in path validation).
+ *
+ * Throws Error exception if path is ever invalid.
+ *
+ * The definition of a path always begins with '/'.
+ */
+export declare class ValidationPath {
+    errorPrefix_: string;
+    parts_: string[];
+    /** Initialize to number of '/' chars needed in path. */
+    byteLength_: number;
+    /**
+     * @param path - Initial Path.
+     * @param errorPrefix_ - Prefix for any error messages.
+     */
+    constructor(path: Path, errorPrefix_: string);
+}
+export declare function validationPathPush(validationPath: ValidationPath, child: string): void;
+export declare function validationPathPop(validationPath: ValidationPath): void;
+/**
+ * String for use in error messages - uses '.' notation for path.
+ */
+export declare function validationPathToErrorString(validationPath: ValidationPath): string;