@react-native-firebase/firestore 18.4.0 → 18.5.0

package/CHANGELOG.md

@@ -3,6 +3,12 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+## [18.5.0](https://github.com/invertase/react-native-firebase/compare/v18.4.0...v18.5.0) (2023-09-22)
+
+### Features
+
+- **firestore:** V9 modular APIs ([#7235](https://github.com/invertase/react-native-firebase/issues/7235)) ([29d81c4](https://github.com/invertase/react-native-firebase/commit/29d81c4d8023f5c0d9c883a8b73b94ad393c8d44))
+
 ## [18.4.0](https://github.com/invertase/react-native-firebase/compare/v18.3.2...v18.4.0) (2023-09-11)
 
 **Note:** Version bump only for package @react-native-firebase/firestore

package/lib/index.js

@@ -359,6 +359,8 @@ class FirebaseFirestoreModule extends FirebaseModule {
 // import { SDK_VERSION } from '@react-native-firebase/firestore';
 export const SDK_VERSION = version;
 
+export * from './modular';
+
 // import firestore from '@react-native-firebase/firestore';
 // firestore().X(...);
 export default createModuleNamespace({

package/lib/modular/Bytes.d.ts

@@ -0,0 +1,11 @@
+export declare class Bytes {
+  static fromBase64String(base64: string): Bytes;
+
+  static fromUint8Array(array: Uint8Array): Bytes;
+
+  toBase64(): string;
+
+  toUint8Array(): Uint8Array;
+
+  isEqual(other: Bytes): boolean;
+}

package/lib/modular/Bytes.js

@@ -0,0 +1,59 @@
+import { firebase } from '../index';
+
+/**
+ * An immutable object representing an array of bytes.
+ */
+export class Bytes {
+  /**
+   * @hideconstructor
+   * @param {firebase.firestore.Blob} blob
+   */
+  constructor(blob) {
+    this._blob = blob;
+  }
+
+  /**
+   * @param {string} base64
+   * @returns {Bytes}
+   */
+  static fromBase64String(base64) {
+    return new Bytes(firebase.firestore.Blob.fromBase64String(base64));
+  }
+
+  /**
+   * @param {Uint8Array} array
+   * @returns {Bytes}
+   */
+  static fromUint8Array(array) {
+    return new Bytes(firebase.firestore.Blob.fromUint8Array(array));
+  }
+
+  /**
+   * @returns {string}
+   */
+  toBase64() {
+    return this._blob.toBase64();
+  }
+
+  /**
+   * @returns {Uint8Array}
+   */
+  toUint8Array() {
+    return this._blob.toUint8Array();
+  }
+
+  /**
+   * @returns {string}
+   */
+  toString() {
+    return 'Bytes(base64: ' + this.toBase64() + ')';
+  }
+
+  /**
+   * @param {Bytes} other
+   * @returns {boolean}
+   */
+  isEqual(other) {
+    return this._blob.isEqual(other._blob);
+  }
+}

package/lib/modular/FieldPath.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 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).
+ *
+ * Create a `FieldPath` by providing field names. If more than one field
+ * name is provided, the path will point to a nested field in a document.
+ */
+export declare class FieldPath {
+  constructor(...fieldNames: string[]);
+
+  isEqual(other: FieldPath): boolean;
+}

package/lib/modular/FieldPath.js

@@ -0,0 +1,3 @@
+import FirestoreFieldPath from '../FirestoreFieldPath';
+
+export const FieldPath = FirestoreFieldPath;

package/lib/modular/FieldValue.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Sentinel values that can be used when writing document fields with `set()`
+ * or `update()`.
+ */
+export declare class FieldValue {
+  isEqual(other: FieldValue): boolean;
+}
+
+/**
+ * Returns a sentinel for use with {@link @firebase/firestore#(updateDoc:1)} or
+ * {@link @firebase/firestore/lite#(setDoc:1)} with `{merge: true}` to mark a field for deletion.
+ */
+export function deleteField(): FieldValue;
+
+/**
+ * Returns a sentinel used with {@link @firebase/firestore#(setDoc:1)} or {@link @firebase/firestore/lite#(updateDoc:1)} to
+ * include a server-generated timestamp in the written data.
+ */
+export function serverTimestamp(): FieldValue;
+
+/**
+ * Returns a special value that can be used with {@link @firebase/firestore#(setDoc:1)} or {@link
+ * @firebase/firestore/lite#(updateDoc:1)} that tells the server to union the given elements with any array
+ * value that already exists on the server. Each specified element that doesn't
+ * already exist in the array will be added to the end. If the field being
+ * modified is not already an array it will be overwritten with an array
+ * containing exactly the specified elements.
+ *
+ * @param elements - The elements to union into the array.
+ * @returns The `FieldValue` sentinel for use in a call to `setDoc()` or
+ * `updateDoc()`.
+ */
+export function arrayUnion(...elements: unknown[]): FieldValue;
+
+/**
+ * Returns a special value that can be used with {@link (setDoc:1)} or {@link
+ * updateDoc:1} that tells the server to remove the given elements from any
+ * array value that already exists on the server. All instances of each element
+ * specified will be removed from the array. If the field being modified is not
+ * already an array it will be overwritten with an empty array.
+ *
+ * @param elements - The elements to remove from the array.
+ * @returns The `FieldValue` sentinel for use in a call to `setDoc()` or
+ * `updateDoc()`
+ */
+export function arrayRemove(...elements: unknown[]): FieldValue;
+
+/**
+ * Returns a special value that can be used with {@link @firebase/firestore#(setDoc:1)} or {@link
+ * @firebase/firestore/lite#(updateDoc:1)} that tells the server to increment the field's current value by
+ * the given value.
+ *
+ * If either the operand or the current field value uses floating point
+ * precision, all arithmetic follows IEEE 754 semantics. If both values are
+ * integers, values outside of JavaScript's safe number range
+ * (`Number.MIN_SAFE_INTEGER` to `Number.MAX_SAFE_INTEGER`) are also subject to
+ * precision loss. Furthermore, once processed by the Firestore backend, all
+ * integer operations are capped between -2^63 and 2^63-1.
+ *
+ * If the current field value is not of type `number`, or if the field does not
+ * yet exist, the transformation sets the field to the given value.
+ *
+ * @param n - The value to increment by.
+ * @returns The `FieldValue` sentinel for use in a call to `setDoc()` or
+ * `updateDoc()`
+ */
+export function increment(n: number): FieldValue;

package/lib/modular/FieldValue.js

@@ -0,0 +1,41 @@
+import FirestoreFieldValue from '../FirestoreFieldValue';
+
+export const FieldValue = FirestoreFieldValue;
+
+/**
+ * @returns {FieldValue}
+ */
+export function deleteField() {
+  return FieldValue.delete();
+}
+
+/**
+ * @returns {FieldValue}
+ */
+export function serverTimestamp() {
+  return FieldValue.serverTimestamp();
+}
+
+/**
+ * @param {unknown} elements
+ * @returns {FieldValue}
+ */
+export function arrayUnion(...elements) {
+  return FieldValue.arrayUnion(...elements);
+}
+
+/**
+ * @param {unknown} elements
+ * @returns {FieldValue}
+ */
+export function arrayRemove(...elements) {
+  return FieldValue.arrayRemove(...elements);
+}
+
+/**
+ * @param {number} n
+ * @returns {FieldValue}
+ */
+export function increment(n) {
+  return FieldValue.increment(n);
+}

package/lib/modular/GeoPoint.d.ts

@@ -0,0 +1,17 @@
+/**
+ * An immutable object representing a geographic location in Firestore. The
+ * location is represented as latitude/longitude pair.
+ *
+ * Latitude values are in the range of [-90, 90].
+ * Longitude values are in the range of [-180, 180].
+ */
+export declare class GeoPoint {
+  readonly latitude: number;
+  readonly longitude: number;
+
+  constructor(latitude: number, longitude: number);
+
+  isEqual(other: GeoPoint): boolean;
+
+  toJSON(): { latitude: number; longitude: number };
+}

package/lib/modular/GeoPoint.js

@@ -0,0 +1,3 @@
+import FirestoreGeoPoint from '../FirestoreGeoPoint';
+
+export const GeoPoint = FirestoreGeoPoint;

package/lib/modular/Timestamp.d.ts

@@ -0,0 +1,85 @@
+/**
+ * A `Timestamp` represents a point in time independent of any time zone or
+ * calendar, represented as seconds and fractions of seconds at nanosecond
+ * resolution in UTC Epoch time.
+ *
+ * It is encoded using the Proleptic Gregorian Calendar which extends the
+ * Gregorian calendar backwards to year one. It is encoded assuming all minutes
+ * are 60 seconds long, i.e. leap seconds are "smeared" so that no leap second
+ * table is needed for interpretation. Range is from 0001-01-01T00:00:00Z to
+ * 9999-12-31T23:59:59.999999999Z.
+ *
+ * For examples and further specifications, refer to the
+ * {@link https://github.com/google/protobuf/blob/master/src/google/protobuf/timestamp.proto | Timestamp definition}.
+ */
+export declare class Timestamp {
+  readonly seconds: number;
+  readonly nanoseconds: number;
+
+  constructor(seconds: number, nanoseconds: number);
+
+  /**
+   * Creates a new timestamp with the current date, with millisecond precision.
+   *
+   * @returns a new timestamp representing the current date.
+   */
+  static now(): Timestamp;
+
+  /**
+   * Creates a new timestamp from the given date.
+   *
+   * @param date - The date to initialize the `Timestamp` from.
+   * @returns A new `Timestamp` representing the same point in time as the given
+   *     date.
+   */
+  static fromDate(date: Date): Timestamp;
+
+  /**
+   * Creates a new timestamp from the given number of milliseconds.
+   *
+   * @param milliseconds - Number of milliseconds since Unix epoch
+   *     1970-01-01T00:00:00Z.
+   * @returns A new `Timestamp` representing the same point in time as the given
+   *     number of milliseconds.
+   */
+  static fromMillis(milliseconds: number): Timestamp;
+
+  /**
+   * Converts a `Timestamp` to a JavaScript `Date` object. This conversion
+   * causes a loss of precision since `Date` objects only support millisecond
+   * precision.
+   *
+   * @returns JavaScript `Date` object representing the same point in time as
+   *     this `Timestamp`, with millisecond precision.
+   */
+  toDate(): Date;
+
+  /**
+   * Converts a `Timestamp` to a numeric timestamp (in milliseconds since
+   * epoch). This operation causes a loss of precision.
+   *
+   * @returns The point in time corresponding to this timestamp, represented as
+   *     the number of milliseconds since Unix epoch 1970-01-01T00:00:00Z.
+   */
+  toMillis(): number;
+
+  /**
+   * Returns true if this `Timestamp` is equal to the provided one.
+   *
+   * @param other - The `Timestamp` to compare against.
+   * @returns true if this `Timestamp` is equal to the provided one.
+   */
+  isEqual(other: Timestamp): boolean;
+
+  /** Returns a JSON-serializable representation of this `Timestamp`. */
+  toJSON(): { seconds: number; nanoseconds: number };
+
+  /** Returns a textual representation of this `Timestamp`. */
+  toString(): string;
+
+  /**
+   * Converts this object to a primitive string, which allows `Timestamp` objects
+   * to be compared using the `>`, `<=`, `>=` and `>` operators.
+   */
+  valueOf(): string;
+}

package/lib/modular/Timestamp.js

@@ -0,0 +1,3 @@
+import FirestoreTimestamp from '../FirestoreTimestamp';
+
+export const Timestamp = FirestoreTimestamp;