npm - react-fathom - Versions diffs - 0.1.0 - Mend

react-fathom 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (96) hide show

package/LICENSE +21 -0
package/README.md +199 -0
package/dist/cjs/index.cjs +410 -0
package/dist/cjs/index.cjs.map +1 -0
package/dist/cjs/next/index.cjs +910 -0
package/dist/cjs/next/index.cjs.map +1 -0
package/dist/es/index.js +381 -0
package/dist/es/index.js.map +1 -0
package/dist/es/next/index.js +885 -0
package/dist/es/next/index.js.map +1 -0
package/dist/react-fathom.js +413 -0
package/dist/react-fathom.js.map +1 -0
package/dist/react-fathom.min.js +3 -0
package/dist/react-fathom.min.js.map +1 -0
package/package.json +127 -0
package/src/FathomContext.tsx +5 -0
package/src/FathomProvider.test.tsx +532 -0
package/src/FathomProvider.tsx +122 -0
package/src/components/TrackClick.test.tsx +191 -0
package/src/components/TrackClick.tsx +62 -0
package/src/components/TrackPageview.test.tsx +111 -0
package/src/components/TrackPageview.tsx +36 -0
package/src/components/TrackVisible.test.tsx +311 -0
package/src/components/TrackVisible.tsx +105 -0
package/src/components/index.ts +3 -0
package/src/hooks/index.ts +4 -0
package/src/hooks/useFathom.test.tsx +51 -0
package/src/hooks/useFathom.ts +11 -0
package/src/hooks/useTrackOnClick.test.tsx +197 -0
package/src/hooks/useTrackOnClick.ts +65 -0
package/src/hooks/useTrackOnMount.test.tsx +79 -0
package/src/hooks/useTrackOnMount.ts +24 -0
package/src/hooks/useTrackOnVisible.test.tsx +313 -0
package/src/hooks/useTrackOnVisible.ts +99 -0
package/src/index.ts +4 -0
package/src/next/NextFathomProvider.test.tsx +131 -0
package/src/next/NextFathomProvider.tsx +62 -0
package/src/next/NextFathomProviderApp.test.tsx +308 -0
package/src/next/NextFathomProviderApp.tsx +106 -0
package/src/next/NextFathomProviderPages.test.tsx +330 -0
package/src/next/NextFathomProviderPages.tsx +112 -0
package/src/next/compositions/withAppRouter.test.tsx +113 -0
package/src/next/compositions/withAppRouter.tsx +48 -0
package/src/next/compositions/withPagesRouter.test.tsx +113 -0
package/src/next/compositions/withPagesRouter.tsx +44 -0
package/src/next/index.ts +7 -0
package/src/next/types.ts +19 -0
package/src/types.ts +37 -0
package/types/FathomContext.d.ts +3 -0
package/types/FathomContext.d.ts.map +1 -0
package/types/FathomProvider.d.ts +5 -0
package/types/FathomProvider.d.ts.map +1 -0
package/types/components/TrackClick.d.ts +39 -0
package/types/components/TrackClick.d.ts.map +1 -0
package/types/components/TrackPageview.d.ts +21 -0
package/types/components/TrackPageview.d.ts.map +1 -0
package/types/components/TrackVisible.d.ts +39 -0
package/types/components/TrackVisible.d.ts.map +1 -0
package/types/components/index.d.ts +4 -0
package/types/components/index.d.ts.map +1 -0
package/types/hooks/index.d.ts +5 -0
package/types/hooks/index.d.ts.map +1 -0
package/types/hooks/useFathom.d.ts +6 -0
package/types/hooks/useFathom.d.ts.map +1 -0
package/types/hooks/useTrackOnClick.d.ts +39 -0
package/types/hooks/useTrackOnClick.d.ts.map +1 -0
package/types/hooks/useTrackOnMount.d.ts +14 -0
package/types/hooks/useTrackOnMount.d.ts.map +1 -0
package/types/hooks/useTrackOnVisible.d.ts +43 -0
package/types/hooks/useTrackOnVisible.d.ts.map +1 -0
package/types/index.d.ts +5 -0
package/types/index.d.ts.map +1 -0
package/types/next/AppRouterProvider.d.ts +7 -0
package/types/next/AppRouterProvider.d.ts.map +1 -0
package/types/next/NextFathomProvider.d.ts +34 -0
package/types/next/NextFathomProvider.d.ts.map +1 -0
package/types/next/NextFathomProviderApp.d.ts +6 -0
package/types/next/NextFathomProviderApp.d.ts.map +1 -0
package/types/next/NextFathomProviderPages.d.ts +6 -0
package/types/next/NextFathomProviderPages.d.ts.map +1 -0
package/types/next/PagesRouterProvider.d.ts +7 -0
package/types/next/PagesRouterProvider.d.ts.map +1 -0
package/types/next/compositions/withAppRouter.d.ts +29 -0
package/types/next/compositions/withAppRouter.d.ts.map +1 -0
package/types/next/compositions/withPagesRouter.d.ts +25 -0
package/types/next/compositions/withPagesRouter.d.ts.map +1 -0
package/types/next/index.d.ts +6 -0
package/types/next/index.d.ts.map +1 -0
package/types/next/types.d.ts +16 -0
package/types/next/types.d.ts.map +1 -0
package/types/test-setup.d.ts +2 -0
package/types/test-setup.d.ts.map +1 -0
package/types/types.d.ts +34 -0
package/types/types.d.ts.map +1 -0
package/types/useFathom.d.ts +7 -0
package/types/useFathom.d.ts.map +1 -0

package/LICENSE ADDED Viewed

@@ -0,0 +1,21 @@
+MIT License
+Copyright (c) 2025 Ryan Hefner, Commune Software
+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 ADDED Viewed

@@ -0,0 +1,199 @@
+# 😻 react-fathom
+Easily compose Fathom Analytics into your React/Next.js apps with automatic pageview tracking and full TypeScript support.
+## Features
+- 🚀 **Zero-config** Fathom Analytics integration for React
+- 📦 **Tree-shakeable** - Only bundle what you use
+- 🔄 **Automatic pageview tracking** for Next.js (Pages Router & App Router)
+- 💪 **Full TypeScript** support with type definitions
+- 🎯 **Flexible** - Works with any React app or Next.js
+- ⚡ **Lightweight** - Minimal bundle size impact
+## Install
+Via [npm](https://npmjs.com/package/react-fathom)
+```sh
+npm install react-fathom fathom-client
+```
+Via [Yarn](https://yarn.pm/react-fathom)
+```sh
+yarn add react-fathom fathom-client
+```
+## Peer Dependencies
+- `react` >= 16.8
+- `react-dom` >= 16.8
+- `fathom-client` >= 3.0.0
+- `next` >= 10.0.0 (only if using Next.js providers)
+## Usage
+### Basic React Setup
+Wrap your app with `FathomProvider`:
+```tsx
+import { FathomProvider } from 'react-fathom'
+function App() {
+  return <FathomProvider siteId="YOUR_SITE_ID">{/* Your app */}</FathomProvider>
+}
+```
+### Using the Hook
+Access Fathom methods via the `useFathom` hook:
+```tsx
+import { useFathom } from 'react-fathom'
+function MyComponent() {
+  const { trackPageview, trackEvent, load } = useFathom()
+  const handleClick = () => {
+    trackEvent?.('button-click', { id: 'signup-button' })
+  }
+  return <button onClick={handleClick}>Sign Up</button>
+}
+```
+### Next.js Pages Router
+Use `PagesRouterProvider` for automatic route tracking:
+```tsx
+// pages/_app.tsx
+import { PagesRouterProvider } from 'react-fathom/next'
+function MyApp({ Component, pageProps }) {
+  return (
+    <PagesRouterProvider siteId="YOUR_SITE_ID">
+      <Component {...pageProps} />
+    </PagesRouterProvider>
+  )
+}
+export default MyApp
+```
+Or use the HOC:
+```tsx
+// pages/_app.tsx
+import { withPagesRouter } from 'react-fathom/next'
+function MyApp({ Component, pageProps }) {
+  return <Component {...pageProps} />
+}
+export default withPagesRouter(MyApp, {
+  siteId: 'YOUR_SITE_ID',
+  clientOptions: {
+    spa: 'auto',
+  },
+})
+```
+### Next.js App Router
+Use `AppRouterProvider` for automatic route tracking:
+```tsx
+// app/layout.tsx
+import { AppRouterProvider } from 'react-fathom/next'
+export default function RootLayout({ children }) {
+  return (
+    <html>
+      <body>
+        <AppRouterProvider siteId="YOUR_SITE_ID">{children}</AppRouterProvider>
+      </body>
+    </html>
+  )
+}
+```
+Or use the HOC:
+```tsx
+// app/layout.tsx
+import { withAppRouter } from 'react-fathom/next'
+function RootLayout({ children }) {
+  return (
+    <html>
+      <body>{children}</body>
+    </html>
+  )
+}
+export default withAppRouter(RootLayout, {
+  siteId: 'YOUR_SITE_ID',
+  clientOptions: {
+    spa: 'auto',
+  },
+})
+```
+## API
+### `FathomProvider`
+Main provider component for React apps.
+**Props:**
+- `siteId` (string, required): Your Fathom Analytics site ID
+- `client` (FathomClient, optional): Custom Fathom client instance
+- `clientOptions` (LoadOptions, optional): Options passed to `fathom-client`
+- `disableDefaultTrack` (boolean, optional): Disable automatic pageview tracking
+- `trackDefaultOptions` (PageViewOptions, optional): Default options for pageview tracking
+### `PagesRouterProvider` / `AppRouterProvider`
+Next.js-specific providers with automatic route tracking.
+**Props:**
+- All `FathomProvider` props, plus:
+- `disableAutoTrack` (boolean, optional): Disable automatic pageview tracking on route changes
+- `trackDefaultOptions` (PageViewOptions, optional): Default options for route change pageviews
+### `useFathom()`
+Hook to access Fathom methods.
+**Returns:**
+- `trackPageview(options?)`: Track a pageview
+- `trackEvent(eventName, options?)`: Track a custom event
+- `load(siteId, options?)`: Load Fathom with a site ID
+- `setSite(siteId)`: Change the site ID
+- `blockTrackingForMe()`: Block tracking for current user
+- `enableTrackingForMe()`: Enable tracking for current user
+- `isTrackingEnabled()`: Check if tracking is enabled
+## Tree-shaking
+This library is optimized for tree-shaking. When you import only what you need:
+```tsx
+import { useFathom } from 'react-fathom'
+```
+Bundlers will automatically exclude unused code, keeping your bundle size minimal.
+## TypeScript
+Full TypeScript support is included. Types are automatically generated and exported.
+## License
+[MIT](LICENSE) © [Ryan Hefner](https://www.ryanhefner.com)

package/dist/cjs/index.cjs ADDED Viewed

@@ -0,0 +1,410 @@
+/*! react-fathom - 0.1.0 !*/
+'use strict';
+var React = require('react');
+var Fathom = require('fathom-client');
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+var Fathom__namespace = /*#__PURE__*/_interopNamespaceDefault(Fathom);
+var FathomContext = /*#__PURE__*/React.createContext({});
+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;
+}
+function ownKeys$2(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$2(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$2(Object(t), true).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$2(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,
+    clientOptions = _ref.clientOptions;
+    _ref.disableDefaultTrack;
+    var siteId = _ref.siteId,
+    providedDefaultPageviewOptions = _ref.defaultPageviewOptions,
+    providedDefaultEventOptions = _ref.defaultEventOptions;
+  // Read parent context if it exists
+  var parentContext = React.useContext(FathomContext);
+  // Use provided client or fall back to parent client or default Fathom
+  var client = React.useMemo(function () {
+    var _ref2;
+    return (_ref2 = providedClient !== null && providedClient !== void 0 ? providedClient : parentContext.client) !== null && _ref2 !== void 0 ? _ref2 : Fathom__namespace;
+  }, [providedClient, parentContext.client]);
+  // Merge defaultPageviewOptions: provided > parent > undefined
+  var defaultPageviewOptions = React.useMemo(function () {
+    return providedDefaultPageviewOptions !== null && providedDefaultPageviewOptions !== void 0 ? providedDefaultPageviewOptions : parentContext.defaultPageviewOptions;
+  }, [providedDefaultPageviewOptions, parentContext.defaultPageviewOptions]);
+  // Merge defaultEventOptions: provided > parent > undefined
+  var defaultEventOptions = React.useMemo(function () {
+    return providedDefaultEventOptions !== null && providedDefaultEventOptions !== void 0 ? providedDefaultEventOptions : parentContext.defaultEventOptions;
+  }, [providedDefaultEventOptions, parentContext.defaultEventOptions]);
+  var blockTrackingForMe = React.useCallback(function () {
+    client.blockTrackingForMe();
+  }, [client]);
+  var enableTrackingForMe = React.useCallback(function () {
+    client.enableTrackingForMe();
+  }, [client]);
+  var isTrackingEnabled = React.useCallback(function () {
+    var _client$isTrackingEna;
+    return (_client$isTrackingEna = client.isTrackingEnabled()) !== null && _client$isTrackingEna !== void 0 ? _client$isTrackingEna : false;
+  }, [client]);
+  var load = React.useCallback(function (siteId, clientOptions) {
+    client.load(siteId, clientOptions);
+  }, [client]);
+  var setSite = React.useCallback(function (siteId) {
+    client.setSite(siteId);
+  }, [client]);
+  var trackEvent = React.useCallback(function (category, options) {
+    client.trackEvent(category, _objectSpread$2(_objectSpread$2({}, defaultEventOptions), options));
+  }, [client, defaultEventOptions]);
+  var trackPageview = React.useCallback(function (options) {
+    client.trackPageview(_objectSpread$2(_objectSpread$2({}, defaultPageviewOptions), options));
+  }, [client, defaultPageviewOptions]);
+  var trackGoal = React.useCallback(function (code, cents) {
+    client.trackGoal(code, cents);
+  }, [client]);
+  React.useEffect(function () {
+    if (siteId !== undefined) {
+      load(siteId, clientOptions);
+    }
+  }, [clientOptions, load, siteId]);
+  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 = React.useContext(FathomContext);
+  return context;
+};
+useFathom.displayName = 'useFathom';
+/**
+ * Hook to track a pageview when a component mounts
+ *
+ * @example
+ * ```tsx
+ * function MyComponent() {
+ *   useTrackOnMount({ url: '/custom-page' })
+ *   return <div>Content</div>
+ * }
+ * ```
+ */
+var useTrackOnMount = function useTrackOnMount(options) {
+  var _useFathom = useFathom(),
+    trackPageview = _useFathom.trackPageview;
+  React.useEffect(function () {
+    trackPageview === null || trackPageview === void 0 || trackPageview(options);
+  }, []); // eslint-disable-line react-hooks/exhaustive-deps
+};
+function _objectWithoutPropertiesLoose(r, e) {
+  if (null == r) return {};
+  var t = {};
+  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
+    if (-1 !== e.indexOf(n)) continue;
+    t[n] = r[n];
+  }
+  return t;
+}
+function _objectWithoutProperties(e, t) {
+  if (null == e) return {};
+  var o,
+    r,
+    i = _objectWithoutPropertiesLoose(e, t);
+  if (Object.getOwnPropertySymbols) {
+    var n = Object.getOwnPropertySymbols(e);
+    for (r = 0; r < n.length; r++) o = n[r], -1 === t.indexOf(o) && {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
+  }
+  return i;
+}
+var _excluded$4 = ["eventName", "preventDefault", "callback"];
+/**
+ * Hook that returns a click handler function that tracks an event
+ *
+ * @example
+ * ```tsx
+ * function Button() {
+ *   const handleClick = useTrackOnClick({
+ *     eventName: 'button-click',
+ *     id: 'signup-button',
+ *     callback: (e) => {
+ *       console.log('Button clicked!')
+ *       // Your custom logic here
+ *     },
+ *   })
+ *
+ *   return <button onClick={handleClick}>Sign Up</button>
+ * }
+ * ```
+ */
+var useTrackOnClick = function useTrackOnClick(options) {
+  var _useFathom = useFathom(),
+    trackEvent = _useFathom.trackEvent;
+  var eventName = options.eventName,
+    _options$preventDefau = options.preventDefault,
+    preventDefault = _options$preventDefau === void 0 ? false : _options$preventDefau,
+    callback = options.callback,
+    eventOptions = _objectWithoutProperties(options, _excluded$4);
+  return React.useCallback(function (e) {
+    if (preventDefault && e) {
+      e.preventDefault();
+    }
+    trackEvent === null || trackEvent === void 0 || trackEvent(eventName, eventOptions);
+    callback === null || callback === void 0 || callback(e);
+  }, [eventName, preventDefault, trackEvent, eventOptions, callback]);
+};
+var _excluded$3 = ["eventName", "observerOptions", "trackOnce", "callback"];
+function ownKeys$1(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$1(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys$1(Object(t), true).forEach(function (r) { _defineProperty(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys$1(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
+/**
+ * Hook to track an event when an element becomes visible (using Intersection Observer)
+ *
+ * @example
+ * ```tsx
+ * function Section() {
+ *   const ref = useTrackOnVisible({
+ *     eventName: 'section-viewed',
+ *     section: 'hero',
+ *     callback: (entry) => {
+ *       console.log('Section is visible!', entry.isIntersecting)
+ *       // Your custom logic here
+ *     },
+ *   })
+ *
+ *   return <section ref={ref}>Content</section>
+ * }
+ * ```
+ */
+var useTrackOnVisible = function useTrackOnVisible(options) {
+  var _useFathom = useFathom(),
+    trackEvent = _useFathom.trackEvent;
+  var eventName = options.eventName,
+    observerOptions = options.observerOptions,
+    _options$trackOnce = options.trackOnce,
+    trackOnce = _options$trackOnce === void 0 ? true : _options$trackOnce,
+    callback = options.callback,
+    eventOptions = _objectWithoutProperties(options, _excluded$3);
+  var ref = React.useRef(null);
+  var hasTracked = React.useRef(false);
+  React.useEffect(function () {
+    var element = ref.current;
+    if (!element) return;
+    var observer = new IntersectionObserver(function (entries) {
+      entries.forEach(function (entry) {
+        if (entry.isIntersecting) {
+          if (!trackOnce || !hasTracked.current) {
+            trackEvent === null || trackEvent === void 0 || trackEvent(eventName, eventOptions);
+            callback === null || callback === void 0 || callback(entry);
+            hasTracked.current = true;
+          }
+        }
+      });
+    }, _objectSpread$1({
+      threshold: 0.1
+    }, observerOptions));
+    observer.observe(element);
+    return function () {
+      observer.disconnect();
+    };
+  }, [eventName, eventOptions, observerOptions, trackOnce, trackEvent, callback]);
+  return ref;
+};
+var _excluded$2 = ["eventName", "children", "preventDefault", "onClick", "as"];
+/**
+ * Component wrapper that automatically tracks clicks on its children
+ *
+ * @example
+ * ```tsx
+ * <TrackClick eventName="cta-clicked" id="hero-cta">
+ *   <button>Get Started</button>
+ * </TrackClick>
+ * ```
+ */
+var TrackClick = function TrackClick(_ref) {
+  var eventName = _ref.eventName,
+    children = _ref.children,
+    _ref$preventDefault = _ref.preventDefault,
+    preventDefault = _ref$preventDefault === void 0 ? false : _ref$preventDefault,
+    onClick = _ref.onClick,
+    _ref$as = _ref.as,
+    Component = _ref$as === void 0 ? 'div' : _ref$as,
+    eventOptions = _objectWithoutProperties(_ref, _excluded$2);
+  var _useFathom = useFathom(),
+    trackEvent = _useFathom.trackEvent;
+  var handleClick = function handleClick(e) {
+    if (preventDefault) {
+      e.preventDefault();
+    }
+    onClick === null || onClick === void 0 || onClick(e);
+    trackEvent === null || trackEvent === void 0 || trackEvent(eventName, eventOptions);
+  };
+  return /*#__PURE__*/React.createElement(Component, {
+    onClick: handleClick
+  }, children);
+};
+var _excluded$1 = ["children"];
+/**
+ * Component that tracks a pageview when it mounts
+ *
+ * @example
+ * ```tsx
+ * <TrackPageview url="/custom-page">
+ *   <div>Page content</div>
+ * </TrackPageview>
+ * ```
+ */
+var TrackPageview = function TrackPageview(_ref) {
+  var children = _ref.children,
+    pageviewOptions = _objectWithoutProperties(_ref, _excluded$1);
+  var _useFathom = useFathom(),
+    trackPageview = _useFathom.trackPageview;
+  React.useEffect(function () {
+    trackPageview === null || trackPageview === void 0 || trackPageview(pageviewOptions);
+  }, []); // eslint-disable-line react-hooks/exhaustive-deps
+  return /*#__PURE__*/React.createElement(React.Fragment, null, children);
+};
+var _excluded = ["eventName", "children", "observerOptions", "trackOnce", "as"];
+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; }
+/**
+ * Component that tracks an event when it becomes visible in the viewport
+ *
+ * @example
+ * ```tsx
+ * <TrackVisible eventName="section-viewed" section="hero">
+ *   <HeroSection />
+ * </TrackVisible>
+ * ```
+ */
+var TrackVisible = /*#__PURE__*/React.forwardRef(function TrackVisible(_ref, forwardedRef) {
+  var eventName = _ref.eventName,
+    children = _ref.children,
+    observerOptions = _ref.observerOptions,
+    _ref$trackOnce = _ref.trackOnce,
+    trackOnce = _ref$trackOnce === void 0 ? true : _ref$trackOnce,
+    _ref$as = _ref.as,
+    Component = _ref$as === void 0 ? 'div' : _ref$as,
+    eventOptions = _objectWithoutProperties(_ref, _excluded);
+  var _useFathom = useFathom(),
+    trackEvent = _useFathom.trackEvent;
+  var internalRef = React.useRef(null);
+  var hasTracked = React.useRef(false);
+  // Callback ref that handles both forwarded and internal refs
+  var setRef = React.useCallback(function (node) {
+    internalRef.current = node;
+    if (typeof forwardedRef === 'function') {
+      forwardedRef(node);
+    } else if (forwardedRef !== null && forwardedRef !== undefined) {
+      forwardedRef.current = node;
+    }
+  }, [forwardedRef]);
+  React.useEffect(function () {
+    var element = internalRef.current;
+    if (element === null) {
+      return;
+    }
+    var observer = new IntersectionObserver(function (entries) {
+      entries.forEach(function (entry) {
+        if (entry.isIntersecting) {
+          if (!trackOnce || !hasTracked.current) {
+            trackEvent === null || trackEvent === void 0 || trackEvent(eventName, eventOptions);
+            hasTracked.current = true;
+          }
+        }
+      });
+    }, _objectSpread({
+      threshold: 0.1
+    }, observerOptions));
+    observer.observe(element);
+    return function () {
+      observer.disconnect();
+    };
+  }, [eventName, eventOptions, observerOptions, trackOnce, trackEvent]);
+  return /*#__PURE__*/React.createElement(Component, {
+    ref: setRef
+  }, children);
+});
+exports.FathomContext = FathomContext;
+exports.FathomProvider = FathomProvider;
+exports.TrackClick = TrackClick;
+exports.TrackPageview = TrackPageview;
+exports.TrackVisible = TrackVisible;
+exports.useFathom = useFathom;
+exports.useTrackOnClick = useTrackOnClick;
+exports.useTrackOnMount = useTrackOnMount;
+exports.useTrackOnVisible = useTrackOnVisible;
+/* Copyright 2025 - Ryan Hefner <hi@ryanhefner.com> (https://www.ryanhefner.com) */
+//# sourceMappingURL=index.cjs.map