@mcp-fe/react-event-tracker 0.0.5 → 0.0.9

package/hooks/useReactRouterEventTracker.d.ts

@@ -0,0 +1,2 @@
+export declare function useReactRouterEventTracker(): void;
+//# sourceMappingURL=useReactRouterEventTracker.d.ts.map

package/hooks/useReactRouterEventTracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useReactRouterEventTracker.d.ts","sourceRoot":"","sources":["../../../../libs/react-event-tracker/src/hooks/useReactRouterEventTracker.ts"],"names":[],"mappings":"AASA,wBAAgB,0BAA0B,IAAI,IAAI,CAuFjD"}

package/hooks/useTanstackRouterEventTracker.d.ts

@@ -0,0 +1,2 @@
+export declare function useTanstackRouterEventTracker(): void;
+//# sourceMappingURL=useTanstackRouterEventTracker.d.ts.map

package/hooks/useTanstackRouterEventTracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useTanstackRouterEventTracker.d.ts","sourceRoot":"","sources":["../../../../libs/react-event-tracker/src/hooks/useTanstackRouterEventTracker.ts"],"names":[],"mappings":"AASA,wBAAgB,6BAA6B,IAAI,IAAI,CAuFpD"}

package/{src/index.ts → index.d.ts}

@@ -1,2 +1,3 @@
 export * from './hooks/useTanstackRouterEventTracker';
 export * from './hooks/useReactRouterEventTracker';
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../libs/react-event-tracker/src/index.ts"],"names":[],"mappings":"AAAA,cAAc,uCAAuC,CAAC;AACtD,cAAc,oCAAoC,CAAC"}

package/index.mjs

@@ -0,0 +1,757 @@
+import * as S from "react";
+import A, { useRef as R, useState as Q, useEffect as _ } from "react";
+const se = Object.prototype.hasOwnProperty;
+function Z(t, e, n = 0) {
+  if (t === e)
+    return t;
+  if (n > 500) return e;
+  const r = e, o = z(t) && z(r);
+  if (!o && !(U(t) && U(r))) return r;
+  const i = o ? t : x(t);
+  if (!i) return r;
+  const c = o ? r : x(r);
+  if (!c) return r;
+  const u = i.length, a = c.length, s = o ? new Array(a) : {};
+  let v = 0;
+  for (let h = 0; h < a; h++) {
+    const p = o ? h : c[h], l = t[p], f = r[p];
+    if (l === f) {
+      s[p] = l, (o ? h < u : se.call(t, p)) && v++;
+      continue;
+    }
+    if (l === null || f === null || typeof l != "object" || typeof f != "object") {
+      s[p] = f;
+      continue;
+    }
+    const d = Z(l, f, n + 1);
+    s[p] = d, d === l && v++;
+  }
+  return u === a && v === u ? t : s;
+}
+function x(t) {
+  const e = [], n = Object.getOwnPropertyNames(t);
+  for (const o of n) {
+    if (!Object.prototype.propertyIsEnumerable.call(t, o)) return !1;
+    e.push(o);
+  }
+  const r = Object.getOwnPropertySymbols(t);
+  for (const o of r) {
+    if (!Object.prototype.propertyIsEnumerable.call(t, o)) return !1;
+    e.push(o);
+  }
+  return e;
+}
+function U(t) {
+  if (!H(t))
+    return !1;
+  const e = t.constructor;
+  if (typeof e > "u")
+    return !0;
+  const n = e.prototype;
+  return !(!H(n) || !n.hasOwnProperty("isPrototypeOf"));
+}
+function H(t) {
+  return Object.prototype.toString.call(t) === "[object Object]";
+}
+function z(t) {
+  return Array.isArray(t) && t.length === Object.keys(t).length;
+}
+var ce = process.env.NODE_ENV === "production";
+function ue(t, e) {
+  if (!ce) {
+    if (t)
+      return;
+    var n = "Warning: " + e;
+    typeof console < "u" && console.warn(n);
+    try {
+      throw Error(n);
+    } catch {
+    }
+  }
+}
+var C = { exports: {} }, L = {}, N = { exports: {} }, P = {};
+var K;
+function le() {
+  if (K) return P;
+  K = 1;
+  var t = A;
+  function e(h, p) {
+    return h === p && (h !== 0 || 1 / h === 1 / p) || h !== h && p !== p;
+  }
+  var n = typeof Object.is == "function" ? Object.is : e, r = t.useState, o = t.useEffect, i = t.useLayoutEffect, c = t.useDebugValue;
+  function u(h, p) {
+    var l = p(), f = r({ inst: { value: l, getSnapshot: p } }), d = f[0].inst, k = f[1];
+    return i(
+      function() {
+        d.value = l, d.getSnapshot = p, a(d) && k({ inst: d });
+      },
+      [h, l, p]
+    ), o(
+      function() {
+        return a(d) && k({ inst: d }), h(function() {
+          a(d) && k({ inst: d });
+        });
+      },
+      [h]
+    ), c(l), l;
+  }
+  function a(h) {
+    var p = h.getSnapshot;
+    h = h.value;
+    try {
+      var l = p();
+      return !n(h, l);
+    } catch {
+      return !0;
+    }
+  }
+  function s(h, p) {
+    return p();
+  }
+  var v = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? s : u;
+  return P.useSyncExternalStore = t.useSyncExternalStore !== void 0 ? t.useSyncExternalStore : v, P;
+}
+var b = {};
+var F;
+function fe() {
+  return F || (F = 1, process.env.NODE_ENV !== "production" && (function() {
+    function t(l, f) {
+      return l === f && (l !== 0 || 1 / l === 1 / f) || l !== l && f !== f;
+    }
+    function e(l, f) {
+      v || o.startTransition === void 0 || (v = !0, console.error(
+        "You are using an outdated, pre-release alpha of React 18 that does not support useSyncExternalStore. The use-sync-external-store shim will not work correctly. Upgrade to a newer pre-release."
+      ));
+      var d = f();
+      if (!h) {
+        var k = f();
+        i(d, k) || (console.error(
+          "The result of getSnapshot should be cached to avoid an infinite loop"
+        ), h = !0);
+      }
+      k = c({
+        inst: { value: d, getSnapshot: f }
+      });
+      var g = k[0].inst, T = k[1];
+      return a(
+        function() {
+          g.value = d, g.getSnapshot = f, n(g) && T({ inst: g });
+        },
+        [l, d, f]
+      ), u(
+        function() {
+          return n(g) && T({ inst: g }), l(function() {
+            n(g) && T({ inst: g });
+          });
+        },
+        [l]
+      ), s(d), d;
+    }
+    function n(l) {
+      var f = l.getSnapshot;
+      l = l.value;
+      try {
+        var d = f();
+        return !i(l, d);
+      } catch {
+        return !0;
+      }
+    }
+    function r(l, f) {
+      return f();
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var o = A, i = typeof Object.is == "function" ? Object.is : t, c = o.useState, u = o.useEffect, a = o.useLayoutEffect, s = o.useDebugValue, v = !1, h = !1, p = typeof window > "u" || typeof window.document > "u" || typeof window.document.createElement > "u" ? r : e;
+    b.useSyncExternalStore = o.useSyncExternalStore !== void 0 ? o.useSyncExternalStore : p, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })()), b;
+}
+var G;
+function ee() {
+  return G || (G = 1, process.env.NODE_ENV === "production" ? N.exports = le() : N.exports = fe()), N.exports;
+}
+var q;
+function de() {
+  if (q) return L;
+  q = 1;
+  var t = A, e = ee();
+  function n(s, v) {
+    return s === v && (s !== 0 || 1 / s === 1 / v) || s !== s && v !== v;
+  }
+  var r = typeof Object.is == "function" ? Object.is : n, o = e.useSyncExternalStore, i = t.useRef, c = t.useEffect, u = t.useMemo, a = t.useDebugValue;
+  return L.useSyncExternalStoreWithSelector = function(s, v, h, p, l) {
+    var f = i(null);
+    if (f.current === null) {
+      var d = { hasValue: !1, value: null };
+      f.current = d;
+    } else d = f.current;
+    f = u(
+      function() {
+        function g(m) {
+          if (!T) {
+            if (T = !0, y = m, m = p(m), l !== void 0 && d.hasValue) {
+              var E = d.value;
+              if (l(E, m))
+                return O = E;
+            }
+            return O = m;
+          }
+          if (E = O, r(y, m)) return E;
+          var W = p(m);
+          return l !== void 0 && l(E, W) ? (y = m, E) : (y = m, O = W);
+        }
+        var T = !1, y, O, w = h === void 0 ? null : h;
+        return [
+          function() {
+            return g(v());
+          },
+          w === null ? void 0 : function() {
+            return g(w());
+          }
+        ];
+      },
+      [v, h, p, l]
+    );
+    var k = o(s, f[0], f[1]);
+    return c(
+      function() {
+        d.hasValue = !0, d.value = k;
+      },
+      [k]
+    ), a(k), k;
+  }, L;
+}
+var I = {};
+var X;
+function he() {
+  return X || (X = 1, process.env.NODE_ENV !== "production" && (function() {
+    function t(s, v) {
+      return s === v && (s !== 0 || 1 / s === 1 / v) || s !== s && v !== v;
+    }
+    typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStart(Error());
+    var e = A, n = ee(), r = typeof Object.is == "function" ? Object.is : t, o = n.useSyncExternalStore, i = e.useRef, c = e.useEffect, u = e.useMemo, a = e.useDebugValue;
+    I.useSyncExternalStoreWithSelector = function(s, v, h, p, l) {
+      var f = i(null);
+      if (f.current === null) {
+        var d = { hasValue: !1, value: null };
+        f.current = d;
+      } else d = f.current;
+      f = u(
+        function() {
+          function g(m) {
+            if (!T) {
+              if (T = !0, y = m, m = p(m), l !== void 0 && d.hasValue) {
+                var E = d.value;
+                if (l(E, m))
+                  return O = E;
+              }
+              return O = m;
+            }
+            if (E = O, r(y, m))
+              return E;
+            var W = p(m);
+            return l !== void 0 && l(E, W) ? (y = m, E) : (y = m, O = W);
+          }
+          var T = !1, y, O, w = h === void 0 ? null : h;
+          return [
+            function() {
+              return g(v());
+            },
+            w === null ? void 0 : function() {
+              return g(w());
+            }
+          ];
+        },
+        [v, h, p, l]
+      );
+      var k = o(s, f[0], f[1]);
+      return c(
+        function() {
+          d.hasValue = !0, d.value = k;
+        },
+        [k]
+      ), a(k), k;
+    }, typeof __REACT_DEVTOOLS_GLOBAL_HOOK__ < "u" && typeof __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop == "function" && __REACT_DEVTOOLS_GLOBAL_HOOK__.registerInternalModuleStop(Error());
+  })()), I;
+}
+var $;
+function pe() {
+  return $ || ($ = 1, process.env.NODE_ENV === "production" ? C.exports = de() : C.exports = he()), C.exports;
+}
+var ve = pe();
+function ke(t, e = (r) => r, n = {}) {
+  const r = n.equal ?? me;
+  return ve.useSyncExternalStoreWithSelector(
+    t.subscribe,
+    () => t.state,
+    () => t.state,
+    e,
+    r
+  );
+}
+function me(t, e) {
+  if (Object.is(t, e))
+    return !0;
+  if (typeof t != "object" || t === null || typeof e != "object" || e === null)
+    return !1;
+  if (t instanceof Map && e instanceof Map) {
+    if (t.size !== e.size) return !1;
+    for (const [r, o] of t)
+      if (!e.has(r) || !Object.is(o, e.get(r))) return !1;
+    return !0;
+  }
+  if (t instanceof Set && e instanceof Set) {
+    if (t.size !== e.size) return !1;
+    for (const r of t)
+      if (!e.has(r)) return !1;
+    return !0;
+  }
+  if (t instanceof Date && e instanceof Date)
+    return t.getTime() === e.getTime();
+  const n = j(t);
+  if (n.length !== j(e).length)
+    return !1;
+  for (let r = 0; r < n.length; r++)
+    if (!Object.prototype.hasOwnProperty.call(e, n[r]) || !Object.is(t[n[r]], e[n[r]]))
+      return !1;
+  return !0;
+}
+function j(t) {
+  return Object.keys(t).concat(
+    Object.getOwnPropertySymbols(t)
+  );
+}
+const D = S.createContext(null);
+function ge() {
+  return typeof document > "u" ? D : window.__TSR_ROUTER_CONTEXT__ ? window.__TSR_ROUTER_CONTEXT__ : (window.__TSR_ROUTER_CONTEXT__ = D, D);
+}
+function Ee(t) {
+  const e = S.useContext(ge());
+  return ue(
+    !((t?.warn ?? !0) && !e),
+    "useRouter must be used inside a <RouterProvider> component!"
+  ), e;
+}
+function Se(t) {
+  const e = Ee({
+    warn: t?.router === void 0
+  }), n = t?.router || e, r = R(void 0);
+  return ke(n.__store, (o) => {
+    if (t?.select) {
+      if (t.structuralSharing ?? n.options.defaultStructuralSharing) {
+        const i = Z(
+          r.current,
+          t.select(o)
+        );
+        return r.current = i, i;
+      }
+      return t.select(o);
+    }
+    return o;
+  });
+}
+function _e(t) {
+  return Se({
+    select: (e) => e.location
+  });
+}
+class Te {
+  serviceWorkerRegistration = null;
+  sharedWorker = null;
+  sharedWorkerPort = null;
+  workerType = null;
+  pendingAuthToken = null;
+  // connection status subscribers
+  connectionStatusCallbacks = /* @__PURE__ */ new Set();
+  serviceWorkerMessageHandler = null;
+  // Mutex/promise to prevent concurrent init runs
+  initPromise = null;
+  // Initialize and choose worker implementation (prefer SharedWorker)
+  async init(e) {
+    return this.initPromise ? this.initPromise.then(async () => {
+      e && this.workerType !== "service" && await this.init(e);
+    }) : (this.initPromise = (async () => {
+      try {
+        if (e) {
+          this.serviceWorkerRegistration = e, this.workerType = "service", console.log("[WorkerClient] Using ServiceWorker (explicit registration)"), this.pendingAuthToken && (this.sendAuthTokenToServiceWorker(this.pendingAuthToken), this.pendingAuthToken = null);
+          return;
+        }
+        if (typeof SharedWorker < "u")
+          try {
+            if (this.sharedWorker = new SharedWorker("/shared-worker.js", { type: "module" }), this.sharedWorkerPort = this.sharedWorker.port, this.sharedWorkerPort.start(), this.pendingAuthToken && this.sharedWorkerPort)
+              try {
+                this.sharedWorkerPort.postMessage({ type: "SET_AUTH_TOKEN", token: this.pendingAuthToken });
+              } catch (r) {
+                console.warn("[WorkerClient] Immediate postMessage to SharedWorker failed (will retry after init):", r);
+              }
+            this.sharedWorker.onerror = (r) => {
+              console.error("[WorkerClient] SharedWorker error:", r.message || r.error || r), this.workerType !== "shared" && this.initServiceWorkerFallback().catch((o) => {
+                console.error("[WorkerClient] Failed to initialize ServiceWorker fallback:", o);
+              });
+            }, await new Promise((r, o) => {
+              let i = !1;
+              const c = setTimeout(() => {
+                if (!i) {
+                  const a = this.sharedWorkerPort;
+                  a && (a.onmessage = null), o(new Error("SharedWorker initialization timeout"));
+                }
+              }, 2e3), u = this.sharedWorkerPort;
+              if (!u)
+                return clearTimeout(c), o(new Error("SharedWorker port not available"));
+              u.onmessage = (a) => {
+                try {
+                  const s = a.data;
+                  s && s.type === "CONNECTION_STATUS" && (clearTimeout(c), i = !0, this.workerType = "shared", u.onmessage = null, r());
+                } catch {
+                }
+              };
+            });
+            const n = this.sharedWorkerPort;
+            if (this.pendingAuthToken && n)
+              try {
+                n.postMessage({ type: "SET_AUTH_TOKEN", token: this.pendingAuthToken }), this.pendingAuthToken = null;
+              } catch (r) {
+                console.error("[WorkerClient] Failed to send pending auth token to SharedWorker:", r);
+              }
+            n && (n.onmessage = (r) => {
+              try {
+                const o = r.data;
+                if (o && o.type === "CONNECTION_STATUS") {
+                  const i = !!o.connected;
+                  this.connectionStatusCallbacks.forEach((c) => {
+                    try {
+                      c(i);
+                    } catch {
+                    }
+                  });
+                }
+              } catch {
+              }
+            }), console.log("[WorkerClient] Using SharedWorker");
+            return;
+          } catch (n) {
+            console.warn("[WorkerClient] SharedWorker not available, falling back to ServiceWorker:", n);
+          }
+        console.log("this should not be called"), await this.initServiceWorkerFallback(), this.pendingAuthToken && this.workerType === "service" && (this.sendAuthTokenToServiceWorker(this.pendingAuthToken), this.pendingAuthToken = null);
+      } finally {
+        this.initPromise = null;
+      }
+    })(), this.initPromise);
+  }
+  async initServiceWorkerFallback() {
+    if (console.log("initServiceWorkerFallback called"), "serviceWorker" in navigator)
+      try {
+        const e = await navigator.serviceWorker.getRegistration();
+        if (e) {
+          this.serviceWorkerRegistration = e, this.workerType = "service", console.log("[WorkerClient] Using existing ServiceWorker registration");
+          return;
+        }
+        const n = await navigator.serviceWorker.register("/sw.js");
+        this.serviceWorkerRegistration = n, this.workerType = "service", console.log("[WorkerClient] Using ServiceWorker (fallback)"), this.serviceWorkerMessageHandler && (navigator.serviceWorker.removeEventListener("message", this.serviceWorkerMessageHandler), this.serviceWorkerMessageHandler = null), this.serviceWorkerMessageHandler = (r) => {
+          try {
+            const o = r.data;
+            if (o && o.type === "CONNECTION_STATUS") {
+              const i = !!o.connected;
+              this.connectionStatusCallbacks.forEach((c) => {
+                try {
+                  c(i);
+                } catch {
+                }
+              });
+            }
+          } catch {
+          }
+        }, navigator.serviceWorker.addEventListener("message", this.serviceWorkerMessageHandler);
+      } catch (e) {
+        throw console.error("[WorkerClient] Failed to register ServiceWorker:", e), e;
+      }
+    else
+      throw new Error("Neither SharedWorker nor ServiceWorker is supported");
+  }
+  // Low-level request that expects a reply via MessageChannel
+  async request(e, n, r = 5e3) {
+    if (this.workerType === "shared" && this.sharedWorkerPort)
+      return new Promise((o, i) => {
+        const c = new MessageChannel(), u = setTimeout(() => {
+          c.port1.onmessage = null, i(new Error("Request timeout"));
+        }, r);
+        c.port1.onmessage = (a) => {
+          clearTimeout(u), a.data && a.data.success ? o(a.data) : a.data && a.data.success === !1 ? i(new Error(a.data.error || "Worker error")) : o(a.data);
+        };
+        try {
+          const a = this.sharedWorkerPort;
+          if (!a)
+            return clearTimeout(u), i(new Error("SharedWorker port not available"));
+          a.postMessage({ type: e, ...n || {} }, [c.port2]);
+        } catch (a) {
+          clearTimeout(u), i(a instanceof Error ? a : new Error(String(a)));
+        }
+      });
+    if (this.workerType === "service" && this.serviceWorkerRegistration) {
+      const o = this.serviceWorkerRegistration;
+      if (!o) throw new Error("Service worker registration missing");
+      if (!o.active && (await navigator.serviceWorker.ready, !o.active))
+        throw new Error("Service worker not active");
+      return new Promise((i, c) => {
+        const u = new MessageChannel(), a = setTimeout(() => {
+          u.port1.onmessage = null, c(new Error("Request timeout"));
+        }, r);
+        u.port1.onmessage = (s) => {
+          clearTimeout(a), s.data && s.data.success ? i(s.data) : s.data && s.data.success === !1 ? c(new Error(s.data.error || "Worker error")) : i(s.data);
+        };
+        try {
+          const s = o.active;
+          if (!s)
+            return clearTimeout(a), c(new Error("Service worker active instance not available"));
+          s.postMessage({ type: e, ...n || {} }, [u.port2]);
+        } catch (s) {
+          clearTimeout(a), c(s instanceof Error ? s : new Error(String(s)));
+        }
+      });
+    }
+    throw new Error("No worker registered");
+  }
+  // Fire-and-forget postMessage (no response expected)
+  async post(e, n) {
+    if (this.workerType === "shared" && this.sharedWorkerPort) {
+      try {
+        this.sharedWorkerPort.postMessage({ type: e, ...n || {} });
+      } catch (r) {
+        console.error("[WorkerClient] Failed to post to SharedWorker:", r);
+      }
+      return;
+    }
+    if (this.workerType === "service" && this.serviceWorkerRegistration?.active) {
+      try {
+        this.serviceWorkerRegistration.active.postMessage({ type: e, ...n || {} });
+      } catch (r) {
+        console.error("[WorkerClient] Failed to post to ServiceWorker (active):", r);
+      }
+      return;
+    }
+    if ("serviceWorker" in navigator && navigator.serviceWorker.controller) {
+      try {
+        navigator.serviceWorker.controller.postMessage({ type: e, ...n || {} });
+      } catch (r) {
+        console.error("[WorkerClient] Failed to post to ServiceWorker.controller:", r);
+      }
+      return;
+    }
+    if (e === "SET_AUTH_TOKEN" && n) {
+      const r = n.token;
+      typeof r == "string" && (this.pendingAuthToken = r);
+    }
+  }
+  sendAuthTokenToServiceWorker(e) {
+    if (this.serviceWorkerRegistration?.active)
+      try {
+        this.serviceWorkerRegistration.active.postMessage({ type: "SET_AUTH_TOKEN", token: e });
+      } catch (n) {
+        console.error("[WorkerClient] Failed to send auth token to ServiceWorker:", n);
+      }
+    else if ("serviceWorker" in navigator && navigator.serviceWorker.controller)
+      try {
+        navigator.serviceWorker.controller.postMessage({ type: "SET_AUTH_TOKEN", token: e });
+      } catch (n) {
+        console.error("[WorkerClient] Failed to send auth token to ServiceWorker.controller:", n);
+      }
+    else
+      this.pendingAuthToken = e;
+  }
+  // Subscription API for consumers to listen for connection status updates
+  onConnectionStatus(e) {
+    this.connectionStatusCallbacks.add(e);
+  }
+  offConnectionStatus(e) {
+    this.connectionStatusCallbacks.delete(e);
+  }
+  async getConnectionStatus() {
+    try {
+      const e = await this.request("GET_CONNECTION_STATUS", void 0, 2e3);
+      return e && typeof e == "object" && "connected" in e, !!e.connected;
+    } catch {
+      return !1;
+    }
+  }
+  setAuthToken(e) {
+    if (this.pendingAuthToken = e, this.workerType === "shared" && this.sharedWorkerPort)
+      try {
+        this.sharedWorkerPort.postMessage({ type: "SET_AUTH_TOKEN", token: e }), this.pendingAuthToken = null;
+      } catch (n) {
+        console.error("[WorkerClient] Failed to set auth token on SharedWorker:", n);
+      }
+    else this.workerType === "service" && (this.sendAuthTokenToServiceWorker(e), this.pendingAuthToken = null);
+  }
+}
+const te = new Te();
+async function re(t) {
+  return te.init(t);
+}
+async function M(t) {
+  const e = { ...t, timestamp: Date.now() };
+  await te.request("STORE_EVENT", { event: e });
+}
+async function ne(t, e, n) {
+  return M({ type: "navigation", from: t, to: e, path: n || e });
+}
+async function oe(t, e, n) {
+  const r = t.id || void 0, o = t.className || void 0, i = t.textContent?.trim().substring(0, 100) || void 0, c = t.tagName.toLowerCase();
+  return M({
+    type: "click",
+    element: c,
+    elementId: r,
+    elementClass: o,
+    elementText: i,
+    path: e || window.location.pathname,
+    metadata: n
+  });
+}
+async function ie(t, e, n) {
+  const r = t.id || void 0, o = t.className || void 0, i = t.tagName.toLowerCase();
+  return M({
+    type: "input",
+    element: i,
+    elementId: r,
+    elementClass: o,
+    path: n || window.location.pathname,
+    metadata: {
+      valueLength: e?.length || 0,
+      value: e
+    }
+  });
+}
+function be() {
+  const t = _e(), [e, n] = Q(!1), r = R(t.pathname), o = R(null);
+  _(() => {
+    r.current !== t.pathname && (o.current = r.current, r.current = t.pathname);
+  }, [t.pathname]), _(() => {
+    re().then(() => n(!0)).catch((i) => {
+      console.error("Worker initialization failed:", i);
+    });
+  }, []), _(() => {
+    if (!e) return;
+    const i = o.current, c = r.current;
+    i && i !== c && ne(i, c, c).catch((u) => {
+      console.error("Failed to track navigation:", u);
+    });
+  }, [t.pathname, e]), _(() => {
+    if (!e) return;
+    const i = (c) => {
+      const u = c.target;
+      if (!u) return;
+      u.tagName === "BUTTON" || u.tagName === "A" || u.closest("button") || u.closest("a") || oe(u, r.current).catch((s) => {
+        console.error("Failed to track click:", s);
+      });
+    };
+    return document.addEventListener("click", i, !0), () => document.removeEventListener("click", i, !0);
+  }, [e]), _(() => {
+    if (!e) return;
+    let i;
+    const c = (u) => {
+      const a = u.target;
+      a && (a.tagName === "INPUT" || a.tagName === "TEXTAREA") && (clearTimeout(i), i = setTimeout(() => {
+        ie(a, a.value, r.current).catch(
+          (s) => {
+            console.error("Failed to track input:", s);
+          }
+        );
+      }, 1e3));
+    };
+    return document.addEventListener("input", c, !0), () => {
+      clearTimeout(i), document.removeEventListener("input", c, !0);
+    };
+  }, [e]);
+}
+var Y;
+(function(t) {
+  t.Pop = "POP", t.Push = "PUSH", t.Replace = "REPLACE";
+})(Y || (Y = {}));
+function B(t, e) {
+  throw new Error(e);
+}
+var J;
+(function(t) {
+  t.data = "data", t.deferred = "deferred", t.redirect = "redirect", t.error = "error";
+})(J || (J = {}));
+const ae = ["post", "put", "patch", "delete"];
+new Set(ae);
+const ye = ["get", ...ae];
+new Set(ye);
+const Oe = /* @__PURE__ */ S.createContext(null);
+process.env.NODE_ENV !== "production" && (Oe.displayName = "DataRouter");
+const we = /* @__PURE__ */ S.createContext(null);
+process.env.NODE_ENV !== "production" && (we.displayName = "DataRouterState");
+const We = /* @__PURE__ */ S.createContext(null);
+process.env.NODE_ENV !== "production" && (We.displayName = "Await");
+const Re = /* @__PURE__ */ S.createContext(null);
+process.env.NODE_ENV !== "production" && (Re.displayName = "Navigation");
+const V = /* @__PURE__ */ S.createContext(null);
+process.env.NODE_ENV !== "production" && (V.displayName = "Location");
+const Ce = /* @__PURE__ */ S.createContext({
+  outlet: null,
+  matches: [],
+  isDataRoute: !1
+});
+process.env.NODE_ENV !== "production" && (Ce.displayName = "Route");
+const Ne = /* @__PURE__ */ S.createContext(null);
+process.env.NODE_ENV !== "production" && (Ne.displayName = "RouteError");
+function Ae() {
+  return S.useContext(V) != null;
+}
+function Le() {
+  return Ae() || (process.env.NODE_ENV !== "production" ? B(
+    !1,
+    // TODO: This error is probably because they somehow have 2 versions of the
+    // router loaded. We can help them understand how to avoid that.
+    "useLocation() may be used only in the context of a <Router> component."
+  ) : B()), S.useContext(V).location;
+}
+new Promise(() => {
+});
+function Ie() {
+  const t = Le(), [e, n] = Q(!1), r = R(t.pathname), o = R(null);
+  _(() => {
+    o.current = r.current, r.current = t.pathname;
+  }, [t.pathname]), _(() => {
+    re().then(() => {
+      n(!0);
+    }).catch((i) => {
+      console.error("Worker initialization failed:", i);
+    });
+  }, []), _(() => {
+    if (!e) return;
+    const i = o.current, c = r.current;
+    i && i !== c && ne(i, c, c).catch((u) => {
+      console.error("Failed to track navigation:", u);
+    });
+  }, [t.pathname, e]), _(() => {
+    if (!e) return;
+    const i = (c) => {
+      const u = c.target;
+      if (!u) return;
+      u.tagName === "BUTTON" || u.tagName === "A" || u.closest("button") || u.closest("a") || oe(u, r.current).catch((s) => {
+        console.error("Failed to track click:", s);
+      });
+    };
+    return document.addEventListener("click", i, !0), () => document.removeEventListener("click", i, !0);
+  }, [e]), _(() => {
+    if (!e) return;
+    let i;
+    const c = (u) => {
+      const a = u.target;
+      a && (a.tagName === "INPUT" || a.tagName === "TEXTAREA") && (clearTimeout(i), i = setTimeout(() => {
+        ie(a, a.value, r.current).catch(
+          (s) => {
+            console.error("Failed to track input:", s);
+          }
+        );
+      }, 1e3));
+    };
+    return document.addEventListener("input", c, !0), () => {
+      clearTimeout(i), document.removeEventListener("input", c, !0);
+    };
+  }, [e]);
+}
+export {
+  Ie as useReactRouterEventTracker,
+  be as useTanstackRouterEventTracker
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mcp-fe/react-event-tracker",
-  "version": "0.0.5",
+  "version": "0.0.9",
   "main": "./index.js",
   "types": "./index.d.ts",
   "exports": {
@@ -10,7 +10,7 @@
     }
   },
   "dependencies": {
-    "@mcp-fe/event-tracker": "0.0.5"
+    "@mcp-fe/event-tracker": "0.0.9"
   },
   "publishConfig": {
     "access": "public"

package/.babelrc

@@ -1,12 +0,0 @@
-{
-  "presets": [
-    [
-      "@nx/react/babel",
-      {
-        "runtime": "automatic",
-        "useBuiltIns": "usage"
-      }
-    ]
-  ],
-  "plugins": []
-}

package/eslint.config.mjs

@@ -1,12 +0,0 @@
-import nx from '@nx/eslint-plugin';
-import baseConfig from '../../eslint.config.mjs';
-
-export default [
-  ...baseConfig,
-  ...nx.configs['flat/react'],
-  {
-    files: ['**/*.ts', '**/*.tsx', '**/*.js', '**/*.jsx'],
-    // Override or add rules here
-    rules: {},
-  },
-];

package/project.json

@@ -1,9 +0,0 @@
-{
-  "name": "react-event-tracker",
-  "$schema": "../../node_modules/nx/schemas/project-schema.json",
-  "sourceRoot": "libs/react-event-tracker/src",
-  "projectType": "library",
-  "tags": [],
-  "// targets": "to see all targets run: nx show project react-event-tracker --web",
-  "targets": {}
-}

package/src/hooks/useReactRouterEventTracker.ts

@@ -1,97 +0,0 @@
-import { useEffect, useRef, useState } from 'react';
-import { useLocation } from 'react-router-dom';
-import {
-  initEventTracker,
-  trackNavigation,
-  trackClick,
-  trackInput,
-} from '@mcp-fe/event-tracker';
-
-export function useReactRouterEventTracker(): void {
-  const location = useLocation();
-  const [isInitialized, setIsInitialized] = useState(false);
-
-  const currentPathRef = useRef(location.pathname);
-  const prevPathRef = useRef<string | null>(null);
-
-  useEffect(() => {
-    prevPathRef.current = currentPathRef.current;
-    currentPathRef.current = location.pathname;
-  }, [location.pathname]);
-
-  useEffect(() => {
-    initEventTracker()
-      .then(() => {
-        setIsInitialized(true);
-      })
-      .catch((error) => {
-        console.error('Worker initialization failed:', error);
-      });
-  }, []);
-
-  useEffect(() => {
-    if (!isInitialized) return;
-
-    const prevPath = prevPathRef.current;
-    const currentPath = currentPathRef.current;
-
-    if (prevPath && prevPath !== currentPath) {
-      trackNavigation(prevPath, currentPath, currentPath).catch((error) => {
-        console.error('Failed to track navigation:', error);
-      });
-    }
-  }, [location.pathname, isInitialized]);
-
-  useEffect(() => {
-    if (!isInitialized) return;
-
-    const handleClick = (event: MouseEvent): void => {
-      const target = event.target as HTMLElement;
-      if (!target) return;
-
-      const isInteractive =
-        target.tagName === 'BUTTON' ||
-        target.tagName === 'A' ||
-        target.closest('button') ||
-        target.closest('a');
-
-      if (!isInteractive) {
-        trackClick(target, currentPathRef.current).catch((error) => {
-          console.error('Failed to track click:', error);
-        });
-      }
-    };
-
-    document.addEventListener('click', handleClick, true);
-    return () => document.removeEventListener('click', handleClick, true);
-  }, [isInitialized]);
-
-  useEffect(() => {
-    if (!isInitialized) return;
-
-    let timeoutId: ReturnType<typeof setTimeout>;
-
-    const handleInput = (event: Event): void => {
-      const target = event.target as HTMLInputElement | HTMLTextAreaElement;
-      if (
-        target &&
-        (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA')
-      ) {
-        clearTimeout(timeoutId);
-        timeoutId = setTimeout(() => {
-          trackInput(target, target.value, currentPathRef.current).catch(
-            (error) => {
-              console.error('Failed to track input:', error);
-            },
-          );
-        }, 1000); // Debounce by 1 second
-      }
-    };
-
-    document.addEventListener('input', handleInput, true);
-    return () => {
-      clearTimeout(timeoutId);
-      document.removeEventListener('input', handleInput, true);
-    };
-  }, [isInitialized]);
-}

package/src/hooks/useTanstackRouterEventTracker.ts

@@ -1,97 +0,0 @@
-import { useEffect, useRef, useState } from 'react';
-import { useLocation } from '@tanstack/react-router';
-import {
-  initEventTracker,
-  trackNavigation,
-  trackClick,
-  trackInput,
-} from '@mcp-fe/event-tracker';
-
-export function useTanstackRouterEventTracker(): void {
-  const location = useLocation();
-  const [isInitialized, setIsInitialized] = useState(false);
-
-  const currentPathRef = useRef(location.pathname);
-  const prevPathRef = useRef<string | null>(null);
-
-  useEffect(() => {
-    if (currentPathRef.current !== location.pathname) {
-      prevPathRef.current = currentPathRef.current;
-      currentPathRef.current = location.pathname;
-    }
-  }, [location.pathname]);
-
-  useEffect(() => {
-    initEventTracker()
-      .then(() => setIsInitialized(true))
-      .catch((error) => {
-        console.error('Worker initialization failed:', error);
-      });
-  }, []);
-
-  useEffect(() => {
-    if (!isInitialized) return;
-
-    const prevPath = prevPathRef.current;
-    const currentPath = currentPathRef.current;
-
-    if (prevPath && prevPath !== currentPath) {
-      trackNavigation(prevPath, currentPath, currentPath).catch((error) => {
-        console.error('Failed to track navigation:', error);
-      });
-    }
-  }, [location.pathname, isInitialized]);
-
-  useEffect(() => {
-    if (!isInitialized) return;
-
-    const handleClick = (event: MouseEvent): void => {
-      const target = event.target as HTMLElement;
-      if (!target) return;
-
-      const isInteractive =
-        target.tagName === 'BUTTON' ||
-        target.tagName === 'A' ||
-        target.closest('button') ||
-        target.closest('a');
-
-      if (!isInteractive) {
-        trackClick(target, currentPathRef.current).catch((error) => {
-          console.error('Failed to track click:', error);
-        });
-      }
-    };
-
-    document.addEventListener('click', handleClick, true);
-    return () => document.removeEventListener('click', handleClick, true);
-  }, [isInitialized]);
-
-  useEffect(() => {
-    if (!isInitialized) return;
-
-    let timeoutId: ReturnType<typeof setTimeout>;
-
-    const handleInput = (event: Event): void => {
-      const target = event.target as HTMLInputElement | HTMLTextAreaElement;
-      if (
-        target &&
-        (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA')
-      ) {
-        clearTimeout(timeoutId);
-        timeoutId = setTimeout(() => {
-          trackInput(target, target.value, currentPathRef.current).catch(
-            (error) => {
-              console.error('Failed to track input:', error);
-            },
-          );
-        }, 1000);
-      }
-    };
-
-    document.addEventListener('input', handleInput, true);
-    return () => {
-      clearTimeout(timeoutId);
-      document.removeEventListener('input', handleInput, true);
-    };
-  }, [isInitialized]);
-}

package/tsconfig.json

@@ -1,22 +0,0 @@
-{
-  "compilerOptions": {
-    "jsx": "react-jsx",
-    "allowJs": false,
-    "esModuleInterop": false,
-    "allowSyntheticDefaultImports": true,
-    "strict": true,
-    "types": ["vite/client", "vitest"],
-    "lib": ["dom", "esnext"]
-  },
-  "files": [],
-  "include": [],
-  "references": [
-    {
-      "path": "./tsconfig.lib.json"
-    },
-    {
-      "path": "./tsconfig.spec.json"
-    }
-  ],
-  "extends": "../../tsconfig.base.json"
-}

package/tsconfig.lib.json

@@ -1,36 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../dist/out-tsc",
-    "types": [
-      "node",
-      "@nx/react/typings/cssmodule.d.ts",
-      "@nx/react/typings/image.d.ts",
-      "vite/client"
-    ]
-  },
-  "exclude": [
-    "**/*.spec.ts",
-    "**/*.test.ts",
-    "**/*.spec.tsx",
-    "**/*.test.tsx",
-    "**/*.spec.js",
-    "**/*.test.js",
-    "**/*.spec.jsx",
-    "**/*.test.jsx",
-    "vite.config.ts",
-    "vite.config.mts",
-    "vitest.config.ts",
-    "vitest.config.mts",
-    "src/**/*.test.ts",
-    "src/**/*.spec.ts",
-    "src/**/*.test.tsx",
-    "src/**/*.spec.tsx",
-    "src/**/*.test.js",
-    "src/**/*.spec.js",
-    "src/**/*.test.jsx",
-    "src/**/*.spec.jsx"
-  ],
-  "include": ["src/**/*.js", "src/**/*.jsx", "src/**/*.ts", "src/**/*.tsx"],
-  "references": []
-}

package/tsconfig.spec.json

@@ -1,28 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "outDir": "../../dist/out-tsc",
-    "types": [
-      "vitest/globals",
-      "vitest/importMeta",
-      "vite/client",
-      "node",
-      "vitest"
-    ]
-  },
-  "include": [
-    "vite.config.ts",
-    "vite.config.mts",
-    "vitest.config.ts",
-    "vitest.config.mts",
-    "src/**/*.test.ts",
-    "src/**/*.spec.ts",
-    "src/**/*.test.tsx",
-    "src/**/*.spec.tsx",
-    "src/**/*.test.js",
-    "src/**/*.spec.js",
-    "src/**/*.test.jsx",
-    "src/**/*.spec.jsx",
-    "src/**/*.d.ts"
-  ]
-}

package/vite.config.mts

@@ -1,61 +0,0 @@
-/// <reference types='vitest' />
-import { defineConfig } from 'vite';
-import react from '@vitejs/plugin-react';
-import dts from 'vite-plugin-dts';
-import * as path from 'path';
-import { nxViteTsPaths } from '@nx/vite/plugins/nx-tsconfig-paths.plugin';
-import { nxCopyAssetsPlugin } from '@nx/vite/plugins/nx-copy-assets.plugin';
-
-export default defineConfig(() => ({
-  root: import.meta.dirname,
-  cacheDir: '../../node_modules/.vite/libs/react-event-tracker',
-  plugins: [
-    react(),
-    nxViteTsPaths(),
-    nxCopyAssetsPlugin(['*.md']),
-    dts({
-      entryRoot: 'src',
-      tsconfigPath: path.join(import.meta.dirname, 'tsconfig.lib.json'),
-      pathsToAliases: false,
-    }),
-  ],
-  // Uncomment this if you are using workers.
-  // worker: {
-  //   plugins: () => [ nxViteTsPaths() ],
-  // },
-  // Configuration for building your library.
-  // See: https://vite.dev/guide/build.html#library-mode
-  build: {
-    outDir: '../../dist/libs/react-event-tracker',
-    emptyOutDir: true,
-    reportCompressedSize: true,
-    commonjsOptions: {
-      transformMixedEsModules: true,
-    },
-    lib: {
-      // Could also be a dictionary or array of multiple entry points.
-      entry: 'src/index.ts',
-      name: 'react-event-tracker',
-      fileName: 'index',
-      // Change this to the formats you want to support.
-      // Don't forget to update your package.json as well.
-      formats: ['es' as const],
-    },
-    rollupOptions: {
-      // External packages that should not be bundled into your library.
-      external: ['react', 'react-dom', 'react/jsx-runtime'],
-    },
-  },
-  test: {
-    name: 'react-event-tracker',
-    watch: false,
-    globals: true,
-    environment: 'jsdom',
-    include: ['{src,tests}/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
-    reporters: ['default'],
-    coverage: {
-      reportsDirectory: '../../coverage/libs/react-event-tracker',
-      provider: 'v8' as const,
-    },
-  },
-}));