@react-native-firebase/app 23.6.0 → 23.8.0

package/dist/typescript/module/lib/utils/index.d.ts

@@ -0,0 +1,4 @@
+import { Utils } from '../types/app';
+declare const _default: Utils.Statics & (() => Utils.Module);
+export default _default;
+//# sourceMappingURL=index.d.ts.map

package/dist/typescript/module/lib/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../lib/utils/index.ts"],"names":[],"mappings":"AAoBA,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;wBAyEpB,KAAK,CAAC,OAAO,GAAG,CAAC,MAAM,KAAK,CAAC,MAAM,CAAC;AATrD,wBASsD"}

package/dist/typescript/module/lib/version.d.ts

@@ -0,0 +1,2 @@
+export declare const version = "23.8.0";
+//# sourceMappingURL=version.d.ts.map

package/dist/typescript/module/lib/version.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../../lib/version.ts"],"names":[],"mappings":"AACA,eAAO,MAAM,OAAO,WAAW,CAAC"}

package/dist/typescript/module/package.json

@@ -0,0 +1 @@
+{"type":"module"}

package/lib/FirebaseApp.ts

@@ -0,0 +1,98 @@
+/*
+ * 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 { warnIfNotModularCall } from './common';
+import { getAppModule } from './internal/registry/nativeModule';
+import type { ReactNativeFirebase, Utils } from './types/app';
+
+export default class FirebaseApp implements ReactNativeFirebase.FirebaseAppBase {
+  private _name: string;
+  private _deleted: boolean;
+  private _deleteApp: () => Promise<void>;
+  private _options: ReactNativeFirebase.FirebaseAppOptions;
+  private _automaticDataCollectionEnabled: boolean;
+  _initialized: boolean;
+  _nativeInitialized: boolean;
+
+  constructor(
+    options: ReactNativeFirebase.FirebaseAppOptions,
+    appConfig: ReactNativeFirebase.FirebaseAppConfig,
+    fromNative: boolean,
+    deleteApp: () => Promise<void>,
+  ) {
+    const { name = '[DEFAULT]', automaticDataCollectionEnabled } = appConfig;
+
+    this._name = name;
+    this._deleted = false;
+    this._deleteApp = deleteApp;
+    this._options = Object.assign({}, options);
+    this._automaticDataCollectionEnabled = !!automaticDataCollectionEnabled;
+
+    if (fromNative) {
+      this._initialized = true;
+      this._nativeInitialized = true;
+    } else {
+      this._initialized = false;
+      this._nativeInitialized = false;
+    }
+  }
+
+  get name(): string {
+    return this._name;
+  }
+
+  get options(): ReactNativeFirebase.FirebaseAppOptions {
+    return Object.assign({}, this._options);
+  }
+
+  get automaticDataCollectionEnabled(): boolean {
+    return this._automaticDataCollectionEnabled;
+  }
+
+  set automaticDataCollectionEnabled(enabled: boolean) {
+    this._checkDestroyed();
+    getAppModule().setAutomaticDataCollectionEnabled(this.name, enabled);
+    this._automaticDataCollectionEnabled = enabled;
+  }
+
+  private _checkDestroyed(): void {
+    if (this._deleted) {
+      throw new Error(`Firebase App named '${this._name}' already deleted`);
+    }
+  }
+
+  extendApp(extendedProps: Record<string, unknown>): void {
+    warnIfNotModularCall(arguments);
+    this._checkDestroyed();
+    Object.assign(this, extendedProps);
+  }
+
+  delete(): Promise<void> {
+    warnIfNotModularCall(arguments, 'deleteApp()');
+    this._checkDestroyed();
+    return this._deleteApp();
+  }
+
+  toString(): string {
+    warnIfNotModularCall(arguments, '.name property');
+    return this.name;
+  }
+
+  // For backward compatibility - utils method added by registry
+  utils(): Utils.Module {
+    throw new Error('utils() should be added by registry');
+  }
+}

package/lib/common/{Base64.js → Base64.ts}

@@ -15,6 +15,7 @@
  *
  */
 
+// @ts-expect-error - No type declarations available
 import binaryToBase64 from 'react-native/Libraries/Utilities/binaryToBase64';
 import { promiseDefer } from './promise';
 
@@ -23,7 +24,7 @@ const CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=
 /**
  * window.btoa
  */
-function btoa(input) {
+function btoa(input: string): string {
   let map;
   let i = 0;
   let block = 0;
@@ -51,11 +52,11 @@ function btoa(input) {
 /**
  * window.atob
  */
-function atob(input) {
+function atob(input: string): string {
   let i = 0;
   let bc = 0;
   let bs = 0;
-  let buffer;
+  let buffer: number | string;
   let output = '';
 
   const str = input.replace(/[=]+$/, '');
@@ -69,7 +70,7 @@ function atob(input) {
   for (
     bc = 0, bs = 0, i = 0;
     (buffer = str.charAt(i++));
-    ~buffer && ((bs = bc % 4 ? bs * 64 + buffer : buffer), bc++ % 4)
+    ~buffer && ((bs = bc % 4 ? bs * 64 + (buffer as number) : buffer), bc++ % 4)
       ? (output += String.fromCharCode(255 & (bs >> ((-2 * bc) & 6))))
       : 0
   ) {
@@ -79,23 +80,30 @@ function atob(input) {
   return output;
 }
 
+export interface Base64Result {
+  string: string | ArrayBuffer | null;
+  format: 'data_url' | 'base64';
+}
+
 /**
  * Converts a Blob, ArrayBuffer or Uint8Array to a base64 string.
  */
-function fromData(data) {
+function fromData(data: Blob | ArrayBuffer | Uint8Array): Promise<Base64Result> {
   if (data instanceof Blob) {
     const fileReader = new FileReader();
-    const { resolve, reject, promise } = promiseDefer();
+    const { resolve, reject, promise } = promiseDefer<Base64Result>();
 
     fileReader.readAsDataURL(data);
 
-    fileReader.onloadend = function onloadend() {
-      resolve({ string: fileReader.result, format: 'data_url' });
+    fileReader.onloadend = () => {
+      if (fileReader?.result) {
+        resolve?.({ string: fileReader.result, format: 'data_url' });
+      }
     };
 
-    fileReader.onerror = function onerror(event) {
-      fileReader.abort();
-      reject(event);
+    fileReader.onerror = event => {
+      fileReader?.abort();
+      reject?.(event);
     };
 
     return promise;

package/lib/common/MutatableParams.ts

@@ -0,0 +1,50 @@
+/*
+ * 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 { deepGet, deepSet } from './deeps';
+
+export default class MutatableParams {
+  _mutatableParams: Record<string, unknown>;
+  _parentInstance: MutatableParams;
+
+  constructor(parentInstance?: MutatableParams) {
+    if (parentInstance) {
+      this._mutatableParams = parentInstance._mutatableParams;
+      this._parentInstance = parentInstance;
+    } else {
+      this._mutatableParams = {};
+      this._parentInstance = this;
+    }
+  }
+
+  set(param: string, value: unknown): MutatableParams {
+    deepSet(this._mutatableParams, param, value);
+    return this._parentInstance;
+  }
+
+  get<T = unknown>(param: string): T | undefined {
+    return deepGet<T>(this._mutatableParams, param, '.');
+  }
+
+  toJSON(): Record<string, unknown> {
+    return Object.assign({}, this._mutatableParams);
+  }
+
+  validate(): void {
+    // do nothing
+  }
+}

package/lib/common/ReferenceBase.ts

@@ -0,0 +1,45 @@
+/*
+ * 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.
+ *
+ */
+
+export default class ReferenceBase {
+  path: string;
+
+  constructor(_path: string) {
+    let path = _path;
+
+    if (path) {
+      path = path.length > 1 && path.endsWith('/') ? path.substring(0, path.length - 1) : path;
+      if (path.startsWith('/') && path.length > 1) {
+        path = path.substring(1, path.length);
+      }
+    } else {
+      path = '/';
+    }
+
+    this.path = path;
+  }
+
+  /**
+   * The last part of a Reference's path (after the last '/')
+   * The key of a root Reference is null.
+   * @type {String}
+   * {@link https://firebase.google.com/docs/reference/js/firebase.database.Reference#key}
+   */
+  get key(): string | null {
+    return this.path === '/' ? null : this.path.substring(this.path.lastIndexOf('/') + 1);
+  }
+}

package/lib/common/deeps.ts

@@ -0,0 +1,92 @@
+/*
+ * 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, isObject } from './validate';
+
+/**
+ * Deep get a value from an object.
+ * @website https://github.com/Salakar/deeps
+ * @param object
+ * @param path
+ * @param joiner
+ * @returns {*}
+ */
+export function deepGet<T = unknown>(
+  object: Record<string, unknown> | unknown[],
+  path: string,
+  joiner: string = '/',
+): T | undefined {
+  if (!isObject(object) && !Array.isArray(object)) {
+    return undefined;
+  }
+  const keys = path.split(joiner);
+
+  let i = 0;
+  let tmp: unknown = object;
+  const len = keys.length;
+
+  while (i < len) {
+    const key = keys[i++]!;
+    if (!tmp || !Object.hasOwnProperty.call(tmp, key)) {
+      return undefined;
+    }
+    tmp = (tmp as Record<string, unknown>)[key];
+  }
+
+  return tmp as T;
+}
+
+/**
+ * Deep set a value
+ * @param object
+ * @param path
+ * @param value
+ * @param initPaths
+ * @param joiner
+ */
+export function deepSet(
+  object: Record<string, unknown>,
+  path: string,
+  value: unknown,
+  initPaths: boolean = true,
+  joiner: string = '.',
+): boolean {
+  if (!isObject(object)) {
+    return false;
+  }
+  const keys = path.split(joiner);
+
+  let i = 0;
+  let _object: unknown = object;
+  const len = keys.length - 1;
+
+  while (i < len) {
+    const key = keys[i++]!;
+    if (initPaths && !Object.hasOwnProperty.call(object, key)) {
+      (_object as Record<string, unknown>)[key] = {};
+    }
+    _object = (_object as Record<string, unknown>)[key];
+  }
+
+  if (isObject(_object) || (isArray(_object) && !Number.isNaN(keys[i]))) {
+    (_object as Record<string, unknown>)[keys[i]!] = value;
+  } else {
+    return false;
+  }
+
+  return true;
+}

package/lib/common/id.ts

@@ -0,0 +1,91 @@
+/*
+ * 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.
+ *
+ */
+
+const PUSH_CHARS = '-0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz';
+
+const AUTO_ID_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+
+// 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: number[] = [];
+
+/**
+ * Generate a firebase id - for use with ref().push(val, cb) - e.g. -KXMr7k2tXUFQqiaZRY4'
+ * @param serverTimeOffset - pass in server time offset from native side
+ * @returns {string}
+ */
+export function generateDatabaseId(serverTimeOffset: number = 0): string {
+  const timeStampChars = new Array(8);
+  let now = new Date().getTime() + serverTimeOffset;
+  const duplicateTime = now === lastPushTime;
+
+  lastPushTime = now;
+
+  for (let i = 7; i >= 0; i -= 1) {
+    timeStampChars[i] = PUSH_CHARS.charAt(now % 64);
+    now = Math.floor(now / 64);
+  }
+
+  if (now !== 0) {
+    throw new Error('We should have converted the entire timestamp.');
+  }
+
+  let id = timeStampChars.join('');
+
+  if (!duplicateTime) {
+    for (let i = 0; i < 12; i += 1) {
+      lastRandChars[i] = Math.floor(Math.random() * 64);
+    }
+  } else {
+    // if the timestamp hasn't changed since last push,
+    // use the same random number, but increment it by 1.
+    let i;
+    for (i = 11; i >= 0 && lastRandChars[i] === 63; i -= 1) {
+      lastRandChars[i] = 0;
+    }
+
+    lastRandChars[i]! += 1;
+  }
+
+  for (let i = 0; i < 12; i++) {
+    id += PUSH_CHARS.charAt(lastRandChars[i]!);
+  }
+
+  if (id.length !== 20) {
+    throw new Error('Length should be 20.');
+  }
+
+  return id;
+}
+
+/**
+ * Generate a firestore auto id for use with collection/document .add()
+ * @return {string}
+ */
+export function generateFirestoreId(): string {
+  let autoId = '';
+
+  for (let i = 0; i < 20; i++) {
+    autoId += AUTO_ID_CHARS.charAt(Math.floor(Math.random() * AUTO_ID_CHARS.length));
+  }
+  return autoId;
+}