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

package/dist/cjs/transports/offline/OfflineCache.js

@@ -0,0 +1,265 @@
+"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.AsyncStorageOfflineCache = void 0;
+var async_storage_1 = __importDefault(require("@react-native-async-storage/async-storage"));
+/**
+ * Default storage key prefix for the offline cache.
+ */
+var DEFAULT_STORAGE_KEY_PREFIX = 'faro_offline_cache';
+/**
+ * Default maximum number of cached payloads.
+ */
+var DEFAULT_MAX_CACHE_SIZE = 1000;
+/**
+ * File-based offline cache implementation using AsyncStorage.
+ *
+ * Stores cached telemetry payloads as JSONL (one JSON object per line)
+ * following the Flutter SDK's offline transport pattern.
+ *
+ * Uses a mutex pattern for thread-safe file access.
+ */
+var AsyncStorageOfflineCache = /** @class */ (function () {
+    function AsyncStorageOfflineCache(options) {
+        if (options === void 0) { options = {}; }
+        var _a, _b;
+        this.lockPromise = Promise.resolve();
+        this.storageKey = "".concat((_a = options.storageKeyPrefix) !== null && _a !== void 0 ? _a : DEFAULT_STORAGE_KEY_PREFIX, "_data");
+        this.maxCacheSize = (_b = options.maxCacheSize) !== null && _b !== void 0 ? _b : DEFAULT_MAX_CACHE_SIZE;
+    }
+    AsyncStorageOfflineCache.prototype.write = function (payload) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.withLock(function () { return __awaiter(_this, void 0, void 0, function () {
+                            var payloads;
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, this.readAllInternal()];
+                                    case 1:
+                                        payloads = _a.sent();
+                                        // Add new payload
+                                        payloads.push(payload);
+                                        // Trim to max size (remove oldest entries)
+                                        while (payloads.length > this.maxCacheSize) {
+                                            payloads.shift();
+                                        }
+                                        return [4 /*yield*/, this.writeAll(payloads)];
+                                    case 2:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AsyncStorageOfflineCache.prototype.readAll = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.withLock(function () { return __awaiter(_this, void 0, void 0, function () {
+                        return __generator(this, function (_a) {
+                            return [2 /*return*/, this.readAllInternal()];
+                        });
+                    }); })];
+            });
+        });
+    };
+    AsyncStorageOfflineCache.prototype.clear = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.withLock(function () { return __awaiter(_this, void 0, void 0, function () {
+                            return __generator(this, function (_a) {
+                                switch (_a.label) {
+                                    case 0: return [4 /*yield*/, async_storage_1.default.removeItem(this.storageKey)];
+                                    case 1:
+                                        _a.sent();
+                                        return [2 /*return*/];
+                                }
+                            });
+                        }); })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AsyncStorageOfflineCache.prototype.removeByTimestamps = function (timestamps) {
+        return __awaiter(this, void 0, void 0, function () {
+            var timestampSet;
+            var _this = this;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (timestamps.length === 0)
+                            return [2 /*return*/];
+                        timestampSet = new Set(timestamps);
+                        return [4 /*yield*/, this.withLock(function () { return __awaiter(_this, void 0, void 0, function () {
+                                var payloads, remaining;
+                                return __generator(this, function (_a) {
+                                    switch (_a.label) {
+                                        case 0: return [4 /*yield*/, this.readAllInternal()];
+                                        case 1:
+                                            payloads = _a.sent();
+                                            remaining = payloads.filter(function (p) { return !timestampSet.has(p.timestamp); });
+                                            return [4 /*yield*/, this.writeAll(remaining)];
+                                        case 2:
+                                            _a.sent();
+                                            return [2 /*return*/];
+                                    }
+                                });
+                            }); })];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AsyncStorageOfflineCache.prototype.getCount = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var payloads;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.readAllInternal()];
+                    case 1:
+                        payloads = _a.sent();
+                        return [2 /*return*/, payloads.length];
+                }
+            });
+        });
+    };
+    /**
+     * Execute an operation with a mutex lock to ensure thread-safe access.
+     * Follows Flutter SDK's Completer-based lock pattern.
+     */
+    AsyncStorageOfflineCache.prototype.withLock = function (operation) {
+        return __awaiter(this, void 0, void 0, function () {
+            var currentLock, resolveLock;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        currentLock = this.lockPromise;
+                        this.lockPromise = new Promise(function (resolve) {
+                            resolveLock = resolve;
+                        });
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, , 4, 5]);
+                        return [4 /*yield*/, currentLock];
+                    case 2:
+                        _a.sent();
+                        return [4 /*yield*/, operation()];
+                    case 3: return [2 /*return*/, _a.sent()];
+                    case 4:
+                        resolveLock();
+                        return [7 /*endfinally*/];
+                    case 5: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AsyncStorageOfflineCache.prototype.readAllInternal = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var data, parsed, _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:
+                        data = _b.sent();
+                        if (!data) {
+                            return [2 /*return*/, []];
+                        }
+                        parsed = JSON.parse(data);
+                        if (!Array.isArray(parsed)) {
+                            return [2 /*return*/, []];
+                        }
+                        return [2 /*return*/, parsed.filter(this.isValidCachedPayload)];
+                    case 2:
+                        _a = _b.sent();
+                        // If parsing fails, return empty array
+                        return [2 /*return*/, []];
+                    case 3: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AsyncStorageOfflineCache.prototype.writeAll = function (payloads) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!(payloads.length === 0)) return [3 /*break*/, 2];
+                        return [4 /*yield*/, async_storage_1.default.removeItem(this.storageKey)];
+                    case 1:
+                        _a.sent();
+                        return [3 /*break*/, 4];
+                    case 2: return [4 /*yield*/, async_storage_1.default.setItem(this.storageKey, JSON.stringify(payloads))];
+                    case 3:
+                        _a.sent();
+                        _a.label = 4;
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    AsyncStorageOfflineCache.prototype.isValidCachedPayload = function (payload) {
+        if (typeof payload !== 'object' || payload === null) {
+            return false;
+        }
+        var p = payload;
+        return typeof p['timestamp'] === 'number' && Array.isArray(p['items']);
+    };
+    return AsyncStorageOfflineCache;
+}());
+exports.AsyncStorageOfflineCache = AsyncStorageOfflineCache;
+//# sourceMappingURL=OfflineCache.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"OfflineCache.js","sourceRoot":"","sources":["../../../../src/transports/offline/OfflineCache.ts"],"names":[],"mappings":"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","sourcesContent":["import AsyncStorage from '@react-native-async-storage/async-storage';\n\nimport type { CachedPayload, OfflineCache } from './types';\n\n/**\n * Default storage key prefix for the offline cache.\n */\nconst DEFAULT_STORAGE_KEY_PREFIX = 'faro_offline_cache';\n\n/**\n * Default maximum number of cached payloads.\n */\nconst DEFAULT_MAX_CACHE_SIZE = 1000;\n\n/**\n * File-based offline cache implementation using AsyncStorage.\n *\n * Stores cached telemetry payloads as JSONL (one JSON object per line)\n * following the Flutter SDK's offline transport pattern.\n *\n * Uses a mutex pattern for thread-safe file access.\n */\nexport class AsyncStorageOfflineCache implements OfflineCache {\n  private readonly storageKey: string;\n  private readonly maxCacheSize: number;\n  private lockPromise: Promise<void> = Promise.resolve();\n\n  constructor(options: { storageKeyPrefix?: string; maxCacheSize?: number } = {}) {\n    this.storageKey = `${options.storageKeyPrefix ?? DEFAULT_STORAGE_KEY_PREFIX}_data`;\n    this.maxCacheSize = options.maxCacheSize ?? DEFAULT_MAX_CACHE_SIZE;\n  }\n\n  async write(payload: CachedPayload): Promise<void> {\n    await this.withLock(async () => {\n      const payloads = await this.readAllInternal();\n\n      // Add new payload\n      payloads.push(payload);\n\n      // Trim to max size (remove oldest entries)\n      while (payloads.length > this.maxCacheSize) {\n        payloads.shift();\n      }\n\n      await this.writeAll(payloads);\n    });\n  }\n\n  async readAll(): Promise<CachedPayload[]> {\n    return this.withLock(async () => {\n      return this.readAllInternal();\n    });\n  }\n\n  async clear(): Promise<void> {\n    await this.withLock(async () => {\n      await AsyncStorage.removeItem(this.storageKey);\n    });\n  }\n\n  async removeByTimestamps(timestamps: number[]): Promise<void> {\n    if (timestamps.length === 0) return;\n\n    const timestampSet = new Set(timestamps);\n\n    await this.withLock(async () => {\n      const payloads = await this.readAllInternal();\n      const remaining = payloads.filter((p) => !timestampSet.has(p.timestamp));\n      await this.writeAll(remaining);\n    });\n  }\n\n  async getCount(): Promise<number> {\n    const payloads = await this.readAllInternal();\n    return payloads.length;\n  }\n\n  /**\n   * Execute an operation with a mutex lock to ensure thread-safe access.\n   * Follows Flutter SDK's Completer-based lock pattern.\n   */\n  private async withLock<T>(operation: () => Promise<T>): Promise<T> {\n    const currentLock = this.lockPromise;\n    let resolveLock: () => void;\n    this.lockPromise = new Promise<void>((resolve) => {\n      resolveLock = resolve;\n    });\n\n    try {\n      await currentLock;\n      return await operation();\n    } finally {\n      resolveLock!();\n    }\n  }\n\n  private async readAllInternal(): Promise<CachedPayload[]> {\n    try {\n      const data = await AsyncStorage.getItem(this.storageKey);\n      if (!data) {\n        return [];\n      }\n\n      const parsed = JSON.parse(data);\n      if (!Array.isArray(parsed)) {\n        return [];\n      }\n\n      return parsed.filter(this.isValidCachedPayload);\n    } catch {\n      // If parsing fails, return empty array\n      return [];\n    }\n  }\n\n  private async writeAll(payloads: CachedPayload[]): Promise<void> {\n    if (payloads.length === 0) {\n      await AsyncStorage.removeItem(this.storageKey);\n    } else {\n      await AsyncStorage.setItem(this.storageKey, JSON.stringify(payloads));\n    }\n  }\n\n  private isValidCachedPayload(payload: unknown): payload is CachedPayload {\n    if (typeof payload !== 'object' || payload === null) {\n      return false;\n    }\n\n    const p = payload as Record<string, unknown>;\n    return typeof p['timestamp'] === 'number' && Array.isArray(p['items']);\n  }\n}\n"]}

package/dist/cjs/transports/offline/index.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultConnectivityService = exports.AsyncStorageOfflineCache = exports.OfflineTransport = void 0;
+var transport_1 = require("./transport");
+Object.defineProperty(exports, "OfflineTransport", { enumerable: true, get: function () { return transport_1.OfflineTransport; } });
+var OfflineCache_1 = require("./OfflineCache");
+Object.defineProperty(exports, "AsyncStorageOfflineCache", { enumerable: true, get: function () { return OfflineCache_1.AsyncStorageOfflineCache; } });
+var ConnectivityService_1 = require("./ConnectivityService");
+Object.defineProperty(exports, "DefaultConnectivityService", { enumerable: true, get: function () { return ConnectivityService_1.DefaultConnectivityService; } });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/transports/offline/index.ts"],"names":[],"mappings":";;;AAAA,yCAA+C;AAAtC,6GAAA,gBAAgB,OAAA;AACzB,+CAA0D;AAAjD,wHAAA,wBAAwB,OAAA;AACjC,6DAAmE;AAA1D,iIAAA,0BAA0B,OAAA","sourcesContent":["export { OfflineTransport } from './transport';\nexport { AsyncStorageOfflineCache } from './OfflineCache';\nexport { DefaultConnectivityService } from './ConnectivityService';\nexport type { CachedPayload, ConnectivityService, OfflineCache, OfflineTransportOptions } from './types';\n"]}

package/dist/cjs/transports/offline/transport.js

@@ -0,0 +1,335 @@
+"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 __());
+    };
+})();
+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 };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OfflineTransport = void 0;
+var faro_core_1 = require("@grafana/faro-core");
+var ConnectivityService_1 = require("./ConnectivityService");
+var OfflineCache_1 = require("./OfflineCache");
+/**
+ * Default maximum cache duration: 3 days in milliseconds.
+ */
+var DEFAULT_MAX_CACHE_DURATION_MS = 3 * 24 * 60 * 60 * 1000;
+/**
+ * OfflineTransport - Caches telemetry when offline and replays when online.
+ *
+ * This transport wraps other transports and provides offline caching functionality.
+ * When the device is offline, telemetry is cached to AsyncStorage.
+ * When connectivity is restored, cached telemetry is replayed through the wrapped transports.
+ *
+ * Implementation follows Flutter SDK's OfflineTransport pattern:
+ * - Uses AsyncStorage for persistent caching (matching Flutter's SharedPreferences)
+ * - Respects maxCacheDuration to skip expired entries
+ * - Uses mutex pattern for thread-safe cache access
+ * - Excludes itself when replaying to prevent infinite loops
+ *
+ * @example
+ * ```typescript
+ * import { initializeFaro, FetchTransport, OfflineTransport } from '@grafana/faro-react-native';
+ *
+ * initializeFaro({
+ *   url: 'https://collector.example.com',
+ *   transports: [
+ *     new OfflineTransport({
+ *       maxCacheDurationMs: 3 * 24 * 60 * 60 * 1000, // 3 days
+ *     }),
+ *     new FetchTransport({ url: 'https://collector.example.com' }),
+ *   ],
+ * });
+ * ```
+ */
+var OfflineTransport = /** @class */ (function (_super) {
+    __extends(OfflineTransport, _super);
+    function OfflineTransport(options) {
+        if (options === void 0) { options = {}; }
+        var _a;
+        var _this = _super.call(this) || this;
+        _this.name = '@grafana/faro-react-native:transport-offline';
+        _this.version = faro_core_1.VERSION;
+        _this.otherTransports = [];
+        _this.unsubscribeConnectivity = null;
+        _this.isReplaying = false;
+        _this.maxCacheDurationMs = (_a = options.maxCacheDurationMs) !== null && _a !== void 0 ? _a : DEFAULT_MAX_CACHE_DURATION_MS;
+        _this.cache = new OfflineCache_1.AsyncStorageOfflineCache({
+            storageKeyPrefix: options.storageKeyPrefix,
+            maxCacheSize: options.maxCacheSize,
+        });
+        _this.connectivityService = new ConnectivityService_1.DefaultConnectivityService(options.connectivityCheckIntervalMs);
+        // Subscribe to connectivity changes
+        _this.unsubscribeConnectivity = _this.connectivityService.subscribe(function (isOnline) {
+            if (isOnline && !_this.isReplaying) {
+                _this.replayCachedPayloads();
+            }
+        });
+        return _this;
+    }
+    /**
+     * Send telemetry items.
+     *
+     * When offline, items are cached for later replay.
+     * When online, this transport does nothing (other transports handle sending).
+     */
+    OfflineTransport.prototype.send = function (items) {
+        return __awaiter(this, void 0, void 0, function () {
+            var itemsArray, payload, error_1;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        itemsArray = Array.isArray(items) ? items : [items];
+                        if (itemsArray.length === 0) {
+                            return [2 /*return*/];
+                        }
+                        if (!!this.connectivityService.isOnline) return [3 /*break*/, 4];
+                        payload = {
+                            timestamp: Date.now(),
+                            items: itemsArray,
+                        };
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 3, , 4]);
+                        return [4 /*yield*/, this.cache.write(payload)];
+                    case 2:
+                        _a.sent();
+                        this.logDebug("Cached ".concat(itemsArray.length, " items for offline replay"));
+                        return [3 /*break*/, 4];
+                    case 3:
+                        error_1 = _a.sent();
+                        this.logError('Failed to cache offline payload', error_1);
+                        return [3 /*break*/, 4];
+                    case 4: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    OfflineTransport.prototype.getIgnoreUrls = function () {
+        return [];
+    };
+    OfflineTransport.prototype.isBatched = function () {
+        return true;
+    };
+    /**
+     * Register other transports for replay.
+     * Called by the transport system after initialization.
+     */
+    OfflineTransport.prototype.setOtherTransports = function (transports) {
+        this.otherTransports.length = 0;
+        for (var _i = 0, transports_1 = transports; _i < transports_1.length; _i++) {
+            var transport = transports_1[_i];
+            if (transport !== this) {
+                this.otherTransports.push(transport);
+            }
+        }
+    };
+    /**
+     * Get the current number of cached payloads.
+     */
+    OfflineTransport.prototype.getCachedCount = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, this.cache.getCount()];
+            });
+        });
+    };
+    /**
+     * Manually trigger replay of cached payloads.
+     * Useful for testing or when you want to force a replay attempt.
+     */
+    OfflineTransport.prototype.forceReplay = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (!this.connectivityService.isOnline) return [3 /*break*/, 2];
+                        return [4 /*yield*/, this.replayCachedPayloads()];
+                    case 1:
+                        _a.sent();
+                        _a.label = 2;
+                    case 2: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Clear all cached payloads.
+     */
+    OfflineTransport.prototype.clearCache = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cache.clear()];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Clean up resources.
+     */
+    OfflineTransport.prototype.dispose = function () {
+        if (this.unsubscribeConnectivity) {
+            this.unsubscribeConnectivity();
+            this.unsubscribeConnectivity = null;
+        }
+        this.connectivityService.dispose();
+    };
+    /**
+     * Replay cached payloads through other transports.
+     * Follows Flutter SDK's _readFromFile pattern.
+     */
+    OfflineTransport.prototype.replayCachedPayloads = function () {
+        return __awaiter(this, void 0, void 0, function () {
+            var payloads, now, successfulTimestamps, _i, payloads_1, payload, success, error_2;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (this.isReplaying) {
+                            return [2 /*return*/];
+                        }
+                        this.isReplaying = true;
+                        _a.label = 1;
+                    case 1:
+                        _a.trys.push([1, 9, 10, 11]);
+                        return [4 /*yield*/, this.cache.readAll()];
+                    case 2:
+                        payloads = _a.sent();
+                        if (payloads.length === 0) {
+                            return [2 /*return*/];
+                        }
+                        this.logDebug("Replaying ".concat(payloads.length, " cached payloads"));
+                        now = Date.now();
+                        successfulTimestamps = [];
+                        _i = 0, payloads_1 = payloads;
+                        _a.label = 3;
+                    case 3:
+                        if (!(_i < payloads_1.length)) return [3 /*break*/, 6];
+                        payload = payloads_1[_i];
+                        // Skip expired payloads
+                        if (now - payload.timestamp > this.maxCacheDurationMs) {
+                            this.logDebug("Skipping expired payload from ".concat(new Date(payload.timestamp).toISOString()));
+                            successfulTimestamps.push(payload.timestamp);
+                            return [3 /*break*/, 5];
+                        }
+                        return [4 /*yield*/, this.sendToOtherTransports(payload.items)];
+                    case 4:
+                        success = _a.sent();
+                        if (success) {
+                            successfulTimestamps.push(payload.timestamp);
+                        }
+                        _a.label = 5;
+                    case 5:
+                        _i++;
+                        return [3 /*break*/, 3];
+                    case 6:
+                        if (!(successfulTimestamps.length > 0)) return [3 /*break*/, 8];
+                        return [4 /*yield*/, this.cache.removeByTimestamps(successfulTimestamps)];
+                    case 7:
+                        _a.sent();
+                        this.logDebug("Removed ".concat(successfulTimestamps.length, " payloads from cache"));
+                        _a.label = 8;
+                    case 8: return [3 /*break*/, 11];
+                    case 9:
+                        error_2 = _a.sent();
+                        this.logError('Failed to replay cached payloads', error_2);
+                        return [3 /*break*/, 11];
+                    case 10:
+                        this.isReplaying = false;
+                        return [7 /*endfinally*/];
+                    case 11: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Send items to all other registered transports.
+     * Follows Flutter SDK's _sendCachedData pattern.
+     */
+    OfflineTransport.prototype.sendToOtherTransports = function (items) {
+        return __awaiter(this, void 0, void 0, function () {
+            var _i, _a, transport, error_3;
+            return __generator(this, function (_b) {
+                switch (_b.label) {
+                    case 0:
+                        if (this.otherTransports.length === 0) {
+                            this.logWarn('No other transports registered for offline replay');
+                            return [2 /*return*/, false];
+                        }
+                        _b.label = 1;
+                    case 1:
+                        _b.trys.push([1, 6, , 7]);
+                        _i = 0, _a = this.otherTransports;
+                        _b.label = 2;
+                    case 2:
+                        if (!(_i < _a.length)) return [3 /*break*/, 5];
+                        transport = _a[_i];
+                        return [4 /*yield*/, transport.send(items)];
+                    case 3:
+                        _b.sent();
+                        _b.label = 4;
+                    case 4:
+                        _i++;
+                        return [3 /*break*/, 2];
+                    case 5: return [2 /*return*/, true];
+                    case 6:
+                        error_3 = _b.sent();
+                        this.logError('Failed to send cached payload to transports', error_3);
+                        return [2 /*return*/, false];
+                    case 7: return [2 /*return*/];
+                }
+            });
+        });
+    };
+    return OfflineTransport;
+}(faro_core_1.BaseTransport));
+exports.OfflineTransport = OfflineTransport;
+//# sourceMappingURL=transport.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"transport.js","sourceRoot":"","sources":["../../../../src/transports/offline/transport.ts"],"names":[],"mappings":"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","sourcesContent":["import { BaseTransport, VERSION } from '@grafana/faro-core';\nimport type { Patterns, Transport, TransportItem } from '@grafana/faro-core';\n\nimport { DefaultConnectivityService } from './ConnectivityService';\nimport { AsyncStorageOfflineCache } from './OfflineCache';\nimport type { CachedPayload, ConnectivityService, OfflineCache, OfflineTransportOptions } from './types';\n\n/**\n * Default maximum cache duration: 3 days in milliseconds.\n */\nconst DEFAULT_MAX_CACHE_DURATION_MS = 3 * 24 * 60 * 60 * 1000;\n\n/**\n * OfflineTransport - Caches telemetry when offline and replays when online.\n *\n * This transport wraps other transports and provides offline caching functionality.\n * When the device is offline, telemetry is cached to AsyncStorage.\n * When connectivity is restored, cached telemetry is replayed through the wrapped transports.\n *\n * Implementation follows Flutter SDK's OfflineTransport pattern:\n * - Uses AsyncStorage for persistent caching (matching Flutter's SharedPreferences)\n * - Respects maxCacheDuration to skip expired entries\n * - Uses mutex pattern for thread-safe cache access\n * - Excludes itself when replaying to prevent infinite loops\n *\n * @example\n * ```typescript\n * import { initializeFaro, FetchTransport, OfflineTransport } from '@grafana/faro-react-native';\n *\n * initializeFaro({\n *   url: 'https://collector.example.com',\n *   transports: [\n *     new OfflineTransport({\n *       maxCacheDurationMs: 3 * 24 * 60 * 60 * 1000, // 3 days\n *     }),\n *     new FetchTransport({ url: 'https://collector.example.com' }),\n *   ],\n * });\n * ```\n */\nexport class OfflineTransport extends BaseTransport {\n  readonly name = '@grafana/faro-react-native:transport-offline';\n  readonly version = VERSION;\n\n  private readonly cache: OfflineCache;\n  private readonly connectivityService: ConnectivityService;\n  private readonly maxCacheDurationMs: number;\n  private readonly otherTransports: Transport[] = [];\n  private unsubscribeConnectivity: (() => void) | null = null;\n  private isReplaying: boolean = false;\n\n  constructor(options: OfflineTransportOptions = {}) {\n    super();\n\n    this.maxCacheDurationMs = options.maxCacheDurationMs ?? DEFAULT_MAX_CACHE_DURATION_MS;\n\n    this.cache = new AsyncStorageOfflineCache({\n      storageKeyPrefix: options.storageKeyPrefix,\n      maxCacheSize: options.maxCacheSize,\n    });\n\n    this.connectivityService = new DefaultConnectivityService(options.connectivityCheckIntervalMs);\n\n    // Subscribe to connectivity changes\n    this.unsubscribeConnectivity = this.connectivityService.subscribe((isOnline) => {\n      if (isOnline && !this.isReplaying) {\n        this.replayCachedPayloads();\n      }\n    });\n  }\n\n  /**\n   * Send telemetry items.\n   *\n   * When offline, items are cached for later replay.\n   * When online, this transport does nothing (other transports handle sending).\n   */\n  async send(items: TransportItem | TransportItem[]): Promise<void> {\n    const itemsArray = Array.isArray(items) ? items : [items];\n\n    if (itemsArray.length === 0) {\n      return;\n    }\n\n    if (!this.connectivityService.isOnline) {\n      // Cache items when offline\n      const payload: CachedPayload = {\n        timestamp: Date.now(),\n        items: itemsArray,\n      };\n\n      try {\n        await this.cache.write(payload);\n        this.logDebug(`Cached ${itemsArray.length} items for offline replay`);\n      } catch (error) {\n        this.logError('Failed to cache offline payload', error);\n      }\n    }\n    // When online, do nothing - other transports handle sending\n  }\n\n  override getIgnoreUrls(): Patterns {\n    return [];\n  }\n\n  override isBatched(): boolean {\n    return true;\n  }\n\n  /**\n   * Register other transports for replay.\n   * Called by the transport system after initialization.\n   */\n  setOtherTransports(transports: Transport[]): void {\n    this.otherTransports.length = 0;\n    for (const transport of transports) {\n      if (transport !== this) {\n        this.otherTransports.push(transport);\n      }\n    }\n  }\n\n  /**\n   * Get the current number of cached payloads.\n   */\n  async getCachedCount(): Promise<number> {\n    return this.cache.getCount();\n  }\n\n  /**\n   * Manually trigger replay of cached payloads.\n   * Useful for testing or when you want to force a replay attempt.\n   */\n  async forceReplay(): Promise<void> {\n    if (this.connectivityService.isOnline) {\n      await this.replayCachedPayloads();\n    }\n  }\n\n  /**\n   * Clear all cached payloads.\n   */\n  async clearCache(): Promise<void> {\n    await this.cache.clear();\n  }\n\n  /**\n   * Clean up resources.\n   */\n  dispose(): void {\n    if (this.unsubscribeConnectivity) {\n      this.unsubscribeConnectivity();\n      this.unsubscribeConnectivity = null;\n    }\n    this.connectivityService.dispose();\n  }\n\n  /**\n   * Replay cached payloads through other transports.\n   * Follows Flutter SDK's _readFromFile pattern.\n   */\n  private async replayCachedPayloads(): Promise<void> {\n    if (this.isReplaying) {\n      return;\n    }\n\n    this.isReplaying = true;\n\n    try {\n      const payloads = await this.cache.readAll();\n\n      if (payloads.length === 0) {\n        return;\n      }\n\n      this.logDebug(`Replaying ${payloads.length} cached payloads`);\n\n      const now = Date.now();\n      const successfulTimestamps: number[] = [];\n\n      for (const payload of payloads) {\n        // Skip expired payloads\n        if (now - payload.timestamp > this.maxCacheDurationMs) {\n          this.logDebug(`Skipping expired payload from ${new Date(payload.timestamp).toISOString()}`);\n          successfulTimestamps.push(payload.timestamp);\n          continue;\n        }\n\n        const success = await this.sendToOtherTransports(payload.items);\n\n        if (success) {\n          successfulTimestamps.push(payload.timestamp);\n        }\n      }\n\n      // Remove successfully sent or expired payloads\n      if (successfulTimestamps.length > 0) {\n        await this.cache.removeByTimestamps(successfulTimestamps);\n        this.logDebug(`Removed ${successfulTimestamps.length} payloads from cache`);\n      }\n    } catch (error) {\n      this.logError('Failed to replay cached payloads', error);\n    } finally {\n      this.isReplaying = false;\n    }\n  }\n\n  /**\n   * Send items to all other registered transports.\n   * Follows Flutter SDK's _sendCachedData pattern.\n   */\n  private async sendToOtherTransports(items: TransportItem[]): Promise<boolean> {\n    if (this.otherTransports.length === 0) {\n      this.logWarn('No other transports registered for offline replay');\n      return false;\n    }\n\n    try {\n      for (const transport of this.otherTransports) {\n        await transport.send(items);\n      }\n      return true;\n    } catch (error) {\n      this.logError('Failed to send cached payload to transports', error);\n      return false;\n    }\n  }\n}\n"]}

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

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