@firebase/database 1.0.9 → 1.0.10

package/dist/src/core/operation/Operation.d.ts

@@ -1,45 +1,45 @@
-/**
- * @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 '../util/Path';
-/**
- *
- * @enum
- */
-export declare enum OperationType {
-    OVERWRITE = 0,
-    MERGE = 1,
-    ACK_USER_WRITE = 2,
-    LISTEN_COMPLETE = 3
-}
-/**
- * @interface
- */
-export interface Operation {
-    source: OperationSource;
-    type: OperationType;
-    path: Path;
-    operationForChild(childName: string): Operation | null;
-}
-export interface OperationSource {
-    fromUser: boolean;
-    fromServer: boolean;
-    queryId: string | null;
-    tagged: boolean;
-}
-export declare function newOperationSourceUser(): OperationSource;
-export declare function newOperationSourceServer(): OperationSource;
-export declare function newOperationSourceServerTaggedQuery(queryId: string): OperationSource;
+/**
+ * @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 '../util/Path';
+/**
+ *
+ * @enum
+ */
+export declare enum OperationType {
+    OVERWRITE = 0,
+    MERGE = 1,
+    ACK_USER_WRITE = 2,
+    LISTEN_COMPLETE = 3
+}
+/**
+ * @interface
+ */
+export interface Operation {
+    source: OperationSource;
+    type: OperationType;
+    path: Path;
+    operationForChild(childName: string): Operation | null;
+}
+export interface OperationSource {
+    fromUser: boolean;
+    fromServer: boolean;
+    queryId: string | null;
+    tagged: boolean;
+}
+export declare function newOperationSourceUser(): OperationSource;
+export declare function newOperationSourceServer(): OperationSource;
+export declare function newOperationSourceServerTaggedQuery(queryId: string): OperationSource;

package/dist/src/core/operation/Overwrite.d.ts

@@ -1,28 +1,28 @@
-/**
- * @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 { Node } from '../snap/Node';
-import { Path } from '../util/Path';
-import { Operation, OperationSource, OperationType } from './Operation';
-export declare class Overwrite implements Operation {
-    source: OperationSource;
-    path: Path;
-    snap: Node;
-    /** @inheritDoc */
-    type: OperationType;
-    constructor(source: OperationSource, path: Path, snap: Node);
-    operationForChild(childName: string): Overwrite;
-}
+/**
+ * @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 { Node } from '../snap/Node';
+import { Path } from '../util/Path';
+import { Operation, OperationSource, OperationType } from './Operation';
+export declare class Overwrite implements Operation {
+    source: OperationSource;
+    path: Path;
+    snap: Node;
+    /** @inheritDoc */
+    type: OperationType;
+    constructor(source: OperationSource, path: Path, snap: Node);
+    operationForChild(childName: string): Overwrite;
+}

package/dist/src/core/snap/ChildrenNode.d.ts

@@ -1,112 +1,112 @@
-/**
- * @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 '../util/Path';
-import { SortedMap, SortedMapIterator } from '../util/SortedMap';
-import { Index } from './indexes/Index';
-import { IndexMap } from './IndexMap';
-import { NamedNode, Node } from './Node';
-export interface ChildrenNodeConstructor {
-    new (children_: SortedMap<string, Node>, priorityNode_: Node | null, indexMap_: IndexMap): ChildrenNode;
-    EMPTY_NODE: ChildrenNode;
-}
-/**
- * ChildrenNode is a class for storing internal nodes in a DataSnapshot
- * (i.e. nodes with children).  It implements Node and stores the
- * list of children in the children property, sorted by child name.
- */
-export declare class ChildrenNode implements Node {
-    private readonly children_;
-    private readonly priorityNode_;
-    private indexMap_;
-    private lazyHash_;
-    static get EMPTY_NODE(): ChildrenNode;
-    /**
-     * @param children_ - List of children of this node..
-     * @param priorityNode_ - The priority of this node (as a snapshot node).
-     */
-    constructor(children_: SortedMap<string, Node>, priorityNode_: Node | null, indexMap_: IndexMap);
-    /** @inheritDoc */
-    isLeafNode(): boolean;
-    /** @inheritDoc */
-    getPriority(): Node;
-    /** @inheritDoc */
-    updatePriority(newPriorityNode: Node): Node;
-    /** @inheritDoc */
-    getImmediateChild(childName: string): Node;
-    /** @inheritDoc */
-    getChild(path: Path): Node;
-    /** @inheritDoc */
-    hasChild(childName: string): boolean;
-    /** @inheritDoc */
-    updateImmediateChild(childName: string, newChildNode: Node): Node;
-    /** @inheritDoc */
-    updateChild(path: Path, newChildNode: Node): Node;
-    /** @inheritDoc */
-    isEmpty(): boolean;
-    /** @inheritDoc */
-    numChildren(): number;
-    private static INTEGER_REGEXP_;
-    /** @inheritDoc */
-    val(exportFormat?: boolean): object;
-    /** @inheritDoc */
-    hash(): string;
-    /** @inheritDoc */
-    getPredecessorChildName(childName: string, childNode: Node, index: Index): string;
-    getFirstChildName(indexDefinition: Index): string | null;
-    getFirstChild(indexDefinition: Index): NamedNode | null;
-    /**
-     * Given an index, return the key name of the largest value we have, according to that index
-     */
-    getLastChildName(indexDefinition: Index): string | null;
-    getLastChild(indexDefinition: Index): NamedNode | null;
-    forEachChild(index: Index, action: (key: string, node: Node) => boolean | void): boolean;
-    getIterator(indexDefinition: Index): SortedMapIterator<string | NamedNode, Node, NamedNode>;
-    getIteratorFrom(startPost: NamedNode, indexDefinition: Index): SortedMapIterator<string | NamedNode, Node, NamedNode>;
-    getReverseIterator(indexDefinition: Index): SortedMapIterator<string | NamedNode, Node, NamedNode>;
-    getReverseIteratorFrom(endPost: NamedNode, indexDefinition: Index): SortedMapIterator<string | NamedNode, Node, NamedNode>;
-    compareTo(other: ChildrenNode): number;
-    withIndex(indexDefinition: Index): Node;
-    isIndexed(index: Index): boolean;
-    equals(other: Node): boolean;
-    /**
-     * Returns a SortedMap ordered by index, or null if the default (by-key) ordering can be used
-     * instead.
-     *
-     */
-    private resolveIndex_;
-}
-export declare class MaxNode extends ChildrenNode {
-    constructor();
-    compareTo(other: Node): number;
-    equals(other: Node): boolean;
-    getPriority(): MaxNode;
-    getImmediateChild(childName: string): ChildrenNode;
-    isEmpty(): boolean;
-}
-/**
- * Marker that will sort higher than any other snapshot.
- */
-export declare const MAX_NODE: MaxNode;
-/**
- * Document NamedNode extensions
- */
-declare module './Node' {
-    interface NamedNode {
-        MIN: NamedNode;
-        MAX: NamedNode;
-    }
-}
+/**
+ * @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 '../util/Path';
+import { SortedMap, SortedMapIterator } from '../util/SortedMap';
+import { Index } from './indexes/Index';
+import { IndexMap } from './IndexMap';
+import { NamedNode, Node } from './Node';
+export interface ChildrenNodeConstructor {
+    new (children_: SortedMap<string, Node>, priorityNode_: Node | null, indexMap_: IndexMap): ChildrenNode;
+    EMPTY_NODE: ChildrenNode;
+}
+/**
+ * ChildrenNode is a class for storing internal nodes in a DataSnapshot
+ * (i.e. nodes with children).  It implements Node and stores the
+ * list of children in the children property, sorted by child name.
+ */
+export declare class ChildrenNode implements Node {
+    private readonly children_;
+    private readonly priorityNode_;
+    private indexMap_;
+    private lazyHash_;
+    static get EMPTY_NODE(): ChildrenNode;
+    /**
+     * @param children_ - List of children of this node..
+     * @param priorityNode_ - The priority of this node (as a snapshot node).
+     */
+    constructor(children_: SortedMap<string, Node>, priorityNode_: Node | null, indexMap_: IndexMap);
+    /** @inheritDoc */
+    isLeafNode(): boolean;
+    /** @inheritDoc */
+    getPriority(): Node;
+    /** @inheritDoc */
+    updatePriority(newPriorityNode: Node): Node;
+    /** @inheritDoc */
+    getImmediateChild(childName: string): Node;
+    /** @inheritDoc */
+    getChild(path: Path): Node;
+    /** @inheritDoc */
+    hasChild(childName: string): boolean;
+    /** @inheritDoc */
+    updateImmediateChild(childName: string, newChildNode: Node): Node;
+    /** @inheritDoc */
+    updateChild(path: Path, newChildNode: Node): Node;
+    /** @inheritDoc */
+    isEmpty(): boolean;
+    /** @inheritDoc */
+    numChildren(): number;
+    private static INTEGER_REGEXP_;
+    /** @inheritDoc */
+    val(exportFormat?: boolean): object;
+    /** @inheritDoc */
+    hash(): string;
+    /** @inheritDoc */
+    getPredecessorChildName(childName: string, childNode: Node, index: Index): string;
+    getFirstChildName(indexDefinition: Index): string | null;
+    getFirstChild(indexDefinition: Index): NamedNode | null;
+    /**
+     * Given an index, return the key name of the largest value we have, according to that index
+     */
+    getLastChildName(indexDefinition: Index): string | null;
+    getLastChild(indexDefinition: Index): NamedNode | null;
+    forEachChild(index: Index, action: (key: string, node: Node) => boolean | void): boolean;
+    getIterator(indexDefinition: Index): SortedMapIterator<string | NamedNode, Node, NamedNode>;
+    getIteratorFrom(startPost: NamedNode, indexDefinition: Index): SortedMapIterator<string | NamedNode, Node, NamedNode>;
+    getReverseIterator(indexDefinition: Index): SortedMapIterator<string | NamedNode, Node, NamedNode>;
+    getReverseIteratorFrom(endPost: NamedNode, indexDefinition: Index): SortedMapIterator<string | NamedNode, Node, NamedNode>;
+    compareTo(other: ChildrenNode): number;
+    withIndex(indexDefinition: Index): Node;
+    isIndexed(index: Index): boolean;
+    equals(other: Node): boolean;
+    /**
+     * Returns a SortedMap ordered by index, or null if the default (by-key) ordering can be used
+     * instead.
+     *
+     */
+    private resolveIndex_;
+}
+export declare class MaxNode extends ChildrenNode {
+    constructor();
+    compareTo(other: Node): number;
+    equals(other: Node): boolean;
+    getPriority(): MaxNode;
+    getImmediateChild(childName: string): ChildrenNode;
+    isEmpty(): boolean;
+}
+/**
+ * Marker that will sort higher than any other snapshot.
+ */
+export declare const MAX_NODE: MaxNode;
+/**
+ * Document NamedNode extensions
+ */
+declare module './Node' {
+    interface NamedNode {
+        MIN: NamedNode;
+        MAX: NamedNode;
+    }
+}

package/dist/src/core/snap/IndexMap.d.ts

@@ -1,43 +1,43 @@
-/**
- * @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 { SortedMap } from '../util/SortedMap';
-import { Index } from './indexes/Index';
-import { NamedNode, Node } from './Node';
-export declare class IndexMap {
-    private indexes_;
-    private indexSet_;
-    /**
-     * The default IndexMap for nodes without a priority
-     */
-    static get Default(): IndexMap;
-    constructor(indexes_: {
-        [k: string]: SortedMap<NamedNode, Node> | /*FallbackType*/ object;
-    }, indexSet_: {
-        [k: string]: Index;
-    });
-    get(indexKey: string): SortedMap<NamedNode, Node> | null;
-    hasIndex(indexDefinition: Index): boolean;
-    addIndex(indexDefinition: Index, existingChildren: SortedMap<string, Node>): IndexMap;
-    /**
-     * Ensure that this node is properly tracked in any indexes that we're maintaining
-     */
-    addToIndexes(namedNode: NamedNode, existingChildren: SortedMap<string, Node>): IndexMap;
-    /**
-     * Create a new IndexMap instance with the given value removed
-     */
-    removeFromIndexes(namedNode: NamedNode, existingChildren: SortedMap<string, Node>): IndexMap;
-}
+/**
+ * @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 { SortedMap } from '../util/SortedMap';
+import { Index } from './indexes/Index';
+import { NamedNode, Node } from './Node';
+export declare class IndexMap {
+    private indexes_;
+    private indexSet_;
+    /**
+     * The default IndexMap for nodes without a priority
+     */
+    static get Default(): IndexMap;
+    constructor(indexes_: {
+        [k: string]: SortedMap<NamedNode, Node> | /*FallbackType*/ object;
+    }, indexSet_: {
+        [k: string]: Index;
+    });
+    get(indexKey: string): SortedMap<NamedNode, Node> | null;
+    hasIndex(indexDefinition: Index): boolean;
+    addIndex(indexDefinition: Index, existingChildren: SortedMap<string, Node>): IndexMap;
+    /**
+     * Ensure that this node is properly tracked in any indexes that we're maintaining
+     */
+    addToIndexes(namedNode: NamedNode, existingChildren: SortedMap<string, Node>): IndexMap;
+    /**
+     * Create a new IndexMap instance with the given value removed
+     */
+    removeFromIndexes(namedNode: NamedNode, existingChildren: SortedMap<string, Node>): IndexMap;
+}

package/dist/src/core/snap/LeafNode.d.ts

@@ -1,83 +1,83 @@
-/**
- * @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 { Indexable } from '../util/misc';
-import { Path } from '../util/Path';
-import { ChildrenNodeConstructor } from './ChildrenNode';
-import { Index } from './indexes/Index';
-import { Node } from './Node';
-/**
- * LeafNode is a class for storing leaf nodes in a DataSnapshot.  It
- * implements Node and stores the value of the node (a string,
- * number, or boolean) accessible via getValue().
- */
-export declare class LeafNode implements Node {
-    private readonly value_;
-    private priorityNode_;
-    static set __childrenNodeConstructor(val: ChildrenNodeConstructor);
-    static get __childrenNodeConstructor(): ChildrenNodeConstructor;
-    /**
-     * The sort order for comparing leaf nodes of different types. If two leaf nodes have
-     * the same type, the comparison falls back to their value
-     */
-    static VALUE_TYPE_ORDER: string[];
-    private lazyHash_;
-    /**
-     * @param value_ - The value to store in this leaf node. The object type is
-     * possible in the event of a deferred value
-     * @param priorityNode_ - The priority of this node.
-     */
-    constructor(value_: string | number | boolean | Indexable, priorityNode_?: Node);
-    /** @inheritDoc */
-    isLeafNode(): boolean;
-    /** @inheritDoc */
-    getPriority(): Node;
-    /** @inheritDoc */
-    updatePriority(newPriorityNode: Node): Node;
-    /** @inheritDoc */
-    getImmediateChild(childName: string): Node;
-    /** @inheritDoc */
-    getChild(path: Path): Node;
-    hasChild(): boolean;
-    /** @inheritDoc */
-    getPredecessorChildName(childName: string, childNode: Node): null;
-    /** @inheritDoc */
-    updateImmediateChild(childName: string, newChildNode: Node): Node;
-    /** @inheritDoc */
-    updateChild(path: Path, newChildNode: Node): Node;
-    /** @inheritDoc */
-    isEmpty(): boolean;
-    /** @inheritDoc */
-    numChildren(): number;
-    /** @inheritDoc */
-    forEachChild(index: Index, action: (s: string, n: Node) => void): boolean;
-    val(exportFormat?: boolean): {};
-    /** @inheritDoc */
-    hash(): string;
-    /**
-     * Returns the value of the leaf node.
-     * @returns The value of the node.
-     */
-    getValue(): Indexable | string | number | boolean;
-    compareTo(other: Node): number;
-    /**
-     * Comparison specifically for two leaf nodes
-     */
-    private compareToLeafNode_;
-    withIndex(): Node;
-    isIndexed(): boolean;
-    equals(other: Node): 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 { Indexable } from '../util/misc';
+import { Path } from '../util/Path';
+import { ChildrenNodeConstructor } from './ChildrenNode';
+import { Index } from './indexes/Index';
+import { Node } from './Node';
+/**
+ * LeafNode is a class for storing leaf nodes in a DataSnapshot.  It
+ * implements Node and stores the value of the node (a string,
+ * number, or boolean) accessible via getValue().
+ */
+export declare class LeafNode implements Node {
+    private readonly value_;
+    private priorityNode_;
+    static set __childrenNodeConstructor(val: ChildrenNodeConstructor);
+    static get __childrenNodeConstructor(): ChildrenNodeConstructor;
+    /**
+     * The sort order for comparing leaf nodes of different types. If two leaf nodes have
+     * the same type, the comparison falls back to their value
+     */
+    static VALUE_TYPE_ORDER: string[];
+    private lazyHash_;
+    /**
+     * @param value_ - The value to store in this leaf node. The object type is
+     * possible in the event of a deferred value
+     * @param priorityNode_ - The priority of this node.
+     */
+    constructor(value_: string | number | boolean | Indexable, priorityNode_?: Node);
+    /** @inheritDoc */
+    isLeafNode(): boolean;
+    /** @inheritDoc */
+    getPriority(): Node;
+    /** @inheritDoc */
+    updatePriority(newPriorityNode: Node): Node;
+    /** @inheritDoc */
+    getImmediateChild(childName: string): Node;
+    /** @inheritDoc */
+    getChild(path: Path): Node;
+    hasChild(): boolean;
+    /** @inheritDoc */
+    getPredecessorChildName(childName: string, childNode: Node): null;
+    /** @inheritDoc */
+    updateImmediateChild(childName: string, newChildNode: Node): Node;
+    /** @inheritDoc */
+    updateChild(path: Path, newChildNode: Node): Node;
+    /** @inheritDoc */
+    isEmpty(): boolean;
+    /** @inheritDoc */
+    numChildren(): number;
+    /** @inheritDoc */
+    forEachChild(index: Index, action: (s: string, n: Node) => void): boolean;
+    val(exportFormat?: boolean): {};
+    /** @inheritDoc */
+    hash(): string;
+    /**
+     * Returns the value of the leaf node.
+     * @returns The value of the node.
+     */
+    getValue(): Indexable | string | number | boolean;
+    compareTo(other: Node): number;
+    /**
+     * Comparison specifically for two leaf nodes
+     */
+    private compareToLeafNode_;
+    withIndex(): Node;
+    isIndexed(): boolean;
+    equals(other: Node): boolean;
+}