@stacksee/analytics 0.11.0 → 0.12.0

package/dist/adapters/client/browser-analytics.d.ts

@@ -47,6 +47,10 @@ export declare class BrowserAnalytics<TEventMap extends DefaultEventMap = Defaul
      * Checks if a method should be called on a provider based on routing configuration
      */
     private shouldCallMethod;
+    /**
+     * Checks if an event should be tracked on a provider based on event filtering configuration
+     */
+    private shouldTrackEvent;
     /**
      * Initializes all analytics providers and sets up browser context.
      *
@@ -394,6 +398,42 @@ export declare class BrowserAnalytics<TEventMap extends DefaultEventMap = Defaul
      * ```
      */
     reset(): void;
+    /**
+     * Manually flush all queued events to providers.
+     *
+     * This method is useful when you need to ensure events are sent immediately,
+     * such as before navigation or critical user actions. Providers that support
+     * batching (like ProxyProvider) will flush their queues when this is called.
+     *
+     * If `useBeacon` is true, providers that support it will use the Beacon API
+     * for more reliable delivery during page unload.
+     *
+     * @param useBeacon Whether to use the Beacon API for flushing (default: false)
+     * @returns Promise that resolves when all providers have flushed
+     *
+     * @example
+     * ```typescript
+     * // Flush before navigation
+     * analytics.track('button_clicked', { buttonId: 'checkout' });
+     * await analytics.flush();
+     * window.location.href = '/checkout';
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Flush with beacon API before page unload
+     * await analytics.flush(true);
+     * ```
+     *
+     * @example
+     * ```typescript
+     * // Ensure critical events are sent immediately
+     * await analytics.track('purchase_completed', { orderId: '123' });
+     * await analytics.flush(); // Wait for confirmation
+     * showThankYouPage();
+     * ```
+     */
+    flush(useBeacon?: boolean): Promise<void>;
     /**
      * Updates the analytics context with new information.
      *

package/dist/adapters/server/server-analytics.d.ts

@@ -43,6 +43,10 @@ export declare class ServerAnalytics<TEventMap extends Record<string, Record<str
      * Checks if a method should be called on a provider based on routing configuration
      */
     private shouldCallMethod;
+    /**
+     * Checks if an event should be tracked on a provider based on event filtering configuration
+     */
+    private shouldTrackEvent;
     /**
      * Initializes all analytics providers.
      *

package/dist/client.d.ts

@@ -1,8 +1,8 @@
 import { BrowserAnalytics } from './adapters/client/browser-analytics.js';
-import { AnalyticsProvider } from './core/events/types.js';
+import { ProviderConfigOrProvider } from './core/events/types.js';
 import { EventMapFromCollection } from './core/events/index.js';
 export interface ClientAnalyticsConfig {
-    providers?: AnalyticsProvider[];
+    providers?: ProviderConfigOrProvider[];
     debug?: boolean;
     enabled?: boolean;
 }
@@ -60,6 +60,10 @@ export declare function pageLeave(properties?: Record<string, unknown>): void;
  * Convenience function to reset user session
  */
 export declare function reset(): void;
+/**
+ * Convenience function to flush queued events
+ */
+export declare function flush(useBeacon?: boolean): Promise<void>;
 /**
  * Reset the analytics instance (for testing purposes)
  * @internal

package/dist/client.js

@@ -1,10 +1,10 @@
-var c = Object.defineProperty;
-var u = (t, e, i) => e in t ? c(t, e, { enumerable: !0, configurable: !0, writable: !0, value: i }) : t[e] = i;
-var s = (t, e, i) => u(t, typeof e != "symbol" ? e + "" : e, i);
-import { i as f } from "./client-DTHZYkxx.js";
-import { P } from "./client-DTHZYkxx.js";
-import { B as k } from "./base.provider-AfFL5W_P.js";
-class p {
+var f = Object.defineProperty;
+var p = (n, e, t) => e in n ? f(n, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : n[e] = t;
+var a = (n, e, t) => p(n, typeof e != "symbol" ? e + "" : e, t);
+import { i as g } from "./client-DTHZYkxx.js";
+import { P as k } from "./client-DTHZYkxx.js";
+import { B as O } from "./base.provider-AfFL5W_P.js";
+class m {
   /**
    * Creates a new BrowserAnalytics instance for client-side event tracking.
    *
@@ -36,20 +36,20 @@ class p {
    * ```
    */
   constructor(e) {
-    s(this, "providerConfigs", []);
-    s(this, "context", {});
-    s(this, "userId");
-    s(this, "sessionId");
-    s(this, "userTraits");
-    s(this, "initialized", !1);
-    s(this, "initializePromise");
+    a(this, "providerConfigs", []);
+    a(this, "context", {});
+    a(this, "userId");
+    a(this, "sessionId");
+    a(this, "userTraits");
+    a(this, "initialized", !1);
+    a(this, "initializePromise");
     this.providerConfigs = this.normalizeProviders(e.providers), e.defaultContext && (this.context = { ...e.defaultContext }), this.sessionId = this.generateSessionId();
   }
   /**
    * Normalizes provider configurations into a consistent internal format
    */
   normalizeProviders(e) {
-    const i = [
+    const t = [
       "initialize",
       "identify",
       "track",
@@ -61,31 +61,51 @@ class p {
       if ("initialize" in r && "track" in r)
         return {
           provider: r,
-          enabledMethods: new Set(i)
+          enabledMethods: new Set(t)
         };
-      const n = r;
-      n.methods && n.exclude && console.warn(
-        `[Analytics] Provider ${n.provider.name} has both 'methods' and 'exclude' specified. Using 'methods' and ignoring 'exclude'.`
+      const i = r;
+      i.methods && i.exclude && console.warn(
+        `[Analytics] Provider ${i.provider.name} has both 'methods' and 'exclude' specified. Using 'methods' and ignoring 'exclude'.`
+      ), i.events && i.excludeEvents && console.warn(
+        `[Analytics] Provider ${i.provider.name} has both 'events' and 'excludeEvents' specified. Using 'events' and ignoring 'excludeEvents'.`
+      ), i.events && i.eventPatterns && console.warn(
+        `[Analytics] Provider ${i.provider.name} has both 'events' and 'eventPatterns' specified. Using 'events' and ignoring 'eventPatterns'.`
+      ), i.excludeEvents && i.eventPatterns && console.warn(
+        `[Analytics] Provider ${i.provider.name} has both 'excludeEvents' and 'eventPatterns' specified. Using 'eventPatterns' and ignoring 'excludeEvents'.`
       );
-      let o;
-      return n.methods ? o = new Set(n.methods) : n.exclude ? o = new Set(
-        i.filter(
-          (d) => {
-            var h;
-            return !((h = n.exclude) != null && h.includes(d));
+      let d;
+      i.methods ? d = new Set(i.methods) : i.exclude ? d = new Set(
+        t.filter(
+          (u) => {
+            var c;
+            return !((c = i.exclude) != null && c.includes(u));
           }
         )
-      ) : o = new Set(i), {
-        provider: n.provider,
-        enabledMethods: o
+      ) : d = new Set(t);
+      let s, h, v;
+      return i.events && i.events.length > 0 ? s = new Set(i.events) : i.eventPatterns && i.eventPatterns.length > 0 ? v = i.eventPatterns.map((u) => {
+        const c = u.replace(/\*/g, ".*");
+        return new RegExp(`^${c}$`);
+      }) : i.excludeEvents && i.excludeEvents.length > 0 && (h = new Set(i.excludeEvents)), {
+        provider: i.provider,
+        enabledMethods: d,
+        enabledEvents: s,
+        excludedEvents: h,
+        eventPatterns: v
       };
     });
   }
   /**
    * Checks if a method should be called on a provider based on routing configuration
    */
-  shouldCallMethod(e, i) {
-    return e.enabledMethods.has(i);
+  shouldCallMethod(e, t) {
+    return e.enabledMethods.has(t);
+  }
+  /**
+   * Checks if an event should be tracked on a provider based on event filtering configuration
+   */
+  shouldTrackEvent(e, t) {
+    return !e.enabledEvents && !e.excludedEvents && !e.eventPatterns ? !0 : e.enabledEvents ? e.enabledEvents.has(t) : e.eventPatterns ? e.eventPatterns.some((r) => r.test(t)) : e.excludedEvents ? !e.excludedEvents.has(t) : !0;
   }
   /**
    * Initializes all analytics providers and sets up browser context.
@@ -118,12 +138,12 @@ class p {
    * ```
    */
   async initialize() {
-    if (f() && !this.initialized)
+    if (g() && !this.initialized)
       return this.initializePromise ? this.initializePromise : (this.initializePromise = this._doInitialize(), this.initializePromise);
   }
   async _doInitialize() {
     const e = this.providerConfigs.map(
-      (i) => i.provider.initialize()
+      (t) => t.provider.initialize()
     );
     await Promise.all(e), this.initialized = !0, this.updateContext({
       page: {
@@ -208,12 +228,12 @@ class p {
    * }
    * ```
    */
-  identify(e, i) {
-    this.userId = e, this.userTraits = i, this.ensureInitialized().catch((r) => {
+  identify(e, t) {
+    this.userId = e, this.userTraits = t, this.ensureInitialized().catch((r) => {
       console.error("[Analytics] Failed to initialize during identify:", r);
     });
     for (const r of this.providerConfigs)
-      this.shouldCallMethod(r, "identify") && r.provider.identify(e, i);
+      this.shouldCallMethod(r, "identify") && r.provider.identify(e, t);
   }
   /**
    * Tracks a custom event with properties.
@@ -290,33 +310,35 @@ class p {
    * }
    * ```
    */
-  async track(e, i) {
+  async track(e, t) {
     await this.ensureInitialized();
     const r = {
       action: e,
       category: this.getCategoryFromEventName(e),
-      properties: i,
+      properties: t,
       timestamp: Date.now(),
       userId: this.userId,
       sessionId: this.sessionId
-    }, n = {
+    }, i = {
       ...this.context,
       user: this.userId || this.userTraits ? {
         userId: this.userId,
         email: this.userTraits && "email" in this.userTraits ? this.userTraits.email : void 0,
         traits: this.userTraits
       } : void 0
-    }, o = this.providerConfigs.filter((d) => this.shouldCallMethod(d, "track")).map(async (d) => {
+    }, d = this.providerConfigs.filter(
+      (s) => this.shouldCallMethod(s, "track") && this.shouldTrackEvent(s, e)
+    ).map(async (s) => {
       try {
-        await d.provider.track(r, n);
+        await s.provider.track(r, i);
       } catch (h) {
         console.error(
-          `[Analytics] Provider ${d.provider.name} failed to track event:`,
+          `[Analytics] Provider ${s.provider.name} failed to track event:`,
           h
         );
       }
     });
-    await Promise.all(o);
+    await Promise.all(d);
   }
   /**
    * Tracks a page view event.
@@ -379,8 +401,8 @@ class p {
    * ```
    */
   pageView(e) {
-    this.ensureInitialized().catch((i) => {
-      console.error("[Analytics] Failed to initialize during pageView:", i);
+    this.ensureInitialized().catch((t) => {
+      console.error("[Analytics] Failed to initialize during pageView:", t);
     }), this.updateContext({
       page: {
         path: window.location.pathname,
@@ -388,8 +410,8 @@ class p {
         referrer: document.referrer
       }
     });
-    for (const i of this.providerConfigs)
-      this.shouldCallMethod(i, "pageView") && i.provider.pageView(e, this.context);
+    for (const t of this.providerConfigs)
+      this.shouldCallMethod(t, "pageView") && t.provider.pageView(e, this.context);
   }
   /**
    * Tracks when a user leaves a page.
@@ -447,14 +469,14 @@ class p {
    * ```
    */
   pageLeave(e) {
-    this.ensureInitialized().catch((i) => {
+    this.ensureInitialized().catch((t) => {
       console.error(
         "[Analytics] Failed to initialize during pageLeave:",
-        i
+        t
       );
     });
-    for (const i of this.providerConfigs)
-      this.shouldCallMethod(i, "pageLeave") && i.provider.pageLeave && i.provider.pageLeave(e, this.context);
+    for (const t of this.providerConfigs)
+      this.shouldCallMethod(t, "pageLeave") && t.provider.pageLeave && t.provider.pageLeave(e, this.context);
   }
   /**
    * Resets the analytics state, clearing user ID and generating a new session.
@@ -513,6 +535,55 @@ class p {
     for (const e of this.providerConfigs)
       this.shouldCallMethod(e, "reset") && e.provider.reset();
   }
+  /**
+   * Manually flush all queued events to providers.
+   *
+   * This method is useful when you need to ensure events are sent immediately,
+   * such as before navigation or critical user actions. Providers that support
+   * batching (like ProxyProvider) will flush their queues when this is called.
+   *
+   * If `useBeacon` is true, providers that support it will use the Beacon API
+   * for more reliable delivery during page unload.
+   *
+   * @param useBeacon Whether to use the Beacon API for flushing (default: false)
+   * @returns Promise that resolves when all providers have flushed
+   *
+   * @example
+   * ```typescript
+   * // Flush before navigation
+   * analytics.track('button_clicked', { buttonId: 'checkout' });
+   * await analytics.flush();
+   * window.location.href = '/checkout';
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Flush with beacon API before page unload
+   * await analytics.flush(true);
+   * ```
+   *
+   * @example
+   * ```typescript
+   * // Ensure critical events are sent immediately
+   * await analytics.track('purchase_completed', { orderId: '123' });
+   * await analytics.flush(); // Wait for confirmation
+   * showThankYouPage();
+   * ```
+   */
+  async flush(e = !1) {
+    const t = this.providerConfigs.map(async (r) => {
+      if (r.provider.flush && typeof r.provider.flush == "function")
+        try {
+          await r.provider.flush(e);
+        } catch (i) {
+          console.error(
+            `[Analytics] Provider ${r.provider.name} failed to flush:`,
+            i
+          );
+        }
+    });
+    await Promise.all(t);
+  }
   /**
    * Updates the analytics context with new information.
    *
@@ -574,14 +645,14 @@ class p {
    * ```
    */
   updateContext(e) {
-    var i, r, n;
+    var t, r, i;
     this.context = {
       ...this.context,
       ...e,
       page: e.page ? {
-        path: e.page.path || ((i = this.context.page) == null ? void 0 : i.path) || window.location.pathname,
+        path: e.page.path || ((t = this.context.page) == null ? void 0 : t.path) || window.location.pathname,
         title: e.page.title || ((r = this.context.page) == null ? void 0 : r.title),
-        referrer: e.page.referrer || ((n = this.context.page) == null ? void 0 : n.referrer)
+        referrer: e.page.referrer || ((i = this.context.page) == null ? void 0 : i.referrer)
       } : this.context.page,
       device: {
         ...this.context.device,
@@ -594,8 +665,8 @@ class p {
     };
   }
   getCategoryFromEventName(e) {
-    const i = e.split("_");
-    return i.length > 1 && i[0] ? i[0] : "engagement";
+    const t = e.split("_");
+    return t.length > 1 && t[0] ? t[0] : "engagement";
   }
   generateSessionId() {
     return `${Date.now()}-${Math.random().toString(36).substring(2, 11)}`;
@@ -615,51 +686,51 @@ class p {
     return e.indexOf("Chrome") !== -1 ? "Chrome" : e.indexOf("Safari") !== -1 ? "Safari" : e.indexOf("Firefox") !== -1 ? "Firefox" : e.indexOf("Edge") !== -1 ? "Edge" : "Unknown";
   }
 }
-let a = null;
-function v(t) {
-  if (a)
-    return console.warn("[Analytics] Already initialized"), a;
+let o = null;
+function y(n) {
+  if (o)
+    return console.warn("[Analytics] Already initialized"), o;
   const e = {
-    providers: t.providers || [],
-    debug: t.debug,
-    enabled: t.enabled
+    providers: n.providers || [],
+    debug: n.debug,
+    enabled: n.enabled
   };
-  return a = new p(e), a.initialize().catch((i) => {
-    console.error("[Analytics] Failed to initialize:", i);
-  }), a;
+  return o = new m(e), o.initialize().catch((t) => {
+    console.error("[Analytics] Failed to initialize:", t);
+  }), o;
 }
 function l() {
-  if (!a)
+  if (!o)
     throw new Error(
       "[Analytics] Not initialized. Call createAnalytics() first."
     );
-  return a;
+  return o;
 }
-function w(t, e) {
-  return l().track(t, e);
+function P(n, e) {
+  return l().track(n, e);
 }
-function y(t, e) {
-  l().identify(t, e);
+function z(n, e) {
+  l().identify(n, e);
 }
-function x(t) {
-  l().pageView(t);
+function C(n) {
+  l().pageView(n);
 }
-function z(t) {
-  l().pageLeave(t);
+function A(n) {
+  l().pageLeave(n);
 }
-function C() {
+function b() {
   l().reset();
 }
 export {
-  k as BaseAnalyticsProvider,
-  p as BrowserAnalytics,
-  P as PostHogClientProvider,
-  v as createAnalytics,
-  v as createClientAnalytics,
+  O as BaseAnalyticsProvider,
+  m as BrowserAnalytics,
+  k as PostHogClientProvider,
+  y as createAnalytics,
+  y as createClientAnalytics,
   l as getAnalytics,
-  y as identify,
-  z as pageLeave,
-  x as pageView,
-  C as reset,
-  w as track
+  z as identify,
+  A as pageLeave,
+  C as pageView,
+  b as reset,
+  P as track
 };

package/dist/core/events/types.d.ts

@@ -67,14 +67,16 @@ export interface AnalyticsProvider {
     pageView(properties?: Record<string, unknown>, context?: EventContext): Promise<void> | void;
     pageLeave?(properties?: Record<string, unknown>, context?: EventContext): Promise<void> | void;
     reset(): Promise<void> | void;
+    flush?(useBeacon?: boolean): Promise<void> | void;
 }
 /**
  * Provider methods that can be selectively enabled/disabled through routing
  */
 export type ProviderMethod = "initialize" | "identify" | "track" | "pageView" | "pageLeave" | "reset";
 /**
- * Configuration for selective provider method routing.
- * Allows you to control which methods are called on a specific provider.
+ * Configuration for selective provider method routing and event filtering.
+ * Allows you to control which methods are called on a specific provider
+ * and which events are tracked.
  *
  * @example
  * ```typescript
@@ -93,6 +95,33 @@ export type ProviderMethod = "initialize" | "identify" | "track" | "pageView" |
  *   exclude: ['pageView']
  * }
  * ```
+ *
+ * @example
+ * ```typescript
+ * // Only track specific events (solves 1-to-50 problem)
+ * {
+ *   provider: new EmitKitServerProvider({...}),
+ *   events: ['newsletter_signup', 'user_registered']
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Track all events except specific ones
+ * {
+ *   provider: new PostHogServerProvider({...}),
+ *   excludeEvents: ['newsletter_signup']
+ * }
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Use glob patterns to match multiple events
+ * {
+ *   provider: new EmitKitServerProvider({...}),
+ *   eventPatterns: ['newsletter_*', 'user_*']
+ * }
+ * ```
  */
 export interface ProviderConfig {
     /**
@@ -111,6 +140,49 @@ export interface ProviderConfig {
      * Mutually exclusive with `methods`.
      */
     exclude?: ProviderMethod[];
+    /**
+     * Only track these specific event names on this provider.
+     * If specified, all other events will be skipped.
+     * Mutually exclusive with `excludeEvents`.
+     *
+     * @example
+     * ```typescript
+     * {
+     *   provider: new EmitKitServerProvider({...}),
+     *   events: ['newsletter_signup'] // Only this event goes to EmitKit
+     * }
+     * ```
+     */
+    events?: string[];
+    /**
+     * Skip these specific event names on this provider.
+     * All other events will be tracked normally.
+     * Mutually exclusive with `events` and `eventPatterns`.
+     *
+     * @example
+     * ```typescript
+     * {
+     *   provider: new BentoClientProvider({...}),
+     *   excludeEvents: ['page_view'] // Everything except page views
+     * }
+     * ```
+     */
+    excludeEvents?: string[];
+    /**
+     * Glob-style patterns to match event names.
+     * Supports wildcards (*) for flexible event routing.
+     * Mutually exclusive with `excludeEvents`.
+     *
+     * @example
+     * ```typescript
+     * {
+     *   provider: new EmitKitServerProvider({...}),
+     *   eventPatterns: ['newsletter_*', 'user_registered']
+     *   // Matches: newsletter_signup, newsletter_unsubscribe, user_registered
+     * }
+     * ```
+     */
+    eventPatterns?: string[];
 }
 /**
  * Provider configuration - supports both simple provider instances

package/dist/server.d.ts

@@ -1,8 +1,8 @@
 import { ServerAnalytics } from './adapters/server/server-analytics.js';
-import { AnalyticsProvider } from './core/events/types.js';
+import { ProviderConfigOrProvider } from './core/events/types.js';
 import { EventMapFromCollection } from './core/events/index.js';
 export interface ServerAnalyticsConfig {
-    providers?: AnalyticsProvider[];
+    providers?: ProviderConfigOrProvider[];
     debug?: boolean;
     enabled?: boolean;
 }

package/dist/server.js

@@ -1,9 +1,9 @@
-var h = Object.defineProperty;
-var f = (a, r, e) => r in a ? h(a, r, { enumerable: !0, configurable: !0, writable: !0, value: e }) : a[r] = e;
-var o = (a, r, e) => f(a, typeof r != "symbol" ? r + "" : r, e);
+var u = Object.defineProperty;
+var h = (i, e, t) => e in i ? u(i, e, { enumerable: !0, configurable: !0, writable: !0, value: t }) : i[e] = t;
+var c = (i, e, t) => h(i, typeof e != "symbol" ? e + "" : e, t);
 import { P as w } from "./server-DjEk1fUD.js";
-import { B as x } from "./base.provider-AfFL5W_P.js";
-class v {
+import { B as y } from "./base.provider-AfFL5W_P.js";
+class f {
   /**
    * Creates a new ServerAnalytics instance for server-side event tracking.
    *
@@ -34,17 +34,17 @@ class v {
    * analytics.initialize();
    * ```
    */
-  constructor(r) {
-    o(this, "providerConfigs", []);
-    o(this, "config");
-    o(this, "initialized", !1);
-    this.config = r, this.providerConfigs = this.normalizeProviders(r.providers);
+  constructor(e) {
+    c(this, "providerConfigs", []);
+    c(this, "config");
+    c(this, "initialized", !1);
+    this.config = e, this.providerConfigs = this.normalizeProviders(e.providers);
   }
   /**
    * Normalizes provider configurations into a consistent internal format
    */
-  normalizeProviders(r) {
-    const e = [
+  normalizeProviders(e) {
+    const t = [
       "initialize",
       "identify",
       "track",
@@ -52,35 +52,55 @@ class v {
       "pageLeave",
       "reset"
     ];
-    return r.map((i) => {
-      if ("initialize" in i && "track" in i)
+    return e.map((n) => {
+      if ("initialize" in n && "track" in n)
         return {
-          provider: i,
-          enabledMethods: new Set(e)
+          provider: n,
+          enabledMethods: new Set(t)
         };
-      const t = i;
-      t.methods && t.exclude && console.warn(
-        `[Analytics] Provider ${t.provider.name} has both 'methods' and 'exclude' specified. Using 'methods' and ignoring 'exclude'.`
+      const r = n;
+      r.methods && r.exclude && console.warn(
+        `[Analytics] Provider ${r.provider.name} has both 'methods' and 'exclude' specified. Using 'methods' and ignoring 'exclude'.`
+      ), r.events && r.excludeEvents && console.warn(
+        `[Analytics] Provider ${r.provider.name} has both 'events' and 'excludeEvents' specified. Using 'events' and ignoring 'excludeEvents'.`
+      ), r.events && r.eventPatterns && console.warn(
+        `[Analytics] Provider ${r.provider.name} has both 'events' and 'eventPatterns' specified. Using 'events' and ignoring 'eventPatterns'.`
+      ), r.excludeEvents && r.eventPatterns && console.warn(
+        `[Analytics] Provider ${r.provider.name} has both 'excludeEvents' and 'eventPatterns' specified. Using 'eventPatterns' and ignoring 'excludeEvents'.`
       );
-      let n;
-      return t.methods ? n = new Set(t.methods) : t.exclude ? n = new Set(
-        e.filter(
+      let a;
+      r.methods ? a = new Set(r.methods) : r.exclude ? a = new Set(
+        t.filter(
           (l) => {
-            var d;
-            return !((d = t.exclude) != null && d.includes(l));
+            var v;
+            return !((v = r.exclude) != null && v.includes(l));
           }
         )
-      ) : n = new Set(e), {
-        provider: t.provider,
-        enabledMethods: n
+      ) : a = new Set(t);
+      let o, d, s;
+      return r.events && r.events.length > 0 ? o = new Set(r.events) : r.eventPatterns && r.eventPatterns.length > 0 ? s = r.eventPatterns.map((l) => {
+        const v = l.replace(/\*/g, ".*");
+        return new RegExp(`^${v}$`);
+      }) : r.excludeEvents && r.excludeEvents.length > 0 && (d = new Set(r.excludeEvents)), {
+        provider: r.provider,
+        enabledMethods: a,
+        enabledEvents: o,
+        excludedEvents: d,
+        eventPatterns: s
       };
     });
   }
   /**
    * Checks if a method should be called on a provider based on routing configuration
    */
-  shouldCallMethod(r, e) {
-    return r.enabledMethods.has(e);
+  shouldCallMethod(e, t) {
+    return e.enabledMethods.has(t);
+  }
+  /**
+   * Checks if an event should be tracked on a provider based on event filtering configuration
+   */
+  shouldTrackEvent(e, t) {
+    return !e.enabledEvents && !e.excludedEvents && !e.eventPatterns ? !0 : e.enabledEvents ? e.enabledEvents.has(t) : e.eventPatterns ? e.eventPatterns.some((n) => n.test(t)) : e.excludedEvents ? !e.excludedEvents.has(t) : !0;
   }
   /**
    * Initializes all analytics providers.
@@ -120,8 +140,8 @@ class v {
    */
   initialize() {
     if (!this.initialized) {
-      for (const r of this.providerConfigs)
-        r.provider.initialize();
+      for (const e of this.providerConfigs)
+        e.provider.initialize();
       this.initialized = !0;
     }
   }
@@ -171,9 +191,9 @@ class v {
    * }
    * ```
    */
-  identify(r, e) {
-    for (const i of this.providerConfigs)
-      this.shouldCallMethod(i, "identify") && i.provider.identify(r, e);
+  identify(e, t) {
+    for (const n of this.providerConfigs)
+      this.shouldCallMethod(n, "identify") && n.provider.identify(e, t);
   }
   /**
    * Tracks a custom event with properties and optional context.
@@ -296,34 +316,36 @@ class v {
    * }
    * ```
    */
-  async track(r, e, i) {
+  async track(e, t, n) {
     var d;
     if (!this.initialized) {
       console.warn("[Analytics] Not initialized. Call initialize() first.");
       return;
     }
-    const t = {
-      action: r,
-      category: this.getCategoryFromEventName(r),
-      properties: e,
+    const r = {
+      action: e,
+      category: this.getCategoryFromEventName(e),
+      properties: t,
       timestamp: Date.now(),
-      userId: i == null ? void 0 : i.userId,
-      sessionId: i == null ? void 0 : i.sessionId
-    }, n = {
+      userId: n == null ? void 0 : n.userId,
+      sessionId: n == null ? void 0 : n.sessionId
+    }, a = {
       ...this.config.defaultContext,
-      ...i == null ? void 0 : i.context,
-      user: (i == null ? void 0 : i.user) || ((d = i == null ? void 0 : i.context) == null ? void 0 : d.user)
-    }, l = this.providerConfigs.filter((s) => this.shouldCallMethod(s, "track")).map(async (s) => {
+      ...n == null ? void 0 : n.context,
+      user: (n == null ? void 0 : n.user) || ((d = n == null ? void 0 : n.context) == null ? void 0 : d.user)
+    }, o = this.providerConfigs.filter(
+      (s) => this.shouldCallMethod(s, "track") && this.shouldTrackEvent(s, e)
+    ).map(async (s) => {
       try {
-        await s.provider.track(t, n);
-      } catch (c) {
+        await s.provider.track(r, a);
+      } catch (l) {
         console.error(
           `[Analytics] Provider ${s.provider.name} failed to track event:`,
-          c
+          l
         );
       }
     });
-    await Promise.all(l);
+    await Promise.all(o);
   }
   /**
    * Tracks a page view event from the server side.
@@ -385,14 +407,14 @@ class v {
    * }
    * ```
    */
-  pageView(r, e) {
+  pageView(e, t) {
     if (!this.initialized) return;
-    const i = {
+    const n = {
       ...this.config.defaultContext,
-      ...e == null ? void 0 : e.context
+      ...t == null ? void 0 : t.context
     };
-    for (const t of this.providerConfigs)
-      this.shouldCallMethod(t, "pageView") && t.provider.pageView(r, i);
+    for (const r of this.providerConfigs)
+      this.shouldCallMethod(r, "pageView") && r.provider.pageView(e, n);
   }
   /**
    * Tracks when a user leaves a page from the server side.
@@ -453,14 +475,14 @@ class v {
    * }
    * ```
    */
-  pageLeave(r, e) {
+  pageLeave(e, t) {
     if (!this.initialized) return;
-    const i = {
+    const n = {
       ...this.config.defaultContext,
-      ...e == null ? void 0 : e.context
+      ...t == null ? void 0 : t.context
     };
-    for (const t of this.providerConfigs)
-      this.shouldCallMethod(t, "pageLeave") && t.provider.pageLeave && t.provider.pageLeave(r, i);
+    for (const r of this.providerConfigs)
+      this.shouldCallMethod(r, "pageLeave") && r.provider.pageLeave && r.provider.pageLeave(e, n);
   }
   /**
    * Shuts down all analytics providers and flushes pending events.
@@ -547,25 +569,25 @@ class v {
    * ```
    */
   async shutdown() {
-    const r = this.providerConfigs.map((e) => "shutdown" in e.provider && typeof e.provider.shutdown == "function" ? e.provider.shutdown() : Promise.resolve());
-    await Promise.all(r);
+    const e = this.providerConfigs.map((t) => "shutdown" in t.provider && typeof t.provider.shutdown == "function" ? t.provider.shutdown() : Promise.resolve());
+    await Promise.all(e);
   }
-  getCategoryFromEventName(r) {
-    const e = r.split("_");
-    return e.length > 1 && e[0] ? e[0] : "engagement";
+  getCategoryFromEventName(e) {
+    const t = e.split("_");
+    return t.length > 1 && t[0] ? t[0] : "engagement";
   }
 }
-function g(a) {
-  const r = {
-    providers: a.providers || [],
-    debug: a.debug,
-    enabled: a.enabled
-  }, e = new v(r);
-  return e.initialize(), e;
+function x(i) {
+  const e = {
+    providers: i.providers || [],
+    debug: i.debug,
+    enabled: i.enabled
+  }, t = new f(e);
+  return t.initialize(), t;
 }
 export {
-  x as BaseAnalyticsProvider,
+  y as BaseAnalyticsProvider,
   w as PostHogServerProvider,
-  v as ServerAnalytics,
-  g as createServerAnalytics
+  f as ServerAnalytics,
+  x as createServerAnalytics
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@stacksee/analytics",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "A highly typed, provider-agnostic analytics library for TypeScript applications",
   "type": "module",
   "exports": {