@outlit/browser 1.2.0 → 1.4.0

package/dist/react/index.mjs

@@ -605,6 +605,27 @@ function setCookie(name, value, days) {
   }
   document.cookie = cookie;
 }
+var CONSENT_KEY = "outlit_consent";
+function getConsentState() {
+  try {
+    const stored = localStorage.getItem(CONSENT_KEY);
+    if (stored === "1") return true;
+    if (stored === "0") return false;
+  } catch {
+  }
+  const cookieValue = getCookie(CONSENT_KEY);
+  if (cookieValue === "1") return true;
+  if (cookieValue === "0") return false;
+  return null;
+}
+function setConsentState(granted) {
+  const value = granted ? "1" : "0";
+  try {
+    localStorage.setItem(CONSENT_KEY, value);
+  } catch {
+  }
+  setCookie(CONSENT_KEY, value, 365);
+}
 
 // src/tracker.ts
 var MAX_PENDING_STAGE_EVENTS = 10;
@@ -647,7 +668,8 @@ var Outlit = class {
       window.addEventListener("beforeunload", handleExit);
     }
     this.isInitialized = true;
-    if (options.autoTrack !== false) {
+    const consent = getConsentState();
+    if (consent === true || consent === null && options.autoTrack !== false) {
       this.enableTracking();
     }
   }
@@ -680,11 +702,38 @@ var Outlit = class {
       this.initCalendarTracking();
     }
     this.isTrackingEnabled = true;
+    setConsentState(true);
     if (this.pendingUser) {
       this.applyUser(this.pendingUser);
       this.pendingUser = null;
     }
   }
+  /**
+   * Disable tracking. Call this when a user revokes consent.
+   * This will:
+   * - Flush any pending events (captured while user had consent)
+   * - Stop the flush timer, pageview tracking, form tracking, and session tracking
+   * - Persist the opt-out decision so it's remembered across sessions
+   *
+   * The SDK instance remains usable — enableTracking() can be called again to re-enable.
+   */
+  async disableTracking() {
+    if (!this.isTrackingEnabled) {
+      setConsentState(false);
+      return;
+    }
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    stopAutocapture();
+    stopCalendarTracking();
+    stopSessionTracking();
+    await this.flush();
+    this.sessionTracker = null;
+    this.isTrackingEnabled = false;
+    setConsentState(false);
+  }
   /**
    * Check if tracking is currently enabled.
    */
@@ -1000,50 +1049,82 @@ var OutlitContext = createContext({
   isInitialized: false,
   isTrackingEnabled: false,
   enableTracking: () => {
+  },
+  disableTracking: () => {
   }
 });
-function OutlitProvider({
-  children,
-  publicKey,
-  apiHost,
-  trackPageviews = true,
-  trackForms = true,
-  formFieldDenylist,
-  flushInterval,
-  autoTrack = true,
-  autoIdentify = true,
-  user
-}) {
+function OutlitProvider(props) {
+  const { children, user } = props;
   const outlitRef = useRef(null);
   const initializedRef = useRef(false);
+  const isExternalClientRef = useRef(false);
+  const [isInitialized, setIsInitialized] = useState(false);
   const [isTrackingEnabled, setIsTrackingEnabled] = useState(false);
   useEffect(() => {
     if (initializedRef.current) return;
-    outlitRef.current = new Outlit({
-      publicKey,
-      apiHost,
-      trackPageviews,
-      trackForms,
-      formFieldDenylist,
-      flushInterval,
-      autoTrack,
-      autoIdentify
-    });
+    if (props.client) {
+      if (process.env.NODE_ENV !== "production") {
+        const configKeys = [
+          "publicKey",
+          "apiHost",
+          "trackPageviews",
+          "trackForms",
+          "formFieldDenylist",
+          "flushInterval",
+          "autoTrack",
+          "autoIdentify",
+          "trackCalendarEmbeds",
+          "trackEngagement",
+          "idleTimeout"
+        ];
+        const conflicting = configKeys.filter(
+          (k) => k in props && props[k] !== void 0
+        );
+        if (conflicting.length > 0) {
+          console.warn(
+            `[Outlit] Both \`client\` and config props (${conflicting.join(", ")}) were provided to OutlitProvider. The \`client\` instance will be used and config props will be ignored.`
+          );
+        }
+      }
+      outlitRef.current = props.client;
+      isExternalClientRef.current = true;
+    } else {
+      const {
+        publicKey,
+        apiHost,
+        trackPageviews = true,
+        trackForms = true,
+        formFieldDenylist,
+        flushInterval,
+        autoTrack = true,
+        autoIdentify = true,
+        trackCalendarEmbeds,
+        trackEngagement,
+        idleTimeout
+      } = props;
+      outlitRef.current = new Outlit({
+        publicKey,
+        apiHost,
+        trackPageviews,
+        trackForms,
+        formFieldDenylist,
+        flushInterval,
+        autoTrack,
+        autoIdentify,
+        trackCalendarEmbeds,
+        trackEngagement,
+        idleTimeout
+      });
+    }
     initializedRef.current = true;
+    setIsInitialized(true);
     setIsTrackingEnabled(outlitRef.current.isEnabled());
     return () => {
-      outlitRef.current?.shutdown();
+      if (!isExternalClientRef.current) {
+        outlitRef.current?.shutdown();
+      }
     };
-  }, [
-    publicKey,
-    apiHost,
-    trackPageviews,
-    trackForms,
-    formFieldDenylist,
-    flushInterval,
-    autoTrack,
-    autoIdentify
-  ]);
+  }, []);
   useEffect(() => {
     if (!outlitRef.current) return;
     if (user && (user.email || user.userId)) {
@@ -1058,14 +1139,21 @@ function OutlitProvider({
       setIsTrackingEnabled(true);
     }
   }, []);
+  const disableTracking = useCallback(() => {
+    if (outlitRef.current) {
+      outlitRef.current.disableTracking();
+      setIsTrackingEnabled(false);
+    }
+  }, []);
   return /* @__PURE__ */ jsx(
     OutlitContext.Provider,
     {
       value: {
         outlit: outlitRef.current,
-        isInitialized: initializedRef.current,
+        isInitialized,
         isTrackingEnabled,
-        enableTracking
+        enableTracking,
+        disableTracking
       },
       children
     }
@@ -1075,7 +1163,7 @@ function OutlitProvider({
 // src/react/hooks.ts
 import { useCallback as useCallback2, useContext } from "react";
 function useOutlit() {
-  const { outlit, isInitialized, isTrackingEnabled, enableTracking } = useContext(OutlitContext);
+  const { outlit, isInitialized, isTrackingEnabled, enableTracking, disableTracking } = useContext(OutlitContext);
   const track = useCallback2(
     (eventName, properties) => {
       if (!outlit) {
@@ -1206,7 +1294,8 @@ function useOutlit() {
     },
     isInitialized,
     isTrackingEnabled,
-    enableTracking
+    enableTracking,
+    disableTracking
   };
 }
 function useTrack() {