@pxlabz/tracey-react 0.0.1

package/dist/LauncherTrigger-DjXDXHTm.cjs

@@ -0,0 +1,1055 @@
+"use strict";
+var __typeError = (msg) => {
+  throw TypeError(msg);
+};
+var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
+var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
+var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
+var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
+var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
+var _apiKey, _baseUrl, _customerId, _TraceyApiClient_instances, request_fn, _listeners;
+const jsxRuntime = require("react/jsx-runtime");
+const react = require("react");
+const reactDom = require("react-dom");
+const TraceyContext = react.createContext(null);
+class TraceyApiClient {
+  constructor(config) {
+    __privateAdd(this, _TraceyApiClient_instances);
+    __privateAdd(this, _apiKey);
+    __privateAdd(this, _baseUrl);
+    __privateAdd(this, _customerId, null);
+    __privateSet(this, _apiKey, config.apiKey);
+    __privateSet(this, _baseUrl, config.baseUrl ?? "https://api.tracey.dev");
+  }
+  setCustomerId(id) {
+    __privateSet(this, _customerId, id);
+  }
+  getCustomerId() {
+    return __privateGet(this, _customerId);
+  }
+  async identify(user) {
+    const { userHash, ...userData } = user;
+    return __privateMethod(this, _TraceyApiClient_instances, request_fn).call(this, "/api/sdk/identify", {
+      method: "POST",
+      body: JSON.stringify({
+        ...userData,
+        ...userHash ? { userHash } : {}
+      })
+    });
+  }
+  async getAnnouncements(filter = "unread") {
+    const params = new URLSearchParams();
+    if (__privateGet(this, _customerId)) {
+      params.set("customerId", __privateGet(this, _customerId));
+    }
+    params.set("filter", filter);
+    return __privateMethod(this, _TraceyApiClient_instances, request_fn).call(this, `/api/sdk/announcements?${params.toString()}`);
+  }
+  async getUnreadCount() {
+    if (!__privateGet(this, _customerId)) {
+      throw new Error("Customer ID not set. Call identify first.");
+    }
+    return __privateMethod(this, _TraceyApiClient_instances, request_fn).call(this, `/api/sdk/announcements/unread-count?customerId=${encodeURIComponent(__privateGet(this, _customerId))}`);
+  }
+  async trackAnnouncementView(announcementId) {
+    if (!__privateGet(this, _customerId)) {
+      throw new Error("Customer ID not set. Call identify first.");
+    }
+    await __privateMethod(this, _TraceyApiClient_instances, request_fn).call(this, `/api/sdk/announcements/${announcementId}/view`, {
+      method: "POST",
+      body: JSON.stringify({ customerId: __privateGet(this, _customerId) })
+    });
+  }
+  async trackAnnouncementCta(announcementId) {
+    if (!__privateGet(this, _customerId)) {
+      throw new Error("Customer ID not set. Call identify first.");
+    }
+    await __privateMethod(this, _TraceyApiClient_instances, request_fn).call(this, `/api/sdk/announcements/${announcementId}/cta`, {
+      method: "POST",
+      body: JSON.stringify({ customerId: __privateGet(this, _customerId) })
+    });
+  }
+  async submitFeedback(feedback) {
+    return __privateMethod(this, _TraceyApiClient_instances, request_fn).call(this, "/api/sdk/feedback", {
+      method: "POST",
+      body: JSON.stringify({
+        ...feedback,
+        customerId: __privateGet(this, _customerId) ?? void 0
+      })
+    });
+  }
+  async getMyFeedback(params) {
+    if (!__privateGet(this, _customerId)) {
+      throw new Error("Customer ID not set. Call identify first.");
+    }
+    const searchParams = new URLSearchParams();
+    searchParams.set("customerId", __privateGet(this, _customerId));
+    if ((params == null ? void 0 : params.limit) !== void 0) {
+      searchParams.set("limit", String(params.limit));
+    }
+    if ((params == null ? void 0 : params.offset) !== void 0) {
+      searchParams.set("offset", String(params.offset));
+    }
+    return __privateMethod(this, _TraceyApiClient_instances, request_fn).call(this, `/api/sdk/feedback/mine?${searchParams.toString()}`);
+  }
+  async getActiveSurvey(context) {
+    const params = new URLSearchParams();
+    if (__privateGet(this, _customerId)) params.set("customerId", __privateGet(this, _customerId));
+    if (context == null ? void 0 : context.anonymousSessionId) {
+      params.set("anonymousSessionId", context.anonymousSessionId);
+    }
+    if (context == null ? void 0 : context.url) params.set("url", context.url);
+    const query = params.toString();
+    const response = await __privateMethod(this, _TraceyApiClient_instances, request_fn).call(this, `/api/sdk/surveys${query ? `?${query}` : ""}`);
+    return response.survey;
+  }
+  async submitSurveyResponse(surveyId, payload) {
+    return __privateMethod(this, _TraceyApiClient_instances, request_fn).call(this, `/api/sdk/surveys/${surveyId}/responses`, {
+      method: "POST",
+      body: JSON.stringify({
+        customerId: __privateGet(this, _customerId) ?? void 0,
+        anonymousSessionId: payload.anonymousSessionId,
+        respondentEmail: payload.respondentEmail,
+        respondentName: payload.respondentName,
+        metadata: payload.metadata,
+        answers: payload.answers
+      })
+    });
+  }
+}
+_apiKey = new WeakMap();
+_baseUrl = new WeakMap();
+_customerId = new WeakMap();
+_TraceyApiClient_instances = new WeakSet();
+request_fn = async function(path, options = {}) {
+  const url = `${__privateGet(this, _baseUrl)}${path}`;
+  const headers = new Headers(options.headers);
+  headers.set("Authorization", `Bearer ${__privateGet(this, _apiKey)}`);
+  headers.set("Content-Type", "application/json");
+  const response = await fetch(url, {
+    ...options,
+    headers
+  });
+  if (!response.ok) {
+    const error = await response.json().catch(() => ({
+      message: `HTTP ${response.status}: ${response.statusText}`
+    }));
+    throw new Error(error.message);
+  }
+  return response.json();
+};
+class TraceyEventEmitter {
+  constructor() {
+    __privateAdd(this, _listeners, /* @__PURE__ */ new Map());
+  }
+  subscribe(event, callback) {
+    if (!__privateGet(this, _listeners).has(event)) {
+      __privateGet(this, _listeners).set(event, /* @__PURE__ */ new Set());
+    }
+    const listeners = __privateGet(this, _listeners).get(event);
+    listeners.add(callback);
+    return () => {
+      listeners.delete(callback);
+    };
+  }
+  unsubscribe(event, callback) {
+    const listeners = __privateGet(this, _listeners).get(event);
+    if (listeners) {
+      listeners.delete(callback);
+    }
+  }
+  emit(event, data) {
+    const listeners = __privateGet(this, _listeners).get(event);
+    if (listeners) {
+      listeners.forEach((callback) => {
+        try {
+          callback(data);
+        } catch (error) {
+          console.error(`Error in event listener for ${event}:`, error);
+        }
+      });
+    }
+  }
+  clear() {
+    __privateGet(this, _listeners).clear();
+  }
+}
+_listeners = new WeakMap();
+const UNREAD_POLL_INTERVAL_MS = 5 * 60 * 1e3;
+function getUnreadCacheKey(apiKey, userId) {
+  return `tracey:unread:${apiKey}:${userId}`;
+}
+function readCachedUnreadCount(apiKey, userId) {
+  try {
+    const raw = localStorage.getItem(getUnreadCacheKey(apiKey, userId));
+    if (raw !== null) {
+      const parsed = parseInt(raw, 10);
+      return isNaN(parsed) ? 0 : parsed;
+    }
+  } catch {
+  }
+  return 0;
+}
+function writeCachedUnreadCount(apiKey, userId, count) {
+  try {
+    localStorage.setItem(getUnreadCacheKey(apiKey, userId), String(count));
+  } catch {
+  }
+}
+function TraceyProvider({
+  apiKey,
+  baseUrl,
+  user,
+  children,
+  debug = false
+}) {
+  const config = react.useMemo(
+    () => ({ apiKey, baseUrl, debug }),
+    [apiKey, baseUrl, debug]
+  );
+  const client = react.useMemo(() => new TraceyApiClient(config), [config]);
+  const events = react.useMemo(() => new TraceyEventEmitter(), []);
+  const [isIdentified, setIsIdentified] = react.useState(false);
+  const [isLoading, setIsLoading] = react.useState(true);
+  const [error, setError] = react.useState(null);
+  const [announcements, setAnnouncements] = react.useState([]);
+  const [announcementsLoading, setAnnouncementsLoading] = react.useState(false);
+  const [unreadCount, setUnreadCountState] = react.useState(
+    () => readCachedUnreadCount(apiKey, user.id)
+  );
+  const unreadCountRef = react.useRef(unreadCount);
+  const setUnreadCount = react.useCallback(
+    (count) => {
+      const previousCount = unreadCountRef.current;
+      unreadCountRef.current = count;
+      setUnreadCountState(count);
+      writeCachedUnreadCount(apiKey, user.id, count);
+      if (count !== previousCount) {
+        events.emit("unread-count-changed", {
+          count,
+          previousCount
+        });
+      }
+    },
+    [apiKey, user.id, events]
+  );
+  const fetchUnreadCount = react.useCallback(async () => {
+    try {
+      const { count } = await client.getUnreadCount();
+      setUnreadCount(count);
+    } catch {
+    }
+  }, [client, setUnreadCount]);
+  react.useEffect(() => {
+    let mounted = true;
+    const identify = async () => {
+      setIsLoading(true);
+      setError(null);
+      try {
+        await client.identify(user);
+        client.setCustomerId(user.id);
+        if (mounted) {
+          setIsIdentified(true);
+          events.emit("user:identified", { user });
+        }
+      } catch (err) {
+        if (mounted) {
+          const error2 = err instanceof Error ? err : new Error("Failed to identify user");
+          setError(error2);
+          events.emit("error", { error: error2, context: "identify" });
+        }
+      } finally {
+        if (mounted) {
+          setIsLoading(false);
+        }
+      }
+    };
+    identify();
+    return () => {
+      mounted = false;
+    };
+  }, [client, user, events]);
+  const fetchAnnouncements = react.useCallback(async () => {
+    if (!isIdentified) return;
+    setAnnouncementsLoading(true);
+    try {
+      const data = await client.getAnnouncements();
+      setAnnouncements(data);
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error("Failed to fetch announcements");
+      events.emit("error", { error: error2, context: "announcements" });
+    } finally {
+      setAnnouncementsLoading(false);
+    }
+  }, [client, events, isIdentified]);
+  react.useEffect(() => {
+    if (isIdentified) {
+      fetchAnnouncements();
+      fetchUnreadCount();
+    }
+  }, [isIdentified, fetchAnnouncements, fetchUnreadCount]);
+  react.useEffect(() => {
+    if (!isIdentified) return;
+    const interval = setInterval(fetchUnreadCount, UNREAD_POLL_INTERVAL_MS);
+    return () => clearInterval(interval);
+  }, [isIdentified, fetchUnreadCount]);
+  const contextValue = react.useMemo(
+    () => ({
+      config,
+      client,
+      events,
+      user: isIdentified ? user : null,
+      isIdentified,
+      isLoading,
+      error,
+      announcements,
+      announcementsLoading,
+      refetchAnnouncements: fetchAnnouncements,
+      unreadCount,
+      setUnreadCount
+    }),
+    [
+      config,
+      client,
+      events,
+      user,
+      isIdentified,
+      isLoading,
+      error,
+      announcements,
+      announcementsLoading,
+      fetchAnnouncements,
+      unreadCount,
+      setUnreadCount
+    ]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(TraceyContext.Provider, { value: contextValue, children });
+}
+const defaultMockUser = {
+  id: "mock-user-1",
+  email: "demo@example.com",
+  name: "Demo User",
+  role: "user"
+};
+const defaultMockAnnouncements = [
+  {
+    id: 1,
+    title: "Welcome to Our App!",
+    status: "published",
+    displayType: "modal",
+    publishAt: null,
+    expiresAt: null,
+    slides: [
+      {
+        id: 1,
+        order: 0,
+        title: "Getting Started",
+        body: "Here's how to get the most out of our platform.",
+        imageUrl: null,
+        videoUrl: null,
+        ctaText: "Learn More",
+        ctaUrl: "https://example.com/docs"
+      }
+    ],
+    viewed: false,
+    ctaClicked: false
+  }
+];
+function MockTraceyProvider({
+  children,
+  mockUser = defaultMockUser,
+  mockAnnouncements = defaultMockAnnouncements
+}) {
+  const config = react.useMemo(
+    () => ({
+      apiKey: "mock-api-key",
+      baseUrl: "https://mock.tracey.dev",
+      debug: true
+    }),
+    []
+  );
+  const client = react.useMemo(() => {
+    const apiClient = new TraceyApiClient(config);
+    apiClient.setCustomerId(mockUser.id);
+    apiClient.trackAnnouncementView = async () => {
+    };
+    apiClient.trackAnnouncementCta = async () => {
+    };
+    apiClient.submitFeedback = async (feedback) => ({
+      id: Date.now(),
+      title: feedback.title,
+      description: feedback.description ?? null,
+      type: feedback.type,
+      status: "new",
+      category: feedback.category ?? null,
+      tags: feedback.tags ?? null,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    });
+    apiClient.identify = async () => ({ success: true });
+    apiClient.getAnnouncements = async () => mockAnnouncements;
+    apiClient.getUnreadCount = async () => ({
+      count: mockAnnouncements.filter((a) => !a.viewed).length
+    });
+    apiClient.getActiveSurvey = async () => null;
+    apiClient.submitSurveyResponse = async () => ({
+      success: true,
+      responseId: Date.now()
+    });
+    return apiClient;
+  }, [config, mockUser, mockAnnouncements]);
+  const events = react.useMemo(() => new TraceyEventEmitter(), []);
+  const [announcements, setAnnouncements] = react.useState(mockAnnouncements);
+  const [unreadCount, setUnreadCount] = react.useState(
+    () => mockAnnouncements.filter((a) => !a.viewed).length
+  );
+  const refetchAnnouncements = react.useCallback(async () => {
+    setAnnouncements(mockAnnouncements);
+  }, [mockAnnouncements]);
+  const contextValue = react.useMemo(
+    () => ({
+      config,
+      client,
+      events,
+      user: mockUser,
+      isIdentified: true,
+      isLoading: false,
+      error: null,
+      announcements,
+      announcementsLoading: false,
+      refetchAnnouncements,
+      unreadCount,
+      setUnreadCount
+    }),
+    [
+      config,
+      client,
+      events,
+      mockUser,
+      announcements,
+      refetchAnnouncements,
+      unreadCount
+    ]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(TraceyContext.Provider, { value: contextValue, children });
+}
+function useTracey() {
+  const context = react.useContext(TraceyContext);
+  if (!context) {
+    throw new Error("useTracey must be used within a TraceyProvider");
+  }
+  return context;
+}
+const MAX_SUBMISSIONS_PER_MINUTE = 5;
+const RATE_LIMIT_WINDOW_MS = 6e4;
+function useFeedback() {
+  const { client, events } = useTracey();
+  const [isSubmitting, setIsSubmitting] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [lastSubmission, setLastSubmission] = react.useState(
+    null
+  );
+  const submissionTimestamps = react.useRef([]);
+  const submit = react.useCallback(
+    async (feedback) => {
+      const now = Date.now();
+      submissionTimestamps.current = submissionTimestamps.current.filter(
+        (ts) => now - ts < RATE_LIMIT_WINDOW_MS
+      );
+      if (submissionTimestamps.current.length >= MAX_SUBMISSIONS_PER_MINUTE) {
+        const oldestInWindow = submissionTimestamps.current[0];
+        const retryAfterMs = RATE_LIMIT_WINDOW_MS - (now - oldestInWindow);
+        const rateLimitError = new Error(
+          "Too many submissions. Please wait before submitting again."
+        );
+        setError(rateLimitError);
+        events.emit("feedback:rate-limited", { retryAfterMs });
+        return null;
+      }
+      setIsSubmitting(true);
+      setError(null);
+      try {
+        const response = await client.submitFeedback(feedback);
+        submissionTimestamps.current.push(Date.now());
+        setLastSubmission(response);
+        events.emit("feedback:submitted", { feedback: response });
+        return response;
+      } catch (err) {
+        const error2 = err instanceof Error ? err : new Error("Failed to submit feedback");
+        setError(error2);
+        events.emit("feedback:error", { error: error2 });
+        return null;
+      } finally {
+        setIsSubmitting(false);
+      }
+    },
+    [client, events]
+  );
+  const reset = react.useCallback(() => {
+    setError(null);
+    setLastSubmission(null);
+  }, []);
+  return {
+    submit,
+    isSubmitting,
+    error,
+    lastSubmission,
+    reset
+  };
+}
+function useAnnouncements() {
+  const {
+    client,
+    events,
+    announcements,
+    announcementsLoading,
+    refetchAnnouncements,
+    unreadCount,
+    setUnreadCount
+  } = useTracey();
+  const unread = react.useMemo(
+    () => announcements.filter((a) => !a.viewed),
+    [announcements]
+  );
+  const markAsViewed = react.useCallback(
+    async (announcementId) => {
+      try {
+        await client.trackAnnouncementView(announcementId);
+        const announcement = announcements.find((a) => a.id === announcementId);
+        if (announcement) {
+          events.emit("announcement:viewed", { announcement });
+        }
+        setUnreadCount(Math.max(0, unreadCount - 1));
+        await refetchAnnouncements();
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error("Failed to mark announcement as viewed");
+        events.emit("error", { error, context: "announcement:view" });
+      }
+    },
+    [
+      client,
+      events,
+      announcements,
+      refetchAnnouncements,
+      unreadCount,
+      setUnreadCount
+    ]
+  );
+  const markAsRead = react.useCallback(
+    async (announcementId) => {
+      await markAsViewed(announcementId);
+    },
+    [markAsViewed]
+  );
+  const markAllAsRead = react.useCallback(async () => {
+    const unreadAnnouncements = announcements.filter((a) => !a.viewed);
+    if (unreadAnnouncements.length === 0) return;
+    setUnreadCount(0);
+    try {
+      await Promise.all(
+        unreadAnnouncements.map((a) => client.trackAnnouncementView(a.id))
+      );
+      await refetchAnnouncements();
+    } catch (err) {
+      const error = err instanceof Error ? err : new Error("Failed to mark all announcements as read");
+      events.emit("error", { error, context: "announcement:mark-all-read" });
+      setUnreadCount(unreadAnnouncements.length);
+    }
+  }, [announcements, client, events, refetchAnnouncements, setUnreadCount]);
+  const markCtaClicked = react.useCallback(
+    async (announcementId, slideIndex) => {
+      try {
+        await client.trackAnnouncementCta(announcementId);
+        const announcement = announcements.find((a) => a.id === announcementId);
+        if (announcement) {
+          events.emit("announcement:cta-clicked", {
+            announcement,
+            slideIndex
+          });
+        }
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error("Failed to track CTA click");
+        events.emit("error", { error, context: "announcement:cta" });
+      }
+    },
+    [client, events, announcements]
+  );
+  return {
+    announcements,
+    unread,
+    unreadCount,
+    isLoading: announcementsLoading,
+    markAsViewed,
+    markAsRead,
+    markAllAsRead,
+    markCtaClicked,
+    refetch: refetchAnnouncements
+  };
+}
+function useTraceyEvents() {
+  const { events } = useTracey();
+  const subscribe = react.useCallback(
+    (event, callback) => {
+      return events.subscribe(event, callback);
+    },
+    [events]
+  );
+  const emit = react.useCallback(
+    (event, data) => {
+      events.emit(event, data);
+    },
+    [events]
+  );
+  return { subscribe, emit };
+}
+const FeedbackContext = react.createContext(null);
+function useFeedbackContext() {
+  const context = react.useContext(FeedbackContext);
+  if (!context) {
+    throw new Error(
+      "Feedback compound components must be used within FeedbackRoot"
+    );
+  }
+  return context;
+}
+function FeedbackRoot({
+  children,
+  defaultOpen = false,
+  open,
+  onOpenChange
+}) {
+  const [internalOpen, setInternalOpen] = react.useState(defaultOpen);
+  const isOpen = open ?? internalOpen;
+  const setIsOpen = react.useCallback(
+    (newOpen) => {
+      if (open === void 0) {
+        setInternalOpen(newOpen);
+      }
+      onOpenChange == null ? void 0 : onOpenChange(newOpen);
+    },
+    [open, onOpenChange]
+  );
+  const toggle = react.useCallback(() => {
+    setIsOpen(!isOpen);
+  }, [isOpen, setIsOpen]);
+  return /* @__PURE__ */ jsxRuntime.jsx(FeedbackContext.Provider, { value: { isOpen, setIsOpen, toggle }, children });
+}
+function FeedbackClose({
+  children,
+  asChild = true
+}) {
+  const { setIsOpen } = useFeedbackContext();
+  const handleClose = (e) => {
+    var _a, _b;
+    (_b = (_a = children.props).onClick) == null ? void 0 : _b.call(_a, e);
+    setIsOpen(false);
+  };
+  if (asChild) {
+    return react.cloneElement(children, { onClick: handleClose });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", onClick: handleClose, children });
+}
+function FeedbackFormPrimitive({
+  children,
+  onSuccess,
+  closeOnSuccess = true
+}) {
+  const { setIsOpen } = useFeedbackContext();
+  const { submit, isSubmitting, error } = useFeedback();
+  const [title, setTitle] = react.useState("");
+  const [description, setDescription] = react.useState("");
+  const [type, setType] = react.useState("general");
+  const [screenshot, setScreenshot] = react.useState(null);
+  const handleSubmit = react.useCallback(
+    async (e) => {
+      e.preventDefault();
+      const result = await submit({
+        title,
+        description: description || void 0,
+        type,
+        screenshot: screenshot ?? void 0
+      });
+      if (result) {
+        setTitle("");
+        setDescription("");
+        setType("general");
+        setScreenshot(null);
+        onSuccess == null ? void 0 : onSuccess();
+        if (closeOnSuccess) {
+          setIsOpen(false);
+        }
+      }
+    },
+    [
+      submit,
+      title,
+      description,
+      type,
+      screenshot,
+      onSuccess,
+      closeOnSuccess,
+      setIsOpen
+    ]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: children({
+    title,
+    setTitle,
+    description,
+    setDescription,
+    type,
+    setType,
+    screenshot,
+    setScreenshot,
+    isSubmitting,
+    error,
+    handleSubmit
+  }) });
+}
+function FeedbackContent({ children, ...props }) {
+  const { isOpen } = useFeedbackContext();
+  if (!isOpen) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { role: "dialog", "aria-modal": "true", ...props, children });
+}
+function FeedbackPortal({ children, container }) {
+  const [mounted, setMounted] = react.useState(false);
+  react.useEffect(() => {
+    setMounted(true);
+  }, []);
+  if (!mounted) {
+    return null;
+  }
+  const target = container ?? document.body;
+  return reactDom.createPortal(children, target);
+}
+function FeedbackTrigger({
+  children,
+  asChild = true
+}) {
+  const { toggle } = useFeedbackContext();
+  if (asChild) {
+    return react.cloneElement(children, {
+      onClick: (e) => {
+        var _a, _b;
+        (_b = (_a = children.props).onClick) == null ? void 0 : _b.call(_a, e);
+        toggle();
+      }
+    });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", onClick: toggle, children });
+}
+const AnnouncementContext = react.createContext(
+  null
+);
+function useAnnouncementContext() {
+  const context = react.useContext(AnnouncementContext);
+  if (!context) {
+    throw new Error(
+      "Announcement compound components must be used within AnnouncementRoot"
+    );
+  }
+  return context;
+}
+function AnnouncementRoot({
+  children,
+  announcement = null,
+  defaultOpen = false,
+  open,
+  onOpenChange
+}) {
+  const [internalOpen, setInternalOpen] = react.useState(defaultOpen);
+  const [currentAnnouncement, setCurrentAnnouncement] = react.useState(announcement);
+  const [currentSlideIndex, setCurrentSlideIndex] = react.useState(0);
+  react.useEffect(() => {
+    setCurrentAnnouncement(announcement);
+    setCurrentSlideIndex(0);
+  }, [announcement]);
+  const isOpen = open ?? internalOpen;
+  const totalSlides = (currentAnnouncement == null ? void 0 : currentAnnouncement.slides.length) ?? 0;
+  const setIsOpen = react.useCallback(
+    (newOpen) => {
+      if (open === void 0) {
+        setInternalOpen(newOpen);
+      }
+      onOpenChange == null ? void 0 : onOpenChange(newOpen);
+    },
+    [open, onOpenChange]
+  );
+  const nextSlide = react.useCallback(() => {
+    if (currentSlideIndex < totalSlides - 1) {
+      setCurrentSlideIndex((prev) => prev + 1);
+    }
+  }, [currentSlideIndex, totalSlides]);
+  const prevSlide = react.useCallback(() => {
+    if (currentSlideIndex > 0) {
+      setCurrentSlideIndex((prev) => prev - 1);
+    }
+  }, [currentSlideIndex]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    AnnouncementContext.Provider,
+    {
+      value: {
+        isOpen,
+        setIsOpen,
+        currentAnnouncement,
+        setCurrentAnnouncement,
+        currentSlideIndex,
+        setCurrentSlideIndex,
+        nextSlide,
+        prevSlide,
+        totalSlides
+      },
+      children
+    }
+  );
+}
+function AnnouncementClose({
+  children,
+  asChild = true
+}) {
+  const { setIsOpen } = useAnnouncementContext();
+  const handleClose = (e) => {
+    var _a, _b;
+    (_b = (_a = children.props).onClick) == null ? void 0 : _b.call(_a, e);
+    setIsOpen(false);
+  };
+  if (asChild) {
+    return react.cloneElement(children, { onClick: handleClose });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", onClick: handleClose, children });
+}
+function AnnouncementContent({
+  children,
+  trackView = true,
+  ...props
+}) {
+  const { isOpen, currentAnnouncement } = useAnnouncementContext();
+  const { markAsViewed } = useAnnouncements();
+  const viewedRef = react.useRef(/* @__PURE__ */ new Set());
+  react.useEffect(() => {
+    if (isOpen && trackView && currentAnnouncement && !currentAnnouncement.viewed && !viewedRef.current.has(currentAnnouncement.id)) {
+      viewedRef.current.add(currentAnnouncement.id);
+      markAsViewed(currentAnnouncement.id);
+    }
+  }, [isOpen, trackView, currentAnnouncement, markAsViewed]);
+  if (!isOpen) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { role: "dialog", "aria-modal": "true", ...props, children });
+}
+function AnnouncementNavigation({
+  children
+}) {
+  const {
+    currentSlideIndex,
+    totalSlides,
+    nextSlide,
+    prevSlide,
+    setCurrentSlideIndex
+  } = useAnnouncementContext();
+  const canGoNext = currentSlideIndex < totalSlides - 1;
+  const canGoPrev = currentSlideIndex > 0;
+  return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: children({
+    currentSlide: currentSlideIndex,
+    totalSlides,
+    canGoNext,
+    canGoPrev,
+    nextSlide,
+    prevSlide,
+    goToSlide: setCurrentSlideIndex
+  }) });
+}
+function AnnouncementPortal({
+  children,
+  container
+}) {
+  const [mounted, setMounted] = react.useState(false);
+  react.useEffect(() => {
+    setMounted(true);
+  }, []);
+  if (!mounted) {
+    return null;
+  }
+  const target = container ?? document.body;
+  return reactDom.createPortal(children, target);
+}
+function LauncherBadge({
+  count,
+  children,
+  max = 99
+}) {
+  if (count <= 0) {
+    return null;
+  }
+  if (children) {
+    return /* @__PURE__ */ jsxRuntime.jsx(jsxRuntime.Fragment, { children: children(count) });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("span", { children: count > max ? `${max}+` : count });
+}
+const LauncherContext = react.createContext(null);
+function useLauncherContext() {
+  const context = react.useContext(LauncherContext);
+  if (!context) {
+    throw new Error(
+      "Launcher compound components must be used within LauncherRoot"
+    );
+  }
+  return context;
+}
+function LauncherRoot({
+  children,
+  defaultOpen = false,
+  open,
+  onOpenChange,
+  defaultActiveItem = null
+}) {
+  const [internalOpen, setInternalOpen] = react.useState(defaultOpen);
+  const [activeItem, setActiveItem] = react.useState(defaultActiveItem);
+  const triggerRef = react.useRef(null);
+  const isOpen = open ?? internalOpen;
+  const setIsOpen = react.useCallback(
+    (newOpen) => {
+      if (open === void 0) {
+        setInternalOpen(newOpen);
+      }
+      if (!newOpen) {
+        setActiveItem(defaultActiveItem);
+      }
+      onOpenChange == null ? void 0 : onOpenChange(newOpen);
+    },
+    [open, onOpenChange, defaultActiveItem]
+  );
+  const toggle = react.useCallback(() => {
+    setIsOpen(!isOpen);
+  }, [isOpen, setIsOpen]);
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    LauncherContext.Provider,
+    {
+      value: {
+        isOpen,
+        setIsOpen,
+        toggle,
+        activeItem,
+        setActiveItem,
+        triggerRef
+      },
+      children
+    }
+  );
+}
+function LauncherPanel({ children, ...props }) {
+  const { isOpen, setIsOpen, triggerRef } = useLauncherContext();
+  const panelRef = react.useRef(null);
+  react.useEffect(() => {
+    if (!isOpen) return;
+    const handleClickOutside = (e) => {
+      const target = e.target;
+      if (panelRef.current && !panelRef.current.contains(target) && triggerRef.current && !triggerRef.current.contains(target)) {
+        setIsOpen(false);
+      }
+    };
+    const handleEscape = (e) => {
+      if (e.key === "Escape") {
+        setIsOpen(false);
+      }
+    };
+    document.addEventListener("mousedown", handleClickOutside);
+    document.addEventListener("keydown", handleEscape);
+    return () => {
+      document.removeEventListener("mousedown", handleClickOutside);
+      document.removeEventListener("keydown", handleEscape);
+    };
+  }, [isOpen, setIsOpen, triggerRef]);
+  if (!isOpen) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { ref: panelRef, role: "dialog", "aria-label": "Tracey widget", ...props, children });
+}
+function LauncherPortal({ children, container }) {
+  const [mounted, setMounted] = react.useState(false);
+  react.useEffect(() => {
+    setMounted(true);
+  }, []);
+  if (!mounted) {
+    return null;
+  }
+  const target = container ?? document.body;
+  return reactDom.createPortal(children, target);
+}
+function LauncherTab({ value, children, ...props }) {
+  const { activeItem, setActiveItem } = useLauncherContext();
+  const isActive = activeItem === value;
+  return /* @__PURE__ */ jsxRuntime.jsx(
+    "button",
+    {
+      type: "button",
+      role: "tab",
+      "aria-selected": isActive,
+      "data-state": isActive ? "active" : "inactive",
+      onClick: () => setActiveItem(value),
+      ...props,
+      children
+    }
+  );
+}
+function LauncherTabContent({
+  value,
+  children,
+  ...props
+}) {
+  const { activeItem } = useLauncherContext();
+  if (activeItem !== value) {
+    return null;
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("div", { role: "tabpanel", ...props, children });
+}
+function LauncherTrigger({
+  children,
+  asChild = true
+}) {
+  const { toggle, triggerRef } = useLauncherContext();
+  const refCallback = react.useCallback(
+    (node) => {
+      triggerRef.current = node;
+    },
+    [triggerRef]
+  );
+  if (asChild) {
+    return react.cloneElement(children, {
+      ref: refCallback,
+      onClick: (e) => {
+        var _a, _b;
+        (_b = (_a = children.props).onClick) == null ? void 0 : _b.call(_a, e);
+        toggle();
+      }
+    });
+  }
+  return /* @__PURE__ */ jsxRuntime.jsx("button", { type: "button", ref: refCallback, onClick: toggle, children });
+}
+exports.AnnouncementClose = AnnouncementClose;
+exports.AnnouncementContent = AnnouncementContent;
+exports.AnnouncementNavigation = AnnouncementNavigation;
+exports.AnnouncementPortal = AnnouncementPortal;
+exports.AnnouncementRoot = AnnouncementRoot;
+exports.FeedbackClose = FeedbackClose;
+exports.FeedbackContent = FeedbackContent;
+exports.FeedbackFormPrimitive = FeedbackFormPrimitive;
+exports.FeedbackPortal = FeedbackPortal;
+exports.FeedbackRoot = FeedbackRoot;
+exports.FeedbackTrigger = FeedbackTrigger;
+exports.LauncherBadge = LauncherBadge;
+exports.LauncherPanel = LauncherPanel;
+exports.LauncherPortal = LauncherPortal;
+exports.LauncherRoot = LauncherRoot;
+exports.LauncherTab = LauncherTab;
+exports.LauncherTabContent = LauncherTabContent;
+exports.LauncherTrigger = LauncherTrigger;
+exports.MockTraceyProvider = MockTraceyProvider;
+exports.TraceyProvider = TraceyProvider;
+exports.useAnnouncementContext = useAnnouncementContext;
+exports.useAnnouncements = useAnnouncements;
+exports.useFeedback = useFeedback;
+exports.useLauncherContext = useLauncherContext;
+exports.useTracey = useTracey;
+exports.useTraceyEvents = useTraceyEvents;
+//# sourceMappingURL=LauncherTrigger-DjXDXHTm.cjs.map