diff options
Diffstat (limited to 'frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap')
13 files changed, 639 insertions, 0 deletions
diff --git a/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/ChildrenNode.d.ts b/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/ChildrenNode.d.ts new file mode 100644 index 0000000..0cc0519 --- /dev/null +++ b/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/ChildrenNode.d.ts @@ -0,0 +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; + } +} diff --git a/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/IndexMap.d.ts b/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/IndexMap.d.ts new file mode 100644 index 0000000..42e64ee --- /dev/null +++ b/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/IndexMap.d.ts @@ -0,0 +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; +} diff --git a/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/LeafNode.d.ts b/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/LeafNode.d.ts new file mode 100644 index 0000000..6eecc9d --- /dev/null +++ b/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/LeafNode.d.ts @@ -0,0 +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; +} diff --git a/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/Node.d.ts b/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/Node.d.ts new file mode 100644 index 0000000..99d379c --- /dev/null +++ b/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/Node.d.ts @@ -0,0 +1,126 @@ +/** + * @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. + * @returns Whether this is a leaf node. + */ + isLeafNode(): boolean; + /** + * Gets the priority of the node. + * @returns The priority of the node. + */ + getPriority(): Node; + /** + * Returns a duplicate node with the new priority. + * @param newPriorityNode - New priority to set for the node. + * @returns Node with new priority. + */ + updatePriority(newPriorityNode: Node): Node; + /** + * Returns the specified immediate child, or null if it doesn't exist. + * @param childName - The name of the child to retrieve. + * @returns 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 - The path of the child to retrieve. + * @returns 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 childName - The name of the child to find the predecessor of. + * @param childNode - The node to find the predecessor of. + * @param index - The index to use to determine the predecessor + * @returns 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 childName - The name of the child to update. + * @param newChildNode - The new child node + * @returns 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 - The path of the child to update. + * @param newChildNode - The new child node, which may be an empty node + * @returns The updated node. + */ + updateChild(path: Path, newChildNode: Node): Node; + /** + * True if the immediate child specified exists + */ + hasChild(childName: string): boolean; + /** + * @returns True if this node has no value or children. + */ + isEmpty(): boolean; + /** + * @returns The number of children of this node. + */ + numChildren(): number; + /** + * Calls action for each child. + * @param action - Action to be called for + * each child. It's passed the child name and the child node. + * @returns 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). + * @returns Value of this node as JSON. + */ + val(exportFormat?: boolean): unknown; + /** + * @returns hash representing the node contents. + */ + hash(): string; + /** + * @param other - Another node + * @returns -1 for less than, 0 for equal, 1 for greater than other + */ + compareTo(other: Node): number; + /** + * @returns Whether or not this snapshot equals other + */ + equals(other: Node): boolean; + /** + * @returns This node, with the specified index now available + */ + withIndex(indexDefinition: Index): Node; + isIndexed(indexDefinition: Index): boolean; +} +export declare class NamedNode { + name: string; + node: Node; + constructor(name: string, node: Node); + static Wrap(name: string, node: Node): NamedNode; +} diff --git a/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/childSet.d.ts b/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/childSet.d.ts new file mode 100644 index 0000000..42ce33a --- /dev/null +++ b/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/childSet.d.ts @@ -0,0 +1,32 @@ +/** + * @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 + * + * @param childList - Unsorted list of children + * @param cmp - The comparison method to be used + * @param keyFn - An optional function to extract K from a node wrapper, if K's + * type is not NamedNode + * @param mapSortFn - An optional override for comparator used by the generated sorted map + */ +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>; diff --git a/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/comparators.d.ts b/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/comparators.d.ts new file mode 100644 index 0000000..a39e3aa --- /dev/null +++ b/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/comparators.d.ts @@ -0,0 +1,19 @@ +/** + * @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; diff --git a/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/indexes/Index.d.ts b/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/indexes/Index.d.ts new file mode 100644 index 0000000..04c1fa9 --- /dev/null +++ b/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/indexes/Index.d.ts @@ -0,0 +1,50 @@ +/** + * @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 { Comparator } from '../../util/SortedMap'; +import { Node, NamedNode } from '../Node'; +export declare abstract class Index { + abstract compare(a: NamedNode, b: NamedNode): number; + abstract isDefinedOn(node: Node): boolean; + /** + * @returns 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. + * + * + * @returns True if the portion of the snapshot being indexed changed between oldNode and newNode + */ + indexedValueChanged(oldNode: Node, newNode: Node): boolean; + /** + * @returns a node wrapper that will sort equal to or less than + * any other node wrapper, using this index + */ + minPost(): NamedNode; + /** + * @returns a node wrapper that will sort greater than or equal to + * any other node wrapper, using this index + */ + abstract maxPost(): NamedNode; + abstract makePost(indexValue: unknown, name: string): NamedNode; + /** + * @returns String representation for inclusion in a query spec + */ + abstract toString(): string; +} diff --git a/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/indexes/KeyIndex.d.ts b/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/indexes/KeyIndex.d.ts new file mode 100644 index 0000000..dc4c04f --- /dev/null +++ b/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/indexes/KeyIndex.d.ts @@ -0,0 +1,34 @@ +/** + * @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 { ChildrenNode } from '../ChildrenNode'; +import { Node, NamedNode } from '../Node'; +import { Index } from './Index'; +export declare class KeyIndex extends Index { + static get __EMPTY_NODE(): ChildrenNode; + static set __EMPTY_NODE(val: ChildrenNode); + compare(a: NamedNode, b: NamedNode): number; + isDefinedOn(node: Node): boolean; + indexedValueChanged(oldNode: Node, newNode: Node): boolean; + minPost(): any; + maxPost(): NamedNode; + makePost(indexValue: string, name: string): NamedNode; + /** + * @returns String representation for inclusion in a query spec + */ + toString(): string; +} +export declare const KEY_INDEX: KeyIndex; diff --git a/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/indexes/PathIndex.d.ts b/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/indexes/PathIndex.d.ts new file mode 100644 index 0000000..65af086 --- /dev/null +++ b/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/indexes/PathIndex.d.ts @@ -0,0 +1,29 @@ +/** + * @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 { NamedNode, Node } from '../Node'; +import { Index } from './Index'; +export declare class PathIndex extends Index { + private indexPath_; + constructor(indexPath_: Path); + protected extractChild(snap: Node): Node; + isDefinedOn(node: Node): boolean; + compare(a: NamedNode, b: NamedNode): number; + makePost(indexValue: object, name: string): NamedNode; + maxPost(): NamedNode; + toString(): string; +} diff --git a/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/indexes/PriorityIndex.d.ts b/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/indexes/PriorityIndex.d.ts new file mode 100644 index 0000000..910d780 --- /dev/null +++ b/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/indexes/PriorityIndex.d.ts @@ -0,0 +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. + */ +import { NamedNode, Node } from '../Node'; +import { Index } from './Index'; +export declare function setNodeFromJSON(val: (a: unknown) => Node): void; +export declare function setMaxNode(val: Node): void; +export declare class PriorityIndex extends Index { + compare(a: NamedNode, b: NamedNode): number; + isDefinedOn(node: Node): boolean; + indexedValueChanged(oldNode: Node, newNode: Node): boolean; + minPost(): NamedNode; + maxPost(): NamedNode; + makePost(indexValue: unknown, name: string): NamedNode; + /** + * @returns String representation for inclusion in a query spec + */ + toString(): string; +} +export declare const PRIORITY_INDEX: PriorityIndex; diff --git a/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/indexes/ValueIndex.d.ts b/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/indexes/ValueIndex.d.ts new file mode 100644 index 0000000..6b801a9 --- /dev/null +++ b/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/indexes/ValueIndex.d.ts @@ -0,0 +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 { NamedNode, Node } from '../Node'; +import { Index } from './Index'; +export declare class ValueIndex extends Index { + compare(a: NamedNode, b: NamedNode): number; + isDefinedOn(node: Node): boolean; + indexedValueChanged(oldNode: Node, newNode: Node): boolean; + minPost(): NamedNode; + maxPost(): NamedNode; + makePost(indexValue: object, name: string): NamedNode; + /** + * @returns String representation for inclusion in a query spec + */ + toString(): string; +} +export declare const VALUE_INDEX: ValueIndex; diff --git a/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/nodeFromJSON.d.ts b/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/nodeFromJSON.d.ts new file mode 100644 index 0000000..a20804b --- /dev/null +++ b/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/nodeFromJSON.d.ts @@ -0,0 +1,24 @@ +/** + * @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'; +/** + * Constructs a snapshot node representing the passed JSON and returns it. + * @param json - JSON to create a node for. + * @param priority - Optional priority to use. This will be ignored if the + * passed JSON contains a .priority property. + */ +export declare function nodeFromJSON(json: unknown | null, priority?: unknown): Node; diff --git a/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/snap.d.ts b/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/snap.d.ts new file mode 100644 index 0000000..579a2ed --- /dev/null +++ b/frontend-old/node_modules/@firebase/database/dist/node-esm/src/core/snap/snap.d.ts @@ -0,0 +1,23 @@ +/** + * @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'; +export declare function setMaxNode(val: Node): void; +export declare const priorityHashText: (priority: string | number) => string; +/** + * Validates that a priority snapshot Node is valid. + */ +export declare const validatePriorityNode: (priorityNode: Node) => void; |