@cbnsndwch/react-tracking 0.1.0

package/LICENSE.md

@@ -0,0 +1,9 @@
+# The MIT License
+
+Copyright 2026-present **cbnsndwch LLC**
+
+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,250 @@
+# @cbnsndwch/react-tracking
+
+> **Fork Notice:** This is a modernized fork of [nytimes/react-tracking](https://github.com/nytimes/react-tracking). See [ACKNOWLEDGEMENTS.md](ACKNOWLEDGEMENTS.md) for attribution and license details.
+
+Declarative tracking for React apps.
+
+- React Hook (`useTracking`) and Higher-Order Component (`track()`) APIs
+- Compartmentalize tracking concerns to individual components
+- Analytics platform agnostic
+- Full TypeScript support with bundled type declarations
+- ESM-only, tree-shakeable
+
+## Installation
+
+```sh
+npm install @cbnsndwch/react-tracking
+# or
+pnpm add @cbnsndwch/react-tracking
+```
+
+## Usage
+
+```ts
+import track, { useTracking } from '@cbnsndwch/react-tracking';
+```
+
+Both `track()` and `useTracking()` accept two arguments: `trackingData` and `options`.
+
+- `trackingData` — the data to be tracked (or a function returning that data)
+- `options` — an optional object with the following properties:
+    - `dispatch` — a function to use instead of the default dispatch behavior. See [Custom dispatch](#custom-optionsdispatch-for-tracking-data) below.
+    - `dispatchOnMount` — when `true`, dispatches tracking data when the component mounts. When a function, it is called with all contextual tracking data on initial render.
+    - `process` — a function defined once at some top-level component, used for selectively dispatching tracking events based on each component's tracking data. See [Top level process](#top-level-optionsprocess) below.
+    - `forwardRef` (HoC only) — when `true`, a ref on the wrapped component returns the underlying component instance. Default: `false`.
+    - `mergeOptions` — [deepmerge options](https://github.com/TehShrike/deepmerge#options).
+
+### `useTracking` Hook
+
+The recommended API. Returns `trackEvent`, `getTrackingData`, and a `<Track />` provider component:
+
+```tsx
+import { useTracking } from '@cbnsndwch/react-tracking';
+
+function FooPage() {
+    const { Track, trackEvent } = useTracking({ page: 'FooPage' });
+
+    return (
+        <Track>
+            <button onClick={() => trackEvent({ action: 'click' })}>
+                Click Me
+            </button>
+        </Track>
+    );
+}
+```
+
+Wrap your returned markup with `<Track />` to pass contextual tracking data to child components via [deepmerge]. Leaf components that don't have tracked children can skip `<Track />`:
+
+```tsx
+import { useTracking } from '@cbnsndwch/react-tracking';
+
+function Child() {
+    const { trackEvent } = useTracking();
+
+    return (
+        <button onClick={() => trackEvent({ action: 'childClick' })}>
+            Click
+        </button>
+    );
+}
+
+function FooPage() {
+    const { Track, trackEvent } = useTracking({ page: 'FooPage' });
+
+    return (
+        <Track>
+            <Child />
+            <button onClick={() => trackEvent({ action: 'click' })}>
+                Click Me
+            </button>
+        </Track>
+    );
+}
+```
+
+In this example, clicking the button in `Child` dispatches:
+
+```json
+{ "page": "FooPage", "action": "childClick" }
+```
+
+### `track()` Higher-Order Component
+
+The `track()` export wraps a component and injects a `tracking` prop with `trackEvent()` and `getTrackingData()` methods:
+
+```tsx
+import track from '@cbnsndwch/react-tracking';
+
+function FooPage({ tracking }) {
+    return (
+        <button onClick={() => tracking.trackEvent({ action: 'click' })}>
+            Click Me
+        </button>
+    );
+}
+
+export default track({ page: 'FooPage' })(FooPage);
+```
+
+### Custom `options.dispatch()` for tracking data
+
+By default, tracking data is pushed to `window.dataLayer[]` (see [src/dispatchTrackingEvent.ts](src/dispatchTrackingEvent.ts)), which works well with Google Tag Manager.
+
+Override this by passing a `dispatch` function at a top-level component:
+
+```tsx
+import { useTracking } from '@cbnsndwch/react-tracking';
+
+export default function App({ children }) {
+    const { Track } = useTracking(
+        {},
+        { dispatch: data => window.myCustomDataLayer.push(data) }
+    );
+
+    return <Track>{children}</Track>;
+}
+```
+
+Every child component will inherit this dispatch function.
+
+### `options.dispatchOnMount`
+
+#### As a boolean
+
+Dispatches tracking data when a component mounts — useful for page-level tracking:
+
+```tsx
+function FooPage() {
+    useTracking({ page: 'FooPage' }, { dispatchOnMount: true });
+    return <div>Foo</div>;
+}
+```
+
+#### As a function
+
+Called with all contextual tracking data on mount. The returned object is [deepmerge]d with context data and dispatched:
+
+```tsx
+function FooPage() {
+    useTracking(
+        { page: 'FooPage' },
+        { dispatchOnMount: contextData => ({ event: 'pageDataReady' }) }
+    );
+    return <div>Foo</div>;
+}
+```
+
+Dispatches: `{ event: 'pageDataReady', page: 'FooPage' }`
+
+### Top level `options.process`
+
+Define an `options.process` function once at a top-level component to implicitly dispatch events based on each component's tracking data. Return a falsy value to skip dispatch:
+
+```tsx
+function App() {
+    const { Track } = useTracking(
+        {},
+        {
+            process: ownTrackingData =>
+                ownTrackingData.page ? { event: 'pageview' } : null
+        }
+    );
+
+    return (
+        <Track>
+            <Page1 />
+            <Page2 />
+        </Track>
+    );
+}
+
+function Page1() {
+    useTracking({ page: 'Page1' });
+}
+
+function Page2() {
+    useTracking({});
+}
+```
+
+When `Page1` mounts, `{ page: 'Page1', event: 'pageview' }` is dispatched. `Page2` dispatches nothing.
+
+### Dynamic Tracking Data
+
+Pass a function to compute tracking data from props at render time:
+
+```tsx
+import track from '@cbnsndwch/react-tracking';
+
+const FooPage = track(props => ({
+    page: props.isNew ? 'new' : 'existing'
+}))(({ tracking }) => (
+    <button onClick={() => tracking.trackEvent({ action: 'click' })}>
+        Click
+    </button>
+));
+```
+
+### `getTrackingData()`
+
+Access all contextual tracking data accumulated up the component tree:
+
+```tsx
+import { useMemo } from 'react';
+import { useTracking } from '@cbnsndwch/react-tracking';
+
+function AdComponent() {
+    const randomId = useMemo(() => Math.floor(Math.random() * 100), []);
+    const { getTrackingData } = useTracking({ page_view_id: randomId });
+    const { page_view_id } = getTrackingData();
+
+    return <Ad pageViewId={page_view_id} />;
+}
+```
+
+### Tracking Data Format
+
+There are no restrictions on the shape of tracking data objects. **The format is a contract between your app and the consumer of the tracking data.**
+
+This library merges tracking data objects (via [deepmerge]) as they flow through your React component hierarchy into a single object sent to the tracking agent.
+
+### TypeScript
+
+Types are bundled with the package — no need for `@types/*`. All public APIs are fully typed.
+
+### Deepmerge
+
+You can use the copy of deepmerge bundled with this library:
+
+```ts
+import { deepmerge } from '@cbnsndwch/react-tracking';
+```
+
+## License
+
+[MIT](LICENSE)
+
+This project is a fork of [nytimes/react-tracking](https://github.com/nytimes/react-tracking), originally licensed under Apache 2.0. See [ACKNOWLEDGEMENTS.md](ACKNOWLEDGEMENTS.md).
+
+[deepmerge]: https://www.npmjs.com/package/deepmerge

package/dist/ReactTrackingContext.d.ts

@@ -0,0 +1,4 @@
+import { TrackingContextValue } from './types';
+declare const ReactTrackingContext: import('react').Context<Partial<TrackingContextValue>>;
+export default ReactTrackingContext;
+//# sourceMappingURL=ReactTrackingContext.d.ts.map

package/dist/ReactTrackingContext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ReactTrackingContext.d.ts","sourceRoot":"","sources":["../src/ReactTrackingContext.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAEpD,QAAA,MAAM,oBAAoB,wDAAmD,CAAC;AAE9E,eAAe,oBAAoB,CAAC"}

package/dist/TrackingPropType.d.ts

@@ -0,0 +1,3 @@
+export type { TrackingProp as default } from './types';
+export type { TrackingProp as TrackingPropType } from './types';
+//# sourceMappingURL=TrackingPropType.d.ts.map

package/dist/TrackingPropType.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TrackingPropType.d.ts","sourceRoot":"","sources":["../src/TrackingPropType.ts"],"names":[],"mappings":"AAAA,YAAY,EAAE,YAAY,IAAI,OAAO,EAAE,MAAM,SAAS,CAAC;AACvD,YAAY,EAAE,YAAY,IAAI,gBAAgB,EAAE,MAAM,SAAS,CAAC"}

package/dist/dispatchTrackingEvent.d.ts

@@ -0,0 +1,8 @@
+import { TrackingData } from './types';
+declare global {
+    interface Window {
+        dataLayer?: TrackingData[];
+    }
+}
+export default function dispatchTrackingEvent(data: TrackingData): void;
+//# sourceMappingURL=dispatchTrackingEvent.d.ts.map

package/dist/dispatchTrackingEvent.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"dispatchTrackingEvent.d.ts","sourceRoot":"","sources":["../src/dispatchTrackingEvent.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE5C,OAAO,CAAC,MAAM,CAAC;IACX,UAAU,MAAM;QACZ,SAAS,CAAC,EAAE,YAAY,EAAE,CAAC;KAC9B;CACJ;AAED,MAAM,CAAC,OAAO,UAAU,qBAAqB,CAAC,IAAI,EAAE,YAAY,GAAG,IAAI,CAItE"}

package/dist/index.d.ts

@@ -0,0 +1,10 @@
+import { default as track } from './trackingHoC';
+export { default as deepmerge } from 'deepmerge';
+export { default as withTracking } from './withTrackingComponentDecorator';
+export { default as trackEvent } from './trackEventMethodDecorator';
+export { default as useTracking } from './useTracking';
+export type { TrackingPropType } from './TrackingPropType';
+export type { TrackingData, TrackingDataInput, TrackingOptions, TrackingProp, TrackingContextValue, WithTrackingProps } from './types';
+export { track };
+export default track;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,eAAe,CAAC;AAElC,OAAO,EAAE,OAAO,IAAI,SAAS,EAAE,MAAM,WAAW,CAAC;AAEjD,OAAO,EAAE,OAAO,IAAI,YAAY,EAAE,MAAM,kCAAkC,CAAC;AAC3E,OAAO,EAAE,OAAO,IAAI,UAAU,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAE,OAAO,IAAI,WAAW,EAAE,MAAM,eAAe,CAAC;AAEvD,YAAY,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAE3D,YAAY,EACR,YAAY,EACZ,iBAAiB,EACjB,eAAe,EACf,YAAY,EACZ,oBAAoB,EACpB,iBAAiB,EACpB,MAAM,SAAS,CAAC;AAEjB,OAAO,EAAE,KAAK,EAAE,CAAC;AACjB,eAAe,KAAK,CAAC"}

package/dist/index.js

@@ -0,0 +1,610 @@
+import React, { createContext, useCallback, useContext, useDebugValue, useEffect, useMemo, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+//#region \0rolldown/runtime.js
+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 __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+//#region node_modules/.pnpm/react-is@16.13.1/node_modules/react-is/cjs/react-is.production.min.js
+/** @license React v16.13.1
+* react-is.production.min.js
+*
+* Copyright (c) Facebook, Inc. and its affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var require_react_is_production_min = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var b = "function" === typeof Symbol && Symbol.for, c = b ? Symbol.for("react.element") : 60103, d = b ? Symbol.for("react.portal") : 60106, e = b ? Symbol.for("react.fragment") : 60107, f = b ? Symbol.for("react.strict_mode") : 60108, g = b ? Symbol.for("react.profiler") : 60114, h = b ? Symbol.for("react.provider") : 60109, k = b ? Symbol.for("react.context") : 60110, l = b ? Symbol.for("react.async_mode") : 60111, m = b ? Symbol.for("react.concurrent_mode") : 60111, n = b ? Symbol.for("react.forward_ref") : 60112, p = b ? Symbol.for("react.suspense") : 60113, q = b ? Symbol.for("react.suspense_list") : 60120, r = b ? Symbol.for("react.memo") : 60115, t = b ? Symbol.for("react.lazy") : 60116, v = b ? Symbol.for("react.block") : 60121, w = b ? Symbol.for("react.fundamental") : 60117, x = b ? Symbol.for("react.responder") : 60118, y = b ? Symbol.for("react.scope") : 60119;
+	function z(a) {
+		if ("object" === typeof a && null !== a) {
+			var u = a.$$typeof;
+			switch (u) {
+				case c: switch (a = a.type, a) {
+					case l:
+					case m:
+					case e:
+					case g:
+					case f:
+					case p: return a;
+					default: switch (a = a && a.$$typeof, a) {
+						case k:
+						case n:
+						case t:
+						case r:
+						case h: return a;
+						default: return u;
+					}
+				}
+				case d: return u;
+			}
+		}
+	}
+	function A(a) {
+		return z(a) === m;
+	}
+	exports.AsyncMode = l;
+	exports.ConcurrentMode = m;
+	exports.ContextConsumer = k;
+	exports.ContextProvider = h;
+	exports.Element = c;
+	exports.ForwardRef = n;
+	exports.Fragment = e;
+	exports.Lazy = t;
+	exports.Memo = r;
+	exports.Portal = d;
+	exports.Profiler = g;
+	exports.StrictMode = f;
+	exports.Suspense = p;
+	exports.isAsyncMode = function(a) {
+		return A(a) || z(a) === l;
+	};
+	exports.isConcurrentMode = A;
+	exports.isContextConsumer = function(a) {
+		return z(a) === k;
+	};
+	exports.isContextProvider = function(a) {
+		return z(a) === h;
+	};
+	exports.isElement = function(a) {
+		return "object" === typeof a && null !== a && a.$$typeof === c;
+	};
+	exports.isForwardRef = function(a) {
+		return z(a) === n;
+	};
+	exports.isFragment = function(a) {
+		return z(a) === e;
+	};
+	exports.isLazy = function(a) {
+		return z(a) === t;
+	};
+	exports.isMemo = function(a) {
+		return z(a) === r;
+	};
+	exports.isPortal = function(a) {
+		return z(a) === d;
+	};
+	exports.isProfiler = function(a) {
+		return z(a) === g;
+	};
+	exports.isStrictMode = function(a) {
+		return z(a) === f;
+	};
+	exports.isSuspense = function(a) {
+		return z(a) === p;
+	};
+	exports.isValidElementType = function(a) {
+		return "string" === typeof a || "function" === typeof a || a === e || a === m || a === g || a === f || a === p || a === q || "object" === typeof a && null !== a && (a.$$typeof === t || a.$$typeof === r || a.$$typeof === h || a.$$typeof === k || a.$$typeof === n || a.$$typeof === w || a.$$typeof === x || a.$$typeof === y || a.$$typeof === v);
+	};
+	exports.typeOf = z;
+}));
+//#endregion
+//#region node_modules/.pnpm/react-is@16.13.1/node_modules/react-is/cjs/react-is.development.js
+/** @license React v16.13.1
+* react-is.development.js
+*
+* Copyright (c) Facebook, Inc. and its affiliates.
+*
+* This source code is licensed under the MIT license found in the
+* LICENSE file in the root directory of this source tree.
+*/
+var require_react_is_development = /* @__PURE__ */ __commonJSMin(((exports) => {
+	if (process.env.NODE_ENV !== "production") (function() {
+		"use strict";
+		var hasSymbol = typeof Symbol === "function" && Symbol.for;
+		var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for("react.element") : 60103;
+		var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for("react.portal") : 60106;
+		var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for("react.fragment") : 60107;
+		var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for("react.strict_mode") : 60108;
+		var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for("react.profiler") : 60114;
+		var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for("react.provider") : 60109;
+		var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for("react.context") : 60110;
+		var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for("react.async_mode") : 60111;
+		var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for("react.concurrent_mode") : 60111;
+		var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for("react.forward_ref") : 60112;
+		var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for("react.suspense") : 60113;
+		var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for("react.suspense_list") : 60120;
+		var REACT_MEMO_TYPE = hasSymbol ? Symbol.for("react.memo") : 60115;
+		var REACT_LAZY_TYPE = hasSymbol ? Symbol.for("react.lazy") : 60116;
+		var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for("react.block") : 60121;
+		var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for("react.fundamental") : 60117;
+		var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for("react.responder") : 60118;
+		var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for("react.scope") : 60119;
+		function isValidElementType(type) {
+			return typeof type === "string" || typeof type === "function" || type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === "object" && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
+		}
+		function typeOf(object) {
+			if (typeof object === "object" && object !== null) {
+				var $$typeof = object.$$typeof;
+				switch ($$typeof) {
+					case REACT_ELEMENT_TYPE:
+						var type = object.type;
+						switch (type) {
+							case REACT_ASYNC_MODE_TYPE:
+							case REACT_CONCURRENT_MODE_TYPE:
+							case REACT_FRAGMENT_TYPE:
+							case REACT_PROFILER_TYPE:
+							case REACT_STRICT_MODE_TYPE:
+							case REACT_SUSPENSE_TYPE: return type;
+							default:
+								var $$typeofType = type && type.$$typeof;
+								switch ($$typeofType) {
+									case REACT_CONTEXT_TYPE:
+									case REACT_FORWARD_REF_TYPE:
+									case REACT_LAZY_TYPE:
+									case REACT_MEMO_TYPE:
+									case REACT_PROVIDER_TYPE: return $$typeofType;
+									default: return $$typeof;
+								}
+						}
+					case REACT_PORTAL_TYPE: return $$typeof;
+				}
+			}
+		}
+		var AsyncMode = REACT_ASYNC_MODE_TYPE;
+		var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
+		var ContextConsumer = REACT_CONTEXT_TYPE;
+		var ContextProvider = REACT_PROVIDER_TYPE;
+		var Element = REACT_ELEMENT_TYPE;
+		var ForwardRef = REACT_FORWARD_REF_TYPE;
+		var Fragment = REACT_FRAGMENT_TYPE;
+		var Lazy = REACT_LAZY_TYPE;
+		var Memo = REACT_MEMO_TYPE;
+		var Portal = REACT_PORTAL_TYPE;
+		var Profiler = REACT_PROFILER_TYPE;
+		var StrictMode = REACT_STRICT_MODE_TYPE;
+		var Suspense = REACT_SUSPENSE_TYPE;
+		var hasWarnedAboutDeprecatedIsAsyncMode = false;
+		function isAsyncMode(object) {
+			if (!hasWarnedAboutDeprecatedIsAsyncMode) {
+				hasWarnedAboutDeprecatedIsAsyncMode = true;
+				console["warn"]("The ReactIs.isAsyncMode() alias has been deprecated, and will be removed in React 17+. Update your code to use ReactIs.isConcurrentMode() instead. It has the exact same API.");
+			}
+			return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
+		}
+		function isConcurrentMode(object) {
+			return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
+		}
+		function isContextConsumer(object) {
+			return typeOf(object) === REACT_CONTEXT_TYPE;
+		}
+		function isContextProvider(object) {
+			return typeOf(object) === REACT_PROVIDER_TYPE;
+		}
+		function isElement(object) {
+			return typeof object === "object" && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
+		}
+		function isForwardRef(object) {
+			return typeOf(object) === REACT_FORWARD_REF_TYPE;
+		}
+		function isFragment(object) {
+			return typeOf(object) === REACT_FRAGMENT_TYPE;
+		}
+		function isLazy(object) {
+			return typeOf(object) === REACT_LAZY_TYPE;
+		}
+		function isMemo(object) {
+			return typeOf(object) === REACT_MEMO_TYPE;
+		}
+		function isPortal(object) {
+			return typeOf(object) === REACT_PORTAL_TYPE;
+		}
+		function isProfiler(object) {
+			return typeOf(object) === REACT_PROFILER_TYPE;
+		}
+		function isStrictMode(object) {
+			return typeOf(object) === REACT_STRICT_MODE_TYPE;
+		}
+		function isSuspense(object) {
+			return typeOf(object) === REACT_SUSPENSE_TYPE;
+		}
+		exports.AsyncMode = AsyncMode;
+		exports.ConcurrentMode = ConcurrentMode;
+		exports.ContextConsumer = ContextConsumer;
+		exports.ContextProvider = ContextProvider;
+		exports.Element = Element;
+		exports.ForwardRef = ForwardRef;
+		exports.Fragment = Fragment;
+		exports.Lazy = Lazy;
+		exports.Memo = Memo;
+		exports.Portal = Portal;
+		exports.Profiler = Profiler;
+		exports.StrictMode = StrictMode;
+		exports.Suspense = Suspense;
+		exports.isAsyncMode = isAsyncMode;
+		exports.isConcurrentMode = isConcurrentMode;
+		exports.isContextConsumer = isContextConsumer;
+		exports.isContextProvider = isContextProvider;
+		exports.isElement = isElement;
+		exports.isForwardRef = isForwardRef;
+		exports.isFragment = isFragment;
+		exports.isLazy = isLazy;
+		exports.isMemo = isMemo;
+		exports.isPortal = isPortal;
+		exports.isProfiler = isProfiler;
+		exports.isStrictMode = isStrictMode;
+		exports.isSuspense = isSuspense;
+		exports.isValidElementType = isValidElementType;
+		exports.typeOf = typeOf;
+	})();
+}));
+//#endregion
+//#region node_modules/.pnpm/react-is@16.13.1/node_modules/react-is/index.js
+var require_react_is = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	if (process.env.NODE_ENV === "production") module.exports = require_react_is_production_min();
+	else module.exports = require_react_is_development();
+}));
+//#endregion
+//#region src/ReactTrackingContext.ts
+var import_hoist_non_react_statics_cjs = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var reactIs = require_react_is();
+	/**
+	* Copyright 2015, Yahoo! Inc.
+	* Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.
+	*/
+	var REACT_STATICS = {
+		childContextTypes: true,
+		contextType: true,
+		contextTypes: true,
+		defaultProps: true,
+		displayName: true,
+		getDefaultProps: true,
+		getDerivedStateFromError: true,
+		getDerivedStateFromProps: true,
+		mixins: true,
+		propTypes: true,
+		type: true
+	};
+	var KNOWN_STATICS = {
+		name: true,
+		length: true,
+		prototype: true,
+		caller: true,
+		callee: true,
+		arguments: true,
+		arity: true
+	};
+	var FORWARD_REF_STATICS = {
+		"$$typeof": true,
+		render: true,
+		defaultProps: true,
+		displayName: true,
+		propTypes: true
+	};
+	var MEMO_STATICS = {
+		"$$typeof": true,
+		compare: true,
+		defaultProps: true,
+		displayName: true,
+		propTypes: true,
+		type: true
+	};
+	var TYPE_STATICS = {};
+	TYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;
+	TYPE_STATICS[reactIs.Memo] = MEMO_STATICS;
+	function getStatics(component) {
+		if (reactIs.isMemo(component)) return MEMO_STATICS;
+		return TYPE_STATICS[component["$$typeof"]] || REACT_STATICS;
+	}
+	var defineProperty = Object.defineProperty;
+	var getOwnPropertyNames = Object.getOwnPropertyNames;
+	var getOwnPropertySymbols = Object.getOwnPropertySymbols;
+	var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+	var getPrototypeOf = Object.getPrototypeOf;
+	var objectPrototype = Object.prototype;
+	function hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {
+		if (typeof sourceComponent !== "string") {
+			if (objectPrototype) {
+				var inheritedComponent = getPrototypeOf(sourceComponent);
+				if (inheritedComponent && inheritedComponent !== objectPrototype) hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);
+			}
+			var keys = getOwnPropertyNames(sourceComponent);
+			if (getOwnPropertySymbols) keys = keys.concat(getOwnPropertySymbols(sourceComponent));
+			var targetStatics = getStatics(targetComponent);
+			var sourceStatics = getStatics(sourceComponent);
+			for (var i = 0; i < keys.length; ++i) {
+				var key = keys[i];
+				if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {
+					var descriptor = getOwnPropertyDescriptor(sourceComponent, key);
+					try {
+						defineProperty(targetComponent, key, descriptor);
+					} catch (e) {}
+				}
+			}
+		}
+		return targetComponent;
+	}
+	module.exports = hoistNonReactStatics;
+})))(), 1);
+var ReactTrackingContext = createContext({});
+//#endregion
+//#region src/dispatchTrackingEvent.ts
+var import_cjs = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	var isMergeableObject = function isMergeableObject(value) {
+		return isNonNullObject(value) && !isSpecial(value);
+	};
+	function isNonNullObject(value) {
+		return !!value && typeof value === "object";
+	}
+	function isSpecial(value) {
+		var stringValue = Object.prototype.toString.call(value);
+		return stringValue === "[object RegExp]" || stringValue === "[object Date]" || isReactElement(value);
+	}
+	var REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol.for ? Symbol.for("react.element") : 60103;
+	function isReactElement(value) {
+		return value.$$typeof === REACT_ELEMENT_TYPE;
+	}
+	function emptyTarget(val) {
+		return Array.isArray(val) ? [] : {};
+	}
+	function cloneUnlessOtherwiseSpecified(value, options) {
+		return options.clone !== false && options.isMergeableObject(value) ? deepmerge(emptyTarget(value), value, options) : value;
+	}
+	function defaultArrayMerge(target, source, options) {
+		return target.concat(source).map(function(element) {
+			return cloneUnlessOtherwiseSpecified(element, options);
+		});
+	}
+	function getMergeFunction(key, options) {
+		if (!options.customMerge) return deepmerge;
+		var customMerge = options.customMerge(key);
+		return typeof customMerge === "function" ? customMerge : deepmerge;
+	}
+	function getEnumerableOwnPropertySymbols(target) {
+		return Object.getOwnPropertySymbols ? Object.getOwnPropertySymbols(target).filter(function(symbol) {
+			return Object.propertyIsEnumerable.call(target, symbol);
+		}) : [];
+	}
+	function getKeys(target) {
+		return Object.keys(target).concat(getEnumerableOwnPropertySymbols(target));
+	}
+	function propertyIsOnObject(object, property) {
+		try {
+			return property in object;
+		} catch (_) {
+			return false;
+		}
+	}
+	function propertyIsUnsafe(target, key) {
+		return propertyIsOnObject(target, key) && !(Object.hasOwnProperty.call(target, key) && Object.propertyIsEnumerable.call(target, key));
+	}
+	function mergeObject(target, source, options) {
+		var destination = {};
+		if (options.isMergeableObject(target)) getKeys(target).forEach(function(key) {
+			destination[key] = cloneUnlessOtherwiseSpecified(target[key], options);
+		});
+		getKeys(source).forEach(function(key) {
+			if (propertyIsUnsafe(target, key)) return;
+			if (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) destination[key] = getMergeFunction(key, options)(target[key], source[key], options);
+			else destination[key] = cloneUnlessOtherwiseSpecified(source[key], options);
+		});
+		return destination;
+	}
+	function deepmerge(target, source, options) {
+		options = options || {};
+		options.arrayMerge = options.arrayMerge || defaultArrayMerge;
+		options.isMergeableObject = options.isMergeableObject || isMergeableObject;
+		options.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;
+		var sourceIsArray = Array.isArray(source);
+		if (!(sourceIsArray === Array.isArray(target))) return cloneUnlessOtherwiseSpecified(source, options);
+		else if (sourceIsArray) return options.arrayMerge(target, source, options);
+		else return mergeObject(target, source, options);
+	}
+	deepmerge.all = function deepmergeAll(array, options) {
+		if (!Array.isArray(array)) throw new Error("first argument should be an array");
+		return array.reduce(function(prev, next) {
+			return deepmerge(prev, next, options);
+		}, {});
+	};
+	module.exports = deepmerge;
+})))(), 1);
+function dispatchTrackingEvent(data) {
+	if (typeof window !== "undefined" && Object.keys(data).length > 0) (window.dataLayer = window.dataLayer || []).push(data);
+}
+//#endregion
+//#region src/useTrackingImpl.ts
+function useTrackingImpl(trackingData, options) {
+	const { tracking } = useContext(ReactTrackingContext);
+	const latestData = useRef(trackingData);
+	const latestOptions = useRef(options);
+	useEffect(() => {
+		latestData.current = trackingData;
+		latestOptions.current = options;
+	});
+	const { dispatch = dispatchTrackingEvent, dispatchOnMount = false, process } = useMemo(() => latestOptions.current || {}, []);
+	const getProcessFn = useCallback(() => tracking && tracking.process, [tracking]);
+	const getOwnTrackingData = useCallback(() => {
+		const data = latestData.current;
+		return (typeof data === "function" ? data() : data) || {};
+	}, []);
+	const getTrackingDataFn = useCallback(() => {
+		const contextGetTrackingData = tracking && tracking.getTrackingData || getOwnTrackingData;
+		return () => contextGetTrackingData === getOwnTrackingData ? getOwnTrackingData() : (0, import_cjs.default)(contextGetTrackingData(), getOwnTrackingData(), (latestOptions.current || {}).mergeOptions);
+	}, [getOwnTrackingData, tracking]);
+	const getTrackingDispatcher = useCallback(() => {
+		const contextDispatch = tracking && tracking.dispatch || dispatch;
+		return (data) => contextDispatch((0, import_cjs.default)(getOwnTrackingData(), data || {}, (latestOptions.current || {}).mergeOptions));
+	}, [
+		getOwnTrackingData,
+		tracking,
+		dispatch
+	]);
+	const trackEvent = useCallback((data) => {
+		getTrackingDispatcher()(data);
+	}, [getTrackingDispatcher]);
+	useEffect(() => {
+		const contextProcess = getProcessFn();
+		const getTrackingData = getTrackingDataFn();
+		if (contextProcess && process) console.error("[react-tracking] options.process should be defined once on a top-level component");
+		if (typeof contextProcess === "function" && typeof dispatchOnMount === "function") trackEvent((0, import_cjs.default)(contextProcess(getOwnTrackingData()) || {}, dispatchOnMount(getTrackingData()) || {}, (latestOptions.current || {}).mergeOptions));
+		else if (typeof contextProcess === "function") {
+			const processed = contextProcess(getOwnTrackingData());
+			if (processed || dispatchOnMount === true) trackEvent(processed);
+		} else if (typeof dispatchOnMount === "function") trackEvent(dispatchOnMount(getTrackingData()));
+		else if (dispatchOnMount === true) trackEvent();
+	}, [
+		getOwnTrackingData,
+		getProcessFn,
+		getTrackingDataFn,
+		trackEvent,
+		dispatchOnMount,
+		process
+	]);
+	return useMemo(() => ({ tracking: {
+		dispatch: getTrackingDispatcher(),
+		getTrackingData: getTrackingDataFn(),
+		process: getProcessFn() || process
+	} }), [
+		getTrackingDispatcher,
+		getTrackingDataFn,
+		getProcessFn,
+		process
+	]);
+}
+//#endregion
+//#region src/withTrackingComponentDecorator.tsx
+function withTrackingComponentDecorator(trackingData = {}, { forwardRef: shouldForwardRef = false, ...options } = {}) {
+	return (DecoratedComponent) => {
+		const decoratedComponentName = DecoratedComponent.displayName || DecoratedComponent.name || "Component";
+		function WithTracking(props, ref) {
+			const latestProps = useRef(props);
+			useEffect(() => {
+				latestProps.current = props;
+			});
+			const contextValue = useTrackingImpl(useCallback(() => typeof trackingData === "function" ? trackingData(latestProps.current) : trackingData, []), options);
+			const trackingProp = useMemo(() => ({
+				trackEvent: contextValue.tracking.dispatch,
+				getTrackingData: contextValue.tracking.getTrackingData
+			}), [contextValue]);
+			return /* @__PURE__ */ jsx(ReactTrackingContext.Provider, {
+				value: contextValue,
+				children: React.createElement(DecoratedComponent, {
+					...props,
+					...shouldForwardRef ? { ref } : {},
+					tracking: trackingProp
+				})
+			});
+		}
+		if (shouldForwardRef) {
+			const forwarded = React.forwardRef(WithTracking);
+			forwarded.displayName = `WithTracking(${decoratedComponentName})`;
+			(0, import_hoist_non_react_statics_cjs.default)(forwarded, DecoratedComponent);
+			return forwarded;
+		}
+		WithTracking.displayName = `WithTracking(${decoratedComponentName})`;
+		(0, import_hoist_non_react_statics_cjs.default)(WithTracking, DecoratedComponent);
+		return WithTracking;
+	};
+}
+//#endregion
+//#region src/trackingHoC.ts
+function track(trackingData, options) {
+	return withTrackingComponentDecorator(trackingData, options);
+}
+//#endregion
+//#region src/makeClassMemberDecorator.ts
+function makeClassMemberDecorator(decorate) {
+	return function decorateClassMember(target, name, descriptor) {
+		const { configurable, enumerable, value, get, initializer } = descriptor;
+		if (value) return {
+			configurable,
+			enumerable,
+			value: decorate(value)
+		};
+		if (get || initializer) return {
+			configurable,
+			enumerable,
+			get() {
+				if (this === target) return;
+				const decoratedValue = decorate(initializer ? Reflect.apply(initializer, this, []) : Reflect.apply(get, this, [])).bind(this);
+				Reflect.defineProperty(this, name, {
+					configurable,
+					enumerable,
+					value: decoratedValue
+				});
+				return decoratedValue;
+			}
+		};
+		throw new Error("called makeClassMemberDecorator on unsupported descriptor");
+	};
+}
+//#endregion
+//#region src/trackEventMethodDecorator.ts
+function trackEventMethodDecorator(trackingData = {}) {
+	return makeClassMemberDecorator((decoratedFn) => function(...args) {
+		const trackEvent = (...promiseArguments) => {
+			if (this.props && this.props.tracking && typeof this.props.tracking.trackEvent === "function") {
+				const thisTrackingData = typeof trackingData === "function" ? trackingData(this.props, this.state, args, promiseArguments) : trackingData;
+				if (thisTrackingData) this.props.tracking.trackEvent(thisTrackingData);
+			}
+		};
+		const fn = Reflect.apply(decoratedFn, this, args);
+		if (Promise && Promise.resolve(fn) === fn) return fn.then(trackEvent.bind(this)).then(() => fn).catch((error) => {
+			trackEvent({}, error);
+			throw error;
+		});
+		trackEvent();
+		return fn;
+	});
+}
+//#endregion
+//#region src/useTracking.tsx
+function useTracking(trackingData = {}, options) {
+	const contextValue = useTrackingImpl(trackingData, options);
+	const Track = useCallback(({ children }) => /* @__PURE__ */ jsx(ReactTrackingContext.Provider, {
+		value: contextValue,
+		children
+	}), [contextValue]);
+	useDebugValue(contextValue.tracking.getTrackingData, (getTrackingData) => getTrackingData());
+	return useMemo(() => ({
+		Track,
+		getTrackingData: contextValue.tracking.getTrackingData,
+		trackEvent: contextValue.tracking.dispatch
+	}), [contextValue, Track]);
+}
+//#endregion
+//#region src/index.ts
+var src_default = track;
+//#endregion
+var deepmerge = import_cjs.default;
+export { deepmerge, src_default as default, track, trackEventMethodDecorator as trackEvent, useTracking, withTrackingComponentDecorator as withTracking };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../node_modules/.pnpm/react-is@16.13.1/node_modules/react-is/cjs/react-is.production.min.js","../node_modules/.pnpm/react-is@16.13.1/node_modules/react-is/cjs/react-is.development.js","../node_modules/.pnpm/react-is@16.13.1/node_modules/react-is/index.js","../node_modules/.pnpm/hoist-non-react-statics@3.3.2/node_modules/hoist-non-react-statics/dist/hoist-non-react-statics.cjs.js","../src/ReactTrackingContext.ts","../node_modules/.pnpm/deepmerge@4.3.1/node_modules/deepmerge/dist/cjs.js","../src/dispatchTrackingEvent.ts","../src/useTrackingImpl.ts","../src/withTrackingComponentDecorator.tsx","../src/trackingHoC.ts","../src/makeClassMemberDecorator.ts","../src/trackEventMethodDecorator.ts","../src/useTracking.tsx","../src/index.ts"],"sourcesContent":["/** @license React v16.13.1\n * react-is.production.min.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';var b=\"function\"===typeof Symbol&&Symbol.for,c=b?Symbol.for(\"react.element\"):60103,d=b?Symbol.for(\"react.portal\"):60106,e=b?Symbol.for(\"react.fragment\"):60107,f=b?Symbol.for(\"react.strict_mode\"):60108,g=b?Symbol.for(\"react.profiler\"):60114,h=b?Symbol.for(\"react.provider\"):60109,k=b?Symbol.for(\"react.context\"):60110,l=b?Symbol.for(\"react.async_mode\"):60111,m=b?Symbol.for(\"react.concurrent_mode\"):60111,n=b?Symbol.for(\"react.forward_ref\"):60112,p=b?Symbol.for(\"react.suspense\"):60113,q=b?\nSymbol.for(\"react.suspense_list\"):60120,r=b?Symbol.for(\"react.memo\"):60115,t=b?Symbol.for(\"react.lazy\"):60116,v=b?Symbol.for(\"react.block\"):60121,w=b?Symbol.for(\"react.fundamental\"):60117,x=b?Symbol.for(\"react.responder\"):60118,y=b?Symbol.for(\"react.scope\"):60119;\nfunction z(a){if(\"object\"===typeof a&&null!==a){var u=a.$$typeof;switch(u){case c:switch(a=a.type,a){case l:case m:case e:case g:case f:case p:return a;default:switch(a=a&&a.$$typeof,a){case k:case n:case t:case r:case h:return a;default:return u}}case d:return u}}}function A(a){return z(a)===m}exports.AsyncMode=l;exports.ConcurrentMode=m;exports.ContextConsumer=k;exports.ContextProvider=h;exports.Element=c;exports.ForwardRef=n;exports.Fragment=e;exports.Lazy=t;exports.Memo=r;exports.Portal=d;\nexports.Profiler=g;exports.StrictMode=f;exports.Suspense=p;exports.isAsyncMode=function(a){return A(a)||z(a)===l};exports.isConcurrentMode=A;exports.isContextConsumer=function(a){return z(a)===k};exports.isContextProvider=function(a){return z(a)===h};exports.isElement=function(a){return\"object\"===typeof a&&null!==a&&a.$$typeof===c};exports.isForwardRef=function(a){return z(a)===n};exports.isFragment=function(a){return z(a)===e};exports.isLazy=function(a){return z(a)===t};\nexports.isMemo=function(a){return z(a)===r};exports.isPortal=function(a){return z(a)===d};exports.isProfiler=function(a){return z(a)===g};exports.isStrictMode=function(a){return z(a)===f};exports.isSuspense=function(a){return z(a)===p};\nexports.isValidElementType=function(a){return\"string\"===typeof a||\"function\"===typeof a||a===e||a===m||a===g||a===f||a===p||a===q||\"object\"===typeof a&&null!==a&&(a.$$typeof===t||a.$$typeof===r||a.$$typeof===h||a.$$typeof===k||a.$$typeof===n||a.$$typeof===w||a.$$typeof===x||a.$$typeof===y||a.$$typeof===v)};exports.typeOf=z;\n","/** @license React v16.13.1\n * react-is.development.js\n *\n * Copyright (c) Facebook, Inc. and its affiliates.\n *\n * This source code is licensed under the MIT license found in the\n * LICENSE file in the root directory of this source tree.\n */\n\n'use strict';\n\n\n\nif (process.env.NODE_ENV !== \"production\") {\n  (function() {\n'use strict';\n\n// The Symbol used to tag the ReactElement-like types. If there is no native Symbol\n// nor polyfill, then a plain number is used for performance.\nvar hasSymbol = typeof Symbol === 'function' && Symbol.for;\nvar REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;\nvar REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;\nvar REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;\nvar REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;\nvar REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;\nvar REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;\nvar REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary\n// (unstable) APIs that have been removed. Can we remove the symbols?\n\nvar REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;\nvar REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;\nvar REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;\nvar REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;\nvar REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8;\nvar REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;\nvar REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;\nvar REACT_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9;\nvar REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;\nvar REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;\nvar REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7;\n\nfunction isValidElementType(type) {\n  return typeof type === 'string' || typeof type === 'function' || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.\n  type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);\n}\n\nfunction typeOf(object) {\n  if (typeof object === 'object' && object !== null) {\n    var $$typeof = object.$$typeof;\n\n    switch ($$typeof) {\n      case REACT_ELEMENT_TYPE:\n        var type = object.type;\n\n        switch (type) {\n          case REACT_ASYNC_MODE_TYPE:\n          case REACT_CONCURRENT_MODE_TYPE:\n          case REACT_FRAGMENT_TYPE:\n          case REACT_PROFILER_TYPE:\n          case REACT_STRICT_MODE_TYPE:\n          case REACT_SUSPENSE_TYPE:\n            return type;\n\n          default:\n            var $$typeofType = type && type.$$typeof;\n\n            switch ($$typeofType) {\n              case REACT_CONTEXT_TYPE:\n              case REACT_FORWARD_REF_TYPE:\n              case REACT_LAZY_TYPE:\n              case REACT_MEMO_TYPE:\n              case REACT_PROVIDER_TYPE:\n                return $$typeofType;\n\n              default:\n                return $$typeof;\n            }\n\n        }\n\n      case REACT_PORTAL_TYPE:\n        return $$typeof;\n    }\n  }\n\n  return undefined;\n} // AsyncMode is deprecated along with isAsyncMode\n\nvar AsyncMode = REACT_ASYNC_MODE_TYPE;\nvar ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;\nvar ContextConsumer = REACT_CONTEXT_TYPE;\nvar ContextProvider = REACT_PROVIDER_TYPE;\nvar Element = REACT_ELEMENT_TYPE;\nvar ForwardRef = REACT_FORWARD_REF_TYPE;\nvar Fragment = REACT_FRAGMENT_TYPE;\nvar Lazy = REACT_LAZY_TYPE;\nvar Memo = REACT_MEMO_TYPE;\nvar Portal = REACT_PORTAL_TYPE;\nvar Profiler = REACT_PROFILER_TYPE;\nvar StrictMode = REACT_STRICT_MODE_TYPE;\nvar Suspense = REACT_SUSPENSE_TYPE;\nvar hasWarnedAboutDeprecatedIsAsyncMode = false; // AsyncMode should be deprecated\n\nfunction isAsyncMode(object) {\n  {\n    if (!hasWarnedAboutDeprecatedIsAsyncMode) {\n      hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint\n\n      console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');\n    }\n  }\n\n  return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;\n}\nfunction isConcurrentMode(object) {\n  return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;\n}\nfunction isContextConsumer(object) {\n  return typeOf(object) === REACT_CONTEXT_TYPE;\n}\nfunction isContextProvider(object) {\n  return typeOf(object) === REACT_PROVIDER_TYPE;\n}\nfunction isElement(object) {\n  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;\n}\nfunction isForwardRef(object) {\n  return typeOf(object) === REACT_FORWARD_REF_TYPE;\n}\nfunction isFragment(object) {\n  return typeOf(object) === REACT_FRAGMENT_TYPE;\n}\nfunction isLazy(object) {\n  return typeOf(object) === REACT_LAZY_TYPE;\n}\nfunction isMemo(object) {\n  return typeOf(object) === REACT_MEMO_TYPE;\n}\nfunction isPortal(object) {\n  return typeOf(object) === REACT_PORTAL_TYPE;\n}\nfunction isProfiler(object) {\n  return typeOf(object) === REACT_PROFILER_TYPE;\n}\nfunction isStrictMode(object) {\n  return typeOf(object) === REACT_STRICT_MODE_TYPE;\n}\nfunction isSuspense(object) {\n  return typeOf(object) === REACT_SUSPENSE_TYPE;\n}\n\nexports.AsyncMode = AsyncMode;\nexports.ConcurrentMode = ConcurrentMode;\nexports.ContextConsumer = ContextConsumer;\nexports.ContextProvider = ContextProvider;\nexports.Element = Element;\nexports.ForwardRef = ForwardRef;\nexports.Fragment = Fragment;\nexports.Lazy = Lazy;\nexports.Memo = Memo;\nexports.Portal = Portal;\nexports.Profiler = Profiler;\nexports.StrictMode = StrictMode;\nexports.Suspense = Suspense;\nexports.isAsyncMode = isAsyncMode;\nexports.isConcurrentMode = isConcurrentMode;\nexports.isContextConsumer = isContextConsumer;\nexports.isContextProvider = isContextProvider;\nexports.isElement = isElement;\nexports.isForwardRef = isForwardRef;\nexports.isFragment = isFragment;\nexports.isLazy = isLazy;\nexports.isMemo = isMemo;\nexports.isPortal = isPortal;\nexports.isProfiler = isProfiler;\nexports.isStrictMode = isStrictMode;\nexports.isSuspense = isSuspense;\nexports.isValidElementType = isValidElementType;\nexports.typeOf = typeOf;\n  })();\n}\n","'use strict';\n\nif (process.env.NODE_ENV === 'production') {\n  module.exports = require('./cjs/react-is.production.min.js');\n} else {\n  module.exports = require('./cjs/react-is.development.js');\n}\n","'use strict';\n\nvar reactIs = require('react-is');\n\n/**\n * Copyright 2015, Yahoo! Inc.\n * Copyrights licensed under the New BSD License. See the accompanying LICENSE file for terms.\n */\nvar REACT_STATICS = {\n  childContextTypes: true,\n  contextType: true,\n  contextTypes: true,\n  defaultProps: true,\n  displayName: true,\n  getDefaultProps: true,\n  getDerivedStateFromError: true,\n  getDerivedStateFromProps: true,\n  mixins: true,\n  propTypes: true,\n  type: true\n};\nvar KNOWN_STATICS = {\n  name: true,\n  length: true,\n  prototype: true,\n  caller: true,\n  callee: true,\n  arguments: true,\n  arity: true\n};\nvar FORWARD_REF_STATICS = {\n  '$$typeof': true,\n  render: true,\n  defaultProps: true,\n  displayName: true,\n  propTypes: true\n};\nvar MEMO_STATICS = {\n  '$$typeof': true,\n  compare: true,\n  defaultProps: true,\n  displayName: true,\n  propTypes: true,\n  type: true\n};\nvar TYPE_STATICS = {};\nTYPE_STATICS[reactIs.ForwardRef] = FORWARD_REF_STATICS;\nTYPE_STATICS[reactIs.Memo] = MEMO_STATICS;\n\nfunction getStatics(component) {\n  // React v16.11 and below\n  if (reactIs.isMemo(component)) {\n    return MEMO_STATICS;\n  } // React v16.12 and above\n\n\n  return TYPE_STATICS[component['$$typeof']] || REACT_STATICS;\n}\n\nvar defineProperty = Object.defineProperty;\nvar getOwnPropertyNames = Object.getOwnPropertyNames;\nvar getOwnPropertySymbols = Object.getOwnPropertySymbols;\nvar getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;\nvar getPrototypeOf = Object.getPrototypeOf;\nvar objectPrototype = Object.prototype;\nfunction hoistNonReactStatics(targetComponent, sourceComponent, blacklist) {\n  if (typeof sourceComponent !== 'string') {\n    // don't hoist over string (html) components\n    if (objectPrototype) {\n      var inheritedComponent = getPrototypeOf(sourceComponent);\n\n      if (inheritedComponent && inheritedComponent !== objectPrototype) {\n        hoistNonReactStatics(targetComponent, inheritedComponent, blacklist);\n      }\n    }\n\n    var keys = getOwnPropertyNames(sourceComponent);\n\n    if (getOwnPropertySymbols) {\n      keys = keys.concat(getOwnPropertySymbols(sourceComponent));\n    }\n\n    var targetStatics = getStatics(targetComponent);\n    var sourceStatics = getStatics(sourceComponent);\n\n    for (var i = 0; i < keys.length; ++i) {\n      var key = keys[i];\n\n      if (!KNOWN_STATICS[key] && !(blacklist && blacklist[key]) && !(sourceStatics && sourceStatics[key]) && !(targetStatics && targetStatics[key])) {\n        var descriptor = getOwnPropertyDescriptor(sourceComponent, key);\n\n        try {\n          // Avoid failures from read-only properties\n          defineProperty(targetComponent, key, descriptor);\n        } catch (e) {}\n      }\n    }\n  }\n\n  return targetComponent;\n}\n\nmodule.exports = hoistNonReactStatics;\n","import { createContext } from 'react';\nimport type { TrackingContextValue } from './types';\n\nconst ReactTrackingContext = createContext<Partial<TrackingContextValue>>({});\n\nexport default ReactTrackingContext;\n","'use strict';\n\nvar isMergeableObject = function isMergeableObject(value) {\n\treturn isNonNullObject(value)\n\t\t&& !isSpecial(value)\n};\n\nfunction isNonNullObject(value) {\n\treturn !!value && typeof value === 'object'\n}\n\nfunction isSpecial(value) {\n\tvar stringValue = Object.prototype.toString.call(value);\n\n\treturn stringValue === '[object RegExp]'\n\t\t|| stringValue === '[object Date]'\n\t\t|| isReactElement(value)\n}\n\n// see https://github.com/facebook/react/blob/b5ac963fb791d1298e7f396236383bc955f916c1/src/isomorphic/classic/element/ReactElement.js#L21-L25\nvar canUseSymbol = typeof Symbol === 'function' && Symbol.for;\nvar REACT_ELEMENT_TYPE = canUseSymbol ? Symbol.for('react.element') : 0xeac7;\n\nfunction isReactElement(value) {\n\treturn value.$$typeof === REACT_ELEMENT_TYPE\n}\n\nfunction emptyTarget(val) {\n\treturn Array.isArray(val) ? [] : {}\n}\n\nfunction cloneUnlessOtherwiseSpecified(value, options) {\n\treturn (options.clone !== false && options.isMergeableObject(value))\n\t\t? deepmerge(emptyTarget(value), value, options)\n\t\t: value\n}\n\nfunction defaultArrayMerge(target, source, options) {\n\treturn target.concat(source).map(function(element) {\n\t\treturn cloneUnlessOtherwiseSpecified(element, options)\n\t})\n}\n\nfunction getMergeFunction(key, options) {\n\tif (!options.customMerge) {\n\t\treturn deepmerge\n\t}\n\tvar customMerge = options.customMerge(key);\n\treturn typeof customMerge === 'function' ? customMerge : deepmerge\n}\n\nfunction getEnumerableOwnPropertySymbols(target) {\n\treturn Object.getOwnPropertySymbols\n\t\t? Object.getOwnPropertySymbols(target).filter(function(symbol) {\n\t\t\treturn Object.propertyIsEnumerable.call(target, symbol)\n\t\t})\n\t\t: []\n}\n\nfunction getKeys(target) {\n\treturn Object.keys(target).concat(getEnumerableOwnPropertySymbols(target))\n}\n\nfunction propertyIsOnObject(object, property) {\n\ttry {\n\t\treturn property in object\n\t} catch(_) {\n\t\treturn false\n\t}\n}\n\n// Protects from prototype poisoning and unexpected merging up the prototype chain.\nfunction propertyIsUnsafe(target, key) {\n\treturn propertyIsOnObject(target, key) // Properties are safe to merge if they don't exist in the target yet,\n\t\t&& !(Object.hasOwnProperty.call(target, key) // unsafe if they exist up the prototype chain,\n\t\t\t&& Object.propertyIsEnumerable.call(target, key)) // and also unsafe if they're nonenumerable.\n}\n\nfunction mergeObject(target, source, options) {\n\tvar destination = {};\n\tif (options.isMergeableObject(target)) {\n\t\tgetKeys(target).forEach(function(key) {\n\t\t\tdestination[key] = cloneUnlessOtherwiseSpecified(target[key], options);\n\t\t});\n\t}\n\tgetKeys(source).forEach(function(key) {\n\t\tif (propertyIsUnsafe(target, key)) {\n\t\t\treturn\n\t\t}\n\n\t\tif (propertyIsOnObject(target, key) && options.isMergeableObject(source[key])) {\n\t\t\tdestination[key] = getMergeFunction(key, options)(target[key], source[key], options);\n\t\t} else {\n\t\t\tdestination[key] = cloneUnlessOtherwiseSpecified(source[key], options);\n\t\t}\n\t});\n\treturn destination\n}\n\nfunction deepmerge(target, source, options) {\n\toptions = options || {};\n\toptions.arrayMerge = options.arrayMerge || defaultArrayMerge;\n\toptions.isMergeableObject = options.isMergeableObject || isMergeableObject;\n\t// cloneUnlessOtherwiseSpecified is added to `options` so that custom arrayMerge()\n\t// implementations can use it. The caller may not replace it.\n\toptions.cloneUnlessOtherwiseSpecified = cloneUnlessOtherwiseSpecified;\n\n\tvar sourceIsArray = Array.isArray(source);\n\tvar targetIsArray = Array.isArray(target);\n\tvar sourceAndTargetTypesMatch = sourceIsArray === targetIsArray;\n\n\tif (!sourceAndTargetTypesMatch) {\n\t\treturn cloneUnlessOtherwiseSpecified(source, options)\n\t} else if (sourceIsArray) {\n\t\treturn options.arrayMerge(target, source, options)\n\t} else {\n\t\treturn mergeObject(target, source, options)\n\t}\n}\n\ndeepmerge.all = function deepmergeAll(array, options) {\n\tif (!Array.isArray(array)) {\n\t\tthrow new Error('first argument should be an array')\n\t}\n\n\treturn array.reduce(function(prev, next) {\n\t\treturn deepmerge(prev, next, options)\n\t}, {})\n};\n\nvar deepmerge_1 = deepmerge;\n\nmodule.exports = deepmerge_1;\n","import type { TrackingData } from './types';\n\ndeclare global {\n    interface Window {\n        dataLayer?: TrackingData[];\n    }\n}\n\nexport default function dispatchTrackingEvent(data: TrackingData): void {\n    if (typeof window !== 'undefined' && Object.keys(data).length > 0) {\n        (window.dataLayer = window.dataLayer || []).push(data);\n    }\n}\n","import { useCallback, useContext, useEffect, useMemo, useRef } from 'react';\nimport merge from 'deepmerge';\nimport type { Options as DeepmergeOptions } from 'deepmerge';\n\nimport ReactTrackingContext from './ReactTrackingContext';\nimport dispatchTrackingEvent from './dispatchTrackingEvent';\nimport type { TrackingData, TrackingContextValue } from './types';\n\ninterface UseTrackingImplOptions {\n    dispatch?: (data: TrackingData) => void;\n    dispatchOnMount?:\n        | boolean\n        | ((contextData: TrackingData) => TrackingData | null);\n    process?: (data: TrackingData) => TrackingData | null;\n    mergeOptions?: DeepmergeOptions;\n}\n\nexport default function useTrackingImpl(\n    trackingData: TrackingData | ((...args: unknown[]) => TrackingData),\n    options?: UseTrackingImplOptions\n): TrackingContextValue {\n    const { tracking } = useContext(ReactTrackingContext);\n    const latestData = useRef(trackingData);\n    const latestOptions = useRef(options);\n\n    useEffect(() => {\n        latestData.current = trackingData;\n        latestOptions.current = options;\n    });\n\n    const {\n        dispatch = dispatchTrackingEvent,\n        dispatchOnMount = false,\n        process\n    } = useMemo(() => latestOptions.current || {}, []);\n\n    const getProcessFn = useCallback(\n        () => tracking && tracking.process,\n        [tracking]\n    );\n\n    const getOwnTrackingData = useCallback(() => {\n        const data = latestData.current;\n        const ownTrackingData = typeof data === 'function' ? data() : data;\n        return ownTrackingData || {};\n    }, []);\n\n    const getTrackingDataFn = useCallback(() => {\n        const contextGetTrackingData =\n            (tracking && tracking.getTrackingData) || getOwnTrackingData;\n\n        return () =>\n            contextGetTrackingData === getOwnTrackingData\n                ? getOwnTrackingData()\n                : merge(\n                      contextGetTrackingData(),\n                      getOwnTrackingData(),\n                      (latestOptions.current || ({} as UseTrackingImplOptions))\n                          .mergeOptions\n                  );\n    }, [getOwnTrackingData, tracking]);\n\n    const getTrackingDispatcher = useCallback(() => {\n        const contextDispatch = (tracking && tracking.dispatch) || dispatch;\n        return (data?: TrackingData) =>\n            contextDispatch(\n                merge(\n                    getOwnTrackingData(),\n                    data || {},\n                    (latestOptions.current || ({} as UseTrackingImplOptions))\n                        .mergeOptions\n                )\n            );\n    }, [getOwnTrackingData, tracking, dispatch]);\n\n    const trackEvent = useCallback(\n        (data?: TrackingData) => {\n            getTrackingDispatcher()(data);\n        },\n        [getTrackingDispatcher]\n    );\n\n    useEffect(() => {\n        const contextProcess = getProcessFn();\n        const getTrackingData = getTrackingDataFn();\n\n        if (contextProcess && process) {\n            console.error(\n                '[react-tracking] options.process should be defined once on a top-level component'\n            );\n        }\n\n        if (\n            typeof contextProcess === 'function' &&\n            typeof dispatchOnMount === 'function'\n        ) {\n            trackEvent(\n                merge(\n                    contextProcess(getOwnTrackingData()) || {},\n                    dispatchOnMount(getTrackingData()) || {},\n                    (latestOptions.current || ({} as UseTrackingImplOptions))\n                        .mergeOptions\n                )\n            );\n        } else if (typeof contextProcess === 'function') {\n            const processed = contextProcess(getOwnTrackingData());\n            if (processed || dispatchOnMount === true) {\n                trackEvent(processed!);\n            }\n        } else if (typeof dispatchOnMount === 'function') {\n            trackEvent(dispatchOnMount(getTrackingData())!);\n        } else if (dispatchOnMount === true) {\n            trackEvent();\n        }\n    }, [\n        getOwnTrackingData,\n        getProcessFn,\n        getTrackingDataFn,\n        trackEvent,\n        dispatchOnMount,\n        process\n    ]);\n\n    return useMemo(\n        () => ({\n            tracking: {\n                dispatch: getTrackingDispatcher(),\n                getTrackingData: getTrackingDataFn(),\n                process: getProcessFn() || process\n            }\n        }),\n        [getTrackingDispatcher, getTrackingDataFn, getProcessFn, process]\n    );\n}\n","import React, { useCallback, useEffect, useMemo, useRef } from 'react';\nimport hoistNonReactStatics from 'hoist-non-react-statics';\n\nimport ReactTrackingContext from './ReactTrackingContext';\nimport useTrackingImpl from './useTrackingImpl';\nimport type { TrackingDataInput, TrackingOptions } from './types';\n\nexport default function withTrackingComponentDecorator(\n    trackingData: TrackingDataInput = {},\n    { forwardRef: shouldForwardRef = false, ...options }: TrackingOptions = {}\n) {\n    return (DecoratedComponent: React.ComponentType<any>) => {\n        const decoratedComponentName =\n            DecoratedComponent.displayName ||\n            DecoratedComponent.name ||\n            'Component';\n\n        function WithTracking(\n            props: Record<string, unknown>,\n            ref?: React.Ref<unknown>\n        ) {\n            const latestProps = useRef(props);\n\n            useEffect(() => {\n                latestProps.current = props;\n            });\n\n            const trackingDataFn = useCallback(\n                () =>\n                    typeof trackingData === 'function'\n                        ? trackingData(latestProps.current)\n                        : trackingData,\n                []\n            );\n\n            const contextValue = useTrackingImpl(trackingDataFn, options);\n\n            const trackingProp = useMemo(\n                () => ({\n                    trackEvent: contextValue.tracking.dispatch,\n                    getTrackingData: contextValue.tracking.getTrackingData\n                }),\n                [contextValue]\n            );\n\n            return (\n                <ReactTrackingContext.Provider value={contextValue}>\n                    {React.createElement(DecoratedComponent, {\n                        ...props,\n                        ...(shouldForwardRef ? { ref } : {}),\n                        tracking: trackingProp\n                    })}\n                </ReactTrackingContext.Provider>\n            );\n        }\n\n        if (shouldForwardRef) {\n            const forwarded = React.forwardRef(WithTracking);\n            forwarded.displayName = `WithTracking(${decoratedComponentName})`;\n            hoistNonReactStatics(forwarded, DecoratedComponent);\n            return forwarded;\n        }\n\n        WithTracking.displayName = `WithTracking(${decoratedComponentName})`;\n        hoistNonReactStatics(WithTracking, DecoratedComponent);\n        return WithTracking;\n    };\n}\n","import withTrackingComponentDecorator from './withTrackingComponentDecorator';\nimport type { TrackingDataInput, TrackingOptions } from './types';\n\nexport default function track(\n    trackingData?: TrackingDataInput,\n    options?: TrackingOptions\n) {\n    return withTrackingComponentDecorator(trackingData, options);\n}\n","type DecoratorFn = (decoratedFn: Function) => Function;\n\nexport interface MemberDescriptor {\n    configurable?: boolean;\n    enumerable?: boolean;\n    value?: Function;\n    get?: () => Function;\n    initializer?: () => Function;\n}\n\nexport default function makeClassMemberDecorator(decorate: DecoratorFn) {\n    return function decorateClassMember(\n        target: object,\n        name: string,\n        descriptor: MemberDescriptor\n    ): MemberDescriptor {\n        const { configurable, enumerable, value, get, initializer } =\n            descriptor;\n\n        if (value) {\n            return {\n                configurable,\n                enumerable,\n                value: decorate(value)\n            };\n        }\n\n        // support lazy initializer\n        if (get || initializer) {\n            return {\n                configurable,\n                enumerable,\n                get(this: unknown) {\n                    // This happens if someone accesses the\n                    // property directly on the prototype\n                    if (this === target) {\n                        return undefined;\n                    }\n\n                    const resolvedValue = initializer\n                        ? Reflect.apply(initializer, this, [])\n                        : Reflect.apply(get!, this, []);\n                    const decoratedValue = decorate(resolvedValue).bind(this);\n\n                    Reflect.defineProperty(this as object, name, {\n                        configurable,\n                        enumerable,\n                        value: decoratedValue\n                    });\n\n                    return decoratedValue;\n                }\n            };\n        }\n\n        throw new Error(\n            'called makeClassMemberDecorator on unsupported descriptor'\n        );\n    };\n}\n","import type { TrackingData, TrackingProp } from './types';\nimport makeClassMemberDecorator from './makeClassMemberDecorator';\n\ntype TrackEventDataInput =\n    | TrackingData\n    | ((\n          props: Record<string, unknown>,\n          state: unknown,\n          args: unknown[],\n          promiseArgs: unknown[]\n      ) => TrackingData | null);\n\ninterface DecoratedThis {\n    props?: { tracking?: TrackingProp } & Record<string, unknown>;\n    state?: unknown;\n}\n\nexport default function trackEventMethodDecorator(\n    trackingData: TrackEventDataInput = {}\n) {\n    return makeClassMemberDecorator(\n        (decoratedFn: Function) =>\n            function (this: DecoratedThis, ...args: unknown[]) {\n                const trackEvent = (...promiseArguments: unknown[]) => {\n                    if (\n                        this.props &&\n                        this.props.tracking &&\n                        typeof this.props.tracking.trackEvent === 'function'\n                    ) {\n                        const thisTrackingData =\n                            typeof trackingData === 'function'\n                                ? trackingData(\n                                      this.props,\n                                      this.state,\n                                      args,\n                                      promiseArguments\n                                  )\n                                : trackingData;\n                        if (thisTrackingData) {\n                            this.props.tracking.trackEvent(thisTrackingData);\n                        }\n                    }\n                };\n\n                const fn = Reflect.apply(decoratedFn, this, args);\n                if (Promise && Promise.resolve(fn) === fn) {\n                    return fn\n                        .then(trackEvent.bind(this))\n                        .then(() => fn)\n                        .catch((error: Error) => {\n                            trackEvent({}, error);\n                            throw error;\n                        });\n                }\n                trackEvent();\n                return fn;\n            }\n    );\n}\n","import { useCallback, useDebugValue, useMemo } from 'react';\n\nimport ReactTrackingContext from './ReactTrackingContext';\nimport useTrackingImpl from './useTrackingImpl';\nimport type { TrackingData, TrackingDataInput, TrackingOptions } from './types';\n\ninterface UseTrackingResult {\n    Track: React.FC<{ children: React.ReactNode }>;\n    getTrackingData: () => TrackingData;\n    trackEvent: (data?: TrackingData) => void;\n}\n\nexport default function useTracking(\n    trackingData: TrackingDataInput = {},\n    options?: Omit<TrackingOptions, 'forwardRef'>\n): UseTrackingResult {\n    const contextValue = useTrackingImpl(trackingData as TrackingData, options);\n\n    const Track = useCallback(\n        ({ children }: { children: React.ReactNode }) => (\n            <ReactTrackingContext.Provider value={contextValue}>\n                {children}\n            </ReactTrackingContext.Provider>\n        ),\n        [contextValue]\n    );\n\n    useDebugValue(contextValue.tracking.getTrackingData, getTrackingData =>\n        getTrackingData()\n    );\n\n    return useMemo(\n        () => ({\n            Track,\n            getTrackingData: contextValue.tracking.getTrackingData,\n            trackEvent: contextValue.tracking.dispatch\n        }),\n        [contextValue, Track]\n    );\n}\n","import track from './trackingHoC';\n\nexport { default as deepmerge } from 'deepmerge';\n\nexport { default as withTracking } from './withTrackingComponentDecorator';\nexport { default as trackEvent } from './trackEventMethodDecorator';\nexport { default as useTracking } from './useTracking';\n\nexport type { TrackingPropType } from './TrackingPropType';\n\nexport type {\n    TrackingData,\n    TrackingDataInput,\n    TrackingOptions,\n    TrackingProp,\n    TrackingContextValue,\n    WithTrackingProps\n} from './types';\n\nexport { track };\nexport default track;\n"],"x_google_ignoreList":[0,1,2,3,5],"mappings":"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"}

package/dist/makeClassMemberDecorator.d.ts

@@ -0,0 +1,11 @@
+type DecoratorFn = (decoratedFn: Function) => Function;
+export interface MemberDescriptor {
+    configurable?: boolean;
+    enumerable?: boolean;
+    value?: Function;
+    get?: () => Function;
+    initializer?: () => Function;
+}
+export default function makeClassMemberDecorator(decorate: DecoratorFn): (target: object, name: string, descriptor: MemberDescriptor) => MemberDescriptor;
+export {};
+//# sourceMappingURL=makeClassMemberDecorator.d.ts.map

package/dist/makeClassMemberDecorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"makeClassMemberDecorator.d.ts","sourceRoot":"","sources":["../src/makeClassMemberDecorator.ts"],"names":[],"mappings":"AAAA,KAAK,WAAW,GAAG,CAAC,WAAW,EAAE,QAAQ,KAAK,QAAQ,CAAC;AAEvD,MAAM,WAAW,gBAAgB;IAC7B,YAAY,CAAC,EAAE,OAAO,CAAC;IACvB,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,KAAK,CAAC,EAAE,QAAQ,CAAC;IACjB,GAAG,CAAC,EAAE,MAAM,QAAQ,CAAC;IACrB,WAAW,CAAC,EAAE,MAAM,QAAQ,CAAC;CAChC;AAED,MAAM,CAAC,OAAO,UAAU,wBAAwB,CAAC,QAAQ,EAAE,WAAW,IAE9D,QAAQ,MAAM,EACd,MAAM,MAAM,EACZ,YAAY,gBAAgB,KAC7B,gBAAgB,CA4CtB"}

package/dist/trackEventMethodDecorator.d.ts

@@ -0,0 +1,5 @@
+import { TrackingData } from './types';
+type TrackEventDataInput = TrackingData | ((props: Record<string, unknown>, state: unknown, args: unknown[], promiseArgs: unknown[]) => TrackingData | null);
+export default function trackEventMethodDecorator(trackingData?: TrackEventDataInput): (target: object, name: string, descriptor: import('./makeClassMemberDecorator').MemberDescriptor) => import('./makeClassMemberDecorator').MemberDescriptor;
+export {};
+//# sourceMappingURL=trackEventMethodDecorator.d.ts.map

package/dist/trackEventMethodDecorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trackEventMethodDecorator.d.ts","sourceRoot":"","sources":["../src/trackEventMethodDecorator.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAgB,MAAM,SAAS,CAAC;AAG1D,KAAK,mBAAmB,GAClB,YAAY,GACZ,CAAC,CACG,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,KAAK,EAAE,OAAO,EACd,IAAI,EAAE,OAAO,EAAE,EACf,WAAW,EAAE,OAAO,EAAE,KACrB,YAAY,GAAG,IAAI,CAAC,CAAC;AAOhC,MAAM,CAAC,OAAO,UAAU,yBAAyB,CAC7C,YAAY,GAAE,mBAAwB,8JAwCzC"}

package/dist/trackingHoC.d.ts

@@ -0,0 +1,6 @@
+import { TrackingDataInput, TrackingOptions } from './types';
+export default function track(trackingData?: TrackingDataInput, options?: TrackingOptions): (DecoratedComponent: React.ComponentType<any>) => {
+    (props: Record<string, unknown>, ref?: React.Ref<unknown>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+} | import('react').ForwardRefExoticComponent<Omit<Record<string, unknown>, "ref"> & import('react').RefAttributes<unknown>>;
+//# sourceMappingURL=trackingHoC.d.ts.map

package/dist/trackingHoC.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trackingHoC.d.ts","sourceRoot":"","sources":["../src/trackingHoC.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAElE,MAAM,CAAC,OAAO,UAAU,KAAK,CACzB,YAAY,CAAC,EAAE,iBAAiB,EAChC,OAAO,CAAC,EAAE,eAAe;;;6HAG5B"}

package/dist/types.d.ts

@@ -0,0 +1,28 @@
+import { Options as DeepmergeOptions } from 'deepmerge';
+import { ComponentType } from 'react';
+export type TrackingData = Record<string, unknown>;
+export type TrackingDataFn = (props: any) => TrackingData;
+export type TrackingDataInput = TrackingData | TrackingDataFn;
+export interface TrackingOptions {
+    dispatch?: (data: TrackingData) => void;
+    dispatchOnMount?: boolean | ((contextData: TrackingData) => TrackingData | null);
+    process?: (data: TrackingData) => TrackingData | null;
+    forwardRef?: boolean;
+    mergeOptions?: DeepmergeOptions;
+}
+export interface TrackingProp {
+    trackEvent: (data?: TrackingData) => void;
+    getTrackingData: () => TrackingData;
+}
+export interface TrackingContextValue {
+    tracking: {
+        dispatch: (data?: TrackingData) => void;
+        getTrackingData: () => TrackingData;
+        process?: ((data: TrackingData) => TrackingData | null) | null;
+    };
+}
+export type WithTrackingProps<P = Record<string, unknown>> = P & {
+    tracking: TrackingProp;
+};
+export type TrackingDecorator = <P extends Record<string, unknown>, C extends ComponentType<P>>(component: C) => C;
+//# sourceMappingURL=types.d.ts.map

package/dist/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAE3C,MAAM,MAAM,YAAY,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AAGnD,MAAM,MAAM,cAAc,GAAG,CAAC,KAAK,EAAE,GAAG,KAAK,YAAY,CAAC;AAE1D,MAAM,MAAM,iBAAiB,GAAG,YAAY,GAAG,cAAc,CAAC;AAE9D,MAAM,WAAW,eAAe;IAC5B,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,CAAC;IACxC,eAAe,CAAC,EACV,OAAO,GACP,CAAC,CAAC,WAAW,EAAE,YAAY,KAAK,YAAY,GAAG,IAAI,CAAC,CAAC;IAC3D,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,YAAY,GAAG,IAAI,CAAC;IACtD,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,YAAY,CAAC,EAAE,gBAAgB,CAAC;CACnC;AAED,MAAM,WAAW,YAAY;IACzB,UAAU,EAAE,CAAC,IAAI,CAAC,EAAE,YAAY,KAAK,IAAI,CAAC;IAC1C,eAAe,EAAE,MAAM,YAAY,CAAC;CACvC;AAED,MAAM,WAAW,oBAAoB;IACjC,QAAQ,EAAE;QACN,QAAQ,EAAE,CAAC,IAAI,CAAC,EAAE,YAAY,KAAK,IAAI,CAAC;QACxC,eAAe,EAAE,MAAM,YAAY,CAAC;QACpC,OAAO,CAAC,EAAE,CAAC,CAAC,IAAI,EAAE,YAAY,KAAK,YAAY,GAAG,IAAI,CAAC,GAAG,IAAI,CAAC;KAClE,CAAC;CACL;AAED,MAAM,MAAM,iBAAiB,CAAC,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,CAAC,GAAG;IAC7D,QAAQ,EAAE,YAAY,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAC5B,CAAC,SAAS,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACjC,CAAC,SAAS,aAAa,CAAC,CAAC,CAAC,EAE1B,SAAS,EAAE,CAAC,KACX,CAAC,CAAC"}

package/dist/useTracking.d.ts

@@ -0,0 +1,11 @@
+import { TrackingData, TrackingDataInput, TrackingOptions } from './types';
+interface UseTrackingResult {
+    Track: React.FC<{
+        children: React.ReactNode;
+    }>;
+    getTrackingData: () => TrackingData;
+    trackEvent: (data?: TrackingData) => void;
+}
+export default function useTracking(trackingData?: TrackingDataInput, options?: Omit<TrackingOptions, 'forwardRef'>): UseTrackingResult;
+export {};
+//# sourceMappingURL=useTracking.d.ts.map

package/dist/useTracking.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTracking.d.ts","sourceRoot":"","sources":["../src/useTracking.tsx"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,YAAY,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAEhF,UAAU,iBAAiB;IACvB,KAAK,EAAE,KAAK,CAAC,EAAE,CAAC;QAAE,QAAQ,EAAE,KAAK,CAAC,SAAS,CAAA;KAAE,CAAC,CAAC;IAC/C,eAAe,EAAE,MAAM,YAAY,CAAC;IACpC,UAAU,EAAE,CAAC,IAAI,CAAC,EAAE,YAAY,KAAK,IAAI,CAAC;CAC7C;AAED,MAAM,CAAC,OAAO,UAAU,WAAW,CAC/B,YAAY,GAAE,iBAAsB,EACpC,OAAO,CAAC,EAAE,IAAI,CAAC,eAAe,EAAE,YAAY,CAAC,GAC9C,iBAAiB,CAwBnB"}

package/dist/useTrackingImpl.d.ts

@@ -0,0 +1,11 @@
+import { Options as DeepmergeOptions } from 'deepmerge';
+import { TrackingData, TrackingContextValue } from './types';
+interface UseTrackingImplOptions {
+    dispatch?: (data: TrackingData) => void;
+    dispatchOnMount?: boolean | ((contextData: TrackingData) => TrackingData | null);
+    process?: (data: TrackingData) => TrackingData | null;
+    mergeOptions?: DeepmergeOptions;
+}
+export default function useTrackingImpl(trackingData: TrackingData | ((...args: unknown[]) => TrackingData), options?: UseTrackingImplOptions): TrackingContextValue;
+export {};
+//# sourceMappingURL=useTrackingImpl.d.ts.map

package/dist/useTrackingImpl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTrackingImpl.d.ts","sourceRoot":"","sources":["../src/useTrackingImpl.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,IAAI,gBAAgB,EAAE,MAAM,WAAW,CAAC;AAI7D,OAAO,KAAK,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAC;AAElE,UAAU,sBAAsB;IAC5B,QAAQ,CAAC,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,IAAI,CAAC;IACxC,eAAe,CAAC,EACV,OAAO,GACP,CAAC,CAAC,WAAW,EAAE,YAAY,KAAK,YAAY,GAAG,IAAI,CAAC,CAAC;IAC3D,OAAO,CAAC,EAAE,CAAC,IAAI,EAAE,YAAY,KAAK,YAAY,GAAG,IAAI,CAAC;IACtD,YAAY,CAAC,EAAE,gBAAgB,CAAC;CACnC;AAED,MAAM,CAAC,OAAO,UAAU,eAAe,CACnC,YAAY,EAAE,YAAY,GAAG,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,EAAE,KAAK,YAAY,CAAC,EACnE,OAAO,CAAC,EAAE,sBAAsB,GACjC,oBAAoB,CAiHtB"}

package/dist/withTrackingComponentDecorator.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+import { TrackingDataInput, TrackingOptions } from './types';
+export default function withTrackingComponentDecorator(trackingData?: TrackingDataInput, { forwardRef: shouldForwardRef, ...options }?: TrackingOptions): (DecoratedComponent: React.ComponentType<any>) => {
+    (props: Record<string, unknown>, ref?: React.Ref<unknown>): import("react/jsx-runtime").JSX.Element;
+    displayName: string;
+} | React.ForwardRefExoticComponent<Omit<Record<string, unknown>, "ref"> & React.RefAttributes<unknown>>;
+//# sourceMappingURL=withTrackingComponentDecorator.d.ts.map

package/dist/withTrackingComponentDecorator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"withTrackingComponentDecorator.d.ts","sourceRoot":"","sources":["../src/withTrackingComponentDecorator.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAkD,MAAM,OAAO,CAAC;AAKvE,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,SAAS,CAAC;AAElE,MAAM,CAAC,OAAO,UAAU,8BAA8B,CAClD,YAAY,GAAE,iBAAsB,EACpC,EAAE,UAAU,EAAE,gBAAwB,EAAE,GAAG,OAAO,EAAE,GAAE,eAAoB,IAElE,oBAAoB,KAAK,CAAC,aAAa,CAAC,GAAG,CAAC;YAOrC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,QACxB,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC;;yGAgDnC"}

package/package.json

@@ -0,0 +1,119 @@
+{
+  "name": "@cbnsndwch/react-tracking",
+  "version": "0.1.0",
+  "description": "Declarative tracking for React apps. Based on nytimes/react-tracking",
+  "keywords": [
+    "declarative",
+    "layer",
+    "metrics",
+    "react",
+    "tracking"
+  ],
+  "homepage": "https://github.com/cbnsndwch/react-tracking",
+  "license": "MIT",
+  "author": {
+    "name": "Sergio Leon",
+    "url": "https://cbnsndwch.io"
+  },
+  "contributors": [
+    {
+      "name": "Nicole Baram",
+      "email": "nicole.baram@nytimes.com",
+      "url": "https://github.com/nicolehollyNYT"
+    },
+    {
+      "name": "Oleh Ziniak",
+      "email": "oleh.ziniak@nytimes.com",
+      "url": "https://github.com/oziniak"
+    },
+    {
+      "name": "Ivan Kravchenko",
+      "email": "ivan@kravchenko.rocks",
+      "url": "https://github.com/ivankravchenko"
+    },
+    {
+      "name": "Jeremy Gayed",
+      "email": "jeremy.gayed@gmail.com",
+      "url": "https://github.com/tizmagik"
+    },
+    {
+      "name": "Lukasz Szmit",
+      "email": "lukasz.szmit@workday.com",
+      "url": "https://github.com/lszm"
+    },
+    {
+      "name": "Bryan Gergen",
+      "email": "bryangergen@gmail.com",
+      "url": "https://github.com/bgergen"
+    }
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/cbnsndwch/react-tracking"
+  },
+  "files": [
+    "dist"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "deepmerge": "^4.3.1",
+    "hoist-non-react-statics": "^3.3.2"
+  },
+  "devDependencies": {
+    "@changesets/changelog-github": "^0.6.0",
+    "@changesets/cli": "^2.30.0",
+    "@testing-library/jest-dom": "^6.9.1",
+    "@testing-library/react": "^16.3.2",
+    "@types/hoist-non-react-statics": "^3.3.7",
+    "@types/react": "^19.0.0",
+    "@types/react-dom": "^19.0.0",
+    "@vitejs/plugin-react": "^6.0.1",
+    "husky": "^9.1.7",
+    "jsdom": "^29.0.1",
+    "lint-staged": "^16.4.0",
+    "npm-check-updates": "^19.6.6",
+    "oxc": "^1.0.1",
+    "oxfmt": "^0.42.0",
+    "oxlint": "^1.57.0",
+    "react": "^19.2.0",
+    "react-dom": "^19.2.0",
+    "typescript": "~5.9.3",
+    "vite": "^8.0.3",
+    "vite-plugin-dts": "^4.5.4",
+    "vitest": "^4.1.2"
+  },
+  "peerDependencies": {
+    "react": "^18.2.0 || ^19.0.0"
+  },
+  "lint-staged": {
+    "*.{ts,tsx,json}": [
+      "oxfmt"
+    ]
+  },
+  "engines": {
+    "node": ">=22"
+  },
+  "scripts": {
+    "build": "vite build",
+    "dev": "vite build --watch",
+    "lint": "oxlint ./src",
+    "format": "oxfmt .",
+    "format:check": "oxfmt --check .",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage",
+    "changeset": "changeset",
+    "version-packages": "changeset version",
+    "release": "pnpm run build && changeset publish"
+  }
+}