@react-native-firebase/crashlytics 23.7.0 → 23.8.1

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

@@ -0,0 +1 @@
+{"version":3,"file":"modular.d.ts","sourceRoot":"","sources":["../../../../lib/modular.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAEvD;;;;;;GAMG;AACH,wBAAgB,cAAc,IAAI,WAAW,CAE5C;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,CAGhF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAG3E;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,2BAA2B,CAAC,WAAW,EAAE,WAAW,GAAG,OAAO,CAAC,OAAO,CAAC,CAGtF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,KAAK,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAGpD;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,GAAG,CAAC,WAAW,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAGnE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CAAC,WAAW,EAAE,WAAW,EAAE,KAAK,EAAE,KAAK,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAG9F;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAGhE;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,SAAS,CAAC,WAAW,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAGjF;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,YAAY,CAAC,WAAW,EAAE,WAAW,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAGjG;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,aAAa,CAC3B,WAAW,EAAE,WAAW,EACxB,UAAU,EAAE;IAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;CAAE,GACpC,OAAO,CAAC,IAAI,CAAC,CAGf;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,+BAA+B,CAC7C,WAAW,EAAE,WAAW,EACxB,OAAO,EAAE,OAAO,GACf,OAAO,CAAC,IAAI,CAAC,CAOf"}

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

@@ -0,0 +1,12 @@
+import type { Crashlytics, Statics } from './types/crashlytics';
+import type { ReactNativeFirebase } from '@react-native-firebase/app';
+export declare const SDK_VERSION = "23.8.1";
+type CrashlyticsNamespace = ReactNativeFirebase.FirebaseModuleWithStaticsAndApp<Crashlytics, Statics> & {
+    crashlytics: ReactNativeFirebase.FirebaseModuleWithStaticsAndApp<Crashlytics, Statics>;
+    firebase: ReactNativeFirebase.Module;
+    app(name?: string): ReactNativeFirebase.FirebaseApp;
+};
+declare const _default: CrashlyticsNamespace;
+export default _default;
+export declare const firebase: ReactNativeFirebase.FirebaseNamespacedExport<"crashlytics", Crashlytics, Statics, false>;
+//# sourceMappingURL=namespaced.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"namespaced.d.ts","sourceRoot":"","sources":["../../../../lib/namespaced.ts"],"names":[],"mappings":"AAwCA,OAAO,KAAK,EAAE,WAAW,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAChE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAuHtE,eAAO,MAAM,WAAW,WAAU,CAAC;AAanC,KAAK,oBAAoB,GAAG,mBAAmB,CAAC,+BAA+B,CAC7E,WAAW,EACX,OAAO,CACR,GAAG;IACF,WAAW,EAAE,mBAAmB,CAAC,+BAA+B,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;IACvF,QAAQ,EAAE,mBAAmB,CAAC,MAAM,CAAC;IACrC,GAAG,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,mBAAmB,CAAC,WAAW,CAAC;CACrD,CAAC;wBAIgD,oBAAoB;AAAtE,wBAAuE;AAKvE,eAAO,MAAM,QAAQ,EACa,mBAAmB,CAAC,wBAAwB,CAC1E,aAAa,EACb,WAAW,EACX,OAAO,EACP,KAAK,CACN,CAAC"}

package/dist/typescript/module/lib/types/crashlytics.d.ts

@@ -0,0 +1,117 @@
+import type { ReactNativeFirebase } from '@react-native-firebase/app';
+/**
+ * Crashlytics module instance - returned from firebase.crashlytics() or firebase.app().crashlytics()
+ */
+export interface Crashlytics extends ReactNativeFirebase.FirebaseModule {
+    /** The FirebaseApp this module is associated with */
+    app: ReactNativeFirebase.FirebaseApp;
+    /**
+     * Whether Crashlytics reporting is enabled.
+     */
+    readonly isCrashlyticsCollectionEnabled: boolean;
+    /**
+     * Determines whether there are any unsent crash reports cached on the device.
+     * The callback only executes if automatic data collection is disabled.
+     *
+     * @throws Error if Crashlytics collection is enabled (reports are automatically sent)
+     */
+    checkForUnsentReports(): Promise<boolean>;
+    /**
+     * Cause your app to crash for testing purposes. This is a native crash and will not contain a javascript stack trace.
+     * Note that crashes are intercepted by debuggers on iOS so no report will be seen under those conditions.
+     */
+    crash(): void;
+    /**
+     * Deletes any unsent reports on the device. This method only applies if automatic data collection is disabled.
+     */
+    deleteUnsentReports(): Promise<void>;
+    /**
+     * Returns a boolean value indicating whether the app crashed during the previous execution.
+     */
+    didCrashOnPreviousExecution(): Promise<boolean>;
+    /**
+     * Log a message that will appear in any subsequent Crash or Non-fatal error reports.
+     *
+     * @param message The message to log.
+     */
+    log(message: string): void;
+    /**
+     * Record a JavaScript Error.
+     *
+     * The JavaScript stack trace is converted into a mock native iOS or Android exception before submission.
+     *
+     * @param error Expects an instance of Error; e.g. classes that extend Error will also be supported.
+     * @param jsErrorName Optional string containing Javascript error name
+     */
+    recordError(error: Error, jsErrorName?: string): void;
+    /**
+     * Enqueues any unsent reports on the device to upload to Crashlytics. This method only applies if
+     * automatic data collection is disabled.
+     */
+    sendUnsentReports(): void;
+    /**
+     * Sets a string value to be associated with the given attribute name which will be visible in the Firebase Crashlytics console.
+     *
+     * @param name The name of the attribute to set.
+     * @param value A string value for the given attribute.
+     */
+    setAttribute(name: string, value: string): Promise<null>;
+    /**
+     * Like `setAttribute` but for multiple attributes.
+     *
+     * @param attributes An object of key/value attribute name and values.
+     */
+    setAttributes(attributes: {
+        [key: string]: string;
+    }): Promise<null>;
+    /**
+     * Specify a user identifier which will be visible in the Firebase Crashlytics console.
+     *
+     * It is recommended for privacy purposes that this value be a value that's meaningless to a third-party
+     * observer; such as an arbitrary string that ties an end-user to a record in your system e.g. a database record id.
+     *
+     * @param userId An arbitrary string that ties an end-user to a record in your system e.g. a database record id.
+     */
+    setUserId(userId: string): Promise<null>;
+    /**
+     * Enable/disable Crashlytics reporting.
+     *
+     * Use this for opt-in first user data collection flows combined with `firebase.json` settings to disable auto collection.
+     *
+     * @param enabled A boolean value representing whether to enable Crashlytics error collection.
+     */
+    setCrashlyticsCollectionEnabled(enabled: boolean): Promise<null>;
+}
+/**
+ * Static properties available on firebase.crashlytics
+ */
+export interface Statics {
+    SDK_VERSION: string;
+}
+/**
+ * FirebaseApp type with crashlytics() method.
+ * @deprecated Import FirebaseApp from '@react-native-firebase/app' instead.
+ * The crashlytics() method is added via module augmentation.
+ */
+export type FirebaseApp = ReactNativeFirebase.FirebaseApp;
+declare module '@react-native-firebase/app' {
+    namespace ReactNativeFirebase {
+        interface Module {
+            crashlytics: FirebaseModuleWithStaticsAndApp<Crashlytics, Statics>;
+        }
+        interface FirebaseApp {
+            crashlytics(): Crashlytics;
+        }
+    }
+}
+type _Statics = Statics;
+/**
+ * @deprecated Use the exported types directly instead.
+ * FirebaseCrashlyticsTypes namespace is kept for backwards compatibility.
+ */
+export declare namespace FirebaseCrashlyticsTypes {
+    type Module = Crashlytics;
+    type Statics = _Statics;
+}
+export {};
+//# sourceMappingURL=crashlytics.d.ts.map

package/dist/typescript/module/lib/types/crashlytics.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"crashlytics.d.ts","sourceRoot":"","sources":["../../../../../lib/types/crashlytics.ts"],"names":[],"mappings":"AAiBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,4BAA4B,CAAC;AAItE;;GAEG;AACH,MAAM,WAAW,WAAY,SAAQ,mBAAmB,CAAC,cAAc;IACrE,qDAAqD;IACrD,GAAG,EAAE,mBAAmB,CAAC,WAAW,CAAC;IAErC;;OAEG;IACH,QAAQ,CAAC,8BAA8B,EAAE,OAAO,CAAC;IAEjD;;;;;OAKG;IACH,qBAAqB,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAE1C;;;OAGG;IACH,KAAK,IAAI,IAAI,CAAC;IAEd;;OAEG;IACH,mBAAmB,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAErC;;OAEG;IACH,2BAA2B,IAAI,OAAO,CAAC,OAAO,CAAC,CAAC;IAEhD;;;;OAIG;IACH,GAAG,CAAC,OAAO,EAAE,MAAM,GAAG,IAAI,CAAC;IAE3B;;;;;;;OAOG;IACH,WAAW,CAAC,KAAK,EAAE,KAAK,EAAE,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAEtD;;;OAGG;IACH,iBAAiB,IAAI,IAAI,CAAC;IAE1B;;;;;OAKG;IACH,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzD;;;;OAIG;IACH,aAAa,CAAC,UAAU,EAAE;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEpE;;;;;;;OAOG;IACH,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEzC;;;;;;OAMG;IACH,+BAA+B,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CAClE;AAID;;GAEG;AACH,MAAM,WAAW,OAAO;IACtB,WAAW,EAAE,MAAM,CAAC;CACrB;AAED;;;;GAIG;AACH,MAAM,MAAM,WAAW,GAAG,mBAAmB,CAAC,WAAW,CAAC;AAK1D,OAAO,QAAQ,4BAA4B,CAAC;IAC1C,UAAU,mBAAmB,CAAC;QAC5B,UAAU,MAAM;YACd,WAAW,EAAE,+BAA+B,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;SACpE;QACD,UAAU,WAAW;YACnB,WAAW,IAAI,WAAW,CAAC;SAC5B;KACF;CACF;AAGD,KAAK,QAAQ,GAAG,OAAO,CAAC;AAExB;;;GAGG;AAEH,yBAAiB,wBAAwB,CAAC;IAExC,KAAY,MAAM,GAAG,WAAW,CAAC;IACjC,KAAY,OAAO,GAAG,QAAQ,CAAC;CAChC"}

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

@@ -0,0 +1,2 @@
+export declare const version = "23.8.1";
+//# 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/handlers.ts

@@ -0,0 +1,196 @@
+/*
+ * 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 { firebase } from '.';
+import { isError, once } from '@react-native-firebase/app/lib/common';
+// @ts-ignore - No declaration file for promise/setimmediate/rejection-tracking
+import tracking from 'promise/setimmediate/rejection-tracking';
+import StackTrace from 'stacktrace-js';
+export const FATAL_FLAG = 'com.firebase.crashlytics.reactnative.fatal';
+
+interface NativeErrorFrame {
+  src: string;
+  line: number;
+  col: number;
+  fn: string;
+  file: string;
+}
+
+interface NativeErrorObj {
+  message: string;
+  isUnhandledRejection: boolean;
+  frames: NativeErrorFrame[];
+}
+
+interface NativeModule {
+  isCrashlyticsCollectionEnabled: boolean;
+  isErrorGenerationOnJSCrashEnabled: boolean;
+  isCrashlyticsJavascriptExceptionHandlerChainingEnabled: boolean;
+  logPromise(message: string): Promise<void>;
+  setAttribute(name: string, value: string): Promise<void>;
+  recordErrorPromise(errorObj: NativeErrorObj): Promise<void>;
+  crashWithStackPromise(errorObj: NativeErrorObj): Promise<void>;
+}
+
+export function createNativeErrorObj(
+  error: Error,
+  stackFrames: StackTrace.StackFrame[],
+  isUnhandledRejection: boolean,
+  jsErrorName?: string,
+): NativeErrorObj {
+  const nativeObj: NativeErrorObj = {
+    message: `${error.message}`,
+    isUnhandledRejection,
+    frames: [],
+  };
+
+  if (jsErrorName) {
+    // Option to fix crashlytics display and alerting. You can add an error name to the recordError function
+    nativeObj.frames.push({
+      src: '<unknown>',
+      line: 0,
+      col: 0,
+      fn: '<unknown>',
+      file: jsErrorName,
+    });
+  }
+
+  for (let i = 0; i < stackFrames.length; i++) {
+    const frame = stackFrames[i];
+    if (!frame) continue;
+
+    const { columnNumber, lineNumber, fileName, functionName, source } = frame;
+    let fileNameParsed = '<unknown>';
+    if (fileName) {
+      const subStrLen = fileName.indexOf('?');
+      if (subStrLen < 0) {
+        fileNameParsed = fileName;
+      } else if (subStrLen > 0) {
+        fileNameParsed = fileName.substring(0, subStrLen);
+      }
+    }
+
+    nativeObj.frames.push({
+      src: source || '<unknown>',
+      line: lineNumber || 0,
+      col: columnNumber || 0,
+      fn: functionName || '<unknown>',
+      file: `${fileNameParsed}:${lineNumber || 0}:${columnNumber || 0}`,
+    });
+  }
+
+  return nativeObj;
+}
+
+export const setGlobalErrorHandler = once((nativeModule: NativeModule) => {
+  const originalHandler = ErrorUtils.getGlobalHandler();
+
+  async function handler(error: unknown, fatal?: boolean) {
+    // If collection is disabled, just forward to the original handler
+    if (!nativeModule.isCrashlyticsCollectionEnabled) {
+      return originalHandler(error, fatal);
+    }
+
+    if (!isError(error)) {
+      await nativeModule.logPromise(`Unknown Error: ${error}`);
+      return originalHandler(error, fatal);
+    }
+
+    // If we are supposed to log javascript-level stack traces, convert this error and log it
+    if (nativeModule.isErrorGenerationOnJSCrashEnabled) {
+      try {
+        const stackFrames = await StackTrace.fromError(error, { offline: true });
+        // The backend conversion scan converts the closest event to this timestamp without going over
+        // from the timestamp here. So the timestamp *must* be greater then the event log time.
+        //
+        // For that reason we always round up (`.ceil`) and add a second in case of latency
+        //
+        // Time is specified as seconds since start of Unix epoch as a baseline, as a string
+        const fatalTime = Math.ceil(new Date().getTime() / 1000) + 1 + '';
+
+        // Flag the Crashlytics backend that we have a fatal error, they will transform it
+        await nativeModule.setAttribute(FATAL_FLAG, fatalTime);
+
+        // remember our current deprecation warning state in case users
+        // have set it to non-default
+        const currentDeprecationWarningToggle =
+          globalThis.RNFB_SILENCE_MODULAR_DEPRECATION_WARNINGS;
+
+        // Notify analytics, if it exists - throws error if not
+        try {
+          // FIXME - disable warnings and use the old namespaced style,
+          // See https://github.com/invertase/react-native-firebase/issues/8381
+          // Unfortunately, this fails completely when using modular!
+          // Did not matter if I did named imports above or dynamic require here.
+          // So temporarily reverting and silencing warnings instead
+          globalThis.RNFB_SILENCE_MODULAR_DEPRECATION_WARNINGS = true;
+          // @ts-ignore - analytics types not available in crashlytics
+          await firebase.app().analytics().logEvent(
+            'app_exception', // 'app_exception' is reserved but we make an exception for JS->fatal transforms
+            {
+              fatal: 1, // as in firebase-android-sdk
+              timestamp: fatalTime,
+            },
+          );
+        } catch (_) {
+          // This just means analytics was not present, so we could not log the analytics event
+          // console.log('error logging analytics app_exception: ' + e);
+        } finally {
+          globalThis.RNFB_SILENCE_MODULAR_DEPRECATION_WARNINGS = currentDeprecationWarningToggle;
+        }
+
+        // If we are chaining to other handlers, just record the error, otherwise we need to crash with it
+        if (nativeModule.isCrashlyticsJavascriptExceptionHandlerChainingEnabled) {
+          await nativeModule.recordErrorPromise(createNativeErrorObj(error, stackFrames, false));
+        } else {
+          await nativeModule.crashWithStackPromise(createNativeErrorObj(error, stackFrames, false));
+        }
+      } catch (_) {
+        // do nothing
+        // console.log('error logging handling the exception: ' + e);
+      }
+    }
+
+    // If we are configured to chain exception handlers, do so. It could result in duplicate errors though.
+    if (nativeModule.isCrashlyticsJavascriptExceptionHandlerChainingEnabled) {
+      return originalHandler(error, fatal);
+    }
+  }
+
+  ErrorUtils.setGlobalHandler(handler);
+  return handler;
+});
+
+export const setOnUnhandledPromiseRejectionHandler = once((nativeModule: NativeModule) => {
+  async function onUnhandled(_id: number, error: Error) {
+    if (!__DEV__) {
+      // TODO(salakar): Option to disable
+      try {
+        const stackFrames = await StackTrace.fromError(error, { offline: true });
+        await nativeModule.recordErrorPromise(createNativeErrorObj(error, stackFrames, true));
+      } catch (_) {
+        // do nothing
+      }
+    }
+  }
+  tracking.enable({
+    allRejections: true,
+    onUnhandled,
+  });
+
+  return onUnhandled;
+});

package/lib/index.ts

@@ -0,0 +1,26 @@
+/*
+ * 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 types from types/crashlytics
+export type { Crashlytics, FirebaseCrashlyticsTypes } from './types/crashlytics';
+
+// Export modular API functions
+export * from './modular';
+
+// Export namespaced API
+export * from './namespaced';
+export { default } from './namespaced';

package/lib/modular.ts

@@ -0,0 +1,249 @@
+import { getApp } from '@react-native-firebase/app';
+import { MODULAR_DEPRECATION_ARG } from '@react-native-firebase/app/lib/common';
+import type { Crashlytics } from './types/crashlytics';
+
+/**
+ * Returns Crashlytics instance.
+ * #### Example
+ * ```js
+ * const crashlytics = getCrashlytics();
+ * ```
+ */
+export function getCrashlytics(): Crashlytics {
+  return getApp().crashlytics();
+}
+
+/**
+ * Determines whether there are any unsent crash reports cached on the device. The callback only executes
+ * if automatic data collection is disabled.
+ *
+ * #### Example
+ *
+ * ```js
+ * async checkReports() {
+ * // returns boolean value
+ *  const crashlytics = getCrashlytics();
+ *  const unsentReports = await checkForUnsentReports(crashlytics);
+ * }
+ *
+ * checkReports();
+ * ```
+ * @param crashlytics A crashlytics instance.
+ * @returns Promise that resolves to a boolean indicating if there are unsent reports.
+ */
+export function checkForUnsentReports(crashlytics: Crashlytics): Promise<boolean> {
+  // @ts-ignore - MODULAR_DEPRECATION_ARG is not defined in the global scope
+  return crashlytics.checkForUnsentReports.call(crashlytics, MODULAR_DEPRECATION_ARG);
+}
+
+/**
+ * Deletes any unsent reports on the device. This method only applies if automatic data collection is
+ * disabled.
+ *
+ * #### Example
+ *
+ * ```js
+ * const crashlytics = getCrashlytics();
+ * deleteUnsentReports(crashlytics);
+ * ```
+ * @param crashlytics A crashlytics instance.
+ */
+export function deleteUnsentReports(crashlytics: Crashlytics): Promise<void> {
+  // @ts-ignore - MODULAR_DEPRECATION_ARG is not defined in the global scope
+  return crashlytics.deleteUnsentReports.call(crashlytics, MODULAR_DEPRECATION_ARG);
+}
+
+/**
+ * Returns a boolean value indicating whether the app crashed during the previous execution.
+ *
+ * #### Example
+ *
+ * ```js
+ * async didCrashPreviously() {
+ * // returns boolean value
+ * const crashlytics = getCrashlytics();
+ * const didCrash = await didCrashOnPreviousExecution(crashlytics);
+ * }
+ *
+ * didCrashPreviously();
+ * ```
+ * @param crashlytics A crashlytics instance.
+ * @returns Promise that resolves to a boolean indicating if the app crashed previously.
+ */
+export function didCrashOnPreviousExecution(crashlytics: Crashlytics): Promise<boolean> {
+  // @ts-ignore - MODULAR_DEPRECATION_ARG is not defined in the global scope
+  return crashlytics.didCrashOnPreviousExecution.call(crashlytics, MODULAR_DEPRECATION_ARG);
+}
+
+/**
+ * Cause your app to crash for testing purposes. This is a native crash and will not contain a javascript stack trace.
+ * Note that crashes are intercepted by debuggers on iOS so no report will be seen under those conditions. Additionally
+ * if it is a debug build you will need to ensure your firebase.json is configured to enable crashlytics even in debug mode.
+ *
+ * #### Example
+ *
+ * ```js
+ * const crashlytics = getCrashlytics();
+ * crash(crashlytics);
+ * ```
+ * @param crashlytics A crashlytics instance.
+ */
+export function crash(crashlytics: Crashlytics): void {
+  // @ts-ignore - MODULAR_DEPRECATION_ARG is not defined in the global scope
+  return crashlytics.crash.call(crashlytics, MODULAR_DEPRECATION_ARG);
+}
+
+/**
+ * Log a message that will appear in any subsequent Crash or Non-fatal error reports.
+ *
+ * #### Example
+ *
+ * ```js
+ * const crashlytics = getCrashlytics();
+ * log(crashlytics, 'Testing a crash');
+ * crash(crashlytics);
+ * ```
+ * @param crashlytics A crashlytics instance.
+ * @param message The message to log.
+ */
+export function log(crashlytics: Crashlytics, message: string): void {
+  // @ts-ignore - MODULAR_DEPRECATION_ARG is not defined in the global scope
+  return crashlytics.log.call(crashlytics, message, MODULAR_DEPRECATION_ARG);
+}
+
+/**
+ * Record a JavaScript Error.
+ *
+ * The JavaScript stack trace is converted into a mock native iOS or Android exception before submission.
+ * The line numbers in the stack trace (if available) will be relative to the javascript bundle built by your packager,
+ * after whatever transpilation or minimization steps happen. You will need to maintain sourcemaps to decode them if desired.
+ *
+ * #### Example
+ *
+ * ```js
+ * const crashlytics = getCrashlytics();
+ * recordError(
+ *  crashlytics,
+ *  new Error('An error was caught')
+ * );
+ * ```
+ * @param crashlytics A crashlytics instance.
+ * @param error Expects an instance of Error; e.g. classes that extend Error will also be supported.
+ * @param jsErrorName Optional string containing Javascript error name
+ */
+export function recordError(crashlytics: Crashlytics, error: Error, jsErrorName?: string): void {
+  // @ts-ignore - MODULAR_DEPRECATION_ARG is not defined in the global scope
+  return crashlytics.recordError.call(crashlytics, error, jsErrorName, MODULAR_DEPRECATION_ARG);
+}
+
+/**
+ * Enqueues any unsent reports on the device to upload to Crashlytics. This method only applies if
+ * automatic data collection is disabled.
+ *
+ * #### Example
+ *
+ * ```js
+ * const crashlytics = getCrashlytics();
+ * sendUnsentReports(crashlytics);
+ * ```
+ * @param crashlytics A crashlytics instance.
+ */
+export function sendUnsentReports(crashlytics: Crashlytics): void {
+  // @ts-ignore - MODULAR_DEPRECATION_ARG is not defined in the global scope
+  return crashlytics.sendUnsentReports.call(crashlytics, MODULAR_DEPRECATION_ARG);
+}
+
+/**
+ * Specify a user identifier which will be visible in the Firebase Crashlytics console.
+ *
+ * It is recommended for privacy purposes that this value be a value that's meaningless to a third-party
+ * observer; such as an arbitrary string that ties an end-user to a record in your system e.g. a database record id.
+ *
+ * #### Example
+ *
+ * ```js
+ * const auth = getAuth();
+ * const crashlytics = getCrashlytics();
+ * // Custom user id
+ * await setUserId(crashlytics, '123456789');
+ * // Firebase auth uid
+ * await setUserId(
+ *  crashlytics,
+ *  auth.currentUser.uid
+ * );
+ * ```
+ * @param crashlytics A crashlytics instance.
+ * @param userId An arbitrary string that ties an end-user to a record in your system e.g. a database record id.
+ */
+export function setUserId(crashlytics: Crashlytics, userId: string): Promise<null> {
+  // @ts-ignore - MODULAR_DEPRECATION_ARG is not defined in the global scope
+  return crashlytics.setUserId.call(crashlytics, userId, MODULAR_DEPRECATION_ARG);
+}
+
+/**
+ * Sets a string value to be associated with the given attribute name which will be visible in the Firebase Crashlytics console.
+ *
+ * #### Example
+ *
+ * ```js
+ * const crashlytics = getCrashlytics();
+ * await setAttribute(crashlytics, 'role', 'admin');
+ * ```
+ * @param crashlytics A crashlytics instance.
+ * @param name The name of the attribute to set.
+ * @param value A string value for the given attribute.
+ */
+export function setAttribute(crashlytics: Crashlytics, name: string, value: string): Promise<null> {
+  // @ts-ignore - MODULAR_DEPRECATION_ARG is not defined in the global scope
+  return crashlytics.setAttribute.call(crashlytics, name, value, MODULAR_DEPRECATION_ARG);
+}
+
+/**
+ * Like `setAttribute` but for multiple attributes.
+ *
+ * #### Example
+ *
+ * ```js
+ * const crashlytics = getCrashlytics();
+ * await setAttributes(crashlytics, {
+ *   role: 'admin',
+ *   followers: '13',
+ * });
+ * ```
+ * @param crashlytics A crashlytics instance.
+ * @param attributes An object of key/value attribute name and values.
+ */
+export function setAttributes(
+  crashlytics: Crashlytics,
+  attributes: { [key: string]: string },
+): Promise<null> {
+  // @ts-ignore - MODULAR_DEPRECATION_ARG is not defined in the global scope
+  return crashlytics.setAttributes.call(crashlytics, attributes, MODULAR_DEPRECATION_ARG);
+}
+
+/**
+ * Enable/disable Crashlytics reporting.
+ *
+ * Use this for opt-in first user data collection flows combined with `firebase.json` settings to disable auto collection.
+ *
+ * #### Example
+ *
+ * ```js
+ * const crashlytics = getCrashlytics();
+ * // Disable crash reporting
+ * await setCrashlyticsCollectionEnabled(crashlytics, false);
+ * ```
+ * @param crashlytics A crashlytics instance.
+ * @param enabled A boolean value representing whether to enable Crashlytics error collection.
+ */
+export function setCrashlyticsCollectionEnabled(
+  crashlytics: Crashlytics,
+  enabled: boolean,
+): Promise<null> {
+  return crashlytics.setCrashlyticsCollectionEnabled.call(
+    crashlytics,
+    enabled,
+    // @ts-ignore - MODULAR_DEPRECATION_ARG is not defined in the global scope
+    MODULAR_DEPRECATION_ARG,
+  );
+}