1004 lines
37 KiB
JavaScript
1004 lines
37 KiB
JavaScript
import firebase from '@firebase/app-compat';
|
|
import { FirestoreError, Bytes, _isBase64Available, enableIndexedDbPersistence, enableMultiTabIndexedDbPersistence, clearIndexedDbPersistence, _DatabaseId, _logWarn, connectFirestoreEmulator, enableNetwork, disableNetwork, _validateIsNotUsedTogether, waitForPendingWrites, onSnapshotsInSync, collection, doc, collectionGroup, runTransaction, ensureFirestoreConfigured, WriteBatch as WriteBatch$1, executeWrite, loadBundle, namedQuery, DocumentSnapshot as DocumentSnapshot$1, DocumentReference as DocumentReference$1, _DocumentKey, refEqual, setDoc, updateDoc, deleteDoc, onSnapshot, getDocFromCache, getDocFromServer, getDoc, snapshotEqual, query, where, orderBy, limit, limitToLast, startAt, startAfter, endBefore, endAt, queryEqual, getDocsFromCache, getDocsFromServer, getDocs, QuerySnapshot as QuerySnapshot$1, addDoc, _cast, AbstractUserDataWriter, setLogLevel as setLogLevel$1, QueryDocumentSnapshot as QueryDocumentSnapshot$1, _debugAssert, FieldPath as FieldPath$1, _FieldPath, serverTimestamp, deleteField, arrayUnion, arrayRemove, increment, GeoPoint, Timestamp, CACHE_SIZE_UNLIMITED } from '@firebase/firestore';
|
|
import { getModularInstance } from '@firebase/util';
|
|
import { Component } from '@firebase/component';
|
|
|
|
const name = "@firebase/firestore-compat";
|
|
const version = "0.3.25";
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2021 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.
|
|
*/
|
|
function validateSetOptions(methodName, options) {
|
|
if (options === undefined) {
|
|
return {
|
|
merge: false
|
|
};
|
|
}
|
|
if (options.mergeFields !== undefined && options.merge !== undefined) {
|
|
throw new FirestoreError('invalid-argument', `Invalid options passed to function ${methodName}(): You cannot ` +
|
|
'specify both "merge" and "mergeFields".');
|
|
}
|
|
return options;
|
|
}
|
|
|
|
/**
|
|
* @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.
|
|
*/
|
|
/** Helper function to assert Uint8Array is available at runtime. */
|
|
function assertUint8ArrayAvailable() {
|
|
if (typeof Uint8Array === 'undefined') {
|
|
throw new FirestoreError('unimplemented', 'Uint8Arrays are not available in this environment.');
|
|
}
|
|
}
|
|
/** Helper function to assert Base64 functions are available at runtime. */
|
|
function assertBase64Available() {
|
|
if (!_isBase64Available()) {
|
|
throw new FirestoreError('unimplemented', 'Blobs are unavailable in Firestore in this environment.');
|
|
}
|
|
}
|
|
/** Immutable class holding a blob (binary data) */
|
|
class Blob {
|
|
constructor(_delegate) {
|
|
this._delegate = _delegate;
|
|
}
|
|
static fromBase64String(base64) {
|
|
assertBase64Available();
|
|
return new Blob(Bytes.fromBase64String(base64));
|
|
}
|
|
static fromUint8Array(array) {
|
|
assertUint8ArrayAvailable();
|
|
return new Blob(Bytes.fromUint8Array(array));
|
|
}
|
|
toBase64() {
|
|
assertBase64Available();
|
|
return this._delegate.toBase64();
|
|
}
|
|
toUint8Array() {
|
|
assertUint8ArrayAvailable();
|
|
return this._delegate.toUint8Array();
|
|
}
|
|
isEqual(other) {
|
|
return this._delegate.isEqual(other._delegate);
|
|
}
|
|
toString() {
|
|
return 'Blob(base64: ' + this.toBase64() + ')';
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @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.
|
|
*/
|
|
function isPartialObserver(obj) {
|
|
return implementsAnyMethods(obj, ['next', 'error', 'complete']);
|
|
}
|
|
/**
|
|
* Returns true if obj is an object and contains at least one of the specified
|
|
* methods.
|
|
*/
|
|
function implementsAnyMethods(obj, methods) {
|
|
if (typeof obj !== 'object' || obj === null) {
|
|
return false;
|
|
}
|
|
const object = obj;
|
|
for (const method of methods) {
|
|
if (method in object && typeof object[method] === 'function') {
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* @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.
|
|
*/
|
|
/**
|
|
* The persistence provider included with the full Firestore SDK.
|
|
*/
|
|
class IndexedDbPersistenceProvider {
|
|
enableIndexedDbPersistence(firestore, forceOwnership) {
|
|
return enableIndexedDbPersistence(firestore._delegate, { forceOwnership });
|
|
}
|
|
enableMultiTabIndexedDbPersistence(firestore) {
|
|
return enableMultiTabIndexedDbPersistence(firestore._delegate);
|
|
}
|
|
clearIndexedDbPersistence(firestore) {
|
|
return clearIndexedDbPersistence(firestore._delegate);
|
|
}
|
|
}
|
|
/**
|
|
* Compat class for Firestore. Exposes Firestore Legacy API, but delegates
|
|
* to the functional API of firestore-exp.
|
|
*/
|
|
class Firestore {
|
|
constructor(databaseIdOrApp, _delegate, _persistenceProvider) {
|
|
this._delegate = _delegate;
|
|
this._persistenceProvider = _persistenceProvider;
|
|
this.INTERNAL = {
|
|
delete: () => this.terminate()
|
|
};
|
|
if (!(databaseIdOrApp instanceof _DatabaseId)) {
|
|
this._appCompat = databaseIdOrApp;
|
|
}
|
|
}
|
|
get _databaseId() {
|
|
return this._delegate._databaseId;
|
|
}
|
|
settings(settingsLiteral) {
|
|
const currentSettings = this._delegate._getSettings();
|
|
if (!settingsLiteral.merge &&
|
|
currentSettings.host !== settingsLiteral.host) {
|
|
_logWarn('You are overriding the original host. If you did not intend ' +
|
|
'to override your settings, use {merge: true}.');
|
|
}
|
|
if (settingsLiteral.merge) {
|
|
settingsLiteral = Object.assign(Object.assign({}, currentSettings), settingsLiteral);
|
|
// Remove the property from the settings once the merge is completed
|
|
delete settingsLiteral.merge;
|
|
}
|
|
this._delegate._setSettings(settingsLiteral);
|
|
}
|
|
useEmulator(host, port, options = {}) {
|
|
connectFirestoreEmulator(this._delegate, host, port, options);
|
|
}
|
|
enableNetwork() {
|
|
return enableNetwork(this._delegate);
|
|
}
|
|
disableNetwork() {
|
|
return disableNetwork(this._delegate);
|
|
}
|
|
enablePersistence(settings) {
|
|
let synchronizeTabs = false;
|
|
let experimentalForceOwningTab = false;
|
|
if (settings) {
|
|
synchronizeTabs = !!settings.synchronizeTabs;
|
|
experimentalForceOwningTab = !!settings.experimentalForceOwningTab;
|
|
_validateIsNotUsedTogether('synchronizeTabs', synchronizeTabs, 'experimentalForceOwningTab', experimentalForceOwningTab);
|
|
}
|
|
return synchronizeTabs
|
|
? this._persistenceProvider.enableMultiTabIndexedDbPersistence(this)
|
|
: this._persistenceProvider.enableIndexedDbPersistence(this, experimentalForceOwningTab);
|
|
}
|
|
clearPersistence() {
|
|
return this._persistenceProvider.clearIndexedDbPersistence(this);
|
|
}
|
|
terminate() {
|
|
if (this._appCompat) {
|
|
this._appCompat._removeServiceInstance('firestore-compat');
|
|
this._appCompat._removeServiceInstance('firestore');
|
|
}
|
|
return this._delegate._delete();
|
|
}
|
|
waitForPendingWrites() {
|
|
return waitForPendingWrites(this._delegate);
|
|
}
|
|
onSnapshotsInSync(arg) {
|
|
return onSnapshotsInSync(this._delegate, arg);
|
|
}
|
|
get app() {
|
|
if (!this._appCompat) {
|
|
throw new FirestoreError('failed-precondition', "Firestore was not initialized using the Firebase SDK. 'app' is " +
|
|
'not available');
|
|
}
|
|
return this._appCompat;
|
|
}
|
|
collection(pathString) {
|
|
try {
|
|
return new CollectionReference(this, collection(this._delegate, pathString));
|
|
}
|
|
catch (e) {
|
|
throw replaceFunctionName(e, 'collection()', 'Firestore.collection()');
|
|
}
|
|
}
|
|
doc(pathString) {
|
|
try {
|
|
return new DocumentReference(this, doc(this._delegate, pathString));
|
|
}
|
|
catch (e) {
|
|
throw replaceFunctionName(e, 'doc()', 'Firestore.doc()');
|
|
}
|
|
}
|
|
collectionGroup(collectionId) {
|
|
try {
|
|
return new Query(this, collectionGroup(this._delegate, collectionId));
|
|
}
|
|
catch (e) {
|
|
throw replaceFunctionName(e, 'collectionGroup()', 'Firestore.collectionGroup()');
|
|
}
|
|
}
|
|
runTransaction(updateFunction) {
|
|
return runTransaction(this._delegate, transaction => updateFunction(new Transaction(this, transaction)));
|
|
}
|
|
batch() {
|
|
ensureFirestoreConfigured(this._delegate);
|
|
return new WriteBatch(new WriteBatch$1(this._delegate, mutations => executeWrite(this._delegate, mutations)));
|
|
}
|
|
loadBundle(bundleData) {
|
|
return loadBundle(this._delegate, bundleData);
|
|
}
|
|
namedQuery(name) {
|
|
return namedQuery(this._delegate, name).then(expQuery => {
|
|
if (!expQuery) {
|
|
return null;
|
|
}
|
|
return new Query(this,
|
|
// We can pass `expQuery` here directly since named queries don't have a UserDataConverter.
|
|
// Otherwise, we would have to create a new ExpQuery and pass the old UserDataConverter.
|
|
expQuery);
|
|
});
|
|
}
|
|
}
|
|
class UserDataWriter extends AbstractUserDataWriter {
|
|
constructor(firestore) {
|
|
super();
|
|
this.firestore = firestore;
|
|
}
|
|
convertBytes(bytes) {
|
|
return new Blob(new Bytes(bytes));
|
|
}
|
|
convertReference(name) {
|
|
const key = this.convertDocumentKey(name, this.firestore._databaseId);
|
|
return DocumentReference.forKey(key, this.firestore, /* converter= */ null);
|
|
}
|
|
}
|
|
function setLogLevel(level) {
|
|
setLogLevel$1(level);
|
|
}
|
|
/**
|
|
* A reference to a transaction.
|
|
*/
|
|
class Transaction {
|
|
constructor(_firestore, _delegate) {
|
|
this._firestore = _firestore;
|
|
this._delegate = _delegate;
|
|
this._userDataWriter = new UserDataWriter(_firestore);
|
|
}
|
|
get(documentRef) {
|
|
const ref = castReference(documentRef);
|
|
return this._delegate
|
|
.get(ref)
|
|
.then(result => new DocumentSnapshot(this._firestore, new DocumentSnapshot$1(this._firestore._delegate, this._userDataWriter, result._key, result._document, result.metadata, ref.converter)));
|
|
}
|
|
set(documentRef, data, options) {
|
|
const ref = castReference(documentRef);
|
|
if (options) {
|
|
validateSetOptions('Transaction.set', options);
|
|
this._delegate.set(ref, data, options);
|
|
}
|
|
else {
|
|
this._delegate.set(ref, data);
|
|
}
|
|
return this;
|
|
}
|
|
update(documentRef, dataOrField, value, ...moreFieldsAndValues) {
|
|
const ref = castReference(documentRef);
|
|
if (arguments.length === 2) {
|
|
this._delegate.update(ref, dataOrField);
|
|
}
|
|
else {
|
|
this._delegate.update(ref, dataOrField, value, ...moreFieldsAndValues);
|
|
}
|
|
return this;
|
|
}
|
|
delete(documentRef) {
|
|
const ref = castReference(documentRef);
|
|
this._delegate.delete(ref);
|
|
return this;
|
|
}
|
|
}
|
|
class WriteBatch {
|
|
constructor(_delegate) {
|
|
this._delegate = _delegate;
|
|
}
|
|
set(documentRef, data, options) {
|
|
const ref = castReference(documentRef);
|
|
if (options) {
|
|
validateSetOptions('WriteBatch.set', options);
|
|
this._delegate.set(ref, data, options);
|
|
}
|
|
else {
|
|
this._delegate.set(ref, data);
|
|
}
|
|
return this;
|
|
}
|
|
update(documentRef, dataOrField, value, ...moreFieldsAndValues) {
|
|
const ref = castReference(documentRef);
|
|
if (arguments.length === 2) {
|
|
this._delegate.update(ref, dataOrField);
|
|
}
|
|
else {
|
|
this._delegate.update(ref, dataOrField, value, ...moreFieldsAndValues);
|
|
}
|
|
return this;
|
|
}
|
|
delete(documentRef) {
|
|
const ref = castReference(documentRef);
|
|
this._delegate.delete(ref);
|
|
return this;
|
|
}
|
|
commit() {
|
|
return this._delegate.commit();
|
|
}
|
|
}
|
|
/**
|
|
* Wraps a `PublicFirestoreDataConverter` translating the types from the
|
|
* experimental SDK into corresponding types from the Classic SDK before passing
|
|
* them to the wrapped converter.
|
|
*/
|
|
class FirestoreDataConverter {
|
|
constructor(_firestore, _userDataWriter, _delegate) {
|
|
this._firestore = _firestore;
|
|
this._userDataWriter = _userDataWriter;
|
|
this._delegate = _delegate;
|
|
}
|
|
fromFirestore(snapshot, options) {
|
|
const expSnapshot = new QueryDocumentSnapshot$1(this._firestore._delegate, this._userDataWriter, snapshot._key, snapshot._document, snapshot.metadata,
|
|
/* converter= */ null);
|
|
return this._delegate.fromFirestore(new QueryDocumentSnapshot(this._firestore, expSnapshot), options !== null && options !== void 0 ? options : {});
|
|
}
|
|
toFirestore(modelObject, options) {
|
|
if (!options) {
|
|
return this._delegate.toFirestore(modelObject);
|
|
}
|
|
else {
|
|
return this._delegate.toFirestore(modelObject, options);
|
|
}
|
|
}
|
|
// Use the same instance of `FirestoreDataConverter` for the given instances
|
|
// of `Firestore` and `PublicFirestoreDataConverter` so that isEqual() will
|
|
// compare equal for two objects created with the same converter instance.
|
|
static getInstance(firestore, converter) {
|
|
const converterMapByFirestore = FirestoreDataConverter.INSTANCES;
|
|
let untypedConverterByConverter = converterMapByFirestore.get(firestore);
|
|
if (!untypedConverterByConverter) {
|
|
untypedConverterByConverter = new WeakMap();
|
|
converterMapByFirestore.set(firestore, untypedConverterByConverter);
|
|
}
|
|
let instance = untypedConverterByConverter.get(converter);
|
|
if (!instance) {
|
|
instance = new FirestoreDataConverter(firestore, new UserDataWriter(firestore), converter);
|
|
untypedConverterByConverter.set(converter, instance);
|
|
}
|
|
return instance;
|
|
}
|
|
}
|
|
FirestoreDataConverter.INSTANCES = new WeakMap();
|
|
/**
|
|
* A reference to a particular document in a collection in the database.
|
|
*/
|
|
class DocumentReference {
|
|
constructor(firestore, _delegate) {
|
|
this.firestore = firestore;
|
|
this._delegate = _delegate;
|
|
this._userDataWriter = new UserDataWriter(firestore);
|
|
}
|
|
static forPath(path, firestore, converter) {
|
|
if (path.length % 2 !== 0) {
|
|
throw new FirestoreError('invalid-argument', 'Invalid document reference. Document ' +
|
|
'references must have an even number of segments, but ' +
|
|
`${path.canonicalString()} has ${path.length}`);
|
|
}
|
|
return new DocumentReference(firestore, new DocumentReference$1(firestore._delegate, converter, new _DocumentKey(path)));
|
|
}
|
|
static forKey(key, firestore, converter) {
|
|
return new DocumentReference(firestore, new DocumentReference$1(firestore._delegate, converter, key));
|
|
}
|
|
get id() {
|
|
return this._delegate.id;
|
|
}
|
|
get parent() {
|
|
return new CollectionReference(this.firestore, this._delegate.parent);
|
|
}
|
|
get path() {
|
|
return this._delegate.path;
|
|
}
|
|
collection(pathString) {
|
|
try {
|
|
return new CollectionReference(this.firestore, collection(this._delegate, pathString));
|
|
}
|
|
catch (e) {
|
|
throw replaceFunctionName(e, 'collection()', 'DocumentReference.collection()');
|
|
}
|
|
}
|
|
isEqual(other) {
|
|
other = getModularInstance(other);
|
|
if (!(other instanceof DocumentReference$1)) {
|
|
return false;
|
|
}
|
|
return refEqual(this._delegate, other);
|
|
}
|
|
set(value, options) {
|
|
options = validateSetOptions('DocumentReference.set', options);
|
|
try {
|
|
if (options) {
|
|
return setDoc(this._delegate, value, options);
|
|
}
|
|
else {
|
|
return setDoc(this._delegate, value);
|
|
}
|
|
}
|
|
catch (e) {
|
|
throw replaceFunctionName(e, 'setDoc()', 'DocumentReference.set()');
|
|
}
|
|
}
|
|
update(fieldOrUpdateData, value, ...moreFieldsAndValues) {
|
|
try {
|
|
if (arguments.length === 1) {
|
|
return updateDoc(this._delegate, fieldOrUpdateData);
|
|
}
|
|
else {
|
|
return updateDoc(this._delegate, fieldOrUpdateData, value, ...moreFieldsAndValues);
|
|
}
|
|
}
|
|
catch (e) {
|
|
throw replaceFunctionName(e, 'updateDoc()', 'DocumentReference.update()');
|
|
}
|
|
}
|
|
delete() {
|
|
return deleteDoc(this._delegate);
|
|
}
|
|
onSnapshot(...args) {
|
|
const options = extractSnapshotOptions(args);
|
|
const observer = wrapObserver(args, result => new DocumentSnapshot(this.firestore, new DocumentSnapshot$1(this.firestore._delegate, this._userDataWriter, result._key, result._document, result.metadata, this._delegate.converter)));
|
|
return onSnapshot(this._delegate, options, observer);
|
|
}
|
|
get(options) {
|
|
let snap;
|
|
if ((options === null || options === void 0 ? void 0 : options.source) === 'cache') {
|
|
snap = getDocFromCache(this._delegate);
|
|
}
|
|
else if ((options === null || options === void 0 ? void 0 : options.source) === 'server') {
|
|
snap = getDocFromServer(this._delegate);
|
|
}
|
|
else {
|
|
snap = getDoc(this._delegate);
|
|
}
|
|
return snap.then(result => new DocumentSnapshot(this.firestore, new DocumentSnapshot$1(this.firestore._delegate, this._userDataWriter, result._key, result._document, result.metadata, this._delegate.converter)));
|
|
}
|
|
withConverter(converter) {
|
|
return new DocumentReference(this.firestore, converter
|
|
? this._delegate.withConverter(FirestoreDataConverter.getInstance(this.firestore, converter))
|
|
: this._delegate.withConverter(null));
|
|
}
|
|
}
|
|
/**
|
|
* Replaces the function name in an error thrown by the firestore-exp API
|
|
* with the function names used in the classic API.
|
|
*/
|
|
function replaceFunctionName(e, original, updated) {
|
|
e.message = e.message.replace(original, updated);
|
|
return e;
|
|
}
|
|
/**
|
|
* Iterates the list of arguments from an `onSnapshot` call and returns the
|
|
* first argument that may be an `SnapshotListenOptions` object. Returns an
|
|
* empty object if none is found.
|
|
*/
|
|
function extractSnapshotOptions(args) {
|
|
for (const arg of args) {
|
|
if (typeof arg === 'object' && !isPartialObserver(arg)) {
|
|
return arg;
|
|
}
|
|
}
|
|
return {};
|
|
}
|
|
/**
|
|
* Creates an observer that can be passed to the firestore-exp SDK. The
|
|
* observer converts all observed values into the format expected by the classic
|
|
* SDK.
|
|
*
|
|
* @param args - The list of arguments from an `onSnapshot` call.
|
|
* @param wrapper - The function that converts the firestore-exp type into the
|
|
* type used by this shim.
|
|
*/
|
|
function wrapObserver(args, wrapper) {
|
|
var _a, _b;
|
|
let userObserver;
|
|
if (isPartialObserver(args[0])) {
|
|
userObserver = args[0];
|
|
}
|
|
else if (isPartialObserver(args[1])) {
|
|
userObserver = args[1];
|
|
}
|
|
else if (typeof args[0] === 'function') {
|
|
userObserver = {
|
|
next: args[0],
|
|
error: args[1],
|
|
complete: args[2]
|
|
};
|
|
}
|
|
else {
|
|
userObserver = {
|
|
next: args[1],
|
|
error: args[2],
|
|
complete: args[3]
|
|
};
|
|
}
|
|
return {
|
|
next: val => {
|
|
if (userObserver.next) {
|
|
userObserver.next(wrapper(val));
|
|
}
|
|
},
|
|
error: (_a = userObserver.error) === null || _a === void 0 ? void 0 : _a.bind(userObserver),
|
|
complete: (_b = userObserver.complete) === null || _b === void 0 ? void 0 : _b.bind(userObserver)
|
|
};
|
|
}
|
|
class DocumentSnapshot {
|
|
constructor(_firestore, _delegate) {
|
|
this._firestore = _firestore;
|
|
this._delegate = _delegate;
|
|
}
|
|
get ref() {
|
|
return new DocumentReference(this._firestore, this._delegate.ref);
|
|
}
|
|
get id() {
|
|
return this._delegate.id;
|
|
}
|
|
get metadata() {
|
|
return this._delegate.metadata;
|
|
}
|
|
get exists() {
|
|
return this._delegate.exists();
|
|
}
|
|
data(options) {
|
|
return this._delegate.data(options);
|
|
}
|
|
get(fieldPath, options
|
|
// We are using `any` here to avoid an explicit cast by our users.
|
|
// eslint-disable-next-line @typescript-eslint/no-explicit-any
|
|
) {
|
|
return this._delegate.get(fieldPath, options);
|
|
}
|
|
isEqual(other) {
|
|
return snapshotEqual(this._delegate, other._delegate);
|
|
}
|
|
}
|
|
class QueryDocumentSnapshot extends DocumentSnapshot {
|
|
data(options) {
|
|
const data = this._delegate.data(options);
|
|
if (this._delegate._converter) {
|
|
// Undefined is a possible valid value from converter.
|
|
return data;
|
|
}
|
|
else {
|
|
_debugAssert(data !== undefined, 'Document in a QueryDocumentSnapshot should exist');
|
|
return data;
|
|
}
|
|
}
|
|
}
|
|
class Query {
|
|
constructor(firestore, _delegate) {
|
|
this.firestore = firestore;
|
|
this._delegate = _delegate;
|
|
this._userDataWriter = new UserDataWriter(firestore);
|
|
}
|
|
where(fieldPath, opStr, value) {
|
|
try {
|
|
// The "as string" cast is a little bit of a hack. `where` accepts the
|
|
// FieldPath Compat type as input, but is not typed as such in order to
|
|
// not expose this via our public typings file.
|
|
return new Query(this.firestore, query(this._delegate, where(fieldPath, opStr, value)));
|
|
}
|
|
catch (e) {
|
|
throw replaceFunctionName(e, /(orderBy|where)\(\)/, 'Query.$1()');
|
|
}
|
|
}
|
|
orderBy(fieldPath, directionStr) {
|
|
try {
|
|
// The "as string" cast is a little bit of a hack. `orderBy` accepts the
|
|
// FieldPath Compat type as input, but is not typed as such in order to
|
|
// not expose this via our public typings file.
|
|
return new Query(this.firestore, query(this._delegate, orderBy(fieldPath, directionStr)));
|
|
}
|
|
catch (e) {
|
|
throw replaceFunctionName(e, /(orderBy|where)\(\)/, 'Query.$1()');
|
|
}
|
|
}
|
|
limit(n) {
|
|
try {
|
|
return new Query(this.firestore, query(this._delegate, limit(n)));
|
|
}
|
|
catch (e) {
|
|
throw replaceFunctionName(e, 'limit()', 'Query.limit()');
|
|
}
|
|
}
|
|
limitToLast(n) {
|
|
try {
|
|
return new Query(this.firestore, query(this._delegate, limitToLast(n)));
|
|
}
|
|
catch (e) {
|
|
throw replaceFunctionName(e, 'limitToLast()', 'Query.limitToLast()');
|
|
}
|
|
}
|
|
startAt(...args) {
|
|
try {
|
|
return new Query(this.firestore, query(this._delegate, startAt(...args)));
|
|
}
|
|
catch (e) {
|
|
throw replaceFunctionName(e, 'startAt()', 'Query.startAt()');
|
|
}
|
|
}
|
|
startAfter(...args) {
|
|
try {
|
|
return new Query(this.firestore, query(this._delegate, startAfter(...args)));
|
|
}
|
|
catch (e) {
|
|
throw replaceFunctionName(e, 'startAfter()', 'Query.startAfter()');
|
|
}
|
|
}
|
|
endBefore(...args) {
|
|
try {
|
|
return new Query(this.firestore, query(this._delegate, endBefore(...args)));
|
|
}
|
|
catch (e) {
|
|
throw replaceFunctionName(e, 'endBefore()', 'Query.endBefore()');
|
|
}
|
|
}
|
|
endAt(...args) {
|
|
try {
|
|
return new Query(this.firestore, query(this._delegate, endAt(...args)));
|
|
}
|
|
catch (e) {
|
|
throw replaceFunctionName(e, 'endAt()', 'Query.endAt()');
|
|
}
|
|
}
|
|
isEqual(other) {
|
|
return queryEqual(this._delegate, other._delegate);
|
|
}
|
|
get(options) {
|
|
let query;
|
|
if ((options === null || options === void 0 ? void 0 : options.source) === 'cache') {
|
|
query = getDocsFromCache(this._delegate);
|
|
}
|
|
else if ((options === null || options === void 0 ? void 0 : options.source) === 'server') {
|
|
query = getDocsFromServer(this._delegate);
|
|
}
|
|
else {
|
|
query = getDocs(this._delegate);
|
|
}
|
|
return query.then(result => new QuerySnapshot(this.firestore, new QuerySnapshot$1(this.firestore._delegate, this._userDataWriter, this._delegate, result._snapshot)));
|
|
}
|
|
onSnapshot(...args) {
|
|
const options = extractSnapshotOptions(args);
|
|
const observer = wrapObserver(args, snap => new QuerySnapshot(this.firestore, new QuerySnapshot$1(this.firestore._delegate, this._userDataWriter, this._delegate, snap._snapshot)));
|
|
return onSnapshot(this._delegate, options, observer);
|
|
}
|
|
withConverter(converter) {
|
|
return new Query(this.firestore, converter
|
|
? this._delegate.withConverter(FirestoreDataConverter.getInstance(this.firestore, converter))
|
|
: this._delegate.withConverter(null));
|
|
}
|
|
}
|
|
class DocumentChange {
|
|
constructor(_firestore, _delegate) {
|
|
this._firestore = _firestore;
|
|
this._delegate = _delegate;
|
|
}
|
|
get type() {
|
|
return this._delegate.type;
|
|
}
|
|
get doc() {
|
|
return new QueryDocumentSnapshot(this._firestore, this._delegate.doc);
|
|
}
|
|
get oldIndex() {
|
|
return this._delegate.oldIndex;
|
|
}
|
|
get newIndex() {
|
|
return this._delegate.newIndex;
|
|
}
|
|
}
|
|
class QuerySnapshot {
|
|
constructor(_firestore, _delegate) {
|
|
this._firestore = _firestore;
|
|
this._delegate = _delegate;
|
|
}
|
|
get query() {
|
|
return new Query(this._firestore, this._delegate.query);
|
|
}
|
|
get metadata() {
|
|
return this._delegate.metadata;
|
|
}
|
|
get size() {
|
|
return this._delegate.size;
|
|
}
|
|
get empty() {
|
|
return this._delegate.empty;
|
|
}
|
|
get docs() {
|
|
return this._delegate.docs.map(doc => new QueryDocumentSnapshot(this._firestore, doc));
|
|
}
|
|
docChanges(options) {
|
|
return this._delegate
|
|
.docChanges(options)
|
|
.map(docChange => new DocumentChange(this._firestore, docChange));
|
|
}
|
|
forEach(callback, thisArg) {
|
|
this._delegate.forEach(snapshot => {
|
|
callback.call(thisArg, new QueryDocumentSnapshot(this._firestore, snapshot));
|
|
});
|
|
}
|
|
isEqual(other) {
|
|
return snapshotEqual(this._delegate, other._delegate);
|
|
}
|
|
}
|
|
class CollectionReference extends Query {
|
|
constructor(firestore, _delegate) {
|
|
super(firestore, _delegate);
|
|
this.firestore = firestore;
|
|
this._delegate = _delegate;
|
|
}
|
|
get id() {
|
|
return this._delegate.id;
|
|
}
|
|
get path() {
|
|
return this._delegate.path;
|
|
}
|
|
get parent() {
|
|
const docRef = this._delegate.parent;
|
|
return docRef ? new DocumentReference(this.firestore, docRef) : null;
|
|
}
|
|
doc(documentPath) {
|
|
try {
|
|
if (documentPath === undefined) {
|
|
// Call `doc` without `documentPath` if `documentPath` is `undefined`
|
|
// as `doc` validates the number of arguments to prevent users from
|
|
// accidentally passing `undefined`.
|
|
return new DocumentReference(this.firestore, doc(this._delegate));
|
|
}
|
|
else {
|
|
return new DocumentReference(this.firestore, doc(this._delegate, documentPath));
|
|
}
|
|
}
|
|
catch (e) {
|
|
throw replaceFunctionName(e, 'doc()', 'CollectionReference.doc()');
|
|
}
|
|
}
|
|
add(data) {
|
|
return addDoc(this._delegate, data).then(docRef => new DocumentReference(this.firestore, docRef));
|
|
}
|
|
isEqual(other) {
|
|
return refEqual(this._delegate, other._delegate);
|
|
}
|
|
withConverter(converter) {
|
|
return new CollectionReference(this.firestore, converter
|
|
? this._delegate.withConverter(FirestoreDataConverter.getInstance(this.firestore, converter))
|
|
: this._delegate.withConverter(null));
|
|
}
|
|
}
|
|
function castReference(documentRef) {
|
|
return _cast(documentRef, DocumentReference$1);
|
|
}
|
|
|
|
/**
|
|
* @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.
|
|
*/
|
|
// The objects that are a part of this API are exposed to third-parties as
|
|
// compiled javascript so we want to flag our private members with a leading
|
|
// underscore to discourage their use.
|
|
/**
|
|
* A `FieldPath` refers to a field in a document. The path may consist of a
|
|
* single field name (referring to a top-level field in the document), or a list
|
|
* of field names (referring to a nested field in the document).
|
|
*/
|
|
class FieldPath {
|
|
/**
|
|
* Creates a FieldPath from the provided field names. If more than one field
|
|
* name is provided, the path will point to a nested field in a document.
|
|
*
|
|
* @param fieldNames - A list of field names.
|
|
*/
|
|
constructor(...fieldNames) {
|
|
this._delegate = new FieldPath$1(...fieldNames);
|
|
}
|
|
static documentId() {
|
|
/**
|
|
* Internal Note: The backend doesn't technically support querying by
|
|
* document ID. Instead it queries by the entire document name (full path
|
|
* included), but in the cases we currently support documentId(), the net
|
|
* effect is the same.
|
|
*/
|
|
return new FieldPath(_FieldPath.keyField().canonicalString());
|
|
}
|
|
isEqual(other) {
|
|
other = getModularInstance(other);
|
|
if (!(other instanceof FieldPath$1)) {
|
|
return false;
|
|
}
|
|
return this._delegate._internalPath.isEqual(other._internalPath);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @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.
|
|
*/
|
|
class FieldValue {
|
|
constructor(_delegate) {
|
|
this._delegate = _delegate;
|
|
}
|
|
static serverTimestamp() {
|
|
const delegate = serverTimestamp();
|
|
delegate._methodName = 'FieldValue.serverTimestamp';
|
|
return new FieldValue(delegate);
|
|
}
|
|
static delete() {
|
|
const delegate = deleteField();
|
|
delegate._methodName = 'FieldValue.delete';
|
|
return new FieldValue(delegate);
|
|
}
|
|
static arrayUnion(...elements) {
|
|
const delegate = arrayUnion(...elements);
|
|
delegate._methodName = 'FieldValue.arrayUnion';
|
|
return new FieldValue(delegate);
|
|
}
|
|
static arrayRemove(...elements) {
|
|
const delegate = arrayRemove(...elements);
|
|
delegate._methodName = 'FieldValue.arrayRemove';
|
|
return new FieldValue(delegate);
|
|
}
|
|
static increment(n) {
|
|
const delegate = increment(n);
|
|
delegate._methodName = 'FieldValue.increment';
|
|
return new FieldValue(delegate);
|
|
}
|
|
isEqual(other) {
|
|
return this._delegate.isEqual(other._delegate);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2021 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.
|
|
*/
|
|
const firestoreNamespace = {
|
|
Firestore,
|
|
GeoPoint,
|
|
Timestamp,
|
|
Blob,
|
|
Transaction,
|
|
WriteBatch,
|
|
DocumentReference,
|
|
DocumentSnapshot,
|
|
Query,
|
|
QueryDocumentSnapshot,
|
|
QuerySnapshot,
|
|
CollectionReference,
|
|
FieldPath,
|
|
FieldValue,
|
|
setLogLevel,
|
|
CACHE_SIZE_UNLIMITED
|
|
};
|
|
/**
|
|
* Configures Firestore as part of the Firebase SDK by calling registerComponent.
|
|
*
|
|
* @param firebase - The FirebaseNamespace to register Firestore with
|
|
* @param firestoreFactory - A factory function that returns a new Firestore
|
|
* instance.
|
|
*/
|
|
function configureForFirebase(firebase, firestoreFactory) {
|
|
firebase.INTERNAL.registerComponent(new Component('firestore-compat', container => {
|
|
const app = container.getProvider('app-compat').getImmediate();
|
|
const firestoreExp = container.getProvider('firestore').getImmediate();
|
|
return firestoreFactory(app, firestoreExp);
|
|
}, 'PUBLIC').setServiceProps(Object.assign({}, firestoreNamespace)));
|
|
}
|
|
|
|
/**
|
|
* @license
|
|
* Copyright 2020 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.
|
|
*/
|
|
/**
|
|
* Registers the main Firestore ReactNative build with the components framework.
|
|
* Persistence can be enabled via `firebase.firestore().enablePersistence()`.
|
|
*/
|
|
function registerFirestore(instance) {
|
|
configureForFirebase(instance, (app, firestoreExp) => new Firestore(app, firestoreExp, new IndexedDbPersistenceProvider()));
|
|
instance.registerVersion(name, version, 'rn');
|
|
}
|
|
registerFirestore(firebase);
|
|
|
|
export { registerFirestore };
|
|
//# sourceMappingURL=index.rn.js.map
|