@react-native-firebase/crashlytics 25.1.0 → 26.1.0

package/lib/index.ts

@@ -1,3 +1,4 @@
+/* eslint-disable no-console */
 /*
  * Copyright (c) 2016-present Invertase Limited & Contributors
  *
@@ -15,12 +16,213 @@
  *
  */
 
-// Export types from types/crashlytics
-export type { Crashlytics, FirebaseCrashlyticsTypes } from './types/crashlytics';
+import type { FirebaseApp } from '@react-native-firebase/app';
+import {
+  isBoolean,
+  isError,
+  isObject,
+  isString,
+} from '@react-native-firebase/app/dist/module/common';
+import {
+  FirebaseModule,
+  getOrCreateModularInstance,
+} from '@react-native-firebase/app/dist/module/internal';
+import type { ModuleConfig } from '@react-native-firebase/app/dist/module/internal';
+import './types/internal';
+import StackTrace from 'stacktrace-js';
+import {
+  createNativeErrorObj,
+  setGlobalErrorHandler,
+  setOnUnhandledPromiseRejectionHandler,
+} from './handlers';
+import { version } from './version';
+import type { Crashlytics } from './types/crashlytics';
+import type { CrashlyticsInternal } from './types/internal';
+import type { ReactNativeFirebase } from '@react-native-firebase/app';
 
-// Export modular API functions
-export * from './modular';
+const nativeModuleName = 'NativeRNFBTurboCrashlytics';
 
-// Export namespaced API
-export * from './namespaced';
-export { default } from './namespaced';
+class FirebaseCrashlyticsModule extends FirebaseModule {
+  _isCrashlyticsCollectionEnabled: boolean;
+
+  constructor(
+    app: ReactNativeFirebase.FirebaseAppBase,
+    config: ModuleConfig,
+    customUrlOrRegion?: string | null,
+  ) {
+    super(app, config, customUrlOrRegion);
+    setGlobalErrorHandler(this.native);
+    setOnUnhandledPromiseRejectionHandler(this.native);
+    this._isCrashlyticsCollectionEnabled = this.native.isCrashlyticsCollectionEnabled;
+  }
+
+  get isCrashlyticsCollectionEnabled(): boolean {
+    // Purposefully did not deprecate this as I think it should remain a property rather than a method.
+    return this._isCrashlyticsCollectionEnabled;
+  }
+
+  checkForUnsentReports(): Promise<boolean> {
+    if (this.isCrashlyticsCollectionEnabled) {
+      throw new Error(
+        "firebase.crashlytics().setCrashlyticsCollectionEnabled(*) has been set to 'true', all reports are automatically sent.",
+      );
+    }
+    return this.native.checkForUnsentReports();
+  }
+
+  crash(): void {
+    this.native.crash();
+  }
+
+  async deleteUnsentReports(): Promise<void> {
+    await this.native.deleteUnsentReports();
+  }
+
+  didCrashOnPreviousExecution(): Promise<boolean> {
+    return this.native.didCrashOnPreviousExecution();
+  }
+
+  log(message: string): void {
+    this.native.log(`${message}`);
+  }
+
+  setAttribute(name: string, value: string): Promise<null> {
+    if (!isString(name)) {
+      throw new Error(
+        'firebase.crashlytics().setAttribute(*, _): The supplied property name must be a string.',
+      );
+    }
+
+    if (!isString(value)) {
+      throw new Error(
+        'firebase.crashlytics().setAttribute(_, *): The supplied property value must be a string value.',
+      );
+    }
+
+    return this.native.setAttribute(name, value);
+  }
+
+  setAttributes(object: { [key: string]: string }): Promise<null> {
+    if (!isObject(object)) {
+      throw new Error(
+        'firebase.crashlytics().setAttributes(*): The supplied arg must be an object of key value strings.',
+      );
+    }
+
+    return this.native.setAttributes(object);
+  }
+
+  setUserId(userId: string): Promise<null> {
+    if (!isString(userId)) {
+      throw new Error(
+        'firebase.crashlytics().setUserId(*): The supplied userId must be a string value.',
+      );
+    }
+
+    return this.native.setUserId(userId);
+  }
+
+  recordError(error: Error, jsErrorName?: string): void {
+    if (isError(error)) {
+      StackTrace.fromError(error, { offline: true })
+        .then(stackFrames =>
+          this.native.recordErrorPromise(
+            createNativeErrorObj(error, stackFrames, false, jsErrorName),
+          ),
+        )
+        .catch(() => {});
+    } else {
+      console.warn(
+        'firebase.crashlytics().recordError(*) expects an instance of Error. Non Errors will be ignored.',
+      );
+    }
+  }
+
+  sendUnsentReports(): void {
+    if (this.isCrashlyticsCollectionEnabled) {
+      this.native.sendUnsentReports();
+    }
+  }
+
+  setCrashlyticsCollectionEnabled(enabled: boolean): Promise<null> {
+    if (!isBoolean(enabled)) {
+      throw new Error(
+        "firebase.crashlytics().setCrashlyticsCollectionEnabled(*) 'enabled' must be a boolean.",
+      );
+    }
+
+    this._isCrashlyticsCollectionEnabled = enabled;
+    return this.native.setCrashlyticsCollectionEnabled(enabled);
+  }
+}
+
+const config: ModuleConfig = {
+  namespace: 'crashlytics',
+  nativeModuleName,
+  nativeEvents: false,
+  hasMultiAppSupport: false,
+  hasCustomUrlOrRegionSupport: false,
+  turboModule: true,
+};
+
+export const SDK_VERSION = version;
+
+export function getCrashlytics(app?: FirebaseApp): Crashlytics {
+  return getOrCreateModularInstance(
+    FirebaseCrashlyticsModule,
+    config,
+    app,
+  ) as unknown as Crashlytics;
+}
+
+export function checkForUnsentReports(crashlytics: Crashlytics): Promise<boolean> {
+  return (crashlytics as CrashlyticsInternal).checkForUnsentReports();
+}
+
+export function deleteUnsentReports(crashlytics: Crashlytics): Promise<void> {
+  return (crashlytics as CrashlyticsInternal).deleteUnsentReports();
+}
+
+export function didCrashOnPreviousExecution(crashlytics: Crashlytics): Promise<boolean> {
+  return (crashlytics as CrashlyticsInternal).didCrashOnPreviousExecution();
+}
+
+export function crash(crashlytics: Crashlytics): void {
+  return (crashlytics as CrashlyticsInternal).crash();
+}
+
+export function log(crashlytics: Crashlytics, message: string): void {
+  return (crashlytics as CrashlyticsInternal).log(message);
+}
+
+export function recordError(crashlytics: Crashlytics, error: Error, jsErrorName?: string): void {
+  return (crashlytics as CrashlyticsInternal).recordError(error, jsErrorName);
+}
+
+export function sendUnsentReports(crashlytics: Crashlytics): void {
+  return (crashlytics as CrashlyticsInternal).sendUnsentReports();
+}
+
+export function setUserId(crashlytics: Crashlytics, userId: string): Promise<null> {
+  return (crashlytics as CrashlyticsInternal).setUserId(userId);
+}
+
+export function setAttribute(crashlytics: Crashlytics, name: string, value: string): Promise<null> {
+  return (crashlytics as CrashlyticsInternal).setAttribute(name, value);
+}
+
+export function setAttributes(
+  crashlytics: Crashlytics,
+  attributes: { [key: string]: string },
+): Promise<null> {
+  return (crashlytics as CrashlyticsInternal).setAttributes(attributes);
+}
+
+export function setCrashlyticsCollectionEnabled(
+  crashlytics: Crashlytics,
+  enabled: boolean,
+): Promise<null> {
+  return (crashlytics as CrashlyticsInternal).setCrashlyticsCollectionEnabled(enabled);
+}
+
+export type { Crashlytics } from './types/crashlytics';

package/lib/types/crashlytics.ts

@@ -125,35 +125,5 @@ export interface Statics {
 /**
  * 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;
-
-// ============ Module Augmentation ============
-
-/* eslint-disable @typescript-eslint/no-namespace */
-declare module '@react-native-firebase/app' {
-  namespace ReactNativeFirebase {
-    interface Module {
-      crashlytics: FirebaseModuleWithStaticsAndApp<Crashlytics, Statics>;
-    }
-    interface FirebaseApp {
-      crashlytics(): Crashlytics;
-    }
-  }
-}
-/* eslint-enable @typescript-eslint/no-namespace */
-// ============ Backwards Compatibility Namespace - to be removed with namespaced exports ============
-type _Statics = Statics;
-
-/**
- * @deprecated Use the exported types directly instead.
- * FirebaseCrashlyticsTypes namespace is kept for backwards compatibility.
- */
-/* eslint-disable @typescript-eslint/no-namespace */
-export namespace FirebaseCrashlyticsTypes {
-  // Short name aliases referencing top-level types
-  export type Module = Crashlytics;
-  export type Statics = _Statics;
-}
-/* eslint-enable @typescript-eslint/no-namespace */

package/lib/types/internal.ts

@@ -0,0 +1,59 @@
+/*
+ * 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 type { Crashlytics } from './crashlytics';
+
+export interface NativeRNFBTurboCrashlytics {
+  isCrashlyticsCollectionEnabled: boolean;
+  isErrorGenerationOnJSCrashEnabled: boolean;
+  isCrashlyticsJavascriptExceptionHandlerChainingEnabled: boolean;
+  checkForUnsentReports(): Promise<boolean>;
+  crash(): void;
+  deleteUnsentReports(): Promise<void>;
+  didCrashOnPreviousExecution(): Promise<boolean>;
+  log(message: string): void;
+  setAttribute(name: string, value: string): Promise<null>;
+  setAttributes(object: { [key: string]: string }): Promise<null>;
+  setUserId(userId: string): Promise<null>;
+  recordError(errorObj: unknown): void;
+  sendUnsentReports(): void;
+  setCrashlyticsCollectionEnabled(enabled: boolean): Promise<null>;
+  logPromise(message: string): Promise<void>;
+  recordErrorPromise(errorObj: unknown): Promise<void>;
+  crashWithStackPromise(errorObj: unknown): Promise<void>;
+}
+
+declare module '@react-native-firebase/app/dist/module/internal/NativeModules' {
+  interface ReactNativeFirebaseNativeModules {
+    NativeRNFBTurboCrashlytics: NativeRNFBTurboCrashlytics;
+  }
+}
+
+export interface CrashlyticsInternal extends Crashlytics {
+  checkForUnsentReports(): Promise<boolean>;
+  crash(): void;
+  deleteUnsentReports(): Promise<void>;
+  didCrashOnPreviousExecution(): Promise<boolean>;
+  log(message: string): void;
+  recordError(error: Error, jsErrorName?: string): void;
+  sendUnsentReports(): void;
+  setUserId(userId: string): Promise<null>;
+  setAttribute(name: string, value: string): Promise<null>;
+  setAttributes(attributes: { [key: string]: string }): Promise<null>;
+  setCrashlyticsCollectionEnabled(enabled: boolean): Promise<null>;
+  readonly native: NativeRNFBTurboCrashlytics;
+}

package/lib/version.ts

@@ -1,2 +1,2 @@
 // Generated by genversion.
-export const version = '25.1.0';
+export const version = '26.1.0';

package/package.json

@@ -1,17 +1,34 @@
 {
   "name": "@react-native-firebase/crashlytics",
-  "version": "25.1.0",
+  "version": "26.1.0",
   "author": "Invertase <oss@invertase.io> (http://invertase.io)",
   "description": "React Native Firebase - Firebase Crashlytics is a lightweight, realtime crash reporter that helps you track, prioritize, and fix stability issues that erode your app quality. React Native Firebase provides automatic crash reporting for both native and JavaScript errors, including unhandled promise rejections.",
   "main": "./dist/module/index.js",
   "types": "./dist/typescript/lib/index.d.ts",
+  "codegenConfig": {
+    "name": "RNFBCrashlyticsTurboModules",
+    "type": "modules",
+    "jsSrcsDir": "specs",
+    "includesGeneratedCode": true,
+    "android": {
+      "javaPackageName": "io.invertase.firebase.crashlytics"
+    },
+    "ios": {
+      "modulesProvider": {
+        "NativeRNFBTurboCrashlytics": "RNFBCrashlyticsModule"
+      }
+    }
+  },
   "scripts": {
     "build": "genversion --esm --semi lib/version.ts",
     "build:clean": "rimraf android/build && rimraf ios/build",
     "build:plugin": "rimraf plugin/build && tsc --build plugin",
     "lint:plugin": "eslint plugin/src/*",
     "compile": "bob build",
-    "prepare": "yarn run build && yarn run build:plugin && yarn compile"
+    "prepare": "yarn run build && yarn run build:plugin && yarn compile",
+    "codegen": "yarn android:codegen && yarn ios:codegen",
+    "android:codegen": "npx @react-native-community/cli codegen --platform android --outputPath=./android/src/main/java/io/invertase/firebase/crashlytics/generated",
+    "ios:codegen": "npx @react-native-community/cli codegen --platform ios --outputPath=./ios/generated"
   },
   "repository": {
     "type": "git",
@@ -30,13 +47,14 @@
     "crashlytics"
   ],
   "peerDependencies": {
-    "@react-native-firebase/app": "25.1.0",
+    "@react-native-firebase/app": "26.1.0",
     "expo": ">=47.0.0"
   },
   "dependencies": {
     "stacktrace-js": "^2.0.2"
   },
   "devDependencies": {
+    "@react-native-firebase/app": "26.1.0",
     "expo": "^55.0.18",
     "react-native-builder-bob": "^0.41.0",
     "typescript": "^6.0.3"
@@ -56,7 +74,14 @@
       "types": "./dist/typescript/lib/index.d.ts",
       "default": "./dist/module/index.js"
     },
-    "./app.plugin.js": "./app.plugin.js",
+    "./app.plugin": {
+      "types": "./plugin/build/app.plugin.d.ts",
+      "default": "./app.plugin.js"
+    },
+    "./app.plugin.js": {
+      "types": "./plugin/build/app.plugin.d.ts",
+      "default": "./app.plugin.js"
+    },
     "./package.json": "./package.json"
   },
   "react-native-builder-bob": {
@@ -77,5 +102,5 @@
       ]
     ]
   },
-  "gitHead": "e0a565d8a73a9b103d140ffacfb8876b30d8bdc5"
+  "gitHead": "59d053eca14ab8aa80e5ac76887014925c67e52b"
 }

package/plugin/build/app.plugin.d.ts

@@ -0,0 +1,2 @@
+import plugin from './index';
+export = plugin;

package/plugin/build/app.plugin.js

@@ -0,0 +1,6 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const index_1 = __importDefault(require("./index"));
+module.exports = index_1.default;

package/plugin/src/app.plugin.ts

@@ -0,0 +1,3 @@
+import plugin from './index';
+
+export = plugin;

package/plugin/tsconfig.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/index.ts","./src/android/applyPlugin.ts","./src/android/buildscriptDependency.ts","./src/android/constants.ts","./src/android/index.ts"],"version":"6.0.3"}
+{"root":["./src/app.plugin.ts","./src/index.ts","./src/android/applyPlugin.ts","./src/android/buildscriptDependency.ts","./src/android/constants.ts","./src/android/index.ts"],"version":"6.0.3"}

package/react-native.config.js

@@ -1,34 +1,9 @@
-/*
- *  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.
- */
-
 module.exports = {
   dependency: {
     platforms: {
-      ios: {
-        scriptPhases: [
-          {
-            name: '[RNFB] Crashlytics Configuration',
-            path: './ios_config.sh',
-            execution_position: 'after_compile',
-            input_files: [
-              '${DWARF_DSYM_FOLDER_PATH}/${DWARF_DSYM_FILE_NAME}/Contents/Resources/DWARF/${TARGET_NAME}',
-              '$(BUILT_PRODUCTS_DIR)/$(INFOPLIST_PATH)',
-            ],
-          },
-        ],
+      android: {
+        cmakeListsPath:
+          './src/main/java/io/invertase/firebase/crashlytics/generated/jni/CMakeLists.txt',
       },
     },
   },

package/specs/NativeRNFBTurboCrashlytics.ts

@@ -0,0 +1,41 @@
+import type { TurboModule } from 'react-native';
+import { TurboModuleRegistry } from 'react-native';
+
+export interface CrashlyticsStackFrame {
+  src: string;
+  line: number;
+  col: number;
+  fn: string;
+  file: string;
+}
+
+export interface JavaScriptErrorObject {
+  message: string;
+  isUnhandledRejection: boolean;
+  frames: ReadonlyArray<CrashlyticsStackFrame>;
+}
+
+export interface Spec extends TurboModule {
+  getConstants(): {
+    isCrashlyticsCollectionEnabled: boolean;
+    isErrorGenerationOnJSCrashEnabled: boolean;
+    isCrashlyticsJavascriptExceptionHandlerChainingEnabled: boolean;
+  };
+
+  checkForUnsentReports(): Promise<boolean>;
+  crash(): void;
+  crashWithStackPromise(jsErrorDict: JavaScriptErrorObject): Promise<void>;
+  deleteUnsentReports(): Promise<void>;
+  didCrashOnPreviousExecution(): Promise<boolean>;
+  log(message: string): void;
+  logPromise(message: string): Promise<void>;
+  sendUnsentReports(): void;
+  setAttribute(key: string, value: string): Promise<void>;
+  setAttributes(attributes: { [key: string]: string }): Promise<void>;
+  setUserId(userId: string): Promise<void>;
+  recordError(jsErrorDict: JavaScriptErrorObject): void;
+  recordErrorPromise(jsErrorDict: JavaScriptErrorObject): Promise<void>;
+  setCrashlyticsCollectionEnabled(enabled: boolean): Promise<void>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>('NativeRNFBTurboCrashlytics');

package/typedoc.json

@@ -1,6 +1,5 @@
 {
   "$schema": "https://typedoc.org/schema.json",
-  "entryPoints": ["lib/modular.ts", "lib/types/crashlytics.ts"],
-  "tsconfig": "tsconfig.json",
-  "intentionallyNotExported": ["_Statics"]
+  "entryPoints": ["lib/index.ts", "lib/types/crashlytics.ts"],
+  "tsconfig": "tsconfig.json"
 }