react-fathom 0.1.11 → 0.2.0

package/dist/es/native/index.js

@@ -0,0 +1,1071 @@
+/*! react-fathom - 0.2.0 !*/
+import React, { forwardRef, useRef, useState, useCallback, useImperativeHandle, createContext, useContext, useMemo, useEffect } from 'react';
+import { View, StyleSheet, AppState } from 'react-native';
+import { WebView } from 'react-native-webview';
+
+function _arrayWithHoles(r) {
+  if (Array.isArray(r)) return r;
+}
+
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e,
+      n,
+      i,
+      u,
+      a = [],
+      f = true,
+      o = false;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+    } catch (r) {
+      o = true, n = r;
+    } finally {
+      try {
+        if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+function _slicedToArray(r, e) {
+  return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
+}
+
+/**
+ * Hidden WebView component that loads and manages the Fathom Analytics script.
+ *
+ * This component renders an invisible WebView that loads the official Fathom
+ * tracking script, allowing React Native apps to use Fathom's full functionality.
+ *
+ * @example
+ * ```tsx
+ * const fathomRef = useRef<FathomWebViewRef>(null)
+ *
+ * <FathomWebView
+ *   ref={fathomRef}
+ *   siteId="ABCDEFGH"
+ *   onReady={() => console.log('Fathom ready!')}
+ * />
+ *
+ * // Later, track events:
+ * fathomRef.current?.trackPageview({ url: '/home' })
+ * ```
+ */
+var FathomWebView = /*#__PURE__*/forwardRef(function FathomWebView(_ref, ref) {
+  var siteId = _ref.siteId,
+    _ref$loadOptions = _ref.loadOptions,
+    loadOptions = _ref$loadOptions === void 0 ? {} : _ref$loadOptions,
+    _ref$scriptDomain = _ref.scriptDomain,
+    scriptDomain = _ref$scriptDomain === void 0 ? 'cdn.usefathom.com' : _ref$scriptDomain,
+    onReady = _ref.onReady,
+    _onError = _ref.onError,
+    _ref$debug = _ref.debug,
+    debug = _ref$debug === void 0 ? false : _ref$debug;
+  var webViewRef = useRef(null);
+  var _useState = useState(false),
+    _useState2 = _slicedToArray(_useState, 2),
+    _isReady = _useState2[0],
+    setIsReady = _useState2[1];
+  var log = useCallback(function () {
+    if (debug) {
+      var _console;
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      (_console = console).log.apply(_console, ['[react-fathom/webview]'].concat(args));
+    }
+  }, [debug]);
+
+  // Build data attributes for load options
+  var buildDataAttributes = useCallback(function () {
+    var attrs = ["data-site=\"".concat(siteId, "\"")];
+    if (loadOptions.auto === false) {
+      attrs.push('data-auto="false"');
+    }
+    if (loadOptions.honorDNT) {
+      attrs.push('data-honor-dnt="true"');
+    }
+    if (loadOptions.canonical === false) {
+      attrs.push('data-canonical="false"');
+    }
+    if (loadOptions.spa) {
+      attrs.push("data-spa=\"".concat(loadOptions.spa, "\""));
+    }
+    return attrs.join(' ');
+  }, [siteId, loadOptions]);
+
+  // HTML content that loads the Fathom script
+  var htmlContent = "\n      <!DOCTYPE html>\n      <html>\n        <head>\n          <meta name=\"viewport\" content=\"width=device-width, initial-scale=1.0\">\n          <script src=\"https://".concat(scriptDomain, "/script.js\" ").concat(buildDataAttributes(), " defer></script>\n          <script>\n            // Wait for Fathom to be available\n            function waitForFathom(callback, maxAttempts = 50) {\n              let attempts = 0;\n              const check = () => {\n                attempts++;\n                if (typeof window.fathom !== 'undefined') {\n                  callback();\n                } else if (attempts < maxAttempts) {\n                  setTimeout(check, 100);\n                } else {\n                  window.ReactNativeWebView.postMessage(JSON.stringify({\n                    type: 'error',\n                    message: 'Fathom script failed to load after ' + (maxAttempts * 100) + 'ms'\n                  }));\n                }\n              };\n              check();\n            }\n\n            // Initialize when DOM is ready\n            document.addEventListener('DOMContentLoaded', () => {\n              waitForFathom(() => {\n                window.ReactNativeWebView.postMessage(JSON.stringify({\n                  type: 'ready'\n                }));\n              });\n            });\n\n            // Handle commands from React Native\n            window.handleCommand = function(command) {\n              if (typeof window.fathom === 'undefined') {\n                console.warn('Fathom not loaded yet');\n                return;\n              }\n\n              try {\n                switch (command.action) {\n                  case 'trackPageview':\n                    window.fathom.trackPageview(command.options || {});\n                    break;\n                  case 'trackEvent':\n                    window.fathom.trackEvent(command.eventName, command.options || {});\n                    break;\n                  case 'trackGoal':\n                    window.fathom.trackGoal(command.code, command.cents);\n                    break;\n                  case 'blockTrackingForMe':\n                    window.fathom.blockTrackingForMe();\n                    break;\n                  case 'enableTrackingForMe':\n                    window.fathom.enableTrackingForMe();\n                    break;\n                  default:\n                    console.warn('Unknown command:', command.action);\n                }\n              } catch (error) {\n                window.ReactNativeWebView.postMessage(JSON.stringify({\n                  type: 'error',\n                  message: error.message\n                }));\n              }\n            };\n          </script>\n        </head>\n        <body></body>\n      </html>\n    ");
+  var injectCommand = useCallback(function (command) {
+    if (!webViewRef.current) {
+      log('WebView not available');
+      return;
+    }
+    var script = "window.handleCommand(".concat(JSON.stringify(command), "); true;");
+    webViewRef.current.injectJavaScript(script);
+    log('Injected command:', command);
+  }, [log]);
+  var handleMessage = useCallback(function (event) {
+    try {
+      var data = JSON.parse(event.nativeEvent.data);
+      switch (data.type) {
+        case 'ready':
+          log('Fathom script loaded and ready');
+          setIsReady(true);
+          onReady === null || onReady === void 0 || onReady();
+          break;
+        case 'error':
+          log('Error from WebView:', data.message);
+          _onError === null || _onError === void 0 || _onError(data.message);
+          break;
+        default:
+          log('Unknown message type:', data.type);
+      }
+    } catch (_unused) {
+      log('Failed to parse WebView message:', event.nativeEvent.data);
+    }
+  }, [log, onReady, _onError]);
+
+  // Expose methods via ref
+  useImperativeHandle(ref, function () {
+    return {
+      trackPageview: function trackPageview(opts) {
+        injectCommand({
+          action: 'trackPageview',
+          options: opts
+        });
+      },
+      trackEvent: function trackEvent(eventName, opts) {
+        injectCommand({
+          action: 'trackEvent',
+          eventName: eventName,
+          options: opts
+        });
+      },
+      trackGoal: function trackGoal(code, cents) {
+        injectCommand({
+          action: 'trackGoal',
+          code: code,
+          cents: cents
+        });
+      },
+      blockTrackingForMe: function blockTrackingForMe() {
+        injectCommand({
+          action: 'blockTrackingForMe'
+        });
+      },
+      enableTrackingForMe: function enableTrackingForMe() {
+        injectCommand({
+          action: 'enableTrackingForMe'
+        });
+      },
+      isReady: function isReady() {
+        return _isReady;
+      }
+    };
+  }, [injectCommand, _isReady]);
+  return /*#__PURE__*/React.createElement(View, {
+    style: styles.container
+  }, /*#__PURE__*/React.createElement(WebView, {
+    ref: webViewRef,
+    source: {
+      html: htmlContent
+    },
+    onMessage: handleMessage,
+    onError: function onError(syntheticEvent) {
+      var nativeEvent = syntheticEvent.nativeEvent;
+      log('WebView error:', nativeEvent);
+      _onError === null || _onError === void 0 || _onError(nativeEvent.description || 'WebView error');
+    },
+    javaScriptEnabled: true,
+    domStorageEnabled: true
+    // Hide the WebView completely
+    ,
+    style: styles.webview
+    // Prevent any user interaction
+    ,
+    scrollEnabled: false,
+    bounces: false
+    // Optimize for background operation
+    ,
+    cacheEnabled: true,
+    incognito: false
+  }));
+});
+var styles = StyleSheet.create({
+  container: {
+    position: 'absolute',
+    width: 0,
+    height: 0,
+    overflow: 'hidden'
+  },
+  webview: {
+    width: 1,
+    height: 1,
+    opacity: 0
+  }
+});
+
+/**
+ * Creates a Fathom client that communicates with a FathomWebView component.
+ *
+ * This client queues commands until the WebView is ready, then flushes them.
+ * It implements the standard FathomClient interface for compatibility with
+ * the FathomProvider component.
+ *
+ * @example
+ * ```tsx
+ * import { createWebViewClient, FathomWebView } from 'react-fathom/native'
+ *
+ * function App() {
+ *   const webViewRef = useRef<FathomWebViewRef>(null)
+ *   const client = useMemo(
+ *     () => createWebViewClient(() => webViewRef.current, { debug: __DEV__ }),
+ *     []
+ *   )
+ *
+ *   return (
+ *     <FathomProvider client={client} siteId="YOUR_SITE_ID">
+ *       <FathomWebView ref={webViewRef} siteId="YOUR_SITE_ID" />
+ *       <YourApp />
+ *     </FathomProvider>
+ *   )
+ * }
+ * ```
+ */
+
+function createWebViewClient(getWebViewRef) {
+  var options = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+  var _options$debug = options.debug,
+    debug = _options$debug === void 0 ? false : _options$debug,
+    _options$enableQueue = options.enableQueue,
+    enableQueue = _options$enableQueue === void 0 ? true : _options$enableQueue,
+    _options$maxQueueSize = options.maxQueueSize,
+    maxQueueSize = _options$maxQueueSize === void 0 ? 100 : _options$maxQueueSize;
+  var isTrackingBlocked = false;
+
+  // Queue for commands sent before WebView is ready
+  var commandQueue = [];
+  var log = function log() {
+    if (debug) {
+      var _console;
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      (_console = console).log.apply(_console, ['[react-fathom/webview-client]'].concat(args));
+    }
+  };
+  var warn = function warn() {
+    if (debug) {
+      var _console2;
+      for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+        args[_key2] = arguments[_key2];
+      }
+      (_console2 = console).warn.apply(_console2, ['[react-fathom/webview-client]'].concat(args));
+    }
+  };
+
+  /**
+   * Queue a command for later execution
+   */
+  var queueCommand = function queueCommand(type, args) {
+    if (!enableQueue) {
+      warn('Queue disabled, dropping command:', type);
+      return;
+    }
+    if (commandQueue.length >= maxQueueSize) {
+      commandQueue.shift();
+      log('Queue full, removed oldest command');
+    }
+    commandQueue.push({
+      type: type,
+      args: args,
+      timestamp: Date.now()
+    });
+    log("Command queued (".concat(commandQueue.length, "/").concat(maxQueueSize, "):"), type);
+  };
+
+  /**
+   * Process all queued commands
+   */
+  var processQueue = function processQueue() {
+    var ref = getWebViewRef();
+    if (!(ref !== null && ref !== void 0 && ref.isReady())) {
+      return 0;
+    }
+    log("Processing ".concat(commandQueue.length, " queued commands"));
+    var processed = 0;
+    while (commandQueue.length > 0) {
+      var command = commandQueue.shift();
+      switch (command.type) {
+        case 'pageview':
+          ref.trackPageview(command.args[0]);
+          break;
+        case 'event':
+          ref.trackEvent(command.args[0], command.args[1]);
+          break;
+        case 'goal':
+          ref.trackGoal(command.args[0], command.args[1]);
+          break;
+        case 'block':
+          ref.blockTrackingForMe();
+          break;
+        case 'enable':
+          ref.enableTrackingForMe();
+          break;
+      }
+      processed++;
+    }
+    log("Processed ".concat(processed, " queued commands"));
+    return processed;
+  };
+
+  /**
+   * Execute a command immediately or queue it
+   */
+  var executeOrQueue = function executeOrQueue(type, args, executor) {
+    var ref = getWebViewRef();
+    if (ref !== null && ref !== void 0 && ref.isReady()) {
+      executor();
+    } else {
+      queueCommand(type, args);
+    }
+  };
+  var client = {
+    load: function load(siteId, opts) {
+      log('Client loaded with site ID:', siteId);
+
+      // Process any queued commands now that we're "loaded"
+      // (actual WebView readiness is separate)
+      processQueue();
+    },
+    trackPageview: function trackPageview(opts) {
+      if (isTrackingBlocked) {
+        log('Tracking blocked, skipping pageview');
+        return;
+      }
+      executeOrQueue('pageview', [opts], function () {
+        var ref = getWebViewRef();
+        ref === null || ref === void 0 || ref.trackPageview(opts);
+        log('Tracked pageview:', opts);
+      });
+    },
+    trackEvent: function trackEvent(eventName, opts) {
+      if (isTrackingBlocked) {
+        log('Tracking blocked, skipping event');
+        return;
+      }
+      executeOrQueue('event', [eventName, opts], function () {
+        var ref = getWebViewRef();
+        ref === null || ref === void 0 || ref.trackEvent(eventName, opts);
+        log('Tracked event:', eventName, opts);
+      });
+    },
+    trackGoal: function trackGoal(code, cents) {
+      if (isTrackingBlocked) {
+        log('Tracking blocked, skipping goal');
+        return;
+      }
+      executeOrQueue('goal', [code, cents], function () {
+        var ref = getWebViewRef();
+        ref === null || ref === void 0 || ref.trackGoal(code, cents);
+        log('Tracked goal:', code, cents);
+      });
+    },
+    setSite: function setSite(id) {
+      log('Site ID changed to:', id);
+      // Note: The WebView loads with a specific site ID, so changing it
+      // at runtime would require reloading the WebView
+      warn('setSite() called but WebView was initialized with a different site ID. ' + 'Consider re-mounting the FathomWebView component.');
+    },
+    blockTrackingForMe: function blockTrackingForMe() {
+      isTrackingBlocked = true;
+      executeOrQueue('block', [], function () {
+        var ref = getWebViewRef();
+        ref === null || ref === void 0 || ref.blockTrackingForMe();
+      });
+      log('Tracking blocked');
+    },
+    enableTrackingForMe: function enableTrackingForMe() {
+      isTrackingBlocked = false;
+      executeOrQueue('enable', [], function () {
+        var ref = getWebViewRef();
+        ref === null || ref === void 0 || ref.enableTrackingForMe();
+      });
+      log('Tracking enabled');
+
+      // Process queue when tracking is re-enabled
+      processQueue();
+    },
+    isTrackingEnabled: function isTrackingEnabled() {
+      return !isTrackingBlocked;
+    },
+    // Additional methods for React Native
+    processQueue: processQueue,
+    getQueueLength: function getQueueLength() {
+      return commandQueue.length;
+    },
+    /**
+     * Call this when the WebView signals it's ready.
+     * This will flush any queued commands.
+     */
+    setWebViewReady: function setWebViewReady() {
+      log('WebView ready, processing queue');
+      processQueue();
+    }
+  };
+  return client;
+}
+
+function _typeof(o) {
+  "@babel/helpers - typeof";
+
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) {
+    return typeof o;
+  } : function (o) {
+    return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
+  }, _typeof(o);
+}
+
+function toPrimitive(t, r) {
+  if ("object" != _typeof(t) || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r);
+    if ("object" != _typeof(i)) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+
+function toPropertyKey(t) {
+  var i = toPrimitive(t, "string");
+  return "symbol" == _typeof(i) ? i : i + "";
+}
+
+function _defineProperty(e, r, t) {
+  return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  }) : e[r] = t, e;
+}
+
+// src/index.ts
+var enqueue = (command) => {
+  window.__fathomClientQueue = window.__fathomClientQueue || [];
+  window.__fathomClientQueue.push(command);
+};
+var flushQueue = () => {
+  window.__fathomIsLoading = false;
+  window.__fathomClientQueue = window.__fathomClientQueue || [];
+  window.__fathomClientQueue.forEach((command) => {
+    switch (command.type) {
+      case "trackPageview":
+        trackPageview(command.opts);
+        return;
+      case "trackGoal":
+        trackGoal(command.code, command.cents);
+        return;
+      case "trackEvent":
+        trackEvent(command.eventName, command.opts);
+        return;
+      case "enableTrackingForMe":
+        enableTrackingForMe();
+        return;
+      case "blockTrackingForMe":
+        blockTrackingForMe();
+        return;
+      case "setSite":
+        setSite(command.id);
+        return;
+    }
+  });
+  window.__fathomClientQueue = [];
+};
+var checkDomainsAndWarn = (domains) => {
+  const regex = /(https?)(?=:|\/|$)/;
+  domains.forEach((domain) => {
+    if (regex.exec(domain) !== null)
+      console.warn(
+        `The include domain ${domain} might fail to work as intended as it begins with a transfer protocol (http://, https://). Consider removing the protocol portion of the string.`
+      );
+  });
+};
+var load = (siteId, opts) => {
+  if (window.__fathomIsLoading || window.fathom) return;
+  window.__fathomIsLoading = true;
+  let tracker = document.createElement("script");
+  let firstScript = document.getElementsByTagName("script")[0] || document.querySelector("body");
+  tracker.id = "fathom-script";
+  tracker.async = true;
+  tracker.setAttribute("data-site", siteId);
+  tracker.src = opts && opts.url ? opts.url : "https://cdn.usefathom.com/script.js";
+  if (opts) {
+    if (opts.auto !== void 0)
+      tracker.setAttribute("data-auto", `${opts.auto}`);
+    if (opts.honorDNT !== void 0)
+      tracker.setAttribute("data-honor-dnt", `${opts.honorDNT}`);
+    if (opts.canonical !== void 0)
+      tracker.setAttribute("data-canonical", `${opts.canonical}`);
+    if (opts.includedDomains) {
+      checkDomainsAndWarn(opts.includedDomains);
+      tracker.setAttribute(
+        "data-included-domains",
+        opts.includedDomains.join(",")
+      );
+    }
+    if (opts.excludedDomains) {
+      checkDomainsAndWarn(opts.excludedDomains);
+      tracker.setAttribute(
+        "data-excluded-domains",
+        opts.excludedDomains.join(",")
+      );
+    }
+    if (opts.spa) tracker.setAttribute("data-spa", opts.spa);
+  }
+  tracker.onload = flushQueue;
+  firstScript.parentNode.insertBefore(tracker, firstScript);
+};
+var trackPageview = (opts) => {
+  if (window.fathom) {
+    if (opts) {
+      window.fathom.trackPageview(opts);
+    } else {
+      window.fathom.trackPageview();
+    }
+  } else {
+    enqueue({ type: "trackPageview", opts });
+  }
+};
+var trackGoal = (code, cents) => {
+  if (window.fathom) {
+    window.fathom.trackGoal(code, cents);
+  } else {
+    enqueue({ type: "trackGoal", code, cents });
+  }
+};
+var trackEvent = (eventName, opts) => {
+  if (window.fathom) {
+    window.fathom.trackEvent(eventName, opts);
+  } else {
+    enqueue({ type: "trackEvent", eventName, opts });
+  }
+};
+var blockTrackingForMe = () => {
+  if (window.fathom) {
+    window.fathom.blockTrackingForMe();
+  } else {
+    enqueue({ type: "blockTrackingForMe" });
+  }
+};
+var enableTrackingForMe = () => {
+  if (window.fathom) {
+    window.fathom.enableTrackingForMe();
+  } else {
+    enqueue({ type: "enableTrackingForMe" });
+  }
+};
+var isTrackingEnabled = () => {
+  const preferenceStorage = localStorage.getItem(
+    "blockFathomTracking"
+  );
+  return preferenceStorage !== null ? preferenceStorage !== "true" : true;
+};
+var setSite = (id) => {
+  if (window.fathom) {
+    window.fathom.setSite(id);
+  } else {
+    enqueue({ type: "setSite", id });
+  }
+};
+
+var Fathom = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  blockTrackingForMe: blockTrackingForMe,
+  enableTrackingForMe: enableTrackingForMe,
+  isTrackingEnabled: isTrackingEnabled,
+  load: load,
+  setSite: setSite,
+  trackEvent: trackEvent,
+  trackGoal: trackGoal,
+  trackPageview: trackPageview
+});
+
+var warnMissingProvider = function warnMissingProvider(methodName) {
+  if (process.env.NODE_ENV !== 'production') {
+    console.warn("[react-fathom] ".concat(methodName, "() called without a FathomProvider. ") + 'Wrap your app with <FathomProvider> to enable analytics tracking.');
+  }
+};
+
+/**
+ * Default context value with stub methods that warn in development.
+ * These allow useFathom() to be called without optional chaining,
+ * while still informing developers when the provider is missing.
+ */
+var defaultContextValue = {
+  blockTrackingForMe: function blockTrackingForMe() {
+    return warnMissingProvider('blockTrackingForMe');
+  },
+  enableTrackingForMe: function enableTrackingForMe() {
+    return warnMissingProvider('enableTrackingForMe');
+  },
+  isTrackingEnabled: function isTrackingEnabled() {
+    warnMissingProvider('isTrackingEnabled');
+    return false;
+  },
+  load: function load() {
+    return warnMissingProvider('load');
+  },
+  setSite: function setSite() {
+    return warnMissingProvider('setSite');
+  },
+  trackPageview: function trackPageview() {
+    return warnMissingProvider('trackPageview');
+  },
+  trackEvent: function trackEvent() {
+    return warnMissingProvider('trackEvent');
+  },
+  trackGoal: function trackGoal() {
+    return warnMissingProvider('trackGoal');
+  }
+};
+var FathomContext = /*#__PURE__*/createContext(defaultContextValue);
+
+function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
+function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), true).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+var FathomProvider = function FathomProvider(_ref) {
+  var children = _ref.children,
+    providedClient = _ref.client,
+    clientRef = _ref.clientRef,
+    clientOptions = _ref.clientOptions,
+    siteId = _ref.siteId,
+    providedDefaultPageviewOptions = _ref.defaultPageviewOptions,
+    providedDefaultEventOptions = _ref.defaultEventOptions;
+  // Read parent context if it exists
+  var parentContext = useContext(FathomContext);
+
+  // Use provided client or fall back to parent client or default Fathom
+  var client = useMemo(function () {
+    var _ref2;
+    return (_ref2 = providedClient !== null && providedClient !== void 0 ? providedClient : parentContext.client) !== null && _ref2 !== void 0 ? _ref2 : Fathom;
+  }, [providedClient, parentContext.client]);
+
+  // Merge defaultPageviewOptions: provided > parent > undefined
+  var defaultPageviewOptions = useMemo(function () {
+    return providedDefaultPageviewOptions !== null && providedDefaultPageviewOptions !== void 0 ? providedDefaultPageviewOptions : parentContext.defaultPageviewOptions;
+  }, [providedDefaultPageviewOptions, parentContext.defaultPageviewOptions]);
+
+  // Merge defaultEventOptions: provided > parent > undefined
+  var defaultEventOptions = useMemo(function () {
+    return providedDefaultEventOptions !== null && providedDefaultEventOptions !== void 0 ? providedDefaultEventOptions : parentContext.defaultEventOptions;
+  }, [providedDefaultEventOptions, parentContext.defaultEventOptions]);
+  var blockTrackingForMe = useCallback(function () {
+    client.blockTrackingForMe();
+  }, [client]);
+  var enableTrackingForMe = useCallback(function () {
+    client.enableTrackingForMe();
+  }, [client]);
+  var isTrackingEnabled = useCallback(function () {
+    var _client$isTrackingEna;
+    return (_client$isTrackingEna = client.isTrackingEnabled()) !== null && _client$isTrackingEna !== void 0 ? _client$isTrackingEna : false;
+  }, [client]);
+  var load = useCallback(function (siteId, clientOptions) {
+    client.load(siteId, clientOptions);
+  }, [client]);
+  var setSite = useCallback(function (siteId) {
+    client.setSite(siteId);
+  }, [client]);
+  var trackEvent = useCallback(function (eventName, options) {
+    client.trackEvent(eventName, _objectSpread(_objectSpread({}, defaultEventOptions), options));
+  }, [client, defaultEventOptions]);
+  var trackPageview = useCallback(function (options) {
+    client.trackPageview(_objectSpread(_objectSpread({}, defaultPageviewOptions), options));
+  }, [client, defaultPageviewOptions]);
+  var trackGoal = useCallback(function (code, cents) {
+    client.trackGoal(code, cents);
+  }, [client]);
+  useEffect(function () {
+    if (siteId !== undefined) {
+      load(siteId, clientOptions);
+    }
+  }, [clientOptions, load, siteId]);
+
+  // Populate the clientRef so the parent component can access the client
+  useEffect(function () {
+    if (clientRef) {
+      clientRef.current = client;
+    }
+  }, [client, clientRef]);
+  return /*#__PURE__*/React.createElement(FathomContext.Provider, {
+    value: {
+      blockTrackingForMe: blockTrackingForMe,
+      enableTrackingForMe: enableTrackingForMe,
+      isTrackingEnabled: isTrackingEnabled,
+      load: load,
+      setSite: setSite,
+      trackEvent: trackEvent,
+      trackGoal: trackGoal,
+      trackPageview: trackPageview,
+      client: client,
+      defaultPageviewOptions: defaultPageviewOptions,
+      defaultEventOptions: defaultEventOptions
+    }
+  }, children);
+};
+FathomProvider.displayName = 'FathomProvider';
+
+var useFathom = function useFathom() {
+  var context = useContext(FathomContext);
+  return context;
+};
+useFathom.displayName = 'useFathom';
+
+/**
+ * Hook that tracks app state changes (foreground/background) as Fathom events.
+ *
+ * This is useful for understanding user engagement patterns and session behavior.
+ *
+ * @example
+ * ```tsx
+ * import { useAppStateTracking } from 'react-fathom/native'
+ *
+ * function App() {
+ *   useAppStateTracking({
+ *     foregroundEventName: 'app-resumed',
+ *     backgroundEventName: 'app-paused',
+ *     onStateChange: (state) => {
+ *       console.log('App state:', state)
+ *     },
+ *   })
+ *
+ *   return <YourApp />
+ * }
+ * ```
+ */
+function useAppStateTracking() {
+  var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  var _options$foregroundEv = options.foregroundEventName,
+    foregroundEventName = _options$foregroundEv === void 0 ? 'app-foreground' : _options$foregroundEv,
+    _options$backgroundEv = options.backgroundEventName,
+    backgroundEventName = _options$backgroundEv === void 0 ? 'app-background' : _options$backgroundEv,
+    eventOptions = options.eventOptions,
+    onStateChange = options.onStateChange;
+  var _useFathom = useFathom(),
+    trackEvent = _useFathom.trackEvent;
+  var appStateRef = useRef(AppState.currentState);
+  useEffect(function () {
+    var handleAppStateChange = function handleAppStateChange(nextAppState) {
+      var previousState = appStateRef.current;
+
+      // Track when app comes to foreground
+      if (previousState.match(/inactive|background/) && nextAppState === 'active') {
+        trackEvent === null || trackEvent === void 0 || trackEvent(foregroundEventName, eventOptions);
+      }
+
+      // Track when app goes to background
+      if (previousState === 'active' && nextAppState.match(/inactive|background/)) {
+        trackEvent === null || trackEvent === void 0 || trackEvent(backgroundEventName, eventOptions);
+      }
+
+      // Call the optional state change callback
+      onStateChange === null || onStateChange === void 0 || onStateChange(nextAppState);
+      appStateRef.current = nextAppState;
+    };
+    var subscription = AppState.addEventListener('change', handleAppStateChange);
+    return function () {
+      subscription.remove();
+    };
+  }, [trackEvent, foregroundEventName, backgroundEventName, eventOptions, onStateChange]);
+}
+
+/**
+ * Internal component that handles app state tracking
+ */
+var AppStateTracker = function AppStateTracker() {
+  useAppStateTracking({
+    foregroundEventName: 'app-foreground',
+    backgroundEventName: 'app-background'
+  });
+  return null;
+};
+
+/**
+ * A convenience provider for React Native apps that uses a hidden WebView
+ * to load the official Fathom Analytics script.
+ *
+ * This approach ensures full compatibility with Fathom's tracking by using
+ * their official JavaScript client, while providing a native React API.
+ *
+ * @example
+ * ```tsx
+ * import { NativeFathomProvider } from 'react-fathom/native'
+ *
+ * function App() {
+ *   return (
+ *     <NativeFathomProvider
+ *       siteId="YOUR_SITE_ID"
+ *       debug={__DEV__}
+ *       trackAppState
+ *     >
+ *       <YourApp />
+ *     </NativeFathomProvider>
+ *   )
+ * }
+ * ```
+ *
+ * @remarks
+ * This component renders a hidden WebView that loads Fathom's tracking script.
+ * Events are queued until the WebView is ready, then automatically flushed.
+ *
+ * The WebView approach is used because Fathom Analytics does not currently
+ * provide a public API for server-side or mobile event tracking. This ensures
+ * your analytics are recorded correctly using Fathom's official client.
+ */
+var NativeFathomProvider = function NativeFathomProvider(_ref) {
+  var siteId = _ref.siteId,
+    loadOptions = _ref.loadOptions,
+    scriptDomain = _ref.scriptDomain,
+    defaultPageviewOptions = _ref.defaultPageviewOptions,
+    defaultEventOptions = _ref.defaultEventOptions,
+    _ref$trackAppState = _ref.trackAppState,
+    trackAppState = _ref$trackAppState === void 0 ? false : _ref$trackAppState,
+    _ref$debug = _ref.debug,
+    debug = _ref$debug === void 0 ? false : _ref$debug,
+    onReady = _ref.onReady,
+    onError = _ref.onError,
+    clientRef = _ref.clientRef,
+    children = _ref.children;
+  var webViewRef = useRef(null);
+
+  // Create the WebView-based client
+  var client = useMemo(function () {
+    return createWebViewClient(function () {
+      return webViewRef.current;
+    }, {
+      debug: debug,
+      enableQueue: true,
+      maxQueueSize: 100
+    });
+  }, [debug]);
+
+  // Populate the clientRef so the parent component can access the client
+  useEffect(function () {
+    if (clientRef) {
+      clientRef.current = client;
+    }
+  }, [client, clientRef]);
+
+  // Handle WebView ready event
+  var handleReady = useCallback(function () {
+    // Flush any queued commands
+    client.setWebViewReady();
+    onReady === null || onReady === void 0 || onReady();
+  }, [client, onReady]);
+  return /*#__PURE__*/React.createElement(FathomProvider, {
+    client: client,
+    siteId: siteId,
+    defaultPageviewOptions: defaultPageviewOptions,
+    defaultEventOptions: defaultEventOptions
+  }, /*#__PURE__*/React.createElement(FathomWebView, {
+    ref: webViewRef,
+    siteId: siteId,
+    loadOptions: loadOptions,
+    scriptDomain: scriptDomain,
+    debug: debug,
+    onReady: handleReady,
+    onError: onError
+  }), trackAppState && /*#__PURE__*/React.createElement(AppStateTracker, null), children);
+};
+
+/**
+ * Hook that tracks screen navigation as pageviews using React Navigation.
+ *
+ * This integrates with React Navigation's navigation container to automatically
+ * track screen changes as Fathom pageviews.
+ *
+ * @example
+ * ```tsx
+ * import { NavigationContainer } from '@react-navigation/native'
+ * import { useNavigationTracking } from 'react-fathom/native'
+ *
+ * function App() {
+ *   const navigationRef = useNavigationContainerRef()
+ *
+ *   useNavigationTracking({
+ *     navigationRef,
+ *     transformRouteName: (name) => `/screens/${name}`,
+ *   })
+ *
+ *   return (
+ *     <NavigationContainer ref={navigationRef}>
+ *       <Navigator />
+ *     </NavigationContainer>
+ *   )
+ * }
+ * ```
+ */
+function useNavigationTracking(options) {
+  var navigationRef = options.navigationRef,
+    transformRouteName = options.transformRouteName,
+    shouldTrackRoute = options.shouldTrackRoute,
+    _options$includeParam = options.includeParams,
+    includeParams = _options$includeParam === void 0 ? false : _options$includeParam;
+  var _useFathom = useFathom(),
+    trackPageview = _useFathom.trackPageview;
+  var routeNameRef = useRef(undefined);
+
+  /**
+   * Get the current route name from the navigation state
+   */
+  var getCurrentRouteName = useCallback(function () {
+    var _navigationRef$curren, _navigationRef$curren2, _currentState$routes$2;
+    if (!navigationRef.current) {
+      return undefined;
+    }
+    var state = (_navigationRef$curren = (_navigationRef$curren2 = navigationRef.current).getRootState) === null || _navigationRef$curren === void 0 ? void 0 : _navigationRef$curren.call(_navigationRef$curren2);
+    if (!state) {
+      return undefined;
+    }
+
+    // Navigate through nested navigators to get the deepest route
+    var currentState = state;
+    while ((_currentState$routes$ = currentState.routes[currentState.index]) !== null && _currentState$routes$ !== void 0 && _currentState$routes$.state) {
+      var _currentState$routes$;
+      currentState = currentState.routes[currentState.index].state;
+    }
+    return (_currentState$routes$2 = currentState.routes[currentState.index]) === null || _currentState$routes$2 === void 0 ? void 0 : _currentState$routes$2.name;
+  }, [navigationRef]);
+
+  /**
+   * Get the current route params from the navigation state
+   */
+  var getCurrentRouteParams = useCallback(function () {
+    var _navigationRef$curren3, _navigationRef$curren4, _currentState$routes$4;
+    if (!navigationRef.current) {
+      return undefined;
+    }
+    var state = (_navigationRef$curren3 = (_navigationRef$curren4 = navigationRef.current).getRootState) === null || _navigationRef$curren3 === void 0 ? void 0 : _navigationRef$curren3.call(_navigationRef$curren4);
+    if (!state) {
+      return undefined;
+    }
+
+    // Navigate through nested navigators to get the deepest route
+    var currentState = state;
+    while ((_currentState$routes$3 = currentState.routes[currentState.index]) !== null && _currentState$routes$3 !== void 0 && _currentState$routes$3.state) {
+      var _currentState$routes$3;
+      currentState = currentState.routes[currentState.index].state;
+    }
+    return (_currentState$routes$4 = currentState.routes[currentState.index]) === null || _currentState$routes$4 === void 0 ? void 0 : _currentState$routes$4.params;
+  }, [navigationRef]);
+
+  /**
+   * Build the URL to track
+   */
+  var buildTrackingUrl = useCallback(function (routeName, params) {
+    var url = transformRouteName ? transformRouteName(routeName) : "/".concat(routeName);
+    if (includeParams && params && Object.keys(params).length > 0) {
+      var queryString = Object.entries(params).filter(function (_ref) {
+        var _ref2 = _slicedToArray(_ref, 2);
+          _ref2[0];
+          var value = _ref2[1];
+        return value !== undefined && value !== null;
+      }).map(function (_ref3) {
+        var _ref4 = _slicedToArray(_ref3, 2),
+          key = _ref4[0],
+          value = _ref4[1];
+        return "".concat(encodeURIComponent(key), "=").concat(encodeURIComponent(String(value)));
+      }).join('&');
+      if (queryString) {
+        url += "?".concat(queryString);
+      }
+    }
+    return url;
+  }, [transformRouteName, includeParams]);
+
+  /**
+   * Handle navigation state change
+   */
+  var handleStateChange = useCallback(function () {
+    var currentRouteName = getCurrentRouteName();
+    var previousRouteName = routeNameRef.current;
+    if (currentRouteName && currentRouteName !== previousRouteName) {
+      var params = includeParams ? getCurrentRouteParams() : undefined;
+
+      // Check if this route should be tracked
+      if (shouldTrackRoute && !shouldTrackRoute(currentRouteName, params)) {
+        routeNameRef.current = currentRouteName;
+        return;
+      }
+      var url = buildTrackingUrl(currentRouteName, params);
+      trackPageview === null || trackPageview === void 0 || trackPageview({
+        url: url,
+        referrer: previousRouteName ? buildTrackingUrl(previousRouteName) : undefined
+      });
+      routeNameRef.current = currentRouteName;
+    }
+  }, [getCurrentRouteName, getCurrentRouteParams, shouldTrackRoute, buildTrackingUrl, trackPageview, includeParams]);
+
+  // Track initial route on mount
+  useEffect(function () {
+    // Small delay to ensure navigation is ready
+    var timeout = setTimeout(function () {
+      var initialRoute = getCurrentRouteName();
+      if (initialRoute) {
+        var params = includeParams ? getCurrentRouteParams() : undefined;
+        if (!shouldTrackRoute || shouldTrackRoute(initialRoute, params)) {
+          var url = buildTrackingUrl(initialRoute, params);
+          trackPageview === null || trackPageview === void 0 || trackPageview({
+            url: url
+          });
+          routeNameRef.current = initialRoute;
+        }
+      }
+    }, 0);
+    return function () {
+      return clearTimeout(timeout);
+    };
+  }, []); // Only on mount
+
+  // Set up navigation state change listener
+  useEffect(function () {
+    var _navigationRef$curren5, _navigationRef$curren6;
+    if (!navigationRef.current) {
+      return;
+    }
+
+    // Listen for navigation state changes
+    var unsubscribe = (_navigationRef$curren5 = (_navigationRef$curren6 = navigationRef.current).addListener) === null || _navigationRef$curren5 === void 0 ? void 0 : _navigationRef$curren5.call(_navigationRef$curren6, 'state', handleStateChange);
+    return function () {
+      unsubscribe === null || unsubscribe === void 0 || unsubscribe();
+    };
+  }, [navigationRef, handleStateChange]);
+}
+
+export { FathomProvider, FathomWebView, NativeFathomProvider, createWebViewClient, useAppStateTracking, useFathom, useNavigationTracking };
+/* Copyright 2026 - Ryan Hefner <hi@ryanhefner.com> (https://www.ryanhefner.com) */
+//# sourceMappingURL=index.js.map