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

package/dist/cjs/config/sampling.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sampling.js","sourceRoot":"","sources":["../../../src/config/sampling.ts"],"names":[],"mappings":";;;AA+EA;;;;;;;;;;;;GAYG;AACH;IACE;;;;OAIG;IACH,sBAA4B,IAAY;QAAZ,SAAI,GAAJ,IAAI,CAAQ;IAAG,CAAC;IAE5C,8BAAO,GAAP,UAAQ,QAAyB;QAC/B,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC;IAC7C,CAAC;IACH,mBAAC;AAAD,CAAC,AAXD,IAWC;AAXY,oCAAY;AAazB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IACE;;;;;OAKG;IACH,0BAA6B,EAAwC;QAAxC,OAAE,GAAF,EAAE,CAAsC;IAAG,CAAC;IAEzE,kCAAO,GAAP,UAAQ,OAAwB;QAC9B,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,EAAE,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IACpD,CAAC;IACH,uBAAC;AAAD,CAAC,AAZD,IAYC;AAZY,4CAAgB","sourcesContent":["import type { Meta } from '@grafana/faro-core';\n\n/**\n * Context passed to sampling implementations.\n *\n * Provides access to the current metadata state at SDK initialization time,\n * allowing sampling decisions based on session attributes, user info, app\n * environment, and other metadata.\n *\n * This aligns with the Faro Flutter SDK's `SamplingContext` which provides\n * `meta` to the sampler.\n *\n * @example\n * ```ts\n * sampling: SamplingFunction((context) => {\n *   // Sample all beta users\n *   if (context.meta.user?.attributes?.['role'] === 'beta') {\n *     return 1;\n *   }\n *   // Sample 10% of production sessions\n *   if (context.meta.app?.environment === 'production') {\n *     return 0.1;\n *   }\n *   return 1;\n * })\n * ```\n */\nexport interface SamplingContext {\n  /** The current merged metadata state (session, user, app, sdk, view). */\n  meta: Meta;\n}\n\n/**\n * Defines how sessions should be sampled.\n *\n * Implement this interface to provide custom sampling logic. Use one of the\n * built-in implementations:\n * - {@link SamplingRate} for a fixed sampling rate\n * - {@link SamplingFunction} for dynamic sampling based on context\n *\n * @example\n * ```ts\n * // Fixed 10% sampling\n * sessionTracking: {\n *   sampling: new SamplingRate(0.1),\n * }\n *\n * // Dynamic sampling based on context\n * sessionTracking: {\n *   sampling: new SamplingFunction((context) => {\n *     if (context.meta.app?.environment === 'production') {\n *       return 0.1;\n *     }\n *     return 1;\n *   }),\n * }\n *\n * // Custom implementation\n * class BetaUserSampling implements Sampling {\n *   resolve(context: SamplingContext): number {\n *     return context.meta.user?.attributes?.['role'] === 'beta' ? 1 : 0.1;\n *   }\n * }\n * sessionTracking: { sampling: new BetaUserSampling() }\n * ```\n */\nexport interface Sampling {\n  /**\n   * Resolves the sampling rate for the given context.\n   *\n   * @param context - The current metadata state\n   * @returns A value between 0 and 1 (inclusive). Values are clamped to [0, 1].\n   *   - 1: Sample all sessions (100%)\n   *   - 0.5: Sample half of sessions (50%)\n   *   - 0: Sample no sessions (0%)\n   */\n  resolve(context: SamplingContext): number;\n}\n\n/**\n * Fixed sampling rate.\n *\n * Use this when you want a constant sampling probability regardless of\n * session context.\n *\n * @example\n * ```ts\n * sessionTracking: {\n *   sampling: new SamplingRate(0.1), // 10% of sessions\n * }\n * ```\n */\nexport class SamplingRate implements Sampling {\n  /**\n   * Creates a fixed sampling rate.\n   *\n   * @param rate - The fixed sampling rate (0 to 1). Values are clamped to [0, 1].\n   */\n  constructor(public readonly rate: number) {}\n\n  resolve(_context: SamplingContext): number {\n    return Math.max(0, Math.min(1, this.rate));\n  }\n}\n\n/**\n * Dynamic sampling based on context.\n *\n * Use this when you want to make sampling decisions based on session\n * metadata like user attributes, app environment, or other context.\n *\n * @example\n * ```ts\n * sessionTracking: {\n *   sampling: new SamplingFunction((context) => {\n *     // Sample all beta users\n *     if (context.meta.user?.attributes?.['role'] === 'beta') {\n *       return 1;\n *     }\n *     // Sample 10% of production sessions\n *     if (context.meta.app?.environment === 'production') {\n *       return 0.1;\n *     }\n *     return 1;\n *   }),\n * }\n * ```\n */\nexport class SamplingFunction implements Sampling {\n  /**\n   * Creates a dynamic sampler with the given function.\n   *\n   * @param fn - The function that determines the rate based on context.\n   *   Receives a {@link SamplingContext} and should return a rate between 0 and 1.\n   */\n  constructor(private readonly fn: (context: SamplingContext) => number) {}\n\n  resolve(context: SamplingContext): number {\n    return Math.max(0, Math.min(1, this.fn(context)));\n  }\n}\n"]}

package/dist/cjs/config/types.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/config/types.ts"],"names":[],"mappings":"","sourcesContent":["import type { Config } from '@grafana/faro-core';\n\nimport type { ANRInstrumentationOptions } from '../instrumentations/anr';\nimport type { FrameMonitoringOptions } from '../instrumentations/frameMonitoring';\n\nimport type { Sampling } from './sampling';\n\n/**\n * React Native session tracking config.\n * Extends Config['sessionTracking'] with sampling (Flutter-style) and RN-specific props.\n * Excludes samplingRate and sampler in favor of sampling.\n */\nexport type ReactNativeSessionTrackingConfig = Omit<\n  NonNullable<Config['sessionTracking']>,\n  'samplingRate' | 'sampler'\n> & {\n  /**\n   * Session sampling. Use {@link SamplingRate} for fixed rate or\n   * {@link SamplingFunction} for dynamic sampling.\n   */\n  sampling?: Sampling;\n};\n\n/**\n * Flags for enabling optional built-in transports.\n * FetchTransport is always instantiated when url is provided.\n */\nexport interface EnableTransportsConfig {\n  /** Enable OfflineTransport for caching when offline (default: false) */\n  offline?: boolean;\n  /** Enable ConsoleTransport to log telemetry to Metro console for debugging (default: false) */\n  console?: boolean;\n}\n\n/** RN-specific config: overrides + new props. Omit faro-core props we replace with RN equivalents. */\ntype ReactNativeConfigOverrides = {\n  /** Application metadata (required) */\n  app: Config['app'];\n  sessionTracking?: ReactNativeSessionTrackingConfig;\n  url?: string;\n  apiKey?: string;\n  enableTransports?: EnableTransportsConfig;\n  /**\n   * Which HTTP instrumentations to enable. When tracing is disabled, these control\n   * HttpInstrumentation (fetch) and XHRInstrumentation (xhr). Default: both true.\n   */\n  enableHttpInstrumentation?: {\n    /** HttpInstrumentation - patches fetch API (default: true) */\n    fetch?: boolean;\n    /** XHRInstrumentation - patches XMLHttpRequest (default: true) */\n    xhr?: boolean;\n  };\n  enableTracing?: boolean;\n  /** Passed to TracingInstrumentation. See TracingInstrumentationOptions in @grafana/faro-react-native-tracing. */\n  tracingOptions?: Record<string, unknown>;\n  cpuUsageVitals?: boolean;\n  memoryUsageVitals?: boolean;\n  refreshRateVitals?: boolean;\n  fetchVitalsInterval?: number;\n  frameMonitoringOptions?: FrameMonitoringOptions;\n  enableErrorReporting?: boolean;\n  enableCrashReporting?: boolean;\n  anrTracking?: boolean;\n  anrOptions?: ANRInstrumentationOptions;\n  enableConsoleCapture?: boolean;\n  consoleCaptureOptions?: Config['consoleInstrumentation'];\n  enableUserActions?: boolean;\n  userActionsOptions?: Config['userActionsInstrumentation'];\n};\n\n/**\n * React Native config: Config (omit replaced props) & overrides.\n * Omit: sessionTracking, consoleInstrumentation, userActionsInstrumentation.\n * instrumentations and transports inherited from Config for extras (built-ins come from flags).\n */\nexport type ReactNativeConfig = Partial<\n  Omit<Config, 'sessionTracking' | 'consoleInstrumentation' | 'userActionsInstrumentation'>\n> &\n  ReactNativeConfigOverrides;\n"]}

package/dist/cjs/dataCollection/DataCollectionPolicy.js

@@ -0,0 +1,281 @@
+"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.AsyncStorageDataCollectionPolicy = void 0;
+exports.createDataCollectionPolicy = createDataCollectionPolicy;
+exports.initializeDataCollectionPolicy = initializeDataCollectionPolicy;
+exports.getDataCollectionPolicy = getDataCollectionPolicy;
+exports.setDataCollectionPolicy = setDataCollectionPolicy;
+var async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
+/**
+ * Default storage key for the data collection policy.
+ */
+var DEFAULT_STORAGE_KEY = 'faro_enable_data_collection';
+/**
+ * DataCollectionPolicy implementation using AsyncStorage.
+ *
+ * Controls whether telemetry data is collected and sent.
+ * The setting is persisted to AsyncStorage so it survives app restarts.
+ *
+ * Implementation follows Flutter SDK's DataCollectionPolicy pattern:
+ * - Uses AsyncStorage for persistence (matching Flutter's SharedPreferences)
+ * - Provides enable/disable methods
+ * - Initializes from persisted value or default
+ *
+ * @example
+ * ```typescript
+ * import { createDataCollectionPolicy } from '@grafana/faro-react-native';
+ *
+ * // Create and initialize the policy
+ * const policy = await createDataCollectionPolicy();
+ *
+ * // Check if enabled
+ * if (policy.isEnabled) {
+ *   // Data collection is allowed
+ * }
+ *
+ * // User opts out
+ * await policy.disable();
+ *
+ * // User opts back in
+ * await policy.enable();
+ * ```
+ */
+var AsyncStorageDataCollectionPolicy = /** @class */ (function () {
+    function AsyncStorageDataCollectionPolicy(options) {
+        if (options === void 0) { options = {}; }
+        var _a, _b;
+        this.subscribers = new Set();
+        this.storageKey = (_a = options.storageKey) !== null && _a !== void 0 ? _a : DEFAULT_STORAGE_KEY;
+        this._isEnabled = (_b = options.defaultEnabled) !== null && _b !== void 0 ? _b : true;
+    }
+    /**
+     * Create and initialize a DataCollectionPolicy.
+     *
+     * This async factory method loads the persisted value from AsyncStorage.
+     */
+    AsyncStorageDataCollectionPolicy.create = function () {
+        return __awaiter(this, arguments, void 0, function (options) {
+            var policy;
+            if (options === void 0) { options = {}; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        policy = new AsyncStorageDataCollectionPolicy(options);
+                        return [4 /*yield*/, policy.initialize()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/, policy];
+                }
+            });
+        });
+    };
+    Object.defineProperty(AsyncStorageDataCollectionPolicy.prototype, "isEnabled", {
+        get: function () {
+            return this._isEnabled;
+        },
+        enumerable: false,
+        configurable: true
+    });
+    AsyncStorageDataCollectionPolicy.prototype.enable = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._isEnabled = true;
+                        return [4 /*yield*/, this.persistSetting()];
+                    case 1:
+                        _a.sent();
+                        this.notifySubscribers();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AsyncStorageDataCollectionPolicy.prototype.disable = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        this._isEnabled = false;
+                        return [4 /*yield*/, this.persistSetting()];
+                    case 1:
+                        _a.sent();
+                        this.notifySubscribers();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AsyncStorageDataCollectionPolicy.prototype.subscribe = function (callback) {
+        var _this = this;
+        this.subscribers.add(callback);
+        // Immediately notify subscriber of current state
+        callback(this._isEnabled);
+        return function () {
+            _this.subscribers.delete(callback);
+        };
+    };
+    AsyncStorageDataCollectionPolicy.prototype.initialize = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var storedValue, _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:
+                        storedValue = _b.sent();
+                        if (storedValue !== null) {
+                            this._isEnabled = storedValue === 'true';
+                        }
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _a = _b.sent();
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AsyncStorageDataCollectionPolicy.prototype.persistSetting = 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.setItem(this.storageKey, String(this._isEnabled))];
+                    case 1:
+                        _b.sent();
+                        return [3 /*break*/, 3];
+                    case 2:
+                        _a = _b.sent();
+                        return [3 /*break*/, 3];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AsyncStorageDataCollectionPolicy.prototype.notifySubscribers = function () {
+        var _this = this;
+        this.subscribers.forEach(function (subscriber) {
+            try {
+                subscriber(_this._isEnabled);
+            }
+            catch (_a) {
+                // Ignore subscriber errors
+            }
+        });
+    };
+    return AsyncStorageDataCollectionPolicy;
+}());
+exports.AsyncStorageDataCollectionPolicy = AsyncStorageDataCollectionPolicy;
+/**
+ * Factory function to create a DataCollectionPolicy.
+ *
+ * @example
+ * ```typescript
+ * const policy = await createDataCollectionPolicy();
+ * ```
+ */
+function createDataCollectionPolicy() {
+    return __awaiter(this, arguments, void 0, function (options) {
+        if (options === void 0) { options = {}; }
+        return __generator(this, function (_a) {
+            return [2 /*return*/, AsyncStorageDataCollectionPolicy.create(options)];
+        });
+    });
+}
+/**
+ * Global data collection policy instance.
+ * Must be initialized before use.
+ */
+var globalPolicy = null;
+/**
+ * Initialize the global data collection policy.
+ *
+ * This should be called early in app initialization, before initializeFaro().
+ *
+ * @example
+ * ```typescript
+ * import { initializeDataCollectionPolicy, getDataCollectionPolicy } from '@grafana/faro-react-native';
+ *
+ * // Early in app startup
+ * await initializeDataCollectionPolicy();
+ *
+ * // Later, check if collection is enabled
+ * const policy = getDataCollectionPolicy();
+ * if (policy?.isEnabled) {
+ *   // Initialize Faro
+ * }
+ * ```
+ */
+function initializeDataCollectionPolicy() {
+    return __awaiter(this, arguments, void 0, function (options) {
+        if (options === void 0) { options = {}; }
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, createDataCollectionPolicy(options)];
+                case 1:
+                    globalPolicy = _a.sent();
+                    return [2 /*return*/, globalPolicy];
+            }
+        });
+    });
+}
+/**
+ * Get the global data collection policy.
+ *
+ * Returns null if not initialized.
+ */
+function getDataCollectionPolicy() {
+    return globalPolicy;
+}
+/**
+ * Set a custom data collection policy.
+ *
+ * Useful for testing or custom implementations.
+ */
+function setDataCollectionPolicy(policy) {
+    globalPolicy = policy;
+}
+//# sourceMappingURL=DataCollectionPolicy.js.map

package/dist/cjs/dataCollection/DataCollectionPolicy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataCollectionPolicy.js","sourceRoot":"","sources":["../../../src/dataCollection/DataCollectionPolicy.ts"],"names":[],"mappings":"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","sourcesContent":["import AsyncStorage from '@react-native-async-storage/async-storage';\n\nimport type { DataCollectionPolicy, DataCollectionPolicyOptions } from './types';\n\n/**\n * Default storage key for the data collection policy.\n */\nconst DEFAULT_STORAGE_KEY = 'faro_enable_data_collection';\n\n/**\n * DataCollectionPolicy implementation using AsyncStorage.\n *\n * Controls whether telemetry data is collected and sent.\n * The setting is persisted to AsyncStorage so it survives app restarts.\n *\n * Implementation follows Flutter SDK's DataCollectionPolicy pattern:\n * - Uses AsyncStorage for persistence (matching Flutter's SharedPreferences)\n * - Provides enable/disable methods\n * - Initializes from persisted value or default\n *\n * @example\n * ```typescript\n * import { createDataCollectionPolicy } from '@grafana/faro-react-native';\n *\n * // Create and initialize the policy\n * const policy = await createDataCollectionPolicy();\n *\n * // Check if enabled\n * if (policy.isEnabled) {\n *   // Data collection is allowed\n * }\n *\n * // User opts out\n * await policy.disable();\n *\n * // User opts back in\n * await policy.enable();\n * ```\n */\nexport class AsyncStorageDataCollectionPolicy implements DataCollectionPolicy {\n  private _isEnabled: boolean;\n  private readonly storageKey: string;\n  private readonly subscribers: Set<(isEnabled: boolean) => void> = new Set();\n\n  private constructor(options: DataCollectionPolicyOptions = {}) {\n    this.storageKey = options.storageKey ?? DEFAULT_STORAGE_KEY;\n    this._isEnabled = options.defaultEnabled ?? true;\n  }\n\n  /**\n   * Create and initialize a DataCollectionPolicy.\n   *\n   * This async factory method loads the persisted value from AsyncStorage.\n   */\n  static async create(options: DataCollectionPolicyOptions = {}): Promise<AsyncStorageDataCollectionPolicy> {\n    const policy = new AsyncStorageDataCollectionPolicy(options);\n    await policy.initialize();\n    return policy;\n  }\n\n  get isEnabled(): boolean {\n    return this._isEnabled;\n  }\n\n  async enable(): Promise<void> {\n    this._isEnabled = true;\n    await this.persistSetting();\n    this.notifySubscribers();\n  }\n\n  async disable(): Promise<void> {\n    this._isEnabled = false;\n    await this.persistSetting();\n    this.notifySubscribers();\n  }\n\n  subscribe(callback: (isEnabled: boolean) => void): () => void {\n    this.subscribers.add(callback);\n    // Immediately notify subscriber of current state\n    callback(this._isEnabled);\n\n    return () => {\n      this.subscribers.delete(callback);\n    };\n  }\n\n  private async initialize(): Promise<void> {\n    try {\n      const storedValue = await AsyncStorage.getItem(this.storageKey);\n      if (storedValue !== null) {\n        this._isEnabled = storedValue === 'true';\n      }\n    } catch {\n      // If loading fails, use default value\n    }\n  }\n\n  private async persistSetting(): Promise<void> {\n    try {\n      await AsyncStorage.setItem(this.storageKey, String(this._isEnabled));\n    } catch {\n      // If persisting fails, log but don't throw\n    }\n  }\n\n  private notifySubscribers(): void {\n    this.subscribers.forEach((subscriber) => {\n      try {\n        subscriber(this._isEnabled);\n      } catch {\n        // Ignore subscriber errors\n      }\n    });\n  }\n}\n\n/**\n * Factory function to create a DataCollectionPolicy.\n *\n * @example\n * ```typescript\n * const policy = await createDataCollectionPolicy();\n * ```\n */\nexport async function createDataCollectionPolicy(\n  options: DataCollectionPolicyOptions = {}\n): Promise<DataCollectionPolicy> {\n  return AsyncStorageDataCollectionPolicy.create(options);\n}\n\n/**\n * Global data collection policy instance.\n * Must be initialized before use.\n */\nlet globalPolicy: DataCollectionPolicy | null = null;\n\n/**\n * Initialize the global data collection policy.\n *\n * This should be called early in app initialization, before initializeFaro().\n *\n * @example\n * ```typescript\n * import { initializeDataCollectionPolicy, getDataCollectionPolicy } from '@grafana/faro-react-native';\n *\n * // Early in app startup\n * await initializeDataCollectionPolicy();\n *\n * // Later, check if collection is enabled\n * const policy = getDataCollectionPolicy();\n * if (policy?.isEnabled) {\n *   // Initialize Faro\n * }\n * ```\n */\nexport async function initializeDataCollectionPolicy(\n  options: DataCollectionPolicyOptions = {}\n): Promise<DataCollectionPolicy> {\n  globalPolicy = await createDataCollectionPolicy(options);\n  return globalPolicy;\n}\n\n/**\n * Get the global data collection policy.\n *\n * Returns null if not initialized.\n */\nexport function getDataCollectionPolicy(): DataCollectionPolicy | null {\n  return globalPolicy;\n}\n\n/**\n * Set a custom data collection policy.\n *\n * Useful for testing or custom implementations.\n */\nexport function setDataCollectionPolicy(policy: DataCollectionPolicy | null): void {\n  globalPolicy = policy;\n}\n"]}

package/dist/cjs/dataCollection/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setDataCollectionPolicy = exports.initializeDataCollectionPolicy = exports.getDataCollectionPolicy = exports.createDataCollectionPolicy = exports.AsyncStorageDataCollectionPolicy = void 0;
+var DataCollectionPolicy_1 = require("./DataCollectionPolicy");
+Object.defineProperty(exports, "AsyncStorageDataCollectionPolicy", { enumerable: true, get: function () { return DataCollectionPolicy_1.AsyncStorageDataCollectionPolicy; } });
+Object.defineProperty(exports, "createDataCollectionPolicy", { enumerable: true, get: function () { return DataCollectionPolicy_1.createDataCollectionPolicy; } });
+Object.defineProperty(exports, "getDataCollectionPolicy", { enumerable: true, get: function () { return DataCollectionPolicy_1.getDataCollectionPolicy; } });
+Object.defineProperty(exports, "initializeDataCollectionPolicy", { enumerable: true, get: function () { return DataCollectionPolicy_1.initializeDataCollectionPolicy; } });
+Object.defineProperty(exports, "setDataCollectionPolicy", { enumerable: true, get: function () { return DataCollectionPolicy_1.setDataCollectionPolicy; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/dataCollection/index.ts"],"names":[],"mappings":";;;AAAA,+DAMgC;AAL9B,wIAAA,gCAAgC,OAAA;AAChC,kIAAA,0BAA0B,OAAA;AAC1B,+HAAA,uBAAuB,OAAA;AACvB,sIAAA,8BAA8B,OAAA;AAC9B,+HAAA,uBAAuB,OAAA","sourcesContent":["export {\n  AsyncStorageDataCollectionPolicy,\n  createDataCollectionPolicy,\n  getDataCollectionPolicy,\n  initializeDataCollectionPolicy,\n  setDataCollectionPolicy,\n} from './DataCollectionPolicy';\nexport type { DataCollectionPolicy, DataCollectionPolicyOptions } from './types';\n"]}

package/dist/cjs/dataCollection/types.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/dataCollection/types.ts"],"names":[],"mappings":"","sourcesContent":["/**\n * Interface for data collection policy management.\n *\n * Controls whether telemetry data is collected and sent.\n * Useful for GDPR compliance and user privacy controls.\n */\nexport interface DataCollectionPolicy {\n  /**\n   * Whether data collection is currently enabled.\n   */\n  readonly isEnabled: boolean;\n\n  /**\n   * Enable telemetry data collection.\n   */\n  enable(): Promise<void>;\n\n  /**\n   * Disable telemetry data collection.\n   */\n  disable(): Promise<void>;\n\n  /**\n   * Subscribe to policy changes.\n   * @param callback Function called when policy changes.\n   * @returns Unsubscribe function.\n   */\n  subscribe(callback: (isEnabled: boolean) => void): () => void;\n}\n\n/**\n * Options for creating a DataCollectionPolicy.\n */\nexport interface DataCollectionPolicyOptions {\n  /**\n   * Storage key for persisting the policy setting.\n   * Default: 'faro_enable_data_collection'\n   */\n  storageKey?: string;\n\n  /**\n   * Initial enabled state if no persisted value exists.\n   * Default: true\n   */\n  defaultEnabled?: boolean;\n}\n"]}

package/dist/cjs/errorBoundary/FaroErrorBoundary.js

@@ -0,0 +1,114 @@
+"use strict";
+var __extends = (this && this.__extends) || (function () {
+    var extendStatics = function (d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+    return function (d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FaroErrorBoundary = void 0;
+var react_1 = require("react");
+var faro_core_1 = require("@grafana/faro-core");
+var const_1 = require("./const");
+/**
+ * React Error Boundary with Faro integration
+ *
+ * Catches React component errors and sends them to Faro for monitoring.
+ * Provides lifecycle hooks and custom fallback UI support.
+ *
+ * @example
+ * ```tsx
+ * import { FaroErrorBoundary } from '@grafana/faro-react-native';
+ *
+ * function App() {
+ *   return (
+ *     <FaroErrorBoundary
+ *       fallback={<Text>Something went wrong</Text>}
+ *     >
+ *       <YourApp />
+ *     </FaroErrorBoundary>
+ *   );
+ * }
+ * ```
+ */
+var FaroErrorBoundary = /** @class */ (function (_super) {
+    __extends(FaroErrorBoundary, _super);
+    function FaroErrorBoundary(props) {
+        var _this = _super.call(this, props) || this;
+        _this.state = const_1.faroErrorBoundaryInitialState;
+        _this.resetErrorBoundary = _this.resetErrorBoundary.bind(_this);
+        return _this;
+    }
+    /**
+     * Creates an error with React component stack included
+     */
+    FaroErrorBoundary.prototype.getErrorWithComponentStack = function (error, errorInfo) {
+        if (!errorInfo.componentStack) {
+            return error;
+        }
+        var newError = new Error(error.message);
+        newError.name = "React ErrorBoundary ".concat(error.name);
+        newError.stack = errorInfo.componentStack;
+        return newError;
+    };
+    FaroErrorBoundary.getDerivedStateFromError = function (error) {
+        return {
+            hasError: true,
+            error: error,
+        };
+    };
+    FaroErrorBoundary.prototype.componentDidCatch = function (error, errorInfo) {
+        var _a, _b, _c, _d;
+        var errorWithComponentStack = this.getErrorWithComponentStack(error, errorInfo);
+        // Call beforeCapture hook
+        (_b = (_a = this.props).beforeCapture) === null || _b === void 0 ? void 0 : _b.call(_a, errorWithComponentStack);
+        // Send error to Faro
+        faro_core_1.faro.api.pushError(errorWithComponentStack, this.props.pushErrorOptions);
+        // Call onError hook
+        (_d = (_c = this.props).onError) === null || _d === void 0 ? void 0 : _d.call(_c, errorWithComponentStack);
+        // Note: Don't call setState here - getDerivedStateFromError already set the state
+    };
+    FaroErrorBoundary.prototype.componentDidMount = function () {
+        var _a, _b;
+        (_b = (_a = this.props).onMount) === null || _b === void 0 ? void 0 : _b.call(_a);
+    };
+    FaroErrorBoundary.prototype.componentWillUnmount = function () {
+        var _a, _b;
+        (_b = (_a = this.props).onUnmount) === null || _b === void 0 ? void 0 : _b.call(_a, this.state.error);
+    };
+    FaroErrorBoundary.prototype.resetErrorBoundary = function () {
+        var _a, _b;
+        (_b = (_a = this.props).onReset) === null || _b === void 0 ? void 0 : _b.call(_a, this.state.error);
+        this.setState(const_1.faroErrorBoundaryInitialState);
+    };
+    FaroErrorBoundary.prototype.render = function () {
+        if (!this.state.hasError || !this.state.error) {
+            return typeof this.props.children === 'function'
+                ? this.props.children()
+                : this.props.children;
+        }
+        var element = typeof this.props.fallback !== 'function'
+            ? this.props.fallback
+            : this.props.fallback(this.state.error, this.resetErrorBoundary);
+        // Check if element exists - isValidElement may fail in monorepos with multiple React instances
+        if (element != null) {
+            return element;
+        }
+        if (this.props.fallback) {
+            console.warn('[Faro ErrorBoundary] Cannot get a valid ReactElement from "fallback"');
+        }
+        return null;
+    };
+    return FaroErrorBoundary;
+}(react_1.Component));
+exports.FaroErrorBoundary = FaroErrorBoundary;
+//# sourceMappingURL=FaroErrorBoundary.js.map

package/dist/cjs/errorBoundary/FaroErrorBoundary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"FaroErrorBoundary.js","sourceRoot":"","sources":["../../../src/errorBoundary/FaroErrorBoundary.tsx"],"names":[],"mappings":"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","sourcesContent":["import { Component, type ErrorInfo, type ReactNode } from 'react';\n\nimport { faro } from '@grafana/faro-core';\n\nimport { faroErrorBoundaryInitialState } from './const';\nimport type { FaroErrorBoundaryProps, FaroErrorBoundaryState } from './types';\n\n/**\n * React Error Boundary with Faro integration\n *\n * Catches React component errors and sends them to Faro for monitoring.\n * Provides lifecycle hooks and custom fallback UI support.\n *\n * @example\n * ```tsx\n * import { FaroErrorBoundary } from '@grafana/faro-react-native';\n *\n * function App() {\n *   return (\n *     <FaroErrorBoundary\n *       fallback={<Text>Something went wrong</Text>}\n *     >\n *       <YourApp />\n *     </FaroErrorBoundary>\n *   );\n * }\n * ```\n */\nexport class FaroErrorBoundary extends Component<FaroErrorBoundaryProps, FaroErrorBoundaryState> {\n  override state: FaroErrorBoundaryState = faroErrorBoundaryInitialState;\n\n  constructor(props: FaroErrorBoundaryProps) {\n    super(props);\n    this.resetErrorBoundary = this.resetErrorBoundary.bind(this);\n  }\n\n  /**\n   * Creates an error with React component stack included\n   */\n  getErrorWithComponentStack(error: Error, errorInfo: ErrorInfo): Error {\n    if (!errorInfo.componentStack) {\n      return error;\n    }\n\n    const newError = new Error(error.message);\n    newError.name = `React ErrorBoundary ${error.name}`;\n    newError.stack = errorInfo.componentStack;\n\n    return newError;\n  }\n\n  static getDerivedStateFromError(error: Error): FaroErrorBoundaryState {\n    return {\n      hasError: true,\n      error,\n    };\n  }\n\n  override componentDidCatch(error: Error, errorInfo: ErrorInfo): void {\n    const errorWithComponentStack = this.getErrorWithComponentStack(error, errorInfo);\n\n    // Call beforeCapture hook\n    this.props.beforeCapture?.(errorWithComponentStack);\n\n    // Send error to Faro\n    faro.api.pushError(errorWithComponentStack, this.props.pushErrorOptions);\n\n    // Call onError hook\n    this.props.onError?.(errorWithComponentStack);\n\n    // Note: Don't call setState here - getDerivedStateFromError already set the state\n  }\n\n  override componentDidMount(): void {\n    this.props.onMount?.();\n  }\n\n  override componentWillUnmount(): void {\n    this.props.onUnmount?.(this.state.error);\n  }\n\n  resetErrorBoundary(): void {\n    this.props.onReset?.(this.state.error);\n    this.setState(faroErrorBoundaryInitialState);\n  }\n\n  override render(): ReactNode {\n    if (!this.state.hasError || !this.state.error) {\n      return typeof this.props.children === 'function'\n        ? (this.props.children as () => ReactNode)()\n        : this.props.children;\n    }\n\n    const element =\n      typeof this.props.fallback !== 'function'\n        ? this.props.fallback\n        : this.props.fallback(this.state.error, this.resetErrorBoundary);\n\n    // Check if element exists - isValidElement may fail in monorepos with multiple React instances\n    if (element != null) {\n      return element;\n    }\n\n    if (this.props.fallback) {\n      console.warn('[Faro ErrorBoundary] Cannot get a valid ReactElement from \"fallback\"');\n    }\n\n    return null;\n  }\n}\n"]}

package/dist/cjs/errorBoundary/const.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.faroErrorBoundaryInitialState = void 0;
+exports.faroErrorBoundaryInitialState = {
+    hasError: false,
+    error: null,
+};
+//# sourceMappingURL=const.js.map

package/dist/cjs/errorBoundary/const.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"const.js","sourceRoot":"","sources":["../../../src/errorBoundary/const.ts"],"names":[],"mappings":";;;AAEa,QAAA,6BAA6B,GAA2B;IACnE,QAAQ,EAAE,KAAK;IACf,KAAK,EAAE,IAAI;CACH,CAAC","sourcesContent":["import type { FaroErrorBoundaryState } from './types';\n\nexport const faroErrorBoundaryInitialState: FaroErrorBoundaryState = {\n  hasError: false,\n  error: null,\n} as const;\n"]}

package/dist/cjs/errorBoundary/types.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.js","sourceRoot":"","sources":["../../../src/errorBoundary/types.ts"],"names":[],"mappings":"","sourcesContent":["import type { ReactElement, ReactNode } from 'react';\n\nimport type { PushErrorOptions } from '@grafana/faro-core';\n\nexport type ReactNodeRender = () => ReactNode;\n\nexport type FaroErrorBoundaryFallbackRender = (error: Error, resetError: VoidFunction) => ReactElement;\n\nexport interface FaroErrorBoundaryProps {\n  beforeCapture?: (error: Error | null) => void;\n  children?: ReactNode | ReactNodeRender;\n  fallback?: ReactElement | FaroErrorBoundaryFallbackRender;\n  onError?: (error: Error) => void;\n  onMount?: VoidFunction;\n  onReset?: (error: Error | null) => void;\n  onUnmount?: (error: Error | null) => void;\n  pushErrorOptions?: PushErrorOptions;\n}\n\nexport interface FaroErrorBoundaryState {\n  hasError: boolean;\n  error: Error | null;\n}\n"]}

package/dist/cjs/errorBoundary/withFaroErrorBoundary.js

@@ -0,0 +1,35 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withFaroErrorBoundary = withFaroErrorBoundary;
+var react_1 = __importDefault(require("react"));
+var faro_core_1 = require("@grafana/faro-core");
+var FaroErrorBoundary_1 = require("./FaroErrorBoundary");
+/**
+ * Higher-Order Component that wraps a component with FaroErrorBoundary
+ *
+ * @example
+ * ```tsx
+ * import { withFaroErrorBoundary } from '@grafana/faro-react-native';
+ * import { Text } from 'react-native';
+ *
+ * const MyComponent = () => <Text>Hello</Text>;
+ *
+ * export default withFaroErrorBoundary(MyComponent, {
+ *   fallback: <Text>Error occurred</Text>
+ * });
+ * ```
+ */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any -- Generic HOC must accept any component props
+function withFaroErrorBoundary(WrappedComponent, errorBoundaryProps) {
+    var _a, _b;
+    var componentDisplayName = (_b = (_a = WrappedComponent.displayName) !== null && _a !== void 0 ? _a : WrappedComponent.name) !== null && _b !== void 0 ? _b : faro_core_1.unknownString;
+    var Component = function (wrappedComponentProps) {
+        return react_1.default.createElement(FaroErrorBoundary_1.FaroErrorBoundary, errorBoundaryProps, react_1.default.createElement(WrappedComponent, wrappedComponentProps));
+    };
+    Component.displayName = "faroErrorBoundary(".concat(componentDisplayName, ")");
+    return Component;
+}
+//# sourceMappingURL=withFaroErrorBoundary.js.map

package/dist/cjs/errorBoundary/withFaroErrorBoundary.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"withFaroErrorBoundary.js","sourceRoot":"","sources":["../../../src/errorBoundary/withFaroErrorBoundary.tsx"],"names":[],"mappings":";;;;;AAuBA,sDAgBC;AAvCD,gDAA2D;AAE3D,gDAAmD;AAEnD,yDAAwD;AAGxD;;;;;;;;;;;;;;GAcG;AACH,6GAA6G;AAC7G,SAAgB,qBAAqB,CACnC,gBAAkC,EAClC,kBAA0C;;IAE1C,IAAM,oBAAoB,GAAG,MAAA,MAAA,gBAAgB,CAAC,WAAW,mCAAI,gBAAgB,CAAC,IAAI,mCAAI,yBAAa,CAAC;IAEpG,IAAM,SAAS,GAAU,UAAC,qBAAwB;QAChD,OAAA,eAAK,CAAC,aAAa,CACjB,qCAAiB,EACjB,kBAAkB,EAClB,eAAK,CAAC,aAAa,CAAC,gBAAgB,EAAE,qBAAqB,CAAC,CAC7D;IAJD,CAIC,CAAC;IAEJ,SAAS,CAAC,WAAW,GAAG,4BAAqB,oBAAoB,MAAG,CAAC;IAErE,OAAO,SAAS,CAAC;AACnB,CAAC","sourcesContent":["import React, { type ComponentType, type FC } from 'react';\n\nimport { unknownString } from '@grafana/faro-core';\n\nimport { FaroErrorBoundary } from './FaroErrorBoundary';\nimport type { FaroErrorBoundaryProps } from './types';\n\n/**\n * Higher-Order Component that wraps a component with FaroErrorBoundary\n *\n * @example\n * ```tsx\n * import { withFaroErrorBoundary } from '@grafana/faro-react-native';\n * import { Text } from 'react-native';\n *\n * const MyComponent = () => <Text>Hello</Text>;\n *\n * export default withFaroErrorBoundary(MyComponent, {\n *   fallback: <Text>Error occurred</Text>\n * });\n * ```\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any -- Generic HOC must accept any component props\nexport function withFaroErrorBoundary<P extends Record<string, any> = {}>(\n  WrappedComponent: ComponentType<P>,\n  errorBoundaryProps: FaroErrorBoundaryProps\n): FC<P> {\n  const componentDisplayName = WrappedComponent.displayName ?? WrappedComponent.name ?? unknownString;\n\n  const Component: FC<P> = (wrappedComponentProps: P) =>\n    React.createElement(\n      FaroErrorBoundary,\n      errorBoundaryProps,\n      React.createElement(WrappedComponent, wrappedComponentProps)\n    );\n\n  Component.displayName = `faroErrorBoundary(${componentDisplayName})`;\n\n  return Component;\n}\n"]}