@mcp-fe/event-tracker 0.0.5 → 0.0.11

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

@@ -1 +1,2 @@
 export * from './lib/event-tracker';
+//# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

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

package/index.js

@@ -0,0 +1,327 @@
+class g {
+  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("/mcp-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 (t) {
+                console.warn("[WorkerClient] Immediate postMessage to SharedWorker failed (will retry after init):", t);
+              }
+            this.sharedWorker.onerror = (t) => {
+              console.error("[WorkerClient] SharedWorker error:", t.message || t.error || t), this.workerType !== "shared" && this.initServiceWorkerFallback().catch((n) => {
+                console.error("[WorkerClient] Failed to initialize ServiceWorker fallback:", n);
+              });
+            }, await new Promise((t, n) => {
+              let s = !1;
+              const a = setTimeout(() => {
+                if (!s) {
+                  const i = this.sharedWorkerPort;
+                  i && (i.onmessage = null), n(new Error("SharedWorker initialization timeout"));
+                }
+              }, 2e3), l = this.sharedWorkerPort;
+              if (!l)
+                return clearTimeout(a), n(new Error("SharedWorker port not available"));
+              l.onmessage = (i) => {
+                try {
+                  const c = i.data;
+                  c && c.type === "CONNECTION_STATUS" && (clearTimeout(a), s = !0, this.workerType = "shared", l.onmessage = null, t());
+                } catch {
+                }
+              };
+            });
+            const r = this.sharedWorkerPort;
+            if (this.pendingAuthToken && r)
+              try {
+                r.postMessage({ type: "SET_AUTH_TOKEN", token: this.pendingAuthToken }), this.pendingAuthToken = null;
+              } catch (t) {
+                console.error("[WorkerClient] Failed to send pending auth token to SharedWorker:", t);
+              }
+            r && (r.onmessage = (t) => {
+              try {
+                const n = t.data;
+                if (n && n.type === "CONNECTION_STATUS") {
+                  const s = !!n.connected;
+                  this.connectionStatusCallbacks.forEach((a) => {
+                    try {
+                      a(s);
+                    } catch {
+                    }
+                  });
+                }
+              } catch {
+              }
+            }), console.log("[WorkerClient] Using SharedWorker");
+            return;
+          } catch (r) {
+            console.warn("[WorkerClient] SharedWorker not available, falling back to ServiceWorker:", r);
+          }
+        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 r = await navigator.serviceWorker.register("/mcp-service-worker.js");
+        this.serviceWorkerRegistration = r, this.workerType = "service", console.log("[WorkerClient] Using ServiceWorker (fallback)"), this.serviceWorkerMessageHandler && (navigator.serviceWorker.removeEventListener("message", this.serviceWorkerMessageHandler), this.serviceWorkerMessageHandler = null), this.serviceWorkerMessageHandler = (t) => {
+          try {
+            const n = t.data;
+            if (n && n.type === "CONNECTION_STATUS") {
+              const s = !!n.connected;
+              this.connectionStatusCallbacks.forEach((a) => {
+                try {
+                  a(s);
+                } 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, r, t = 5e3) {
+    if (this.workerType === "shared" && this.sharedWorkerPort)
+      return new Promise((n, s) => {
+        const a = new MessageChannel(), l = setTimeout(() => {
+          a.port1.onmessage = null, s(new Error("Request timeout"));
+        }, t);
+        a.port1.onmessage = (i) => {
+          clearTimeout(l), i.data && i.data.success ? n(i.data) : i.data && i.data.success === !1 ? s(new Error(i.data.error || "Worker error")) : n(i.data);
+        };
+        try {
+          const i = this.sharedWorkerPort;
+          if (!i)
+            return clearTimeout(l), s(new Error("SharedWorker port not available"));
+          i.postMessage({ type: e, ...r || {} }, [a.port2]);
+        } catch (i) {
+          clearTimeout(l), s(i instanceof Error ? i : new Error(String(i)));
+        }
+      });
+    if (this.workerType === "service" && this.serviceWorkerRegistration) {
+      const n = this.serviceWorkerRegistration;
+      if (!n) throw new Error("Service worker registration missing");
+      if (!n.active && (await navigator.serviceWorker.ready, !n.active))
+        throw new Error("Service worker not active");
+      return new Promise((s, a) => {
+        const l = new MessageChannel(), i = setTimeout(() => {
+          l.port1.onmessage = null, a(new Error("Request timeout"));
+        }, t);
+        l.port1.onmessage = (c) => {
+          clearTimeout(i), c.data && c.data.success ? s(c.data) : c.data && c.data.success === !1 ? a(new Error(c.data.error || "Worker error")) : s(c.data);
+        };
+        try {
+          const c = n.active;
+          if (!c)
+            return clearTimeout(i), a(new Error("Service worker active instance not available"));
+          c.postMessage({ type: e, ...r || {} }, [l.port2]);
+        } catch (c) {
+          clearTimeout(i), a(c instanceof Error ? c : new Error(String(c)));
+        }
+      });
+    }
+    throw new Error("No worker registered");
+  }
+  // Fire-and-forget postMessage (no response expected)
+  async post(e, r) {
+    if (this.workerType === "shared" && this.sharedWorkerPort) {
+      try {
+        this.sharedWorkerPort.postMessage({ type: e, ...r || {} });
+      } catch (t) {
+        console.error("[WorkerClient] Failed to post to SharedWorker:", t);
+      }
+      return;
+    }
+    if (this.workerType === "service" && this.serviceWorkerRegistration?.active) {
+      try {
+        this.serviceWorkerRegistration.active.postMessage({ type: e, ...r || {} });
+      } catch (t) {
+        console.error("[WorkerClient] Failed to post to ServiceWorker (active):", t);
+      }
+      return;
+    }
+    if ("serviceWorker" in navigator && navigator.serviceWorker.controller) {
+      try {
+        navigator.serviceWorker.controller.postMessage({ type: e, ...r || {} });
+      } catch (t) {
+        console.error("[WorkerClient] Failed to post to ServiceWorker.controller:", t);
+      }
+      return;
+    }
+    if (e === "SET_AUTH_TOKEN" && r) {
+      const t = r.token;
+      typeof t == "string" && (this.pendingAuthToken = t);
+    }
+  }
+  sendAuthTokenToServiceWorker(e) {
+    if (this.serviceWorkerRegistration?.active)
+      try {
+        this.serviceWorkerRegistration.active.postMessage({ type: "SET_AUTH_TOKEN", token: e });
+      } catch (r) {
+        console.error("[WorkerClient] Failed to send auth token to ServiceWorker:", r);
+      }
+    else if ("serviceWorker" in navigator && navigator.serviceWorker.controller)
+      try {
+        navigator.serviceWorker.controller.postMessage({ type: "SET_AUTH_TOKEN", token: e });
+      } catch (r) {
+        console.error("[WorkerClient] Failed to send auth token to ServiceWorker.controller:", r);
+      }
+    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 (r) {
+        console.error("[WorkerClient] Failed to set auth token on SharedWorker:", r);
+      }
+    else this.workerType === "service" && (this.sendAuthTokenToServiceWorker(e), this.pendingAuthToken = null);
+  }
+}
+const W = "user-activity-db", p = 1, k = "user-events";
+async function v() {
+  return new Promise((o, e) => {
+    const r = indexedDB.open(W, p);
+    r.onerror = () => e(r.error), r.onsuccess = () => o(r.result), r.onupgradeneeded = (t) => {
+      const n = t.target.result;
+      if (!n.objectStoreNames.contains(k)) {
+        const s = n.createObjectStore(k, { keyPath: "id" });
+        s.createIndex("timestamp", "timestamp", { unique: !1 }), s.createIndex("type", "type", { unique: !1 }), s.createIndex("path", "path", { unique: !1 });
+      }
+    };
+  });
+}
+async function T(o) {
+  const n = (await v()).transaction([k], "readonly").objectStore(k).index("timestamp");
+  return new Promise((s, a) => {
+    const l = n.getAll();
+    l.onsuccess = () => {
+      let i = l.result;
+      i.sort((c, d) => d.timestamp - c.timestamp), s(i);
+    }, l.onerror = () => a(l.error);
+  });
+}
+const h = new g();
+async function f(o) {
+  return h.init(o);
+}
+async function u(o) {
+  const e = { ...o, timestamp: Date.now() };
+  await h.request("STORE_EVENT", { event: e });
+}
+async function m() {
+  const o = await T();
+  return Array.isArray(o) ? o : [];
+}
+async function S() {
+  return h.getConnectionStatus();
+}
+function w(o) {
+  h.setAuthToken(o);
+}
+function y(o) {
+  h.onConnectionStatus(o);
+}
+function C(o) {
+  h.offConnectionStatus(o);
+}
+async function E(o, e, r) {
+  return u({ type: "navigation", from: o, to: e, path: r || e });
+}
+async function A(o, e, r) {
+  const t = o.id || void 0, n = o.className || void 0, s = o.textContent?.trim().substring(0, 100) || void 0, a = o.tagName.toLowerCase();
+  return u({
+    type: "click",
+    element: a,
+    elementId: t,
+    elementClass: n,
+    elementText: s,
+    path: e || window.location.pathname,
+    metadata: r
+  });
+}
+async function N(o, e, r) {
+  const t = o.id || void 0, n = o.className || void 0, s = o.tagName.toLowerCase();
+  return u({
+    type: "input",
+    element: s,
+    elementId: t,
+    elementClass: n,
+    path: r || window.location.pathname,
+    metadata: {
+      valueLength: e?.length || 0,
+      value: e
+    }
+  });
+}
+async function b(o, e, r) {
+  return u({
+    type: "custom",
+    path: r || window.location.pathname,
+    metadata: {
+      eventName: o,
+      ...e
+    }
+  });
+}
+export {
+  S as getConnectionStatus,
+  m as getStoredEvents,
+  f as initEventTracker,
+  C as offConnectionStatus,
+  y as onConnectionStatus,
+  w as setAuthToken,
+  A as trackClick,
+  b as trackCustom,
+  u as trackEvent,
+  N as trackInput,
+  E as trackNavigation
+};

package/lib/event-tracker.d.ts

@@ -0,0 +1,25 @@
+import { UserEvent } from '@mcp-fe/mcp-worker';
+export type { UserEvent } from '@mcp-fe/mcp-worker';
+export interface UserEventData {
+    type: 'navigation' | 'click' | 'input' | 'custom';
+    path?: string;
+    from?: string;
+    to?: string;
+    element?: string;
+    elementId?: string;
+    elementClass?: string;
+    elementText?: string;
+    metadata?: Record<string, unknown>;
+}
+export declare function initEventTracker(registration?: ServiceWorkerRegistration): Promise<void>;
+export declare function trackEvent(event: UserEventData): Promise<void>;
+export declare function getStoredEvents(): Promise<UserEvent[]>;
+export declare function getConnectionStatus(): Promise<boolean>;
+export declare function setAuthToken(token: string): void;
+export declare function onConnectionStatus(cb: (connected: boolean) => void): void;
+export declare function offConnectionStatus(cb: (connected: boolean) => void): void;
+export declare function trackNavigation(from: string, to: string, path?: string): Promise<void>;
+export declare function trackClick(element: HTMLElement, path?: string, metadata?: Record<string, unknown>): Promise<void>;
+export declare function trackInput(element: HTMLElement, value?: string, path?: string): Promise<void>;
+export declare function trackCustom(eventName: string, metadata?: Record<string, unknown>, path?: string): Promise<void>;
+//# sourceMappingURL=event-tracker.d.ts.map

package/lib/event-tracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"event-tracker.d.ts","sourceRoot":"","sources":["../../../../libs/event-tracker/src/lib/event-tracker.ts"],"names":[],"mappings":"AAAA,OAAO,EAAe,KAAK,SAAS,EAAgB,MAAM,oBAAoB,CAAC;AAC/E,YAAY,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAGpD,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,YAAY,GAAG,OAAO,GAAG,OAAO,GAAG,QAAQ,CAAC;IAClD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,EAAE,CAAC,EAAE,MAAM,CAAC;IACZ,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;CACpC;AAMD,wBAAsB,gBAAgB,CAAC,YAAY,CAAC,EAAE,yBAAyB,GAAG,OAAO,CAAC,IAAI,CAAC,CAE9F;AAED,wBAAsB,UAAU,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC,CAIpE;AAED,wBAAsB,eAAe,IAAI,OAAO,CAAC,SAAS,EAAE,CAAC,CAG5D;AAED,wBAAsB,mBAAmB,IAAI,OAAO,CAAC,OAAO,CAAC,CAE5D;AAED,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAEhD;AAGD,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI,GAAG,IAAI,CAEzE;AAED,wBAAgB,mBAAmB,CAAC,EAAE,EAAE,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI,GAAG,IAAI,CAE1E;AAGD,wBAAsB,eAAe,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAE5F;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE,WAAW,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAevH;AAED,wBAAsB,UAAU,CAAC,OAAO,EAAE,WAAW,EAAE,KAAK,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAgBnG;AAED,wBAAsB,WAAW,CAAC,SAAS,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CASrH"}

package/package.json

@@ -1,12 +1,12 @@
 {
   "name": "@mcp-fe/event-tracker",
-  "version": "0.0.5",
+  "version": "0.0.11",
   "private": false,
   "type": "module",
   "main": "./index.js",
   "types": "./index.d.ts",
   "dependencies": {
-    "@mcp-fe/mcp-worker": "0.0.5"
+    "@mcp-fe/mcp-worker": "0.0.11"
   },
   "publishConfig": {
     "access": "public"

package/eslint.config.mjs

@@ -1,22 +0,0 @@
-import baseConfig from '../../eslint.config.mjs';
-
-export default [
-  ...baseConfig,
-  {
-    files: ['**/*.json'],
-    rules: {
-      '@nx/dependency-checks': [
-        'error',
-        {
-          ignoredFiles: [
-            '{projectRoot}/eslint.config.{js,cjs,mjs,ts,cts,mts}',
-            '{projectRoot}/vite.config.{js,ts,mjs,mts}',
-          ],
-        },
-      ],
-    },
-    languageOptions: {
-      parser: await import('jsonc-eslint-parser'),
-    },
-  },
-];

package/project.json

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

package/src/lib/event-tracker.ts

@@ -1,102 +0,0 @@
-import { queryEvents, type UserEvent, WorkerClient } from '@mcp-fe/mcp-worker';
-export type { UserEvent } from '@mcp-fe/mcp-worker';
-
-
-export interface UserEventData {
-  type: 'navigation' | 'click' | 'input' | 'custom';
-  path?: string;
-  from?: string;
-  to?: string;
-  element?: string;
-  elementId?: string;
-  elementClass?: string;
-  elementText?: string;
-  metadata?: Record<string, unknown>;
-}
-
-// Singleton client used by exported functions
-const workerClient = new WorkerClient();
-
-// Public API - thin wrappers around workerClient
-export async function initEventTracker(registration?: ServiceWorkerRegistration): Promise<void> {
-  return workerClient.init(registration);
-}
-
-export async function trackEvent(event: UserEventData): Promise<void> {
-  const userEvent = { ...event, timestamp: Date.now() };
-  // use request to ensure the worker stored the event; mimic previous behavior
-  await workerClient.request('STORE_EVENT', { event: userEvent });
-}
-
-export async function getStoredEvents(): Promise<UserEvent[]> {
-  const res = await queryEvents();
-  return Array.isArray(res) ? res : [];
-}
-
-export async function getConnectionStatus(): Promise<boolean> {
-  return workerClient.getConnectionStatus();
-}
-
-export function setAuthToken(token: string): void {
-  workerClient.setAuthToken(token);
-}
-
-// Connection status subscription helpers
-export function onConnectionStatus(cb: (connected: boolean) => void): void {
-  workerClient.onConnectionStatus(cb);
-}
-
-export function offConnectionStatus(cb: (connected: boolean) => void): void {
-  workerClient.offConnectionStatus(cb);
-}
-
-// Convenience helpers (kept outside for ergonomic API)
-export async function trackNavigation(from: string, to: string, path?: string): Promise<void> {
-  return trackEvent({ type: 'navigation', from, to, path: path || to });
-}
-
-export async function trackClick(element: HTMLElement, path?: string, metadata?: Record<string, unknown>): Promise<void> {
-  const elementId = element.id || undefined;
-  const elementClass = element.className || undefined;
-  const elementText = element.textContent?.trim().substring(0, 100) || undefined;
-  const tagName = element.tagName.toLowerCase();
-
-  return trackEvent({
-    type: 'click',
-    element: tagName,
-    elementId,
-    elementClass,
-    elementText,
-    path: path || window.location.pathname,
-    metadata,
-  });
-}
-
-export async function trackInput(element: HTMLElement, value?: string, path?: string): Promise<void> {
-  const elementId = element.id || undefined;
-  const elementClass = element.className || undefined;
-  const tagName = element.tagName.toLowerCase();
-
-  return trackEvent({
-    type: 'input',
-    element: tagName,
-    elementId,
-    elementClass,
-    path: path || window.location.pathname,
-    metadata: {
-      valueLength: value?.length || 0,
-      value: value,
-    },
-  });
-}
-
-export async function trackCustom(eventName: string, metadata?: Record<string, unknown>, path?: string): Promise<void> {
-  return trackEvent({
-    type: 'custom',
-    path: path || window.location.pathname,
-    metadata: {
-      eventName,
-      ...metadata,
-    },
-  });
-}

package/tsconfig.json

@@ -1,24 +0,0 @@
-{
-  "extends": "../../tsconfig.base.json",
-  "compilerOptions": {
-    "module": "commonjs",
-    "forceConsistentCasingInFileNames": true,
-    "strict": true,
-    "importHelpers": true,
-    "noImplicitOverride": true,
-    "noImplicitReturns": true,
-    "noFallthroughCasesInSwitch": true,
-    "noPropertyAccessFromIndexSignature": true,
-    "lib": ["esnext", "dom", "webworker"]
-  },
-  "files": [],
-  "include": [],
-  "references": [
-    {
-      "path": "./tsconfig.lib.json"
-    },
-    {
-      "path": "./tsconfig.spec.json"
-    }
-  ]
-}

package/tsconfig.lib.json

@@ -1,25 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "module": "esnext",
-    "outDir": "../../dist/out-tsc",
-    "declaration": true,
-    "types": ["node", "vite/client"]
-  },
-  "include": ["src/**/*.ts"],
-  "exclude": [
-    "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"
-  ],
-  "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,59 +0,0 @@
-/// <reference types='vitest' />
-import { defineConfig } from 'vite';
-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/event-tracker',
-  plugins: [
-    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/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: '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: [],
-    },
-  },
-  test: {
-    name: 'event-tracker',
-    watch: false,
-    globals: true,
-    environment: 'node',
-    include: ['{src,tests}/**/*.{test,spec}.{js,mjs,cjs,ts,mts,cts,jsx,tsx}'],
-    reporters: ['default'],
-    coverage: {
-      reportsDirectory: '../../coverage/libs/event-tracker',
-      provider: 'v8' as const,
-    },
-  },
-}));