@firebase/database 0.8.3-canary.fb90580e5 → 0.8.3

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

@@ -1,180 +0,0 @@
-/**
- * @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, SortedMapIterator } from '../util/SortedMap';
-import { Node, NamedNode } from './Node';
-import { IndexMap } from './IndexMap';
-import { Index } from './indexes/Index';
-import { Path } from '../util/Path';
-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.
- *
- * @constructor
- * @implements {Node}
- */
-export declare class ChildrenNode implements Node {
-    private readonly children_;
-    private readonly priorityNode_;
-    private indexMap_;
-    private lazyHash_;
-    static get EMPTY_NODE(): ChildrenNode;
-    /**
-     *
-     * @param {!SortedMap.<string, !Node>} children_ List of children
-     * of this node..
-     * @param {?Node} priorityNode_ The priority of this node (as a snapshot node).
-     * @param {!IndexMap} indexMap_
-     */
-    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
-     * @type {RegExp}
-     */
-    private static INTEGER_REGEXP_;
-    /** @inheritDoc */
-    val(exportFormat?: boolean): object;
-    /** @inheritDoc */
-    hash(): string;
-    /** @inheritDoc */
-    getPredecessorChildName(childName: string, childNode: Node, index: Index): string;
-    /**
-     * @param {!Index} indexDefinition
-     * @return {?string}
-     */
-    getFirstChildName(indexDefinition: Index): string | null;
-    /**
-     * @param {!Index} indexDefinition
-     * @return {?NamedNode}
-     */
-    getFirstChild(indexDefinition: Index): NamedNode | null;
-    /**
-     * Given an index, return the key name of the largest value we have, according to that index
-     * @param {!Index} indexDefinition
-     * @return {?string}
-     */
-    getLastChildName(indexDefinition: Index): string | null;
-    /**
-     * @param {!Index} indexDefinition
-     * @return {?NamedNode}
-     */
-    getLastChild(indexDefinition: Index): NamedNode | null;
-    /**
-     * @inheritDoc
-     */
-    forEachChild(index: Index, action: (key: string, node: Node) => boolean | void): boolean;
-    /**
-     * @param {!Index} indexDefinition
-     * @return {SortedMapIterator}
-     */
-    getIterator(indexDefinition: Index): SortedMapIterator<string | NamedNode, Node, NamedNode>;
-    /**
-     *
-     * @param {!NamedNode} startPost
-     * @param {!Index} indexDefinition
-     * @return {!SortedMapIterator}
-     */
-    getIteratorFrom(startPost: NamedNode, indexDefinition: Index): SortedMapIterator<string | NamedNode, Node, NamedNode>;
-    /**
-     * @param {!Index} indexDefinition
-     * @return {!SortedMapIterator}
-     */
-    getReverseIterator(indexDefinition: Index): SortedMapIterator<string | NamedNode, Node, NamedNode>;
-    /**
-     * @param {!NamedNode} endPost
-     * @param {!Index} indexDefinition
-     * @return {!SortedMapIterator}
-     */
-    getReverseIteratorFrom(endPost: NamedNode, indexDefinition: Index): SortedMapIterator<string | NamedNode, Node, NamedNode>;
-    /**
-     * @inheritDoc
-     */
-    compareTo(other: ChildrenNode): number;
-    /**
-     * @inheritDoc
-     */
-    withIndex(indexDefinition: Index): Node;
-    /**
-     * @inheritDoc
-     */
-    isIndexed(index: Index): boolean;
-    /**
-     * @inheritDoc
-     */
-    equals(other: Node): boolean;
-    /**
-     * Returns a SortedMap ordered by index, or null if the default (by-key) ordering can be used
-     * instead.
-     *
-     * @private
-     * @param {!Index} indexDefinition
-     * @return {?SortedMap.<NamedNode, Node>}
-     */
-    private resolveIndex_;
-}
-/**
- * @constructor
- * @extends {ChildrenNode}
- * @private
- */
-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.
- * @type {!MAX_NODE}
- * @const
- */
-export declare const MAX_NODE: MaxNode;
-/**
- * Document NamedNode extensions
- */
-declare module './Node' {
-    interface NamedNode {
-        MIN: NamedNode;
-        MAX: NamedNode;
-    }
-}

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

@@ -1,43 +0,0 @@
-/**
- * @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 { NamedNode, Node } from './Node';
-import { SortedMap } from '../util/SortedMap';
-import { Index } from './indexes/Index';
-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/exp/src/core/snap/LeafNode.d.ts

@@ -1,107 +0,0 @@
-/**
- * @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 './Node';
-import { Path } from '../util/Path';
-import { Index } from './indexes/Index';
-import { ChildrenNodeConstructor } from './ChildrenNode';
-import { Indexable } from '../util/misc';
-/**
- * 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
-     * @type {Array.<!string>}
-     * @const
-     */
-    static VALUE_TYPE_ORDER: string[];
-    private lazyHash_;
-    /**
-     * @implements {Node}
-     * @param {!(string|number|boolean|Object)} value_ The value to store in this leaf node.
-     *                                         The object type is possible in the event of a deferred value
-     * @param {!Node=} 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;
-    /**
-     * @inheritDoc
-     */
-    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;
-    /**
-     * @inheritDoc
-     */
-    val(exportFormat?: boolean): {};
-    /** @inheritDoc */
-    hash(): string;
-    /**
-     * Returns the value of the leaf node.
-     * @return {Object|string|number|boolean} The value of the node.
-     */
-    getValue(): Indexable | string | number | boolean;
-    /**
-     * @inheritDoc
-     */
-    compareTo(other: Node): number;
-    /**
-     * Comparison specifically for two leaf nodes
-     * @param {!LeafNode} otherLeaf
-     * @return {!number}
-     * @private
-     */
-    private compareToLeafNode_;
-    /**
-     * @inheritDoc
-     */
-    withIndex(): Node;
-    /**
-     * @inheritDoc
-     */
-    isIndexed(): boolean;
-    /**
-     * @inheritDoc
-     */
-    equals(other: Node): boolean;
-}

package/dist/exp/src/core/snap/Node.d.ts

@@ -1,148 +0,0 @@
-/**
- * @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 { Index } from './indexes/Index';
-/**
- * Node is an interface defining the common functionality for nodes in
- * a DataSnapshot.
- *
- * @interface
- */
-export interface Node {
-    /**
-     * Whether this node is a leaf node.
-     * @return {boolean} Whether this is a leaf node.
-     */
-    isLeafNode(): boolean;
-    /**
-     * Gets the priority of the node.
-     * @return {!Node} The priority of the node.
-     */
-    getPriority(): Node;
-    /**
-     * Returns a duplicate node with the new priority.
-     * @param {!Node} newPriorityNode New priority to set for the node.
-     * @return {!Node} Node with new priority.
-     */
-    updatePriority(newPriorityNode: Node): Node;
-    /**
-     * Returns the specified immediate child, or null if it doesn't exist.
-     * @param {string} childName The name of the child to retrieve.
-     * @return {!Node} The retrieved child, or an empty node.
-     */
-    getImmediateChild(childName: string): Node;
-    /**
-     * Returns a child by path, or null if it doesn't exist.
-     * @param {!Path} path The path of the child to retrieve.
-     * @return {!Node} The retrieved child or an empty node.
-     */
-    getChild(path: Path): Node;
-    /**
-     * Returns the name of the child immediately prior to the specified childNode, or null.
-     * @param {!string} childName The name of the child to find the predecessor of.
-     * @param {!Node} childNode The node to find the predecessor of.
-     * @param {!Index} index The index to use to determine the predecessor
-     * @return {?string} The name of the predecessor child, or null if childNode is the first child.
-     */
-    getPredecessorChildName(childName: string, childNode: Node, index: Index): string | null;
-    /**
-     * Returns a duplicate node, with the specified immediate child updated.
-     * Any value in the node will be removed.
-     * @param {string} childName The name of the child to update.
-     * @param {!Node} newChildNode The new child node
-     * @return {!Node} The updated node.
-     */
-    updateImmediateChild(childName: string, newChildNode: Node): Node;
-    /**
-     * Returns a duplicate node, with the specified child updated.  Any value will
-     * be removed.
-     * @param {!Path} path The path of the child to update.
-     * @param {!Node} newChildNode The new child node, which may be an empty node
-     * @return {!Node} The updated node.
-     */
-    updateChild(path: Path, newChildNode: Node): Node;
-    /**
-     * True if the immediate child specified exists
-     * @param {!string} childName
-     * @return {boolean}
-     */
-    hasChild(childName: string): boolean;
-    /**
-     * @return {boolean} True if this node has no value or children.
-     */
-    isEmpty(): boolean;
-    /**
-     * @return {number} The number of children of this node.
-     */
-    numChildren(): number;
-    /**
-     * Calls action for each child.
-     * @param {!Index} index
-     * @param {function(string, !Node)} action Action to be called for
-     * each child.  It's passed the child name and the child node.
-     * @return {*} The first truthy value return by action, or the last falsey one
-     */
-    forEachChild(index: Index, action: (a: string, b: Node) => void): unknown;
-    /**
-     * @param exportFormat True for export format (also wire protocol format).
-     * @return Value of this node as JSON.
-     */
-    val(exportFormat?: boolean): unknown;
-    /**
-     * @return {string} hash representing the node contents.
-     */
-    hash(): string;
-    /**
-     * @param {!Node} other Another node
-     * @return {!number} -1 for less than, 0 for equal, 1 for greater than other
-     */
-    compareTo(other: Node): number;
-    /**
-     * @param {!Node} other
-     * @return {boolean} Whether or not this snapshot equals other
-     */
-    equals(other: Node): boolean;
-    /**
-     * @param {!Index} indexDefinition
-     * @return {!Node} This node, with the specified index now available
-     */
-    withIndex(indexDefinition: Index): Node;
-    /**
-     * @param {!Index} indexDefinition
-     * @return {boolean}
-     */
-    isIndexed(indexDefinition: Index): boolean;
-}
-/**
- *
- * @param {!string} name
- * @param {!Node} node
- * @constructor
- * @struct
- */
-export declare class NamedNode {
-    name: string;
-    node: Node;
-    constructor(name: string, node: Node);
-    /**
-     *
-     * @param {!string} name
-     * @param {!Node} node
-     * @return {NamedNode}
-     */
-    static Wrap(name: string, node: Node): NamedNode;
-}

package/dist/exp/src/core/snap/childSet.d.ts

@@ -1,34 +0,0 @@
-/**
- * @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 { NamedNode } from './Node';
-/**
- * Takes a list of child nodes and constructs a SortedSet using the given comparison
- * function
- *
- * Uses the algorithm described in the paper linked here:
- * http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.46.1458
- *
- * @template K, V
- * @param {Array.<!NamedNode>} childList Unsorted list of children
- * @param {function(!NamedNode, !NamedNode):number} cmp The comparison method to be used
- * @param {(function(NamedNode):K)=} keyFn An optional function to extract K from a node wrapper, if K's
- *                                                        type is not NamedNode
- * @param {(function(K, K):number)=} mapSortFn An optional override for comparator used by the generated sorted map
- * @return {SortedMap.<K, V>}
- */
-export declare const buildChildSet: <K, V>(childList: NamedNode[], cmp: (a: NamedNode, b: NamedNode) => number, keyFn?: (a: NamedNode) => K, mapSortFn?: (a: K, b: K) => number) => SortedMap<K, V>;

package/dist/exp/src/core/snap/comparators.d.ts

@@ -1,19 +0,0 @@
-/**
- * @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 { NamedNode } from './Node';
-export declare function NAME_ONLY_COMPARATOR(left: NamedNode, right: NamedNode): number;
-export declare function NAME_COMPARATOR(left: string, right: string): number;

package/dist/exp/src/core/snap/indexes/Index.d.ts

@@ -1,69 +0,0 @@
-/**
- * @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, NamedNode } from '../Node';
-import { Comparator } from '../../util/SortedMap';
-/**
- *
- * @constructor
- */
-export declare abstract class Index {
-    /**
-     * @param {!NamedNode} a
-     * @param {!NamedNode} b
-     * @return {number}
-     */
-    abstract compare(a: NamedNode, b: NamedNode): number;
-    /**
-     * @param {!Node} node
-     * @return {boolean}
-     */
-    abstract isDefinedOn(node: Node): boolean;
-    /**
-     * @return {function(!NamedNode, !NamedNode):number} A standalone comparison function for
-     * this index
-     */
-    getCompare(): Comparator<NamedNode>;
-    /**
-     * Given a before and after value for a node, determine if the indexed value has changed. Even if they are different,
-     * it's possible that the changes are isolated to parts of the snapshot that are not indexed.
-     *
-     * @param {!Node} oldNode
-     * @param {!Node} newNode
-     * @return {boolean} True if the portion of the snapshot being indexed changed between oldNode and newNode
-     */
-    indexedValueChanged(oldNode: Node, newNode: Node): boolean;
-    /**
-     * @return {!NamedNode} a node wrapper that will sort equal to or less than
-     * any other node wrapper, using this index
-     */
-    minPost(): NamedNode;
-    /**
-     * @return {!NamedNode} a node wrapper that will sort greater than or equal to
-     * any other node wrapper, using this index
-     */
-    abstract maxPost(): NamedNode;
-    /**
-     * @param {*} indexValue
-     * @param {string} name
-     * @return {!NamedNode}
-     */
-    abstract makePost(indexValue: unknown, name: string): NamedNode;
-    /**
-     * @return {!string} String representation for inclusion in a query spec
-     */
-    abstract toString(): string;
-}

package/dist/exp/src/core/snap/indexes/KeyIndex.d.ts

@@ -1,54 +0,0 @@
-/**
- * @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 { Index } from './Index';
-import { Node, NamedNode } from '../Node';
-import { ChildrenNode } from '../ChildrenNode';
-export declare class KeyIndex extends Index {
-    static get __EMPTY_NODE(): ChildrenNode;
-    static set __EMPTY_NODE(val: ChildrenNode);
-    /**
-     * @inheritDoc
-     */
-    compare(a: NamedNode, b: NamedNode): number;
-    /**
-     * @inheritDoc
-     */
-    isDefinedOn(node: Node): boolean;
-    /**
-     * @inheritDoc
-     */
-    indexedValueChanged(oldNode: Node, newNode: Node): boolean;
-    /**
-     * @inheritDoc
-     */
-    minPost(): any;
-    /**
-     * @inheritDoc
-     */
-    maxPost(): NamedNode;
-    /**
-     * @param {*} indexValue
-     * @param {string} name
-     * @return {!NamedNode}
-     */
-    makePost(indexValue: string, name: string): NamedNode;
-    /**
-     * @return {!string} String representation for inclusion in a query spec
-     */
-    toString(): string;
-}
-export declare const KEY_INDEX: KeyIndex;