@doow/track-react-native 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Doow
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,171 @@
+# Doow Track React Native SDK
+
+[![React Native](https://img.shields.io/badge/React%20Native-0.70+-blue)](https://reactnative.dev/)
+[![Expo](https://img.shields.io/badge/Expo-Compatible-blue)](https://expo.dev/)
+[![License](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+Official React Native SDK for [Doow](https://doow.co) usage telemetry. Works with React Native CLI and Expo.
+
+## Features
+
+| Feature | Description |
+|---------|-------------|
+| **React Native 0.70+** | Hooks and Context API |
+| **Expo** | Works with Expo managed and bare workflows |
+| **Batching** | Events queued and sent in configurable batches |
+| **Persistence** | Queue survives app restarts via AsyncStorage |
+| **AppState** | Auto-flush on background/inactive |
+| **Navigation** | `useTrackOnFocus` hook for screen tracking |
+
+---
+
+## Installation
+
+```bash
+npm install @doow/track-react-native @react-native-async-storage/async-storage
+# or
+yarn add @doow/track-react-native @react-native-async-storage/async-storage
+```
+
+### Expo
+
+```bash
+npx expo install @doow/track-react-native @react-native-async-storage/async-storage
+```
+
+---
+
+## Quick Start
+
+### Provider Setup
+
+```tsx
+import { DoowProvider } from '@doow/track-react-native';
+
+export default function App() {
+  return (
+    <DoowProvider apiKey="dk_your_api_key">
+      <Navigation />
+    </DoowProvider>
+  );
+}
+```
+
+### Track Events
+
+```tsx
+import { useTrackEvent } from '@doow/track-react-native';
+
+function FeatureButton() {
+  const track = useTrackEvent();
+
+  const handlePress = () => {
+    track({
+      metric: 'feature_usage',
+      quantity: 1,
+      licenseId: 'lic_abc123',
+      attribution: { feature: 'export' },
+    });
+  };
+
+  return <Button onPress={handlePress} title="Export" />;
+}
+```
+
+### Track Screen Views
+
+```tsx
+import { useTrackOnFocus } from '@doow/track-react-native';
+import { useNavigation } from '@react-navigation/native';
+
+function DashboardScreen() {
+  const navigation = useNavigation();
+
+  useTrackOnFocus(navigation, {
+    metric: 'screen_view',
+    quantity: 1,
+    licenseId: 'lic_abc123',
+    attribution: { screen: 'dashboard' },
+  });
+
+  return <View>...</View>;
+}
+```
+
+### Track on Mount
+
+```tsx
+import { useTrackOnMount } from '@doow/track-react-native';
+
+function OnboardingComplete() {
+  useTrackOnMount({
+    metric: 'onboarding_complete',
+    quantity: 1,
+    licenseId: 'lic_abc123',
+  });
+
+  return <Text>Welcome!</Text>;
+}
+```
+
+---
+
+## Configuration
+
+```tsx
+<DoowProvider
+  apiKey="dk_your_api_key"
+  options={{
+    endpoint: 'https://api.doow.co',
+    enabled: true,
+    debug: __DEV__,
+    flushAt: 20,
+    flushIntervalMs: 10000,
+    maxQueueSize: 10000,
+    timeoutMs: 10000,
+    retryCount: 3,
+    persistQueue: true,
+    attribution: { app: 'my-mobile-app', platform: Platform.OS },
+    onError: (e) => console.error('Doow error:', e),
+  }}
+>
+  <App />
+</DoowProvider>
+```
+
+---
+
+## Hooks
+
+| Hook | Description |
+|------|-------------|
+| `useDoow()` | Full context: `{ track, flush, isEnabled }` |
+| `useTrackEvent()` | Just the `track` function |
+| `useTrackOnMount(event)` | Track once on component mount |
+| `useTrackOnFocus(navigation, event)` | Track on React Navigation focus |
+
+---
+
+## Manual Tracker (No Provider)
+
+```tsx
+import { Tracker } from '@doow/track-react-native';
+
+const tracker = new Tracker('dk_your_api_key', { debug: true });
+await tracker.init();
+
+tracker.track({
+  metric: 'api_calls',
+  quantity: 1,
+  licenseId: 'lic_abc123',
+});
+
+// On app shutdown
+await tracker.destroy();
+```
+
+---
+
+## License
+
+MIT

package/dist/index.d.mts

@@ -0,0 +1,62 @@
+interface TrackEvent {
+    metric: string;
+    quantity: number;
+    licenseId: string;
+    unit?: string;
+    attribution?: Record<string, unknown>;
+    timestamp?: string;
+}
+interface TrackerOptions {
+    endpoint?: string;
+    enabled?: boolean;
+    debug?: boolean;
+    flushAt?: number;
+    flushIntervalMs?: number;
+    maxQueueSize?: number;
+    timeoutMs?: number;
+    retryCount?: number;
+    persistQueue?: boolean;
+    attribution?: Record<string, unknown>;
+    onError?: (error: Error) => void;
+}
+interface DoowContextValue {
+    track: (event: TrackEvent) => void;
+    flush: () => Promise<void>;
+    isEnabled: boolean;
+}
+interface DoowProviderProps {
+    apiKey: string;
+    options?: TrackerOptions;
+    children: React.ReactNode;
+}
+
+declare class Tracker {
+    private apiKey;
+    private options;
+    private queue;
+    private flushTimer;
+    private shutdown;
+    private appStateSubscription;
+    constructor(apiKey: string, options?: TrackerOptions);
+    init(): Promise<void>;
+    private loadQueue;
+    private persistQueue;
+    private startFlushTimer;
+    private setupAppStateListener;
+    private log;
+    track(event: TrackEvent): void;
+    flush(): Promise<void>;
+    private sendWithRetry;
+    private sleep;
+    destroy(): Promise<void>;
+}
+
+declare function DoowProvider({ apiKey, options, children }: DoowProviderProps): JSX.Element;
+declare function useDoow(): DoowContextValue;
+declare function useTrackEvent(): (event: TrackEvent) => void;
+declare function useTrackOnMount(event: TrackEvent): void;
+declare function useTrackOnFocus(navigation: {
+    addListener: (event: string, callback: () => void) => () => void;
+}, event: TrackEvent): void;
+
+export { type DoowContextValue, DoowProvider, type DoowProviderProps, type TrackEvent, Tracker, type TrackerOptions, useDoow, useTrackEvent, useTrackOnFocus, useTrackOnMount };

package/dist/index.d.ts

@@ -0,0 +1,62 @@
+interface TrackEvent {
+    metric: string;
+    quantity: number;
+    licenseId: string;
+    unit?: string;
+    attribution?: Record<string, unknown>;
+    timestamp?: string;
+}
+interface TrackerOptions {
+    endpoint?: string;
+    enabled?: boolean;
+    debug?: boolean;
+    flushAt?: number;
+    flushIntervalMs?: number;
+    maxQueueSize?: number;
+    timeoutMs?: number;
+    retryCount?: number;
+    persistQueue?: boolean;
+    attribution?: Record<string, unknown>;
+    onError?: (error: Error) => void;
+}
+interface DoowContextValue {
+    track: (event: TrackEvent) => void;
+    flush: () => Promise<void>;
+    isEnabled: boolean;
+}
+interface DoowProviderProps {
+    apiKey: string;
+    options?: TrackerOptions;
+    children: React.ReactNode;
+}
+
+declare class Tracker {
+    private apiKey;
+    private options;
+    private queue;
+    private flushTimer;
+    private shutdown;
+    private appStateSubscription;
+    constructor(apiKey: string, options?: TrackerOptions);
+    init(): Promise<void>;
+    private loadQueue;
+    private persistQueue;
+    private startFlushTimer;
+    private setupAppStateListener;
+    private log;
+    track(event: TrackEvent): void;
+    flush(): Promise<void>;
+    private sendWithRetry;
+    private sleep;
+    destroy(): Promise<void>;
+}
+
+declare function DoowProvider({ apiKey, options, children }: DoowProviderProps): JSX.Element;
+declare function useDoow(): DoowContextValue;
+declare function useTrackEvent(): (event: TrackEvent) => void;
+declare function useTrackOnMount(event: TrackEvent): void;
+declare function useTrackOnFocus(navigation: {
+    addListener: (event: string, callback: () => void) => () => void;
+}, event: TrackEvent): void;
+
+export { type DoowContextValue, DoowProvider, type DoowProviderProps, type TrackEvent, Tracker, type TrackerOptions, useDoow, useTrackEvent, useTrackOnFocus, useTrackOnMount };

package/dist/index.js

@@ -0,0 +1,273 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DoowProvider: () => DoowProvider,
+  Tracker: () => Tracker,
+  useDoow: () => useDoow,
+  useTrackEvent: () => useTrackEvent,
+  useTrackOnFocus: () => useTrackOnFocus,
+  useTrackOnMount: () => useTrackOnMount
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/tracker.ts
+var import_react_native = require("react-native");
+var import_async_storage = __toESM(require("@react-native-async-storage/async-storage"));
+function generateUUID() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+var STORAGE_KEY = "@doow/track/queue";
+var DEFAULT_OPTIONS = {
+  endpoint: "https://api.doow.co",
+  enabled: true,
+  debug: false,
+  flushAt: 20,
+  flushIntervalMs: 1e4,
+  maxQueueSize: 1e4,
+  timeoutMs: 1e4,
+  retryCount: 3,
+  persistQueue: true
+};
+var Tracker = class {
+  constructor(apiKey, options = {}) {
+    this.queue = [];
+    this.flushTimer = null;
+    this.shutdown = false;
+    this.appStateSubscription = null;
+    if (!apiKey.startsWith("dk_")) {
+      throw new Error("API key must start with dk_");
+    }
+    this.apiKey = apiKey;
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+  async init() {
+    if (this.options.persistQueue) {
+      await this.loadQueue();
+    }
+    this.startFlushTimer();
+    this.setupAppStateListener();
+  }
+  async loadQueue() {
+    try {
+      const stored = await import_async_storage.default.getItem(STORAGE_KEY);
+      if (stored) {
+        this.queue = JSON.parse(stored);
+        this.log(`Loaded ${this.queue.length} events from storage`);
+      }
+    } catch (error) {
+      this.log(`Failed to load queue: ${error}`);
+    }
+  }
+  async persistQueue() {
+    if (!this.options.persistQueue) return;
+    try {
+      await import_async_storage.default.setItem(STORAGE_KEY, JSON.stringify(this.queue));
+    } catch (error) {
+      this.log(`Failed to persist queue: ${error}`);
+    }
+  }
+  startFlushTimer() {
+    if (this.flushTimer) clearInterval(this.flushTimer);
+    this.flushTimer = setInterval(() => this.flush(), this.options.flushIntervalMs);
+  }
+  setupAppStateListener() {
+    this.appStateSubscription = import_react_native.AppState.addEventListener("change", (state) => {
+      if (state === "background" || state === "inactive") {
+        this.flush();
+      }
+    });
+  }
+  log(message) {
+    if (this.options.debug) {
+      console.log(`[DoowTrack] ${message}`);
+    }
+  }
+  track(event) {
+    if (!this.options.enabled || this.shutdown) return;
+    if (this.queue.length >= this.options.maxQueueSize) {
+      this.log("Queue full, dropping event");
+      return;
+    }
+    const enrichedEvent = {
+      ...event,
+      timestamp: event.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+      attribution: { ...event.attribution, ...this.options.attribution }
+    };
+    this.queue.push(enrichedEvent);
+    this.persistQueue();
+    this.log(`Queued event: ${event.metric}`);
+    if (this.queue.length >= this.options.flushAt) {
+      this.flush();
+    }
+  }
+  async flush() {
+    if (this.queue.length === 0 || this.shutdown) return;
+    const batch = [...this.queue];
+    this.queue = [];
+    await this.persistQueue();
+    this.log(`Flushing ${batch.length} events`);
+    try {
+      await this.sendWithRetry(batch);
+    } catch (error) {
+      this.queue = [...batch, ...this.queue];
+      await this.persistQueue();
+      this.options.onError?.(error);
+      this.log(`Flush failed: ${error}`);
+    }
+  }
+  async sendWithRetry(batch) {
+    const payload = JSON.stringify({
+      events: batch.map((e) => ({
+        event_id: generateUUID(),
+        metric: e.metric,
+        quantity: e.quantity,
+        license_id: e.licenseId,
+        unit: e.unit,
+        attribution: e.attribution,
+        timestamp: e.timestamp
+      }))
+    });
+    for (let attempt = 0; attempt <= this.options.retryCount; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.options.timeoutMs);
+        const response = await fetch(`${this.options.endpoint}/telemetry/events`, {
+          method: "POST",
+          headers: {
+            "Authorization": `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json"
+          },
+          body: payload,
+          signal: controller.signal
+        });
+        clearTimeout(timeout);
+        if (response.ok) {
+          this.log("Batch sent successfully");
+          return;
+        }
+        if (response.status === 429) {
+          const retryAfter = response.headers.get("Retry-After");
+          const delay = retryAfter ? parseInt(retryAfter, 10) * 1e3 : 100 * Math.pow(2, attempt);
+          await this.sleep(delay);
+          continue;
+        }
+        if (response.status >= 500) {
+          await this.sleep(100 * Math.pow(2, attempt));
+          continue;
+        }
+        throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+      } catch (error) {
+        if (attempt === this.options.retryCount) throw error;
+        await this.sleep(100 * Math.pow(2, attempt));
+      }
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  async destroy() {
+    this.shutdown = true;
+    if (this.flushTimer) clearInterval(this.flushTimer);
+    this.appStateSubscription?.remove();
+    await this.flush();
+  }
+};
+
+// src/context.tsx
+var import_react = require("react");
+var import_jsx_runtime = require("react/jsx-runtime");
+var DoowContext = (0, import_react.createContext)(null);
+function DoowProvider({ apiKey, options, children }) {
+  const trackerRef = (0, import_react.useRef)(null);
+  const [ready, setReady] = (0, import_react.useState)(false);
+  (0, import_react.useEffect)(() => {
+    const tracker = new Tracker(apiKey, options);
+    trackerRef.current = tracker;
+    tracker.init().then(() => setReady(true));
+    return () => {
+      tracker.destroy();
+    };
+  }, [apiKey]);
+  const value = (0, import_react.useMemo)(
+    () => ({
+      track: (event) => trackerRef.current?.track(event),
+      flush: () => trackerRef.current?.flush() ?? Promise.resolve(),
+      isEnabled: options?.enabled !== false
+    }),
+    [options?.enabled]
+  );
+  if (!ready) return null;
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)(DoowContext.Provider, { value, children });
+}
+function useDoow() {
+  const context = (0, import_react.useContext)(DoowContext);
+  if (!context) {
+    throw new Error("useDoow must be used within a DoowProvider");
+  }
+  return context;
+}
+function useTrackEvent() {
+  const { track } = useDoow();
+  return track;
+}
+function useTrackOnMount(event) {
+  const { track } = useDoow();
+  const tracked = (0, import_react.useRef)(false);
+  (0, import_react.useEffect)(() => {
+    if (!tracked.current) {
+      track(event);
+      tracked.current = true;
+    }
+  }, []);
+}
+function useTrackOnFocus(navigation, event) {
+  const { track } = useDoow();
+  (0, import_react.useEffect)(() => {
+    const unsubscribe = navigation.addListener("focus", () => {
+      track(event);
+    });
+    return unsubscribe;
+  }, [navigation, event, track]);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DoowProvider,
+  Tracker,
+  useDoow,
+  useTrackEvent,
+  useTrackOnFocus,
+  useTrackOnMount
+});

package/dist/index.mjs

@@ -0,0 +1,231 @@
+// src/tracker.ts
+import { AppState } from "react-native";
+import AsyncStorage from "@react-native-async-storage/async-storage";
+function generateUUID() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+var STORAGE_KEY = "@doow/track/queue";
+var DEFAULT_OPTIONS = {
+  endpoint: "https://api.doow.co",
+  enabled: true,
+  debug: false,
+  flushAt: 20,
+  flushIntervalMs: 1e4,
+  maxQueueSize: 1e4,
+  timeoutMs: 1e4,
+  retryCount: 3,
+  persistQueue: true
+};
+var Tracker = class {
+  constructor(apiKey, options = {}) {
+    this.queue = [];
+    this.flushTimer = null;
+    this.shutdown = false;
+    this.appStateSubscription = null;
+    if (!apiKey.startsWith("dk_")) {
+      throw new Error("API key must start with dk_");
+    }
+    this.apiKey = apiKey;
+    this.options = { ...DEFAULT_OPTIONS, ...options };
+  }
+  async init() {
+    if (this.options.persistQueue) {
+      await this.loadQueue();
+    }
+    this.startFlushTimer();
+    this.setupAppStateListener();
+  }
+  async loadQueue() {
+    try {
+      const stored = await AsyncStorage.getItem(STORAGE_KEY);
+      if (stored) {
+        this.queue = JSON.parse(stored);
+        this.log(`Loaded ${this.queue.length} events from storage`);
+      }
+    } catch (error) {
+      this.log(`Failed to load queue: ${error}`);
+    }
+  }
+  async persistQueue() {
+    if (!this.options.persistQueue) return;
+    try {
+      await AsyncStorage.setItem(STORAGE_KEY, JSON.stringify(this.queue));
+    } catch (error) {
+      this.log(`Failed to persist queue: ${error}`);
+    }
+  }
+  startFlushTimer() {
+    if (this.flushTimer) clearInterval(this.flushTimer);
+    this.flushTimer = setInterval(() => this.flush(), this.options.flushIntervalMs);
+  }
+  setupAppStateListener() {
+    this.appStateSubscription = AppState.addEventListener("change", (state) => {
+      if (state === "background" || state === "inactive") {
+        this.flush();
+      }
+    });
+  }
+  log(message) {
+    if (this.options.debug) {
+      console.log(`[DoowTrack] ${message}`);
+    }
+  }
+  track(event) {
+    if (!this.options.enabled || this.shutdown) return;
+    if (this.queue.length >= this.options.maxQueueSize) {
+      this.log("Queue full, dropping event");
+      return;
+    }
+    const enrichedEvent = {
+      ...event,
+      timestamp: event.timestamp || (/* @__PURE__ */ new Date()).toISOString(),
+      attribution: { ...event.attribution, ...this.options.attribution }
+    };
+    this.queue.push(enrichedEvent);
+    this.persistQueue();
+    this.log(`Queued event: ${event.metric}`);
+    if (this.queue.length >= this.options.flushAt) {
+      this.flush();
+    }
+  }
+  async flush() {
+    if (this.queue.length === 0 || this.shutdown) return;
+    const batch = [...this.queue];
+    this.queue = [];
+    await this.persistQueue();
+    this.log(`Flushing ${batch.length} events`);
+    try {
+      await this.sendWithRetry(batch);
+    } catch (error) {
+      this.queue = [...batch, ...this.queue];
+      await this.persistQueue();
+      this.options.onError?.(error);
+      this.log(`Flush failed: ${error}`);
+    }
+  }
+  async sendWithRetry(batch) {
+    const payload = JSON.stringify({
+      events: batch.map((e) => ({
+        event_id: generateUUID(),
+        metric: e.metric,
+        quantity: e.quantity,
+        license_id: e.licenseId,
+        unit: e.unit,
+        attribution: e.attribution,
+        timestamp: e.timestamp
+      }))
+    });
+    for (let attempt = 0; attempt <= this.options.retryCount; attempt++) {
+      try {
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), this.options.timeoutMs);
+        const response = await fetch(`${this.options.endpoint}/telemetry/events`, {
+          method: "POST",
+          headers: {
+            "Authorization": `Bearer ${this.apiKey}`,
+            "Content-Type": "application/json"
+          },
+          body: payload,
+          signal: controller.signal
+        });
+        clearTimeout(timeout);
+        if (response.ok) {
+          this.log("Batch sent successfully");
+          return;
+        }
+        if (response.status === 429) {
+          const retryAfter = response.headers.get("Retry-After");
+          const delay = retryAfter ? parseInt(retryAfter, 10) * 1e3 : 100 * Math.pow(2, attempt);
+          await this.sleep(delay);
+          continue;
+        }
+        if (response.status >= 500) {
+          await this.sleep(100 * Math.pow(2, attempt));
+          continue;
+        }
+        throw new Error(`HTTP ${response.status}: ${await response.text()}`);
+      } catch (error) {
+        if (attempt === this.options.retryCount) throw error;
+        await this.sleep(100 * Math.pow(2, attempt));
+      }
+    }
+  }
+  sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+  async destroy() {
+    this.shutdown = true;
+    if (this.flushTimer) clearInterval(this.flushTimer);
+    this.appStateSubscription?.remove();
+    await this.flush();
+  }
+};
+
+// src/context.tsx
+import { createContext, useContext, useEffect, useMemo, useRef, useState } from "react";
+import { jsx } from "react/jsx-runtime";
+var DoowContext = createContext(null);
+function DoowProvider({ apiKey, options, children }) {
+  const trackerRef = useRef(null);
+  const [ready, setReady] = useState(false);
+  useEffect(() => {
+    const tracker = new Tracker(apiKey, options);
+    trackerRef.current = tracker;
+    tracker.init().then(() => setReady(true));
+    return () => {
+      tracker.destroy();
+    };
+  }, [apiKey]);
+  const value = useMemo(
+    () => ({
+      track: (event) => trackerRef.current?.track(event),
+      flush: () => trackerRef.current?.flush() ?? Promise.resolve(),
+      isEnabled: options?.enabled !== false
+    }),
+    [options?.enabled]
+  );
+  if (!ready) return null;
+  return /* @__PURE__ */ jsx(DoowContext.Provider, { value, children });
+}
+function useDoow() {
+  const context = useContext(DoowContext);
+  if (!context) {
+    throw new Error("useDoow must be used within a DoowProvider");
+  }
+  return context;
+}
+function useTrackEvent() {
+  const { track } = useDoow();
+  return track;
+}
+function useTrackOnMount(event) {
+  const { track } = useDoow();
+  const tracked = useRef(false);
+  useEffect(() => {
+    if (!tracked.current) {
+      track(event);
+      tracked.current = true;
+    }
+  }, []);
+}
+function useTrackOnFocus(navigation, event) {
+  const { track } = useDoow();
+  useEffect(() => {
+    const unsubscribe = navigation.addListener("focus", () => {
+      track(event);
+    });
+    return unsubscribe;
+  }, [navigation, event, track]);
+}
+export {
+  DoowProvider,
+  Tracker,
+  useDoow,
+  useTrackEvent,
+  useTrackOnFocus,
+  useTrackOnMount
+};

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@doow/track-react-native",
+  "version": "0.1.0",
+  "description": "Official React Native SDK for Doow usage telemetry",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup src/index.ts --format cjs,esm --dts --clean",
+    "dev": "tsup src/index.ts --format cjs,esm --dts --watch",
+    "lint": "eslint src",
+    "test": "jest"
+  },
+  "peerDependencies": {
+    "@react-native-async-storage/async-storage": ">=1.0.0",
+    "react": ">=17.0.0",
+    "react-native": ">=0.70.0"
+  },
+  "devDependencies": {
+    "@react-native-async-storage/async-storage": "^1.21.0",
+    "@types/react": "^18.2.0",
+    "@types/react-native": "^0.72.0",
+    "react": "^18.2.0",
+    "react-native": "^0.73.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.3.0"
+  },
+  "keywords": [
+    "doow",
+    "telemetry",
+    "usage",
+    "billing",
+    "react-native",
+    "expo",
+    "mobile"
+  ],
+  "author": "Doow",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Doow-Dev/doow-track-react-native.git"
+  }
+}