@grafana/faro-react-native 1.0.0-alpha.1

package/dist/cjs/transports/offline/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../../src/transports/offline/types.ts"],"names":[],"mappings":"","sourcesContent":["import type { TransportItem } from '@grafana/faro-core';\n\n/**\n * Configuration options for the OfflineTransport.\n */\nexport interface OfflineTransportOptions {\n  /**\n   * Maximum duration to keep cached events.\n   * Events older than this will be discarded on replay.\n   * Default: 3 days (259200000ms)\n   */\n  maxCacheDurationMs?: number;\n\n  /**\n   * Maximum number of events to cache.\n   * Oldest events will be discarded when limit is reached.\n   * Default: 1000\n   */\n  maxCacheSize?: number;\n\n  /**\n   * Interval in milliseconds to check connectivity and replay cached events.\n   * Default: 30000 (30 seconds)\n   */\n  connectivityCheckIntervalMs?: number;\n\n  /**\n   * Storage key prefix for AsyncStorage.\n   * Default: 'faro_offline_cache'\n   */\n  storageKeyPrefix?: string;\n}\n\n/**\n * A cached telemetry payload with timestamp for expiration checking.\n */\nexport interface CachedPayload {\n  /**\n   * Timestamp when the payload was cached (milliseconds since epoch).\n   */\n  timestamp: number;\n\n  /**\n   * The transport items to be sent.\n   */\n  items: TransportItem[];\n}\n\n/**\n * Interface for connectivity detection service.\n */\nexport interface ConnectivityService {\n  /**\n   * Whether the device currently has network connectivity.\n   */\n  readonly isOnline: boolean;\n\n  /**\n   * Subscribe to connectivity changes.\n   * @param callback Function called when connectivity state changes.\n   * @returns Unsubscribe function.\n   */\n  subscribe(callback: (isOnline: boolean) => void): () => void;\n\n  /**\n   * Clean up resources.\n   */\n  dispose(): void;\n}\n\n/**\n * Interface for offline cache storage.\n */\nexport interface OfflineCache {\n  /**\n   * Write a payload to the cache.\n   */\n  write(payload: CachedPayload): Promise<void>;\n\n  /**\n   * Read all cached payloads.\n   */\n  readAll(): Promise<CachedPayload[]>;\n\n  /**\n   * Clear all cached payloads.\n   */\n  clear(): Promise<void>;\n\n  /**\n   * Remove specific payloads by their timestamps.\n   */\n  removeByTimestamps(timestamps: number[]): Promise<void>;\n\n  /**\n   * Get the number of cached payloads.\n   */\n  getCount(): Promise<number>;\n}\n"]}

package/dist/cjs/userPersistence/UserPersistence.js

@@ -0,0 +1,230 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AsyncStorageUserPersistence = void 0;
+exports.createUserPersistence = createUserPersistence;
+exports.initializeUserPersistence = initializeUserPersistence;
+exports.getUserPersistence = getUserPersistence;
+exports.setUserPersistence = setUserPersistence;
+var async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
+/**
+ * Default storage key for user data.
+ */
+var DEFAULT_STORAGE_KEY = 'faro_persisted_user';
+/**
+ * UserPersistence implementation using AsyncStorage.
+ *
+ * Stores user information persistently so it can be restored on app restart.
+ * This ensures early telemetry events include user identification.
+ *
+ * Implementation follows Flutter SDK's UserPersistence pattern:
+ * - Uses AsyncStorage for persistence (matching Flutter's SharedPreferences)
+ * - Stores user as JSON
+ * - Handles null/cleared users
+ *
+ * @example
+ * ```typescript
+ * import { createUserPersistence } from '@grafana/faro-react-native';
+ *
+ * // Load user on app start
+ * const persistence = createUserPersistence();
+ * const user = await persistence.loadUser();
+ *
+ * if (user) {
+ *   faro.api.setUser(user);
+ * }
+ *
+ * // Save user when logged in
+ * const loggedInUser = { id: '123', email: 'user@example.com' };
+ * await persistence.saveUser(loggedInUser);
+ *
+ * // Clear on logout
+ * await persistence.clearUser();
+ * ```
+ */
+var AsyncStorageUserPersistence = /** @class */ (function () {
+    function AsyncStorageUserPersistence(options) {
+        if (options === void 0) { options = {}; }
+        var _a;
+        this.storageKey = (_a = options.storageKey) !== null && _a !== void 0 ? _a : DEFAULT_STORAGE_KEY;
+    }
+    AsyncStorageUserPersistence.prototype.loadUser = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var userJson, userData, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, async_storage_1.default.getItem(this.storageKey)];
+                    case 1:
+                        userJson = _b.sent();
+                        if (userJson === null) {
+                            return [2 /*return*/, null];
+                        }
+                        userData = JSON.parse(userJson);
+                        if (!this.isValidMetaUser(userData)) {
+                            return [2 /*return*/, null];
+                        }
+                        return [2 /*return*/, userData];
+                    case 2:
+                        _a = _b.sent();
+                        return [2 /*return*/, null];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AsyncStorageUserPersistence.prototype.saveUser = function (user) {
+        return __awaiter(this, void 0, void 0, function () {
+            var userJson, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 4, , 5]);
+                        if (!(user === null || this.isCleared(user))) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.clearUser()];
+                    case 1:
+                        _b.sent();
+                        return [2 /*return*/];
+                    case 2:
+                        userJson = JSON.stringify(user);
+                        return [4 /*yield*/, async_storage_1.default.setItem(this.storageKey, userJson)];
+                    case 3:
+                        _b.sent();
+                        return [3 /*break*/, 5];
+                    case 4:
+                        _a = _b.sent();
+                        return [3 /*break*/, 5];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AsyncStorageUserPersistence.prototype.clearUser = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, async_storage_1.default.removeItem(this.storageKey)];
+                    case 1:
+                        _b.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _a = _b.sent();
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AsyncStorageUserPersistence.prototype.hasPersistedUser = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var userJson, _a;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        _b.trys.push([0, 2, , 3]);
+                        return [4 /*yield*/, async_storage_1.default.getItem(this.storageKey)];
+                    case 1:
+                        userJson = _b.sent();
+                        return [2 /*return*/, userJson !== null];
+                    case 2:
+                        _a = _b.sent();
+                        return [2 /*return*/, false];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Check if user is cleared (all fields empty/undefined).
+     */
+    AsyncStorageUserPersistence.prototype.isCleared = function (user) {
+        return !user.id && !user.email && !user.username && !user.fullName && !user.roles;
+    };
+    /**
+     * Validate that the parsed object is a valid MetaUser.
+     */
+    AsyncStorageUserPersistence.prototype.isValidMetaUser = function (obj) {
+        if (typeof obj !== 'object' || obj === null) {
+            return false;
+        }
+        // MetaUser has optional string fields, so any object is technically valid
+        // We just need to make sure it's an object
+        return true;
+    };
+    return AsyncStorageUserPersistence;
+}());
+exports.AsyncStorageUserPersistence = AsyncStorageUserPersistence;
+/**
+ * Factory function to create a UserPersistence instance.
+ */
+function createUserPersistence(options) {
+    if (options === void 0) { options = {}; }
+    return new AsyncStorageUserPersistence(options);
+}
+/**
+ * Global user persistence instance.
+ */
+var globalUserPersistence = null;
+/**
+ * Initialize the global user persistence.
+ */
+function initializeUserPersistence(options) {
+    if (options === void 0) { options = {}; }
+    globalUserPersistence = createUserPersistence(options);
+    return globalUserPersistence;
+}
+/**
+ * Get the global user persistence instance.
+ */
+function getUserPersistence() {
+    return globalUserPersistence;
+}
+/**
+ * Set a custom user persistence instance.
+ */
+function setUserPersistence(persistence) {
+    globalUserPersistence = persistence;
+}
+//# sourceMappingURL=UserPersistence.js.map

package/dist/cjs/userPersistence/UserPersistence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"UserPersistence.js","sourceRoot":"","sources":["../../../src/userPersistence/UserPersistence.ts"],"names":[],"mappings":"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","sourcesContent":["import AsyncStorage from '@react-native-async-storage/async-storage';\n\nimport type { MetaUser } from '@grafana/faro-core';\n\nimport type { UserPersistence, UserPersistenceOptions } from './types';\n\n/**\n * Default storage key for user data.\n */\nconst DEFAULT_STORAGE_KEY = 'faro_persisted_user';\n\n/**\n * UserPersistence implementation using AsyncStorage.\n *\n * Stores user information persistently so it can be restored on app restart.\n * This ensures early telemetry events include user identification.\n *\n * Implementation follows Flutter SDK's UserPersistence pattern:\n * - Uses AsyncStorage for persistence (matching Flutter's SharedPreferences)\n * - Stores user as JSON\n * - Handles null/cleared users\n *\n * @example\n * ```typescript\n * import { createUserPersistence } from '@grafana/faro-react-native';\n *\n * // Load user on app start\n * const persistence = createUserPersistence();\n * const user = await persistence.loadUser();\n *\n * if (user) {\n *   faro.api.setUser(user);\n * }\n *\n * // Save user when logged in\n * const loggedInUser = { id: '123', email: 'user@example.com' };\n * await persistence.saveUser(loggedInUser);\n *\n * // Clear on logout\n * await persistence.clearUser();\n * ```\n */\nexport class AsyncStorageUserPersistence implements UserPersistence {\n  private readonly storageKey: string;\n\n  constructor(options: UserPersistenceOptions = {}) {\n    this.storageKey = options.storageKey ?? DEFAULT_STORAGE_KEY;\n  }\n\n  async loadUser(): Promise<MetaUser | null> {\n    try {\n      const userJson = await AsyncStorage.getItem(this.storageKey);\n      if (userJson === null) {\n        return null;\n      }\n\n      const userData = JSON.parse(userJson);\n      if (!this.isValidMetaUser(userData)) {\n        return null;\n      }\n\n      return userData;\n    } catch {\n      return null;\n    }\n  }\n\n  async saveUser(user: MetaUser | null): Promise<void> {\n    try {\n      if (user === null || this.isCleared(user)) {\n        await this.clearUser();\n        return;\n      }\n\n      const userJson = JSON.stringify(user);\n      await AsyncStorage.setItem(this.storageKey, userJson);\n    } catch {\n      // Log failure but don't throw\n    }\n  }\n\n  async clearUser(): Promise<void> {\n    try {\n      await AsyncStorage.removeItem(this.storageKey);\n    } catch {\n      // Log failure but don't throw\n    }\n  }\n\n  async hasPersistedUser(): Promise<boolean> {\n    try {\n      const userJson = await AsyncStorage.getItem(this.storageKey);\n      return userJson !== null;\n    } catch {\n      return false;\n    }\n  }\n\n  /**\n   * Check if user is cleared (all fields empty/undefined).\n   */\n  private isCleared(user: MetaUser): boolean {\n    return !user.id && !user.email && !user.username && !user.fullName && !user.roles;\n  }\n\n  /**\n   * Validate that the parsed object is a valid MetaUser.\n   */\n  private isValidMetaUser(obj: unknown): obj is MetaUser {\n    if (typeof obj !== 'object' || obj === null) {\n      return false;\n    }\n\n    // MetaUser has optional string fields, so any object is technically valid\n    // We just need to make sure it's an object\n    return true;\n  }\n}\n\n/**\n * Factory function to create a UserPersistence instance.\n */\nexport function createUserPersistence(options: UserPersistenceOptions = {}): UserPersistence {\n  return new AsyncStorageUserPersistence(options);\n}\n\n/**\n * Global user persistence instance.\n */\nlet globalUserPersistence: UserPersistence | null = null;\n\n/**\n * Initialize the global user persistence.\n */\nexport function initializeUserPersistence(options: UserPersistenceOptions = {}): UserPersistence {\n  globalUserPersistence = createUserPersistence(options);\n  return globalUserPersistence;\n}\n\n/**\n * Get the global user persistence instance.\n */\nexport function getUserPersistence(): UserPersistence | null {\n  return globalUserPersistence;\n}\n\n/**\n * Set a custom user persistence instance.\n */\nexport function setUserPersistence(persistence: UserPersistence | null): void {\n  globalUserPersistence = persistence;\n}\n"]}

package/dist/cjs/userPersistence/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setUserPersistence = exports.initializeUserPersistence = exports.getUserPersistence = exports.createUserPersistence = exports.AsyncStorageUserPersistence = void 0;
+var UserPersistence_1 = require("./UserPersistence");
+Object.defineProperty(exports, "AsyncStorageUserPersistence", { enumerable: true, get: function () { return UserPersistence_1.AsyncStorageUserPersistence; } });
+Object.defineProperty(exports, "createUserPersistence", { enumerable: true, get: function () { return UserPersistence_1.createUserPersistence; } });
+Object.defineProperty(exports, "getUserPersistence", { enumerable: true, get: function () { return UserPersistence_1.getUserPersistence; } });
+Object.defineProperty(exports, "initializeUserPersistence", { enumerable: true, get: function () { return UserPersistence_1.initializeUserPersistence; } });
+Object.defineProperty(exports, "setUserPersistence", { enumerable: true, get: function () { return UserPersistence_1.setUserPersistence; } });
+//# sourceMappingURL=index.js.map

package/dist/cjs/userPersistence/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/userPersistence/index.ts"],"names":[],"mappings":";;;AAAA,qDAM2B;AALzB,8HAAA,2BAA2B,OAAA;AAC3B,wHAAA,qBAAqB,OAAA;AACrB,qHAAA,kBAAkB,OAAA;AAClB,4HAAA,yBAAyB,OAAA;AACzB,qHAAA,kBAAkB,OAAA","sourcesContent":["export {\n  AsyncStorageUserPersistence,\n  createUserPersistence,\n  getUserPersistence,\n  initializeUserPersistence,\n  setUserPersistence,\n} from './UserPersistence';\nexport type { UserPersistence, UserPersistenceOptions } from './types';\n"]}

package/dist/cjs/userPersistence/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=types.js.map

package/dist/cjs/userPersistence/types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/userPersistence/types.ts"],"names":[],"mappings":"","sourcesContent":["import type { MetaUser } from '@grafana/faro-core';\n\n/**\n * Interface for user data persistence.\n *\n * Handles saving and loading user data between app sessions.\n */\nexport interface UserPersistence {\n  /**\n   * Load the persisted user from storage.\n   * Returns null if no user has been persisted.\n   */\n  loadUser(): Promise<MetaUser | null>;\n\n  /**\n   * Save the user to storage.\n   * If user is null or cleared, any previously persisted user data is cleared.\n   */\n  saveUser(user: MetaUser | null): Promise<void>;\n\n  /**\n   * Clear any persisted user data.\n   */\n  clearUser(): Promise<void>;\n\n  /**\n   * Check if there is persisted user data.\n   */\n  hasPersistedUser(): Promise<boolean>;\n}\n\n/**\n * Options for creating a UserPersistence instance.\n */\nexport interface UserPersistenceOptions {\n  /**\n   * Storage key for persisting user data.\n   * Default: 'faro_persisted_user'\n   */\n  storageKey?: string;\n}\n"]}

package/dist/cjs/util/performanceObserverPolyfill.js

@@ -0,0 +1,63 @@
+"use strict";
+/**
+ * PerformanceObserver polyfill for React Native iOS
+ *
+ * React Native 0.84's native PerformanceObserver has a bug on iOS that throws
+ * `bad_variant_access` when the observer callback runs and calls getEntries().
+ * This happens in NativePerformance.createObserver when the native bridge
+ * returns data that causes a C++ variant access error.
+ *
+ * OpenTelemetry's FetchInstrumentation (and other libs) may use PerformanceObserver
+ * for resource timing. We provide a no-op polyfill on React Native iOS to prevent
+ * the crash while preserving refresh rate vitals and other functionality.
+ *
+ * @see https://github.com/facebook/react-native/issues (PerformanceObserver iOS)
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyPerformanceObserverPolyfill = applyPerformanceObserverPolyfill;
+var react_native_1 = require("react-native");
+var globalObj = (typeof globalThis !== 'undefined' && globalThis) ||
+    (typeof global !== 'undefined' && global) ||
+    (typeof window !== 'undefined' && window) ||
+    {};
+/**
+ * No-op PerformanceObserver that matches the Web API interface.
+ * Prevents crashes when React Native's native implementation throws.
+ */
+var NoopPerformanceObserver = /** @class */ (function () {
+    function NoopPerformanceObserver(_callback) {
+        // Callback is never invoked - avoids triggering the native bug
+    }
+    NoopPerformanceObserver.prototype.observe = function (_options) {
+        // No-op
+    };
+    NoopPerformanceObserver.prototype.disconnect = function () {
+        // No-op
+    };
+    NoopPerformanceObserver.prototype.takeRecords = function () {
+        return [];
+    };
+    NoopPerformanceObserver.supportedEntryTypes = [];
+    return NoopPerformanceObserver;
+}());
+/**
+ * Apply polyfill on React Native iOS to prevent bad_variant_access crash.
+ * Must run before any code that might use PerformanceObserver.
+ */
+function applyPerformanceObserverPolyfill() {
+    if (react_native_1.Platform.OS !== 'ios') {
+        return;
+    }
+    var record = globalObj;
+    var existing = record['PerformanceObserver'];
+    if (existing && existing.name === 'NoopPerformanceObserver') {
+        return; // Already applied
+    }
+    try {
+        record['PerformanceObserver'] = NoopPerformanceObserver;
+    }
+    catch (_a) {
+        // Ignore if global is frozen (e.g. in some test environments)
+    }
+}
+//# sourceMappingURL=performanceObserverPolyfill.js.map

package/dist/cjs/util/performanceObserverPolyfill.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"performanceObserverPolyfill.js","sourceRoot":"","sources":["../../../src/util/performanceObserverPolyfill.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;GAaG;;AA+DH,4EAgBC;AA7ED,6CAAwC;AAExC,IAAM,SAAS,GACb,CAAC,OAAO,UAAU,KAAK,WAAW,IAAI,UAAU,CAAC;IACjD,CAAC,OAAO,MAAM,KAAK,WAAW,IAAI,MAAM,CAAC;IACzC,CAAC,OAAO,MAAM,KAAK,WAAW,IAAI,MAAM,CAAC;IACzC,EAAE,CAAC;AAqBL;;;GAGG;AACH;IACE,iCACE,SAIS;QAET,+DAA+D;IACjE,CAAC;IAED,yCAAO,GAAP,UAAQ,QAAkC;QACxC,QAAQ;IACV,CAAC;IAED,4CAAU,GAAV;QACE,QAAQ;IACV,CAAC;IAED,6CAAW,GAAX;QACE,OAAO,EAAE,CAAC;IACZ,CAAC;IAEe,2CAAmB,GAAa,EAAE,CAAC;IACrD,8BAAC;CAAA,AAxBD,IAwBC;AAED;;;GAGG;AACH,SAAgB,gCAAgC;IAC9C,IAAI,uBAAQ,CAAC,EAAE,KAAK,KAAK,EAAE,CAAC;QAC1B,OAAO;IACT,CAAC;IAED,IAAM,MAAM,GAAG,SAAoC,CAAC;IACpD,IAAM,QAAQ,GAAG,MAAM,CAAC,qBAAqB,CAAC,CAAC;IAC/C,IAAI,QAAQ,IAAK,QAAyC,CAAC,IAAI,KAAK,yBAAyB,EAAE,CAAC;QAC9F,OAAO,CAAC,kBAAkB;IAC5B,CAAC;IAED,IAAI,CAAC;QACH,MAAM,CAAC,qBAAqB,CAAC,GAAG,uBAAuB,CAAC;IAC1D,CAAC;IAAC,WAAM,CAAC;QACP,8DAA8D;IAChE,CAAC;AACH,CAAC","sourcesContent":["/**\n * PerformanceObserver polyfill for React Native iOS\n *\n * React Native 0.84's native PerformanceObserver has a bug on iOS that throws\n * `bad_variant_access` when the observer callback runs and calls getEntries().\n * This happens in NativePerformance.createObserver when the native bridge\n * returns data that causes a C++ variant access error.\n *\n * OpenTelemetry's FetchInstrumentation (and other libs) may use PerformanceObserver\n * for resource timing. We provide a no-op polyfill on React Native iOS to prevent\n * the crash while preserving refresh rate vitals and other functionality.\n *\n * @see https://github.com/facebook/react-native/issues (PerformanceObserver iOS)\n */\n\nimport { Platform } from 'react-native';\n\nconst globalObj =\n  (typeof globalThis !== 'undefined' && globalThis) ||\n  (typeof global !== 'undefined' && global) ||\n  (typeof window !== 'undefined' && window) ||\n  {};\n\ninterface PerformanceEntry {\n  readonly duration: number;\n  readonly entryType: string;\n  readonly name: string;\n  readonly startTime: number;\n}\n\ninterface PerformanceObserverEntryList {\n  getEntries(): PerformanceEntry[];\n  getEntriesByName(name: string, type?: string): PerformanceEntry[];\n  getEntriesByType(type: string): PerformanceEntry[];\n}\n\ninterface PerformanceObserverInit {\n  entryTypes?: string[];\n  type?: string;\n  buffered?: boolean;\n}\n\n/**\n * No-op PerformanceObserver that matches the Web API interface.\n * Prevents crashes when React Native's native implementation throws.\n */\nclass NoopPerformanceObserver {\n  constructor(\n    _callback: (\n      list: PerformanceObserverEntryList,\n      observer: NoopPerformanceObserver,\n      options?: PerformanceObserverInit\n    ) => void\n  ) {\n    // Callback is never invoked - avoids triggering the native bug\n  }\n\n  observe(_options?: PerformanceObserverInit): void {\n    // No-op\n  }\n\n  disconnect(): void {\n    // No-op\n  }\n\n  takeRecords(): PerformanceEntry[] {\n    return [];\n  }\n\n  static readonly supportedEntryTypes: string[] = [];\n}\n\n/**\n * Apply polyfill on React Native iOS to prevent bad_variant_access crash.\n * Must run before any code that might use PerformanceObserver.\n */\nexport function applyPerformanceObserverPolyfill(): void {\n  if (Platform.OS !== 'ios') {\n    return;\n  }\n\n  const record = globalObj as Record<string, unknown>;\n  const existing = record['PerformanceObserver'];\n  if (existing && (existing as unknown as { name?: string }).name === 'NoopPerformanceObserver') {\n    return; // Already applied\n  }\n\n  try {\n    record['PerformanceObserver'] = NoopPerformanceObserver;\n  } catch {\n    // Ignore if global is frozen (e.g. in some test environments)\n  }\n}\n"]}

package/dist/cjs/utils/throttle.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.throttle = throttle;
+/**
+ * Creates a throttled function that only invokes the provided function at most once per
+ * every `wait` milliseconds.
+ *
+ * @param func - The function to throttle
+ * @param wait - The number of milliseconds to throttle invocations to
+ * @returns A throttled version of the function
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- Generic utility needs to accept any function signature
+function throttle(func, wait) {
+    var timeout = null;
+    var previous = 0;
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Need to preserve function context
+    return function () {
+        var _this = this;
+        var args = [];
+        for (var _i = 0; _i < arguments.length; _i++) {
+            args[_i] = arguments[_i];
+        }
+        var now = Date.now();
+        var remaining = wait - (now - previous);
+        if (remaining <= 0 || remaining > wait) {
+            if (timeout) {
+                clearTimeout(timeout);
+                timeout = null;
+            }
+            previous = now;
+            func.apply(this, args);
+        }
+        else if (!timeout) {
+            timeout = setTimeout(function () {
+                previous = Date.now();
+                timeout = null;
+                func.apply(_this, args);
+            }, remaining);
+        }
+    };
+}
+//# sourceMappingURL=throttle.js.map

package/dist/cjs/utils/throttle.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"throttle.js","sourceRoot":"","sources":["../../../src/utils/throttle.ts"],"names":[],"mappings":";;AASA,4BAwBC;AAjCD;;;;;;;GAOG;AACH,wHAAwH;AACxH,SAAgB,QAAQ,CAAoC,IAAO,EAAE,IAAY;IAC/E,IAAI,OAAO,GAAyC,IAAI,CAAC;IACzD,IAAI,QAAQ,GAAG,CAAC,CAAC;IAEjB,mGAAmG;IACnG,OAAO;QAAA,iBAkBN;QAlB2B,cAAsB;aAAtB,UAAsB,EAAtB,qBAAsB,EAAtB,IAAsB;YAAtB,yBAAsB;;QAChD,IAAM,GAAG,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QACvB,IAAM,SAAS,GAAG,IAAI,GAAG,CAAC,GAAG,GAAG,QAAQ,CAAC,CAAC;QAE1C,IAAI,SAAS,IAAI,CAAC,IAAI,SAAS,GAAG,IAAI,EAAE,CAAC;YACvC,IAAI,OAAO,EAAE,CAAC;gBACZ,YAAY,CAAC,OAAO,CAAC,CAAC;gBACtB,OAAO,GAAG,IAAI,CAAC;YACjB,CAAC;YACD,QAAQ,GAAG,GAAG,CAAC;YACf,IAAI,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC;QACzB,CAAC;aAAM,IAAI,CAAC,OAAO,EAAE,CAAC;YACpB,OAAO,GAAG,UAAU,CAAC;gBACnB,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;gBACtB,OAAO,GAAG,IAAI,CAAC;gBACf,IAAI,CAAC,KAAK,CAAC,KAAI,EAAE,IAAI,CAAC,CAAC;YACzB,CAAC,EAAE,SAAS,CAAC,CAAC;QAChB,CAAC;IACH,CAAM,CAAC;AACT,CAAC","sourcesContent":["/**\n * Creates a throttled function that only invokes the provided function at most once per\n * every `wait` milliseconds.\n *\n * @param func - The function to throttle\n * @param wait - The number of milliseconds to throttle invocations to\n * @returns A throttled version of the function\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any -- Generic utility needs to accept any function signature\nexport function throttle<T extends (...args: any[]) => any>(func: T, wait: number): T {\n  let timeout: ReturnType<typeof setTimeout> | null = null;\n  let previous = 0;\n\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- Need to preserve function context\n  return function (this: any, ...args: Parameters<T>) {\n    const now = Date.now();\n    const remaining = wait - (now - previous);\n\n    if (remaining <= 0 || remaining > wait) {\n      if (timeout) {\n        clearTimeout(timeout);\n        timeout = null;\n      }\n      previous = now;\n      func.apply(this, args);\n    } else if (!timeout) {\n      timeout = setTimeout(() => {\n        previous = Date.now();\n        timeout = null;\n        func.apply(this, args);\n      }, remaining);\n    }\n  } as T;\n}\n"]}

package/dist/esm/config/getRNInstrumentations.js

@@ -0,0 +1,120 @@
+import { Platform } from 'react-native';
+import { ANRInstrumentation } from '../instrumentations/anr';
+import { AppStateInstrumentation } from '../instrumentations/appState';
+import { ConsoleInstrumentation } from '../instrumentations/console';
+import { CrashReportingInstrumentation } from '../instrumentations/crashReporting';
+import { ErrorsInstrumentation } from '../instrumentations/errors';
+import { FrameMonitoringInstrumentation } from '../instrumentations/frameMonitoring';
+import { HttpInstrumentation } from '../instrumentations/http';
+import { PerformanceInstrumentation } from '../instrumentations/performance';
+import { SessionInstrumentation } from '../instrumentations/session';
+import { StartupInstrumentation } from '../instrumentations/startup';
+import { UserActionInstrumentation } from '../instrumentations/userActions';
+import { ViewInstrumentation } from '../instrumentations/view';
+import { XHRInstrumentation } from '../instrumentations/xhr';
+/** Convert Patterns (string | RegExp)[] to RegExp[] for instrumentations that require RegExp[]. */
+function toRegExpArray(patterns) {
+    return patterns.map((p) => (typeof p === 'string' ? new RegExp(p.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')) : p));
+}
+/**
+ * Returns the default set of instrumentations for React Native.
+ *
+ * Reads all options from the Faro config (single source of truth).
+ * Property names are aligned with Flutter SDK FaroConfig:
+ * - cpuUsageVitals, memoryUsageVitals, anrTracking, refreshRateVitals
+ * - enableCrashReporting, enableErrorReporting
+ * - fetchVitalsInterval, ignoreUrls
+ *
+ * @example
+ * ```ts
+ * const config: ReactNativeConfig = {
+ *   app: { name: 'my-app', version: '1.0.0' },
+ *   cpuUsageVitals: true,
+ *   memoryUsageVitals: true,
+ *   anrTracking: true,
+ *   refreshRateVitals: true,
+ *   enableCrashReporting: true,
+ *   fetchVitalsInterval: 30000,
+ *   instrumentations: getRNInstrumentations(config),
+ * };
+ * ```
+ */
+export function getRNInstrumentations(config = {}) {
+    // Aligned with Flutter SDK FaroConfig defaults
+    const { 
+    // Error & crash tracking
+    enableErrorReporting = true, enableCrashReporting = false, anrTracking = false, anrOptions = {}, 
+    // Performance vitals
+    cpuUsageVitals = true, memoryUsageVitals = true, refreshRateVitals = false, fetchVitalsInterval = 30000, frameMonitoringOptions = {}, 
+    // Network
+    ignoreUrls = [], enableHttpInstrumentation = {}, 
+    // Console and user actions
+    enableConsoleCapture = true, enableUserActions = true, 
+    // Tracing
+    enableTracing = false, tracingOptions = {}, } = config;
+    const instrumentations = [];
+    // Error reporting (Flutter: enableFlutterErrorReporting)
+    if (enableErrorReporting) {
+        instrumentations.push(new ErrorsInstrumentation());
+    }
+    // Console capture - not in Flutter SDK, RN-specific
+    if (enableConsoleCapture) {
+        instrumentations.push(new ConsoleInstrumentation());
+    }
+    // Sessions - always enabled in Flutter, same here
+    instrumentations.push(new SessionInstrumentation());
+    // Views - always enabled in Flutter, same here
+    instrumentations.push(new ViewInstrumentation());
+    // App state - always enabled in Flutter, same here
+    instrumentations.push(new AppStateInstrumentation());
+    // User actions - enabled by default, opt-out via enableUserActions
+    if (enableUserActions) {
+        instrumentations.push(new UserActionInstrumentation());
+    }
+    // HTTP/XHR tracking: when tracing is enabled, TracingInstrumentation patches fetch and XHR.
+    // When tracing is disabled, add HttpInstrumentation and/or XHRInstrumentation per enableHttpInstrumentation.
+    if (!enableTracing) {
+        const { fetch: enableFetch = true, xhr: enableXhr = true } = enableHttpInstrumentation;
+        const ignoredUrlsRegExp = toRegExpArray(ignoreUrls);
+        if (enableFetch) {
+            instrumentations.push(new HttpInstrumentation({ ignoredUrls: ignoredUrlsRegExp }));
+        }
+        if (enableXhr) {
+            instrumentations.push(new XHRInstrumentation({ ignoredUrls: ignoredUrlsRegExp }));
+        }
+    }
+    // Performance vitals (CPU/memory)
+    const perfInstrumentation = new PerformanceInstrumentation({
+        memoryUsageVitals,
+        cpuUsageVitals,
+        fetchVitalsInterval,
+    });
+    instrumentations.push(perfInstrumentation);
+    // Startup tracking - always enabled
+    instrumentations.push(new StartupInstrumentation());
+    // Frame monitoring: enabled when refreshRateVitals is true
+    // The instrumentation reads refreshRateVitals from faro.config (single source of truth)
+    if (refreshRateVitals) {
+        instrumentations.push(new FrameMonitoringInstrumentation(frameMonitoringOptions));
+    }
+    // ANR detection (Android only)
+    if (anrTracking && Platform.OS === 'android') {
+        instrumentations.push(new ANRInstrumentation(anrOptions));
+    }
+    // Crash reporting
+    if (enableCrashReporting) {
+        instrumentations.push(new CrashReportingInstrumentation());
+    }
+    if (enableTracing) {
+        try {
+            const { TracingInstrumentation } = require('@grafana/faro-react-native-tracing');
+            instrumentations.push(new TracingInstrumentation(tracingOptions));
+        }
+        catch (_a) {
+            console.warn('[Faro] enableTracing is true but @grafana/faro-react-native-tracing is not installed. ' +
+                'Add it to use tracing: yarn add @grafana/faro-react-native-tracing');
+        }
+    }
+    return instrumentations;
+}
+//# sourceMappingURL=getRNInstrumentations.js.map

package/dist/esm/config/getRNInstrumentations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getRNInstrumentations.js","sourceRoot":"","sources":["../../../src/config/getRNInstrumentations.ts"],"names":[],"mappings":"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","sourcesContent":["import { Platform } from 'react-native';\n\nimport type { Instrumentation, Patterns } from '@grafana/faro-core';\n\nimport { ANRInstrumentation } from '../instrumentations/anr';\nimport { AppStateInstrumentation } from '../instrumentations/appState';\nimport { ConsoleInstrumentation } from '../instrumentations/console';\nimport { CrashReportingInstrumentation } from '../instrumentations/crashReporting';\nimport { ErrorsInstrumentation } from '../instrumentations/errors';\nimport { FrameMonitoringInstrumentation } from '../instrumentations/frameMonitoring';\nimport { HttpInstrumentation } from '../instrumentations/http';\nimport { PerformanceInstrumentation } from '../instrumentations/performance';\nimport { SessionInstrumentation } from '../instrumentations/session';\nimport { StartupInstrumentation } from '../instrumentations/startup';\nimport { UserActionInstrumentation } from '../instrumentations/userActions';\nimport { ViewInstrumentation } from '../instrumentations/view';\nimport { XHRInstrumentation } from '../instrumentations/xhr';\n\nimport type { ReactNativeConfig } from './types';\n\n/** Convert Patterns (string | RegExp)[] to RegExp[] for instrumentations that require RegExp[]. */\nfunction toRegExpArray(patterns: Patterns): RegExp[] {\n  return patterns.map((p) => (typeof p === 'string' ? new RegExp(p.replace(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&')) : p));\n}\n\n/**\n * Returns the default set of instrumentations for React Native.\n *\n * Reads all options from the Faro config (single source of truth).\n * Property names are aligned with Flutter SDK FaroConfig:\n * - cpuUsageVitals, memoryUsageVitals, anrTracking, refreshRateVitals\n * - enableCrashReporting, enableErrorReporting\n * - fetchVitalsInterval, ignoreUrls\n *\n * @example\n * ```ts\n * const config: ReactNativeConfig = {\n *   app: { name: 'my-app', version: '1.0.0' },\n *   cpuUsageVitals: true,\n *   memoryUsageVitals: true,\n *   anrTracking: true,\n *   refreshRateVitals: true,\n *   enableCrashReporting: true,\n *   fetchVitalsInterval: 30000,\n *   instrumentations: getRNInstrumentations(config),\n * };\n * ```\n */\nexport function getRNInstrumentations(config: Partial<ReactNativeConfig> = {}): Instrumentation[] {\n  // Aligned with Flutter SDK FaroConfig defaults\n  const {\n    // Error & crash tracking\n    enableErrorReporting = true,\n    enableCrashReporting = false,\n    anrTracking = false,\n    anrOptions = {},\n\n    // Performance vitals\n    cpuUsageVitals = true,\n    memoryUsageVitals = true,\n    refreshRateVitals = false,\n    fetchVitalsInterval = 30000,\n    frameMonitoringOptions = {},\n\n    // Network\n    ignoreUrls = [],\n    enableHttpInstrumentation = {},\n\n    // Console and user actions\n    enableConsoleCapture = true,\n    enableUserActions = true,\n\n    // Tracing\n    enableTracing = false,\n    tracingOptions = {},\n  } = config;\n\n  const instrumentations: Instrumentation[] = [];\n\n  // Error reporting (Flutter: enableFlutterErrorReporting)\n  if (enableErrorReporting) {\n    instrumentations.push(new ErrorsInstrumentation());\n  }\n\n  // Console capture - not in Flutter SDK, RN-specific\n  if (enableConsoleCapture) {\n    instrumentations.push(new ConsoleInstrumentation());\n  }\n\n  // Sessions - always enabled in Flutter, same here\n  instrumentations.push(new SessionInstrumentation());\n\n  // Views - always enabled in Flutter, same here\n  instrumentations.push(new ViewInstrumentation());\n\n  // App state - always enabled in Flutter, same here\n  instrumentations.push(new AppStateInstrumentation());\n\n  // User actions - enabled by default, opt-out via enableUserActions\n  if (enableUserActions) {\n    instrumentations.push(new UserActionInstrumentation());\n  }\n\n  // HTTP/XHR tracking: when tracing is enabled, TracingInstrumentation patches fetch and XHR.\n  // When tracing is disabled, add HttpInstrumentation and/or XHRInstrumentation per enableHttpInstrumentation.\n  if (!enableTracing) {\n    const { fetch: enableFetch = true, xhr: enableXhr = true } = enableHttpInstrumentation;\n    const ignoredUrlsRegExp = toRegExpArray(ignoreUrls);\n    if (enableFetch) {\n      instrumentations.push(new HttpInstrumentation({ ignoredUrls: ignoredUrlsRegExp }));\n    }\n    if (enableXhr) {\n      instrumentations.push(new XHRInstrumentation({ ignoredUrls: ignoredUrlsRegExp }));\n    }\n  }\n\n  // Performance vitals (CPU/memory)\n  const perfInstrumentation = new PerformanceInstrumentation({\n    memoryUsageVitals,\n    cpuUsageVitals,\n    fetchVitalsInterval,\n  });\n  instrumentations.push(perfInstrumentation);\n\n  // Startup tracking - always enabled\n  instrumentations.push(new StartupInstrumentation());\n\n  // Frame monitoring: enabled when refreshRateVitals is true\n  // The instrumentation reads refreshRateVitals from faro.config (single source of truth)\n  if (refreshRateVitals) {\n    instrumentations.push(new FrameMonitoringInstrumentation(frameMonitoringOptions));\n  }\n\n  // ANR detection (Android only)\n  if (anrTracking && Platform.OS === 'android') {\n    instrumentations.push(new ANRInstrumentation(anrOptions));\n  }\n\n  // Crash reporting\n  if (enableCrashReporting) {\n    instrumentations.push(new CrashReportingInstrumentation());\n  }\n\n  if (enableTracing) {\n    try {\n      const { TracingInstrumentation } = require('@grafana/faro-react-native-tracing');\n      instrumentations.push(new TracingInstrumentation(tracingOptions));\n    } catch {\n      console.warn(\n        '[Faro] enableTracing is true but @grafana/faro-react-native-tracing is not installed. ' +\n          'Add it to use tracing: yarn add @grafana/faro-react-native-tracing'\n      );\n    }\n  }\n\n  return instrumentations;\n}\n"]}

package/dist/esm/config/makeRNConfig.js

@@ -0,0 +1,92 @@
+import { defaultGlobalObjectKey, defaultUnpatchedConsole, InternalLoggerLevel, LogLevel } from '@grafana/faro-core';
+import { getStackFramesFromError } from '../instrumentations/errors/stackTraceParser';
+import { defaultSessionTrackingConfig } from '../instrumentations/session/sessionManager/sessionConstants';
+import { getPageMeta } from '../metas/page';
+import { getScreenMeta } from '../metas/screen';
+import { getSdkMeta } from '../metas/sdk';
+import { ConsoleTransport } from '../transports/console';
+import { FetchTransport } from '../transports/fetch';
+import { OfflineTransport } from '../transports/offline';
+import { getRNInstrumentations } from './getRNInstrumentations';
+const DEFAULT_OFFLINE_CACHE_MS = 3 * 24 * 60 * 60 * 1000; // 3 days
+/**
+ * Builds transports. FetchTransport is always added when url is provided.
+ * User can enable offline and console via enableTransports.
+ */
+function buildTransports(config) {
+    var _a;
+    const { enableTransports = { offline: false, console: false } } = config;
+    if (!config.url) {
+        throw new Error('url is required. Provide the Faro collector URL.');
+    }
+    const builtTransports = [];
+    if (enableTransports.offline) {
+        builtTransports.push(new OfflineTransport({
+            maxCacheDurationMs: DEFAULT_OFFLINE_CACHE_MS,
+        }));
+    }
+    builtTransports.push(new FetchTransport({
+        url: config.url,
+        apiKey: config.apiKey,
+    }));
+    if (enableTransports.console) {
+        builtTransports.push(new ConsoleTransport({ level: LogLevel.DEBUG }));
+    }
+    const extraTransports = (_a = config.transports) !== null && _a !== void 0 ? _a : [];
+    return [...builtTransports, ...extraTransports];
+}
+/**
+ * Builds instrumentations from config flags.
+ */
+function buildInstrumentations(config) {
+    var _a;
+    const baseInstrumentations = getRNInstrumentations(config);
+    const extraInstrumentations = (_a = config.instrumentations) !== null && _a !== void 0 ? _a : [];
+    return [...baseInstrumentations, ...extraInstrumentations];
+}
+/**
+ * React Native stacktrace parser. Uses getStackFramesFromError for RN-specific formats.
+ */
+const parseStacktrace = (err) => ({
+    frames: getStackFramesFromError(err),
+});
+/**
+ * Creates a full Faro config from React Native flag-based config.
+ *
+ * Based on flags, builds instrumentations and transports automatically.
+ * Client just enables what they need; makeRNConfig does the rest.
+ */
+export function makeRNConfig(config) {
+    var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k;
+    const defaultMetas = [getSdkMeta(), getPageMeta(), getScreenMeta()];
+    const customMetas = (_a = config.metas) !== null && _a !== void 0 ? _a : [];
+    const transports = buildTransports(config);
+    const instrumentations = buildInstrumentations(config);
+    return {
+        app: config.app,
+        dedupe: (_b = config.dedupe) !== null && _b !== void 0 ? _b : true,
+        globalObjectKey: (_c = config.globalObjectKey) !== null && _c !== void 0 ? _c : defaultGlobalObjectKey,
+        internalLoggerLevel: (_d = config.internalLoggerLevel) !== null && _d !== void 0 ? _d : InternalLoggerLevel.ERROR,
+        isolate: (_e = config.isolate) !== null && _e !== void 0 ? _e : false,
+        parseStacktrace: (_f = config.parseStacktrace) !== null && _f !== void 0 ? _f : parseStacktrace,
+        paused: (_g = config.paused) !== null && _g !== void 0 ? _g : false,
+        preventGlobalExposure: (_h = config.preventGlobalExposure) !== null && _h !== void 0 ? _h : false,
+        unpatchedConsole: (_j = config.unpatchedConsole) !== null && _j !== void 0 ? _j : defaultUnpatchedConsole,
+        batching: {
+            enabled: false,
+            sendTimeout: 250,
+            itemLimit: 50,
+        },
+        sessionTracking: Object.assign(Object.assign({}, defaultSessionTrackingConfig), config.sessionTracking),
+        metas: [...defaultMetas, ...customMetas],
+        instrumentations,
+        transports,
+        ignoreUrls: (_k = config.ignoreUrls) !== null && _k !== void 0 ? _k : [],
+        ignoreErrors: config.ignoreErrors,
+        beforeSend: config.beforeSend,
+        preserveOriginalError: config.preserveOriginalError,
+        userActionsInstrumentation: config.userActionsOptions,
+        consoleInstrumentation: config.consoleCaptureOptions,
+    };
+}
+//# sourceMappingURL=makeRNConfig.js.map