@firebase/database 0.13.9 → 0.13.10-canary.09dfc3aac

package/dist/internal.d.ts

@@ -2109,8 +2109,6 @@ export declare class _QueryParams {
     indexEndName_: string;
     index_: PriorityIndex;
     hasStart(): boolean;
-    hasStartAfter(): boolean;
-    hasEndBefore(): boolean;
     /**
      * @returns True if it would return from left.
      */

package/dist/node-esm/index.node.esm.js

@@ -1,7 +1,7 @@
 import Websocket from 'faye-websocket';
-import { stringify, jsonEval, contains, assert, isNodeSdk, base64, stringToByteArray, Sha1, deepCopy, base64Encode, isMobileCordova, stringLength, Deferred, safeGet, isAdmin, isValidFormat, isEmpty, isReactNative, assertionError, map, querystring, errorPrefix, getModularInstance, getDefaultEmulatorHostnameAndPort, createMockUserToken } from '@firebase/util';
+import { stringify, jsonEval, contains, assert, isNodeSdk, stringToByteArray, Sha1, base64, deepCopy, base64Encode, isMobileCordova, stringLength, Deferred, safeGet, isAdmin, isValidFormat, isEmpty, isReactNative, assertionError, map, querystring, errorPrefix, getModularInstance, getDefaultEmulatorHostnameAndPort, createMockUserToken } from '@firebase/util';
 import { Logger, LogLevel } from '@firebase/logger';
-import { getApp, _getProvider, SDK_VERSION as SDK_VERSION$1, _registerComponent, registerVersion } from '@firebase/app';
+import { _getProvider, getApp, SDK_VERSION as SDK_VERSION$1, _registerComponent, registerVersion } from '@firebase/app';
 import { Component } from '@firebase/component';
 
 /**
@@ -1250,7 +1250,7 @@ WebSocketConnection.responsesRequiredToBeHealthy = 2;
 WebSocketConnection.healthyTimeout = 30000;
 
 const name = "@firebase/database";
-const version = "0.13.9";
+const version = "0.13.10-canary.09dfc3aac";
 
 /**
  * @license
@@ -5955,153 +5955,6 @@ class ValueIndex extends Index {
 }
 const VALUE_INDEX = new ValueIndex();
 
-/**
- * @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.
- */
-// Modeled after base64 web-safe chars, but ordered by ASCII.
-const PUSH_CHARS = '-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz';
-const MIN_PUSH_CHAR = '-';
-const MAX_PUSH_CHAR = 'z';
-const MAX_KEY_LEN = 786;
-/**
- * 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).
- */
-const nextPushId = (function () {
-    // Timestamp of last push, used to prevent local collisions if you push twice
-    // in one ms.
-    let lastPushTime = 0;
-    // We generate 72-bits of randomness which get turned into 12 characters and
-    // appended to the timestamp to prevent collisions with other clients. We
-    // store the last characters we generated because in the event of a collision,
-    // we'll use those same characters except "incremented" by one.
-    const lastRandChars = [];
-    return function (now) {
-        const duplicateTime = now === lastPushTime;
-        lastPushTime = now;
-        let i;
-        const timeStampChars = new Array(8);
-        for (i = 7; i >= 0; i--) {
-            timeStampChars[i] = PUSH_CHARS.charAt(now % 64);
-            // NOTE: Can't use << here because javascript will convert to int and lose
-            // the upper bits.
-            now = Math.floor(now / 64);
-        }
-        assert(now === 0, 'Cannot push at time == 0');
-        let id = timeStampChars.join('');
-        if (!duplicateTime) {
-            for (i = 0; i < 12; i++) {
-                lastRandChars[i] = Math.floor(Math.random() * 64);
-            }
-        }
-        else {
-            // If the timestamp hasn't changed since last push, use the same random
-            // number, except incremented by 1.
-            for (i = 11; i >= 0 && lastRandChars[i] === 63; i--) {
-                lastRandChars[i] = 0;
-            }
-            lastRandChars[i]++;
-        }
-        for (i = 0; i < 12; i++) {
-            id += PUSH_CHARS.charAt(lastRandChars[i]);
-        }
-        assert(id.length === 20, 'nextPushId: Length should be 20.');
-        return id;
-    };
-})();
-const successor = function (key) {
-    if (key === '' + INTEGER_32_MAX) {
-        // See https://firebase.google.com/docs/database/web/lists-of-data#data-order
-        return MIN_PUSH_CHAR;
-    }
-    const keyAsInt = tryParseInt(key);
-    if (keyAsInt != null) {
-        return '' + (keyAsInt + 1);
-    }
-    const next = new Array(key.length);
-    for (let i = 0; i < next.length; i++) {
-        next[i] = key.charAt(i);
-    }
-    if (next.length < MAX_KEY_LEN) {
-        next.push(MIN_PUSH_CHAR);
-        return next.join('');
-    }
-    let i = next.length - 1;
-    while (i >= 0 && next[i] === MAX_PUSH_CHAR) {
-        i--;
-    }
-    // `successor` was called on the largest possible key, so return the
-    // MAX_NAME, which sorts larger than all keys.
-    if (i === -1) {
-        return MAX_NAME;
-    }
-    const source = next[i];
-    const sourcePlusOne = PUSH_CHARS.charAt(PUSH_CHARS.indexOf(source) + 1);
-    next[i] = sourcePlusOne;
-    return next.slice(0, i + 1).join('');
-};
-// `key` is assumed to be non-empty.
-const predecessor = function (key) {
-    if (key === '' + INTEGER_32_MIN) {
-        return MIN_NAME;
-    }
-    const keyAsInt = tryParseInt(key);
-    if (keyAsInt != null) {
-        return '' + (keyAsInt - 1);
-    }
-    const next = new Array(key.length);
-    for (let i = 0; i < next.length; i++) {
-        next[i] = key.charAt(i);
-    }
-    // If `key` ends in `MIN_PUSH_CHAR`, the largest key lexicographically
-    // smaller than `key`, is `key[0:key.length - 1]`. The next key smaller
-    // than that, `predecessor(predecessor(key))`, is
-    //
-    // `key[0:key.length - 2] + (key[key.length - 1] - 1) + \
-    //   { MAX_PUSH_CHAR repeated MAX_KEY_LEN - (key.length - 1) times }
-    //
-    // analogous to increment/decrement for base-10 integers.
-    //
-    // This works because lexigographic comparison works character-by-character,
-    // using length as a tie-breaker if one key is a prefix of the other.
-    if (next[next.length - 1] === MIN_PUSH_CHAR) {
-        if (next.length === 1) {
-            // See https://firebase.google.com/docs/database/web/lists-of-data#orderbykey
-            return '' + INTEGER_32_MAX;
-        }
-        delete next[next.length - 1];
-        return next.join('');
-    }
-    // Replace the last character with it's immediate predecessor, and
-    // fill the suffix of the key with MAX_PUSH_CHAR. This is the
-    // lexicographically largest possible key smaller than `key`.
-    next[next.length - 1] = PUSH_CHARS.charAt(PUSH_CHARS.indexOf(next[next.length - 1]) - 1);
-    return next.join('') + MAX_PUSH_CHAR.repeat(MAX_KEY_LEN - next.length);
-};
-
 /**
  * @license
  * Copyright 2017 Google LLC
@@ -6270,6 +6123,8 @@ class RangedFilter {
         this.index_ = params.getIndex();
         this.startPost_ = RangedFilter.getStartPost_(params);
         this.endPost_ = RangedFilter.getEndPost_(params);
+        this.startIsInclusive_ = !params.startAfterSet_;
+        this.endIsInclusive_ = !params.endBeforeSet_;
     }
     getStartPost() {
         return this.startPost_;
@@ -6278,8 +6133,13 @@ class RangedFilter {
         return this.endPost_;
     }
     matches(node) {
-        return (this.index_.compare(this.getStartPost(), node) <= 0 &&
-            this.index_.compare(node, this.getEndPost()) <= 0);
+        const isWithinStart = this.startIsInclusive_
+            ? this.index_.compare(this.getStartPost(), node) <= 0
+            : this.index_.compare(this.getStartPost(), node) < 0;
+        const isWithinEnd = this.endIsInclusive_
+            ? this.index_.compare(node, this.getEndPost()) <= 0
+            : this.index_.compare(node, this.getEndPost()) < 0;
+        return isWithinStart && isWithinEnd;
     }
     updateChild(snap, key, newChild, affectedPath, source, optChangeAccumulator) {
         if (!this.matches(new NamedNode(key, newChild))) {
@@ -6357,10 +6217,22 @@ class RangedFilter {
  */
 class LimitedFilter {
     constructor(params) {
+        this.withinDirectionalStart = (node) => this.reverse_ ? this.withinEndPost(node) : this.withinStartPost(node);
+        this.withinDirectionalEnd = (node) => this.reverse_ ? this.withinStartPost(node) : this.withinEndPost(node);
+        this.withinStartPost = (node) => {
+            const compareRes = this.index_.compare(this.rangedFilter_.getStartPost(), node);
+            return this.startIsInclusive_ ? compareRes <= 0 : compareRes < 0;
+        };
+        this.withinEndPost = (node) => {
+            const compareRes = this.index_.compare(node, this.rangedFilter_.getEndPost());
+            return this.endIsInclusive_ ? compareRes <= 0 : compareRes < 0;
+        };
         this.rangedFilter_ = new RangedFilter(params);
         this.index_ = params.getIndex();
         this.limit_ = params.getLimit();
         this.reverse_ = !params.isViewFromLeft();
+        this.startIsInclusive_ = !params.startAfterSet_;
+        this.endIsInclusive_ = !params.endBeforeSet_;
     }
     updateChild(snap, key, newChild, affectedPath, source, optChangeAccumulator) {
         if (!this.rangedFilter_.matches(new NamedNode(key, newChild))) {
@@ -6401,23 +6273,18 @@ class LimitedFilter {
                 let count = 0;
                 while (iterator.hasNext() && count < this.limit_) {
                     const next = iterator.getNext();
-                    let inRange;
-                    if (this.reverse_) {
-                        inRange =
-                            this.index_.compare(this.rangedFilter_.getStartPost(), next) <= 0;
+                    if (!this.withinDirectionalStart(next)) {
+                        // if we have not reached the start, skip to the next element
+                        continue;
                     }
-                    else {
-                        inRange =
-                            this.index_.compare(next, this.rangedFilter_.getEndPost()) <= 0;
+                    else if (!this.withinDirectionalEnd(next)) {
+                        // if we have reached the end, stop adding elements
+                        break;
                     }
-                    if (inRange) {
+                    else {
                         filtered = filtered.updateImmediateChild(next.name, next.node);
                         count++;
                     }
-                    else {
-                        // if we have reached the end post, we cannot keep adding elemments
-                        break;
-                    }
                 }
             }
             else {
@@ -6425,32 +6292,19 @@ class LimitedFilter {
                 filtered = newSnap.withIndex(this.index_);
                 // Don't support priorities on queries
                 filtered = filtered.updatePriority(ChildrenNode.EMPTY_NODE);
-                let startPost;
-                let endPost;
-                let cmp;
                 let iterator;
                 if (this.reverse_) {
                     iterator = filtered.getReverseIterator(this.index_);
-                    startPost = this.rangedFilter_.getEndPost();
-                    endPost = this.rangedFilter_.getStartPost();
-                    const indexCompare = this.index_.getCompare();
-                    cmp = (a, b) => indexCompare(b, a);
                 }
                 else {
                     iterator = filtered.getIterator(this.index_);
-                    startPost = this.rangedFilter_.getStartPost();
-                    endPost = this.rangedFilter_.getEndPost();
-                    cmp = this.index_.getCompare();
                 }
                 let count = 0;
-                let foundStartPost = false;
                 while (iterator.hasNext()) {
                     const next = iterator.getNext();
-                    if (!foundStartPost && cmp(startPost, next) <= 0) {
-                        // start adding
-                        foundStartPost = true;
-                    }
-                    const inRange = foundStartPost && count < this.limit_ && cmp(next, endPost) <= 0;
+                    const inRange = count < this.limit_ &&
+                        this.withinDirectionalStart(next) &&
+                        this.withinDirectionalEnd(next);
                     if (inRange) {
                         count++;
                     }
@@ -6581,10 +6435,10 @@ class QueryParams {
         this.limitSet_ = false;
         this.startSet_ = false;
         this.startNameSet_ = false;
-        this.startAfterSet_ = false;
+        this.startAfterSet_ = false; // can only be true if startSet_ is true
         this.endSet_ = false;
         this.endNameSet_ = false;
-        this.endBeforeSet_ = false;
+        this.endBeforeSet_ = false; // can only be true if endSet_ is true
         this.limit_ = 0;
         this.viewFrom_ = '';
         this.indexStartValue_ = null;
@@ -6596,12 +6450,6 @@ class QueryParams {
     hasStart() {
         return this.startSet_;
     }
-    hasStartAfter() {
-        return this.startAfterSet_;
-    }
-    hasEndBefore() {
-        return this.endBeforeSet_;
-    }
     /**
      * @returns True if it would return from left.
      */
@@ -6690,10 +6538,12 @@ class QueryParams {
         copy.limitSet_ = this.limitSet_;
         copy.limit_ = this.limit_;
         copy.startSet_ = this.startSet_;
+        copy.startAfterSet_ = this.startAfterSet_;
         copy.indexStartValue_ = this.indexStartValue_;
         copy.startNameSet_ = this.startNameSet_;
         copy.indexStartName_ = this.indexStartName_;
         copy.endSet_ = this.endSet_;
+        copy.endBeforeSet_ = this.endBeforeSet_;
         copy.indexEndValue_ = this.indexEndValue_;
         copy.endNameSet_ = this.endNameSet_;
         copy.indexEndName_ = this.indexEndName_;
@@ -6746,21 +6596,11 @@ function queryParamsStartAt(queryParams, indexValue, key) {
 }
 function queryParamsStartAfter(queryParams, indexValue, key) {
     let params;
-    if (queryParams.index_ === KEY_INDEX) {
-        if (typeof indexValue === 'string') {
-            indexValue = successor(indexValue);
-        }
+    if (queryParams.index_ === KEY_INDEX || !!key) {
         params = queryParamsStartAt(queryParams, indexValue, key);
     }
     else {
-        let childKey;
-        if (key == null) {
-            childKey = MAX_NAME;
-        }
-        else {
-            childKey = successor(key);
-        }
-        params = queryParamsStartAt(queryParams, indexValue, childKey);
+        params = queryParamsStartAt(queryParams, indexValue, MAX_NAME);
     }
     params.startAfterSet_ = true;
     return params;
@@ -6783,22 +6623,12 @@ function queryParamsEndAt(queryParams, indexValue, key) {
     return newParams;
 }
 function queryParamsEndBefore(queryParams, indexValue, key) {
-    let childKey;
     let params;
-    if (queryParams.index_ === KEY_INDEX) {
-        if (typeof indexValue === 'string') {
-            indexValue = predecessor(indexValue);
-        }
+    if (queryParams.index_ === KEY_INDEX || !!key) {
         params = queryParamsEndAt(queryParams, indexValue, key);
     }
     else {
-        if (key == null) {
-            childKey = MIN_NAME;
-        }
-        else {
-            childKey = predecessor(key);
-        }
-        params = queryParamsEndAt(queryParams, indexValue, childKey);
+        params = queryParamsEndAt(queryParams, indexValue, MIN_NAME);
     }
     params.endBeforeSet_ = true;
     return params;
@@ -6834,17 +6664,21 @@ function queryParamsToRestQueryStringParameters(queryParams) {
     }
     qs["orderBy" /* ORDER_BY */] = stringify(orderBy);
     if (queryParams.startSet_) {
-        qs["startAt" /* START_AT */] = stringify(queryParams.indexStartValue_);
+        const startParam = queryParams.startAfterSet_
+            ? "startAfter" /* START_AFTER */
+            : "startAt" /* START_AT */;
+        qs[startParam] = stringify(queryParams.indexStartValue_);
         if (queryParams.startNameSet_) {
-            qs["startAt" /* START_AT */] +=
-                ',' + stringify(queryParams.indexStartName_);
+            qs[startParam] += ',' + stringify(queryParams.indexStartName_);
         }
     }
     if (queryParams.endSet_) {
-        qs["endAt" /* END_AT */] = stringify(queryParams.indexEndValue_);
+        const endParam = queryParams.endBeforeSet_
+            ? "endBefore" /* END_BEFORE */
+            : "endAt" /* END_AT */;
+        qs[endParam] = stringify(queryParams.indexEndValue_);
         if (queryParams.endNameSet_) {
-            qs["endAt" /* END_AT */] +=
-                ',' + stringify(queryParams.indexEndName_);
+            qs[endParam] += ',' + stringify(queryParams.indexEndName_);
         }
     }
     if (queryParams.limitSet_) {
@@ -6866,12 +6700,16 @@ function queryParamsGetQueryObject(queryParams) {
             obj["sn" /* INDEX_START_NAME */] =
                 queryParams.indexStartName_;
         }
+        obj["sin" /* INDEX_START_IS_INCLUSIVE */] =
+            !queryParams.startAfterSet_;
     }
     if (queryParams.endSet_) {
         obj["ep" /* INDEX_END_VALUE */] = queryParams.indexEndValue_;
         if (queryParams.endNameSet_) {
             obj["en" /* INDEX_END_NAME */] = queryParams.indexEndName_;
         }
+        obj["ein" /* INDEX_END_IS_INCLUSIVE */] =
+            !queryParams.endBeforeSet_;
     }
     if (queryParams.limitSet_) {
         obj["l" /* LIMIT */] = queryParams.limit_;
@@ -12009,6 +11847,81 @@ const parseDatabaseURL = function (dataURL) {
     };
 };
 
+/**
+ * @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.
+ */
+// Modeled after base64 web-safe chars, but ordered by ASCII.
+const PUSH_CHARS = '-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz';
+/**
+ * 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).
+ */
+const nextPushId = (function () {
+    // Timestamp of last push, used to prevent local collisions if you push twice
+    // in one ms.
+    let lastPushTime = 0;
+    // We generate 72-bits of randomness which get turned into 12 characters and
+    // appended to the timestamp to prevent collisions with other clients. We
+    // store the last characters we generated because in the event of a collision,
+    // we'll use those same characters except "incremented" by one.
+    const lastRandChars = [];
+    return function (now) {
+        const duplicateTime = now === lastPushTime;
+        lastPushTime = now;
+        let i;
+        const timeStampChars = new Array(8);
+        for (i = 7; i >= 0; i--) {
+            timeStampChars[i] = PUSH_CHARS.charAt(now % 64);
+            // NOTE: Can't use << here because javascript will convert to int and lose
+            // the upper bits.
+            now = Math.floor(now / 64);
+        }
+        assert(now === 0, 'Cannot push at time == 0');
+        let id = timeStampChars.join('');
+        if (!duplicateTime) {
+            for (i = 0; i < 12; i++) {
+                lastRandChars[i] = Math.floor(Math.random() * 64);
+            }
+        }
+        else {
+            // If the timestamp hasn't changed since last push, use the same random
+            // number, except incremented by 1.
+            for (i = 11; i >= 0 && lastRandChars[i] === 63; i--) {
+                lastRandChars[i] = 0;
+            }
+            lastRandChars[i]++;
+        }
+        for (i = 0; i < 12; i++) {
+            id += PUSH_CHARS.charAt(lastRandChars[i]);
+        }
+        assert(id.length === 20, 'nextPushId: Length should be 20.');
+        return id;
+    };
+})();
+
 /**
  * @license
  * Copyright 2017 Google LLC