@react-native-firebase/firestore 23.8.6 → 24.0.0

package/android/src/reactnative/java/io/invertase/firebase/firestore/ReactNativeFirebaseFirestoreSerialize.java

@@ -263,7 +263,7 @@ public class ReactNativeFirebaseFirestoreSerialize {
    * @param map Map<String, Object>
    * @return WritableMap
    */
-  private static WritableMap objectMapToWritable(Map<String, Object> map) {
+  static WritableMap objectMapToWritable(Map<String, Object> map) {
     WritableMap writableMap = Arguments.createMap();
 
     for (Map.Entry<String, Object> entry : map.entrySet()) {

package/dist/module/FieldPath.js

@@ -0,0 +1,59 @@
+"use strict";
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library 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 { isString } from '@react-native-firebase/app/dist/module/common';
+const RESERVED = new RegExp('[~*/\\[\\]]');
+export default class FieldPath {
+  constructor(...segments) {
+    if (segments.length === 0) {
+      throw new Error('firebase.firestore.FieldPath cannot construct FieldPath with no segments.');
+    }
+    for (let i = 0; i < segments.length; i++) {
+      const segment = segments[i];
+      if (!isString(segment) || segment === '') {
+        throw new Error(`firebase.firestore.FieldPath invalid segment at index ${i}, expected a non-empty string.`);
+      }
+    }
+    this._segments = segments;
+  }
+  isEqual(other) {
+    if (!(other instanceof FieldPath)) {
+      throw new Error("firebase.firestore.FieldPath.isEqual(*) 'other' expected instance of FieldPath.");
+    }
+    return this._toPath() === other._toPath();
+  }
+  _toPath() {
+    return this._segments.join('.');
+  }
+  _toArray() {
+    return this._segments;
+  }
+}
+export const DOCUMENT_ID = new FieldPath('__name__');
+export function fromDotSeparatedString(path) {
+  if (path === '' || path.startsWith('.') || path.endsWith('.') || path.indexOf('..') > 0) {
+    throw new Error("Invalid field path. Paths must not be empty, begin with '.', end with '.', or contain '..'.");
+  }
+  const found = path.search(RESERVED);
+  if (found > 0) {
+    throw new Error(`Invalid field path (${path}). Paths must not contain '~', '*', '/', '[', or ']'.`);
+  }
+  return new FieldPath(...path.split('.'));
+}
+//# sourceMappingURL=FieldPath.js.map

package/dist/module/FieldPath.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["isString","RESERVED","RegExp","FieldPath","constructor","segments","length","Error","i","segment","_segments","isEqual","other","_toPath","join","_toArray","DOCUMENT_ID","fromDotSeparatedString","path","startsWith","endsWith","indexOf","found","search","split"],"sourceRoot":"../../lib","sources":["FieldPath.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAASA,QAAQ,QAAQ,+CAA+C;AAExE,MAAMC,QAAQ,GAAG,IAAIC,MAAM,CAAC,aAAa,CAAC;AAE1C,eAAe,MAAMC,SAAS,CAAC;EAG7BC,WAAWA,CAAC,GAAGC,QAAkB,EAAE;IACjC,IAAIA,QAAQ,CAACC,MAAM,KAAK,CAAC,EAAE;MACzB,MAAM,IAAIC,KAAK,CAAC,2EAA2E,CAAC;IAC9F;IAEA,KAAK,IAAIC,CAAC,GAAG,CAAC,EAAEA,CAAC,GAAGH,QAAQ,CAACC,MAAM,EAAEE,CAAC,EAAE,EAAE;MACxC,MAAMC,OAAO,GAAGJ,QAAQ,CAACG,CAAC,CAAC;MAC3B,IAAI,CAACR,QAAQ,CAACS,OAAO,CAAC,IAAIA,OAAO,KAAK,EAAE,EAAE;QACxC,MAAM,IAAIF,KAAK,CACb,yDAAyDC,CAAC,gCAC5D,CAAC;MACH;IACF;IAEA,IAAI,CAACE,SAAS,GAAGL,QAAQ;EAC3B;EAEAM,OAAOA,CAACC,KAAgB,EAAW;IACjC,IAAI,EAAEA,KAAK,YAAYT,SAAS,CAAC,EAAE;MACjC,MAAM,IAAII,KAAK,CACb,iFACF,CAAC;IACH;IAEA,OAAO,IAAI,CAACM,OAAO,CAAC,CAAC,KAAKD,KAAK,CAACC,OAAO,CAAC,CAAC;EAC3C;EAEAA,OAAOA,CAAA,EAAW;IAChB,OAAO,IAAI,CAACH,SAAS,CAACI,IAAI,CAAC,GAAG,CAAC;EACjC;EAEAC,QAAQA,CAAA,EAAa;IACnB,OAAO,IAAI,CAACL,SAAS;EACvB;AACF;AAEA,OAAO,MAAMM,WAAW,GAAG,IAAIb,SAAS,CAAC,UAAU,CAAC;AAEpD,OAAO,SAASc,sBAAsBA,CAACC,IAAY,EAAa;EAC9D,IAAIA,IAAI,KAAK,EAAE,IAAIA,IAAI,CAACC,UAAU,CAAC,GAAG,CAAC,IAAID,IAAI,CAACE,QAAQ,CAAC,GAAG,CAAC,IAAIF,IAAI,CAACG,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE;IACvF,MAAM,IAAId,KAAK,CACb,6FACF,CAAC;EACH;EAEA,MAAMe,KAAK,GAAGJ,IAAI,CAACK,MAAM,CAACtB,QAAQ,CAAC;EAEnC,IAAIqB,KAAK,GAAG,CAAC,EAAE;IACb,MAAM,IAAIf,KAAK,CACb,uBAAuBW,IAAI,uDAC7B,CAAC;EACH;EAEA,OAAO,IAAIf,SAAS,CAAC,GAAGe,IAAI,CAACM,KAAK,CAAC,GAAG,CAAC,CAAC;AAC1C","ignoreList":[]}

package/dist/module/FieldValue.js

@@ -0,0 +1,82 @@
+"use strict";
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library 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 { isArray, isNumber } from '@react-native-firebase/app/dist/module/common';
+import { buildNativeArray, provideFieldValueClass } from "./utils/serialize.js";
+export const TypeFieldValueDelete = 'delete';
+export const TypeFieldValueIncrement = 'increment';
+export const TypeFieldValueRemove = 'array_remove';
+export const TypeFieldValueUnion = 'array_union';
+export const TypeFieldValueTimestamp = 'timestamp';
+function validateArrayElements(elements) {
+  for (let i = 0; i < elements.length; i++) {
+    const element = elements[i];
+    if (element instanceof FieldValue) {
+      throw new Error('FieldValue instance cannot be used with other FieldValue methods.');
+    }
+    if (isArray(element)) {
+      throw new Error('Nested arrays are not supported');
+    }
+  }
+}
+export default class FieldValue {
+  constructor(internal = false, type = '', elements) {
+    if (internal === false) {
+      throw new Error('firebase.firestore.FieldValue constructor is private, use FieldValue.<field>() instead.');
+    }
+    this._type = type;
+    this._elements = elements;
+  }
+  static delete() {
+    return new FieldValue(true, TypeFieldValueDelete);
+  }
+  static increment(n) {
+    if (!isNumber(n)) {
+      throw new Error("firebase.firestore.FieldValue.increment(*) 'n' expected a number value.");
+    }
+    return new FieldValue(true, TypeFieldValueIncrement, n);
+  }
+  static serverTimestamp() {
+    return new FieldValue(true, TypeFieldValueTimestamp);
+  }
+  static arrayUnion(...elements) {
+    try {
+      validateArrayElements(elements);
+    } catch (e) {
+      throw new Error(`firebase.firestore.FieldValue.arrayUnion(*) 'elements' called with invalid data. ${e.message}`);
+    }
+    return new FieldValue(true, TypeFieldValueUnion, buildNativeArray(elements));
+  }
+  static arrayRemove(...elements) {
+    try {
+      validateArrayElements(elements);
+    } catch (e) {
+      throw new Error(`firebase.firestore.FieldValue.arrayRemove(*) 'elements' called with invalid data. ${e.message}`);
+    }
+    return new FieldValue(true, TypeFieldValueRemove, buildNativeArray(elements));
+  }
+  isEqual(other) {
+    if (!(other instanceof FieldValue)) {
+      throw new Error("firebase.firestore.FieldValue.isEqual(*) 'other' expected a FieldValue instance.");
+    }
+    return this._type === other._type && JSON.stringify(this._elements) === JSON.stringify(other._elements);
+  }
+}
+provideFieldValueClass(FieldValue);
+//# sourceMappingURL=FieldValue.js.map

package/dist/module/FieldValue.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["isArray","isNumber","buildNativeArray","provideFieldValueClass","TypeFieldValueDelete","TypeFieldValueIncrement","TypeFieldValueRemove","TypeFieldValueUnion","TypeFieldValueTimestamp","validateArrayElements","elements","i","length","element","FieldValue","Error","constructor","internal","type","_type","_elements","delete","increment","n","serverTimestamp","arrayUnion","e","message","arrayRemove","isEqual","other","JSON","stringify"],"sourceRoot":"../../lib","sources":["FieldValue.ts"],"mappings":"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","ignoreList":[]}

package/{lib → dist/module}/FirestoreAggregate.js

@@ -1,3 +1,5 @@
+"use strict";
+
 /*
  * Copyright (c) 2022-present Invertase Limited & Contributors
  *
@@ -15,78 +17,64 @@
  *
  */
 
-import FirestoreFieldPath, { fromDotSeparatedString } from './FirestoreFieldPath';
-
-export class FirestoreAggregateQuery {
+import FieldPath, { fromDotSeparatedString } from "./FieldPath.js";
+export class AggregateQuery {
   constructor(firestore, query, collectionPath, modifiers) {
     this._firestore = firestore;
     this._query = query;
     this._collectionPath = collectionPath;
     this._modifiers = modifiers;
   }
-
   get query() {
     return this._query;
   }
-
   get() {
-    return this._firestore.native
-      .collectionCount(
-        this._collectionPath.relativeName,
-        this._modifiers.type,
-        this._modifiers.filters,
-        this._modifiers.orders,
-        this._modifiers.options,
-      )
-      .then(data => new FirestoreAggregateQuerySnapshot(this._query, data, true));
+    return this._firestore.native.collectionCount(this._collectionPath.relativeName, this._modifiers.type, this._modifiers.filters, this._modifiers.orders, this._modifiers.options).then(data => new AggregateQuerySnapshot(this._query, data, true));
   }
 }
-
-export class FirestoreAggregateQuerySnapshot {
+export class AggregateQuerySnapshot {
+  type = 'AggregateQuerySnapshot';
   constructor(query, data, isGetCountFromServer) {
     this._query = query;
     this._data = data;
     this._isGetCountFromServer = isGetCountFromServer;
   }
-
+  get query() {
+    return this._query;
+  }
   data() {
     if (this._isGetCountFromServer) {
-      return { count: this._data.count };
-    } else {
-      return { ...this._data };
+      return {
+        count: this._data.count
+      };
     }
+    return {
+      ...this._data
+    };
+  }
+  _fieldsProto() {
+    return {
+      ...this._data
+    };
   }
 }
-
-export const AggregateType = {
-  SUM: 'sum',
-  AVG: 'average',
-  COUNT: 'count',
-};
-
 export class AggregateField {
-  /** Indicates the aggregation operation of this AggregateField. */
-  aggregateType;
-  _fieldPath;
+  type = 'AggregateField';
 
-  /**
-   * Create a new AggregateField<T>
-   * @param aggregateType Specifies the type of aggregation operation to perform.
-   * @param _fieldPath Optionally specifies the field that is aggregated.
-   * @internal
-   */
-  constructor(aggregateType, fieldPath) {
+  // Phantom property to anchor the type parameter T for AggregateSpecData inference.
+
+  constructor(aggregateType = 'count', fieldPath) {
     this.aggregateType = aggregateType;
-    this._fieldPath = fieldPath;
+    this._internalFieldPath = fieldPath;
   }
 }
-
 export function fieldPathFromArgument(path) {
-  if (path instanceof FirestoreFieldPath) {
+  if (path instanceof FieldPath) {
     return path;
-  } else if (typeof path === 'string') {
+  }
+  if (typeof path === 'string') {
     return fromDotSeparatedString(path);
-  } else {
-    throw new Error('Field path arguments must be of type `string` or `FieldPath`');
   }
+  throw new Error('Field path arguments must be of type `string` or `FieldPath`');
 }
+//# sourceMappingURL=FirestoreAggregate.js.map

package/dist/module/FirestoreAggregate.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["FieldPath","fromDotSeparatedString","AggregateQuery","constructor","firestore","query","collectionPath","modifiers","_firestore","_query","_collectionPath","_modifiers","get","native","collectionCount","relativeName","type","filters","orders","options","then","data","AggregateQuerySnapshot","isGetCountFromServer","_data","_isGetCountFromServer","count","_fieldsProto","AggregateField","aggregateType","fieldPath","_internalFieldPath","fieldPathFromArgument","path","Error"],"sourceRoot":"../../lib","sources":["FirestoreAggregate.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AASA,OAAOA,SAAS,IAAIC,sBAAsB,QAAQ,gBAAa;AAO/D,OAAO,MAAMC,cAAc,CAAC;EAM1BC,WAAWA,CACTC,SAA4B,EAC5BC,KAAY,EACZC,cAA6B,EAC7BC,SAAyB,EACzB;IACA,IAAI,CAACC,UAAU,GAAGJ,SAAS;IAC3B,IAAI,CAACK,MAAM,GAAGJ,KAAK;IACnB,IAAI,CAACK,eAAe,GAAGJ,cAAc;IACrC,IAAI,CAACK,UAAU,GAAGJ,SAAS;EAC7B;EAEA,IAAIF,KAAKA,CAAA,EAAU;IACjB,OAAO,IAAI,CAACI,MAAM;EACpB;EAEAG,GAAGA,CAAA,EAAoC;IACrC,OAAO,IAAI,CAACJ,UAAU,CAACK,MAAM,CAC1BC,eAAe,CACd,IAAI,CAACJ,eAAe,CAACK,YAAY,EACjC,IAAI,CAACJ,UAAU,CAACK,IAAI,EACpB,IAAI,CAACL,UAAU,CAACM,OAAO,EACvB,IAAI,CAACN,UAAU,CAACO,MAAM,EACtB,IAAI,CAACP,UAAU,CAACQ,OAClB,CAAC,CACAC,IAAI,CAAEC,IAAwB,IAAK,IAAIC,sBAAsB,CAAC,IAAI,CAACb,MAAM,EAAEY,IAAI,EAAE,IAAI,CAAC,CAAC;EAC5F;AACF;AAEA,OAAO,MAAMC,sBAAsB,CAIjC;EACSN,IAAI,GAAG,wBAAwB;EAKxCb,WAAWA,CACTE,KAAgD,EAChDgB,IAAgD,EAChDE,oBAA6B,EAC7B;IACA,IAAI,CAACd,MAAM,GAAGJ,KAAK;IACnB,IAAI,CAACmB,KAAK,GAAGH,IAAI;IACjB,IAAI,CAACI,qBAAqB,GAAGF,oBAAoB;EACnD;EAEA,IAAIlB,KAAKA,CAAA,EAA8C;IACrD,OAAO,IAAI,CAACI,MAAM;EACpB;EAEAY,IAAIA,CAAA,EAAyC;IAC3C,IAAI,IAAI,CAACI,qBAAqB,EAAE;MAC9B,OAAO;QAAEC,KAAK,EAAE,IAAI,CAACF,KAAK,CAACE;MAAM,CAAC;IACpC;IACA,OAAO;MAAE,GAAG,IAAI,CAACF;IAAM,CAAC;EAC1B;EAEAG,YAAYA,CAAA,EAA4B;IACtC,OAAO;MAAE,GAAG,IAAI,CAACH;IAAM,CAAC;EAC1B;AACF;AAEA,OAAO,MAAMI,cAAc,CAAc;EAC9BZ,IAAI,GAAG,gBAAgB;;EAGhC;;EAGAb,WAAWA,CAAC0B,aAA4B,GAAG,OAAO,EAAEC,SAAqB,EAAE;IACzE,IAAI,CAACD,aAAa,GAAGA,aAAa;IAClC,IAAI,CAACE,kBAAkB,GAAGD,SAAS;EACrC;AACF;AAEA,OAAO,SAASE,qBAAqBA,CAACC,IAAwB,EAAa;EACzE,IAAIA,IAAI,YAAYjC,SAAS,EAAE;IAC7B,OAAOiC,IAAI;EACb;EACA,IAAI,OAAOA,IAAI,KAAK,QAAQ,EAAE;IAC5B,OAAOhC,sBAAsB,CAACgC,IAAI,CAAC;EACrC;EACA,MAAM,IAAIC,KAAK,CAAC,8DAA8D,CAAC;AACjF","ignoreList":[]}

package/dist/module/FirestoreBlob.js

@@ -0,0 +1,56 @@
+"use strict";
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library 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 { Base64, isString } from '@react-native-firebase/app/dist/module/common';
+export default class Blob {
+  constructor(internal = false, binaryString) {
+    if (internal === false) {
+      throw new Error('firebase.firestore.Blob constructor is private, use Blob.<field>() instead.');
+    }
+    this._binaryString = binaryString ?? '';
+  }
+  static fromBase64String(base64) {
+    if (!isString(base64) || base64.length < 1) {
+      throw new Error('firestore.Blob.fromBase64String expects a string of at least 1 character in length');
+    }
+    return new Blob(true, Base64.atob(base64));
+  }
+  static fromUint8Array(array) {
+    if (!(array instanceof Uint8Array)) {
+      throw new Error('firestore.Blob.fromUint8Array expects an instance of Uint8Array');
+    }
+    return new Blob(true, Array.prototype.map.call(array, byte => String.fromCharCode(byte)).join(''));
+  }
+  isEqual(blob) {
+    if (!(blob instanceof Blob)) {
+      throw new Error('firestore.Blob.isEqual expects an instance of Blob');
+    }
+    return this._binaryString === blob._binaryString;
+  }
+  toBase64() {
+    return Base64.btoa(this._binaryString);
+  }
+  toUint8Array() {
+    return new Uint8Array(this._binaryString.split('').map(char => char.charCodeAt(0)));
+  }
+  toString() {
+    return `firestore.Blob(base64: ${this.toBase64()})`;
+  }
+}
+//# sourceMappingURL=FirestoreBlob.js.map

package/dist/module/FirestoreBlob.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["Base64","isString","Blob","constructor","internal","binaryString","Error","_binaryString","fromBase64String","base64","length","atob","fromUint8Array","array","Uint8Array","Array","prototype","map","call","byte","String","fromCharCode","join","isEqual","blob","toBase64","btoa","toUint8Array","split","char","charCodeAt","toString"],"sourceRoot":"../../lib","sources":["FirestoreBlob.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAASA,MAAM,EAAEC,QAAQ,QAAQ,+CAA+C;AAEhF,eAAe,MAAMC,IAAI,CAAC;EAGxBC,WAAWA,CAACC,QAAQ,GAAG,KAAK,EAAEC,YAAqB,EAAE;IACnD,IAAID,QAAQ,KAAK,KAAK,EAAE;MACtB,MAAM,IAAIE,KAAK,CACb,6EACF,CAAC;IACH;IAEA,IAAI,CAACC,aAAa,GAAGF,YAAY,IAAI,EAAE;EACzC;EAEA,OAAOG,gBAAgBA,CAACC,MAAc,EAAQ;IAC5C,IAAI,CAACR,QAAQ,CAACQ,MAAM,CAAC,IAAIA,MAAM,CAACC,MAAM,GAAG,CAAC,EAAE;MAC1C,MAAM,IAAIJ,KAAK,CACb,oFACF,CAAC;IACH;IAEA,OAAO,IAAIJ,IAAI,CAAC,IAAI,EAAEF,MAAM,CAACW,IAAI,CAACF,MAAM,CAAC,CAAC;EAC5C;EAEA,OAAOG,cAAcA,CAACC,KAAiB,EAAQ;IAC7C,IAAI,EAAEA,KAAK,YAAYC,UAAU,CAAC,EAAE;MAClC,MAAM,IAAIR,KAAK,CAAC,iEAAiE,CAAC;IACpF;IAEA,OAAO,IAAIJ,IAAI,CACb,IAAI,EACJa,KAAK,CAACC,SAAS,CAACC,GAAG,CAACC,IAAI,CAACL,KAAK,EAAGM,IAAY,IAAKC,MAAM,CAACC,YAAY,CAACF,IAAI,CAAC,CAAC,CAACG,IAAI,CAAC,EAAE,CACtF,CAAC;EACH;EAEAC,OAAOA,CAACC,IAAU,EAAW;IAC3B,IAAI,EAAEA,IAAI,YAAYtB,IAAI,CAAC,EAAE;MAC3B,MAAM,IAAII,KAAK,CAAC,oDAAoD,CAAC;IACvE;IAEA,OAAO,IAAI,CAACC,aAAa,KAAKiB,IAAI,CAACjB,aAAa;EAClD;EAEAkB,QAAQA,CAAA,EAAW;IACjB,OAAOzB,MAAM,CAAC0B,IAAI,CAAC,IAAI,CAACnB,aAAa,CAAC;EACxC;EAEAoB,YAAYA,CAAA,EAAe;IACzB,OAAO,IAAIb,UAAU,CAAC,IAAI,CAACP,aAAa,CAACqB,KAAK,CAAC,EAAE,CAAC,CAACX,GAAG,CAACY,IAAI,IAAIA,IAAI,CAACC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC;EACrF;EAEAC,QAAQA,CAAA,EAAW;IACjB,OAAO,0BAA0B,IAAI,CAACN,QAAQ,CAAC,CAAC,GAAG;EACrD;AACF","ignoreList":[]}

package/dist/module/FirestoreCollectionReference.js

@@ -0,0 +1,70 @@
+"use strict";
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library 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 { generateFirestoreId, isObject, isNull, isUndefined } from '@react-native-firebase/app/dist/module/common';
+import DocumentReference, { provideCollectionReferenceClass } from "./FirestoreDocumentReference.js";
+import Query from "./FirestoreQuery.js";
+import QueryModifiers from "./FirestoreQueryModifiers.js";
+import { validateWithConverter } from "./utils/index.js";
+export default class CollectionReference extends Query {
+  constructor(firestore, collectionPath, converter) {
+    super(firestore, collectionPath, new QueryModifiers(), undefined, converter);
+  }
+  get id() {
+    return this._collectionPath.id;
+  }
+  get parent() {
+    const parent = this._collectionPath.parent();
+    if (!parent) {
+      return null;
+    }
+    return new DocumentReference(this._firestore, parent);
+  }
+  get path() {
+    return this._collectionPath.relativeName;
+  }
+  add(data) {
+    if (!isObject(data)) {
+      throw new Error("firebase.firestore().collection().add(*) 'data' must be an object.");
+    }
+    const documentRef = this.doc();
+    return documentRef.set(data).then(() => Promise.resolve(documentRef));
+  }
+  doc(documentPath) {
+    const newPath = documentPath ?? generateFirestoreId();
+    const path = this._collectionPath.child(newPath);
+    if (!path.isDocument) {
+      throw new Error("firebase.firestore().collection().doc(*) 'documentPath' must point to a document.");
+    }
+    return new DocumentReference(this._firestore, path, this._converter);
+  }
+  withConverter(converter) {
+    if (isUndefined(converter) || isNull(converter)) {
+      return new CollectionReference(this._firestore, this._collectionPath, null);
+    }
+    try {
+      validateWithConverter(converter);
+    } catch (e) {
+      throw new Error(`firebase.firestore().collection().withConverter() ${e.message}`);
+    }
+    return new CollectionReference(this._firestore, this._collectionPath, converter);
+  }
+}
+provideCollectionReferenceClass(CollectionReference);
+//# sourceMappingURL=FirestoreCollectionReference.js.map

package/dist/module/FirestoreCollectionReference.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["generateFirestoreId","isObject","isNull","isUndefined","DocumentReference","provideCollectionReferenceClass","Query","QueryModifiers","validateWithConverter","CollectionReference","constructor","firestore","collectionPath","converter","undefined","id","_collectionPath","parent","_firestore","path","relativeName","add","data","Error","documentRef","doc","set","then","Promise","resolve","documentPath","newPath","child","isDocument","_converter","withConverter","e","message"],"sourceRoot":"../../lib","sources":["FirestoreCollectionReference.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SACEA,mBAAmB,EACnBC,QAAQ,EACRC,MAAM,EACNC,WAAW,QACN,+CAA+C;AACtD,OAAOC,iBAAiB,IAAIC,+BAA+B,QAAQ,iCAA8B;AACjG,OAAOC,KAAK,MAAM,qBAAkB;AACpC,OAAOC,cAAc,MAAM,8BAA2B;AACtD,SAASC,qBAAqB,QAAQ,kBAAS;AAM/C,eAAe,MAAMC,mBAAmB,SAASH,KAAK,CAAC;EACrDI,WAAWA,CACTC,SAA4B,EAC5BC,cAA6B,EAC7BC,SAAqE,EACrE;IACA,KAAK,CAACF,SAAS,EAAEC,cAAc,EAAE,IAAIL,cAAc,CAAC,CAAC,EAAEO,SAAS,EAAED,SAAS,CAAC;EAC9E;EAEA,IAAIE,EAAEA,CAAA,EAAW;IACf,OAAO,IAAI,CAACC,eAAe,CAACD,EAAE;EAChC;EAEA,IAAIE,MAAMA,CAAA,EAA6B;IACrC,MAAMA,MAAM,GAAG,IAAI,CAACD,eAAe,CAACC,MAAM,CAAC,CAAC;IAC5C,IAAI,CAACA,MAAM,EAAE;MACX,OAAO,IAAI;IACb;IACA,OAAO,IAAIb,iBAAiB,CAAC,IAAI,CAACc,UAAU,EAAED,MAAM,CAAC;EACvD;EAEA,IAAIE,IAAIA,CAAA,EAAW;IACjB,OAAO,IAAI,CAACH,eAAe,CAACI,YAAY;EAC1C;EAEAC,GAAGA,CAACC,IAA6B,EAA8B;IAC7D,IAAI,CAACrB,QAAQ,CAACqB,IAAI,CAAC,EAAE;MACnB,MAAM,IAAIC,KAAK,CAAC,oEAAoE,CAAC;IACvF;IAEA,MAAMC,WAAW,GAAG,IAAI,CAACC,GAAG,CAAC,CAAC;IAC9B,OAAOD,WAAW,CAACE,GAAG,CAACJ,IAAI,CAAC,CAACK,IAAI,CAAC,MAAMC,OAAO,CAACC,OAAO,CAACL,WAAW,CAAC,CAAC;EACvE;EAEAC,GAAGA,CAACK,YAAqB,EAAqB;IAC5C,MAAMC,OAAO,GAAGD,YAAY,IAAI9B,mBAAmB,CAAC,CAAC;IACrD,MAAMmB,IAAI,GAAG,IAAI,CAACH,eAAe,CAACgB,KAAK,CAACD,OAAO,CAAC;IAEhD,IAAI,CAACZ,IAAI,CAACc,UAAU,EAAE;MACpB,MAAM,IAAIV,KAAK,CACb,mFACF,CAAC;IACH;IAEA,OAAO,IAAInB,iBAAiB,CAAC,IAAI,CAACc,UAAU,EAAEC,IAAI,EAAE,IAAI,CAACe,UAAU,CAAC;EACtE;EAEAC,aAAaA,CAACtB,SAAkB,EAAuB;IACrD,IAAIV,WAAW,CAACU,SAAS,CAAC,IAAIX,MAAM,CAACW,SAAS,CAAC,EAAE;MAC/C,OAAO,IAAIJ,mBAAmB,CAAC,IAAI,CAACS,UAAU,EAAE,IAAI,CAACF,eAAe,EAAE,IAAI,CAAC;IAC7E;IAEA,IAAI;MACFR,qBAAqB,CAACK,SAAS,CAAC;IAClC,CAAC,CAAC,OAAOuB,CAAC,EAAE;MACV,MAAM,IAAIb,KAAK,CAAC,qDAAsDa,CAAC,CAAWC,OAAO,EAAE,CAAC;IAC9F;IAEA,OAAO,IAAI5B,mBAAmB,CAC5B,IAAI,CAACS,UAAU,EACf,IAAI,CAACF,eAAe,EACpBH,SACF,CAAC;EACH;AACF;AAEAR,+BAA+B,CAACI,mBAAmB,CAAC","ignoreList":[]}

package/{lib → dist/module}/FirestoreDocumentChange.js

@@ -1,3 +1,5 @@
+"use strict";
+
 /*
  * Copyright (c) 2016-present Invertase Limited & Contributors
  *
@@ -14,37 +16,32 @@
  * limitations under the License.
  *
  */
-import { createDeprecationProxy } from '@react-native-firebase/app/dist/module/common';
-import FirestoreDocumentSnapshot from './FirestoreDocumentSnapshot';
 
+import { createDeprecationProxy } from '@react-native-firebase/app/dist/module/common';
+import DocumentSnapshot from "./FirestoreDocumentSnapshot.js";
 const TYPE_MAP = {
   a: 'added',
   m: 'modified',
-  r: 'removed',
+  r: 'removed'
 };
-
-export default class FirestoreDocumentChange {
-  constructor(firestore, nativeData) {
+export default class DocumentChange {
+  constructor(firestore, nativeData, converter) {
     this._firestore = firestore;
     this._nativeData = nativeData;
-    this._isMetadataChange = nativeData.isMetadataChange;
+    this._isMetadataChange = nativeData.isMetadataChange ?? false;
+    this._converter = converter;
   }
-
   get doc() {
-    return createDeprecationProxy(
-      new FirestoreDocumentSnapshot(this._firestore, this._nativeData.doc),
-    );
+    return createDeprecationProxy(new DocumentSnapshot(this._firestore, this._nativeData.doc, this._converter));
   }
-
   get newIndex() {
     return this._nativeData.ni;
   }
-
   get oldIndex() {
     return this._nativeData.oi;
   }
-
   get type() {
-    return TYPE_MAP[this._nativeData.type];
+    return TYPE_MAP[this._nativeData.type] ?? 'modified';
   }
 }
+//# sourceMappingURL=FirestoreDocumentChange.js.map

package/dist/module/FirestoreDocumentChange.js.map

@@ -0,0 +1 @@
+{"version":3,"names":["createDeprecationProxy","DocumentSnapshot","TYPE_MAP","a","m","r","DocumentChange","constructor","firestore","nativeData","converter","_firestore","_nativeData","_isMetadataChange","isMetadataChange","_converter","doc","newIndex","ni","oldIndex","oi","type"],"sourceRoot":"../../lib","sources":["FirestoreDocumentChange.ts"],"mappings":";;AAAA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,SAASA,sBAAsB,QAAQ,+CAA+C;AACtF,OAAOC,gBAAgB,MAAM,gCAA6B;AAI1D,MAAMC,QAA0D,GAAG;EACjEC,CAAC,EAAE,OAAO;EACVC,CAAC,EAAE,UAAU;EACbC,CAAC,EAAE;AACL,CAAC;AAUD,eAAe,MAAMC,cAAc,CAAC;EAMlCC,WAAWA,CACTC,SAA4B,EAC5BC,UAAoC,EACpCC,SAAoE,EACpE;IACA,IAAI,CAACC,UAAU,GAAGH,SAAS;IAC3B,IAAI,CAACI,WAAW,GAAGH,UAAU;IAC7B,IAAI,CAACI,iBAAiB,GAAGJ,UAAU,CAACK,gBAAgB,IAAI,KAAK;IAC7D,IAAI,CAACC,UAAU,GAAGL,SAAS;EAC7B;EAEA,IAAIM,GAAGA,CAAA,EAAqB;IAC1B,OAAOhB,sBAAsB,CAC3B,IAAIC,gBAAgB,CAAC,IAAI,CAACU,UAAU,EAAE,IAAI,CAACC,WAAW,CAACI,GAAG,EAAE,IAAI,CAACD,UAAU,CAC7E,CAAC;EACH;EAEA,IAAIE,QAAQA,CAAA,EAAW;IACrB,OAAO,IAAI,CAACL,WAAW,CAACM,EAAE;EAC5B;EAEA,IAAIC,QAAQA,CAAA,EAAW;IACrB,OAAO,IAAI,CAACP,WAAW,CAACQ,EAAE;EAC5B;EAEA,IAAIC,IAAIA,CAAA,EAAqC;IAC3C,OAAOnB,QAAQ,CAAC,IAAI,CAACU,WAAW,CAACS,IAAI,CAAC,IAAI,UAAU;EACtD;AACF","ignoreList":[]}

package/dist/module/FirestoreDocumentReference.js

@@ -0,0 +1,170 @@
+"use strict";
+
+/*
+ * Copyright (c) 2016-present Invertase Limited & Contributors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this library 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 { isObject, isString, isUndefined, isNull, createDeprecationProxy, filterModularArgument } from '@react-native-firebase/app/dist/module/common';
+import NativeError from '@react-native-firebase/app/dist/module/internal/NativeFirebaseError';
+import { parseSetOptions, parseSnapshotArgs, parseUpdateArgs, validateWithConverter, applyFirestoreDataConverter } from "./utils/index.js";
+import { buildNativeMap, provideDocumentReferenceClass } from "./utils/serialize.js";
+let FirestoreCollectionReference = null;
+export function provideCollectionReferenceClass(collectionReference) {
+  FirestoreCollectionReference = collectionReference;
+}
+let FirestoreDocumentSnapshotClass = null;
+export function provideDocumentSnapshotClass(documentSnapshot) {
+  FirestoreDocumentSnapshotClass = documentSnapshot;
+}
+let _id = 0;
+export default class DocumentReference {
+  constructor(firestore, documentPath, converter) {
+    this._firestore = firestore;
+    this._documentPath = documentPath;
+    this._converter = converter === undefined ? null : converter;
+  }
+  get firestore() {
+    return this._firestore;
+  }
+  get converter() {
+    return this._converter;
+  }
+  get id() {
+    return this._documentPath.id;
+  }
+  get parent() {
+    const parentPath = this._documentPath.parent();
+    return new FirestoreCollectionReference(this._firestore, parentPath, this._converter);
+  }
+  get path() {
+    return this._documentPath.relativeName;
+  }
+  collection(collectionPath) {
+    if (!isString(collectionPath)) {
+      throw new Error("firebase.firestore().doc().collection(*) 'collectionPath' must be a string value.");
+    }
+    if (collectionPath === '') {
+      throw new Error("firebase.firestore().doc().collection(*) 'collectionPath' must be a non-empty string.");
+    }
+    const path = this._documentPath.child(collectionPath);
+    if (!path.isCollection) {
+      throw new Error("firebase.firestore().doc().collection(*) 'collectionPath' must point to a collection.");
+    }
+    return new FirestoreCollectionReference(this._firestore, path);
+  }
+  delete() {
+    return this._firestore.native.documentDelete(this.path);
+  }
+  get(options) {
+    if (!isUndefined(options) && !isObject(options)) {
+      throw new Error("firebase.firestore().doc().get(*) 'options' must be an object is provided.");
+    }
+    if (options && options.source && options.source !== 'default' && options.source !== 'server' && options.source !== 'cache') {
+      throw new Error("firebase.firestore().doc().get(*) 'options' GetOptions.source must be one of 'default', 'server' or 'cache'.");
+    }
+    return this._firestore.native.documentGet(this.path, options).then(data => createDeprecationProxy(new FirestoreDocumentSnapshotClass(this._firestore, data, this._converter)));
+  }
+  isEqual(other) {
+    if (!(other instanceof DocumentReference)) {
+      throw new Error("firebase.firestore().doc().isEqual(*) 'other' expected a DocumentReference instance.");
+    }
+    return !(this.path !== other.path || this.firestore.app.name !== other.firestore.app.name || this.firestore.app.options.projectId !== other.firestore.app.options.projectId || this.converter !== other.converter);
+  }
+  onSnapshot(...args) {
+    let snapshotListenOptions;
+    let callback;
+    let onNext;
+    let onError;
+    try {
+      const options = parseSnapshotArgs(args);
+      snapshotListenOptions = options.snapshotListenOptions;
+      callback = options.callback;
+      onNext = options.onNext;
+      onError = options.onError;
+    } catch (e) {
+      throw new Error(`firebase.firestore().doc().onSnapshot(*) ${e.message}`);
+    }
+    function handleSuccess(documentSnapshot) {
+      callback(documentSnapshot, null);
+      onNext(documentSnapshot);
+    }
+    function handleError(error) {
+      callback(null, error);
+      onError(error);
+    }
+    const listenerId = _id++;
+    const onSnapshotSubscription = this._firestore.emitter.addListener(this._firestore.eventNameForApp(`firestore_document_sync_event:${listenerId}`), event => {
+      if (event.body.error) {
+        handleError(NativeError.fromEvent(event.body.error, 'firestore'));
+      } else {
+        const snapshot = event.body.snapshot;
+        if (!snapshot) return;
+        const documentSnapshot = createDeprecationProxy(new FirestoreDocumentSnapshotClass(this._firestore, snapshot, this._converter));
+        handleSuccess(documentSnapshot);
+      }
+    });
+    const unsubscribe = () => {
+      onSnapshotSubscription.remove();
+      this._firestore.native.documentOffSnapshot(listenerId);
+    };
+    this._firestore.native.documentOnSnapshot(this.path, listenerId, snapshotListenOptions);
+    return unsubscribe;
+  }
+  set(data, options) {
+    let setOptions;
+    try {
+      setOptions = parseSetOptions(options);
+    } catch (e) {
+      throw new Error(`firebase.firestore().doc().set(_, *) ${e.message}.`);
+    }
+    let converted = data;
+    try {
+      converted = applyFirestoreDataConverter(data, this._converter, setOptions);
+    } catch (e) {
+      throw new Error(`firebase.firestore().doc().set(*) 'withConverter.toFirestore' threw an error: ${e.message}.`);
+    }
+    if (!isObject(converted)) {
+      throw new Error("firebase.firestore().doc().set(*) 'data' must be an object.");
+    }
+    return this._firestore.native.documentSet(this.path, buildNativeMap(converted, this._firestore._settings.ignoreUndefinedProperties), setOptions);
+  }
+  update(...args) {
+    const updatedArgs = filterModularArgument(args);
+    if (updatedArgs.length === 0) {
+      throw new Error('firebase.firestore().doc().update(*) expected at least 1 argument but was called with 0 arguments.');
+    }
+    let data;
+    try {
+      data = parseUpdateArgs(updatedArgs);
+    } catch (e) {
+      throw new Error(`firebase.firestore().doc().update(*) ${e.message}`);
+    }
+    return this._firestore.native.documentUpdate(this.path, buildNativeMap(data, this._firestore._settings.ignoreUndefinedProperties));
+  }
+  withConverter(converter) {
+    if (isUndefined(converter) || isNull(converter)) {
+      return new DocumentReference(this._firestore, this._documentPath, null);
+    }
+    try {
+      validateWithConverter(converter);
+    } catch (e) {
+      throw new Error(`firebase.firestore().doc().withConverter() ${e.message}`);
+    }
+    return new DocumentReference(this._firestore, this._documentPath, converter);
+  }
+}
+provideDocumentReferenceClass(DocumentReference);
+//# sourceMappingURL=FirestoreDocumentReference.js.map