@fruga/sdk 1.0.0

package/dist/index.js

@@ -0,0 +1,783 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// packages/core/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  DEFAULT_API_URL: () => DEFAULT_API_URL,
+  DEFAULT_THEME: () => DEFAULT_THEME,
+  DefaultTheme: () => DEFAULT_THEME,
+  HttpActivityService: () => HttpActivityService,
+  HttpOffersService: () => HttpOffersService,
+  HttpPayoutService: () => HttpPayoutService,
+  HttpWalletService: () => HttpWalletService,
+  STORAGE_KEYS: () => STORAGE_KEYS,
+  StorageService: () => StorageService,
+  WidgetButton: () => WidgetButton,
+  WidgetContainer: () => WidgetContainer,
+  WidgetHeader: () => WidgetHeader,
+  WidgetProvider: () => WidgetProvider,
+  formatDate: () => formatDate,
+  getBaseUrl: () => getBaseUrl,
+  getDaysRemaining: () => getDaysRemaining,
+  getResolvedTheme: () => getResolvedTheme,
+  isWithinDays: () => isWithinDays,
+  truncateText: () => truncateText,
+  useDebounce: () => useDebounce,
+  useWidget: () => useWidget,
+  useWidgetStore: () => useWidgetStore
+});
+module.exports = __toCommonJS(src_exports);
+
+// packages/core/src/domain/entities/Theme.ts
+var DEFAULT_THEME = {
+  widgetTitle: "Savings Box",
+  launcherLabel: "Insurance Savings",
+  launcherIcon: "arrow",
+  showLauncher: true,
+  mode: "light",
+  allowUserThemeControl: false,
+  defaultTheme: "light",
+  uiVersion: "current",
+  primary: "#1E40AF",
+  accent: "#2648C9",
+  accentTextLight: "#FFFFFF",
+  accentTextDark: "#FFFFFF",
+  bg: "#0B1220",
+  panel: "#0F1A2E",
+  panel2: "#111F38",
+  itemBg: "rgba(255,255,255,0.03)",
+  text: "#E6EDF7",
+  muted: "#A7B3C6",
+  border: "rgba(255,255,255,0.08)",
+  success: "#34D399",
+  danger: "#EF4444",
+  warning: "#FBBF24",
+  lightBg: "#F8FAFC",
+  lightPanel: "#FFFFFF",
+  lightPanel2: "#F1F5F9",
+  lightItemBg: "rgba(0,0,0,0.04)",
+  lightText: "#0F172A",
+  lightMuted: "#64748B",
+  lightBorder: "rgba(0,0,0,0.1)"
+};
+function getResolvedTheme(theme) {
+  const isLight = theme.mode === "light";
+  const resolvedText = isLight ? theme.textColorLight?.trim() || theme.lightText : theme.textColorDark?.trim() || theme.text;
+  return {
+    ...theme,
+    bg: isLight ? theme.lightBg : theme.bg,
+    panel: isLight ? theme.lightPanel : theme.panel,
+    panel2: isLight ? theme.lightPanel2 : theme.panel2,
+    itemBg: isLight ? theme.lightItemBg : theme.itemBg,
+    text: resolvedText,
+    muted: isLight ? theme.lightMuted : theme.muted,
+    border: isLight ? theme.lightBorder : theme.border,
+    subtleBg: isLight ? "rgba(0,0,0,0.02)" : "rgba(255,255,255,0.03)",
+    tooltipBg: isLight ? "#FFFFFF" : "#0B1220",
+    tooltipBorder: isLight ? "rgba(0,0,0,0.12)" : "rgba(255,255,255,0.12)",
+    accentText: isLight ? theme.accentTextLight?.trim() || "#0F172A" : theme.accentTextDark?.trim() || "#FFFFFF",
+    isLight,
+    mode: theme.mode
+  };
+}
+
+// packages/core/src/infrastructure/adapters/HttpWalletService.ts
+var HttpWalletService = class {
+  constructor(baseUrl, token) {
+    this.baseUrl = baseUrl;
+    this.token = token;
+  }
+  async getWallet() {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/wallet`, {
+        method: "GET",
+        headers: {
+          "Accept": "application/json",
+          "Authorization": `Bearer ${this.token}`
+        }
+      });
+      if (!response.ok) {
+        console.warn(`[FrugaSDK] Failed to fetch wallet: ${response.status}. Returning zeroed wallet.`);
+        return this.getEmptyWallet();
+      }
+      const data = await response.json();
+      return {
+        available: data.available ?? 0,
+        pending: data.pending ?? 0,
+        totalBalance: (data.available || 0) + (data.pending || 0),
+        lifetimeEarned: data.lifetimeEarned ?? 0,
+        lifetimeRedeemed: data.lifetimeRedeemed ?? 0,
+        updatedAt: data.updatedAt ?? (/* @__PURE__ */ new Date()).toISOString(),
+        requiredActions: data.requiredActions ?? null
+      };
+    } catch (error) {
+      console.warn(`[FrugaSDK] Network error fetching wallet. Returning zeroed wallet.`, error);
+      return this.getEmptyWallet();
+    }
+  }
+  getEmptyWallet() {
+    return {
+      available: 0,
+      pending: 0,
+      totalBalance: 0,
+      lifetimeEarned: 0,
+      lifetimeRedeemed: 0,
+      updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+      requiredActions: null
+    };
+  }
+};
+
+// packages/core/src/infrastructure/adapters/BaseHttpService.ts
+var BaseHttpService = class {
+  constructor(baseUrl, token) {
+    this.baseUrl = baseUrl;
+    this.token = token;
+  }
+  async fetchQuery(path, queryParams = {}) {
+    const url = new URL(`${this.baseUrl}${path}`);
+    Object.entries(queryParams).forEach(([key, value]) => {
+      if (value !== void 0 && value !== null) {
+        if (Array.isArray(value)) {
+          value.forEach((item) => url.searchParams.append(key, String(item)));
+        } else {
+          url.searchParams.append(key, String(value));
+        }
+      }
+    });
+    return fetch(url.toString(), {
+      method: "GET",
+      headers: {
+        "Accept": "application/json",
+        "Authorization": `Bearer ${this.token}`
+      }
+    });
+  }
+};
+
+// packages/core/src/infrastructure/adapters/HttpActivityService.ts
+var HttpActivityService = class extends BaseHttpService {
+  constructor(baseUrl, token) {
+    super(baseUrl, token);
+  }
+  async getActivity(pageNumber, pageSize) {
+    try {
+      const response = await this.fetchQuery("/api/activity", { pageNumber, pageSize });
+      if (!response.ok) {
+        console.warn(`[FrugaSDK] Failed to fetch activity: ${response.status}. Returning empty activity.`);
+        return this.getEmptyActivity();
+      }
+      const data = await response.json();
+      return {
+        ...data,
+        transactions: data.transactions || []
+      };
+    } catch (error) {
+      console.warn(`[FrugaSDK] Network error fetching activity. Returning empty activity.`, error);
+      return this.getEmptyActivity();
+    }
+  }
+  getEmptyActivity() {
+    return {
+      actorType: "",
+      partnerId: 0,
+      transactions: []
+    };
+  }
+};
+
+// packages/core/src/infrastructure/adapters/HttpOffersService.ts
+var HttpOffersService = class extends BaseHttpService {
+  constructor(baseUrl, token) {
+    super(baseUrl, token);
+  }
+  async getCategories() {
+    try {
+      const response = await this.fetchQuery("/api/offers/categories");
+      if (!response.ok) {
+        console.warn(`[FrugaSDK] Failed to fetch offer categories: ${response.status}. Returning empty list.`);
+        return [];
+      }
+      const data = await response.json();
+      const categories = data.categories || [];
+      return categories;
+    } catch (error) {
+      console.warn(`[FrugaSDK] Network error fetching offer categories. Returning empty list.`, error);
+      return [];
+    }
+  }
+  async getOffers(query) {
+    try {
+      const response = await this.fetchQuery("/api/offers", {
+        pageNumber: query.pageNumber ?? 0,
+        pageSize: query.pageSize ?? 10,
+        type: query.type,
+        query: query.query,
+        featured: query.featured,
+        categories: query.categories
+      });
+      if (!response.ok) {
+        console.warn(`[FrugaSDK] Failed to fetch offers: ${response.status}. Returning empty response.`);
+        return this.getEmptyPaginatedResponse();
+      }
+      const data = await response.json();
+      return {
+        ...data,
+        content: data.content || []
+      };
+    } catch (error) {
+      console.warn(`[FrugaSDK] Network error fetching offers. Returning empty response.`, error);
+      return this.getEmptyPaginatedResponse();
+    }
+  }
+  getEmptyPaginatedResponse() {
+    return {
+      content: [],
+      totalElements: 0,
+      totalPages: 0,
+      number: 0,
+      size: 0,
+      numberOfElements: 0,
+      numberOfPages: 0
+    };
+  }
+};
+
+// packages/core/src/infrastructure/adapters/HttpPayoutService.ts
+var HttpPayoutService = class {
+  constructor(baseUrl, token) {
+    this.baseUrl = baseUrl;
+    this.token = token;
+  }
+  async listMethods() {
+    try {
+      const response = await fetch(`${this.baseUrl}/api/payout-methods`, {
+        method: "GET",
+        headers: {
+          "Accept": "application/json",
+          "Authorization": `Bearer ${this.token}`
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`Failed to list payout methods: ${response.status}`);
+      }
+      const data = await response.json();
+      return data.items || [];
+    } catch (error) {
+      console.error("[FrugaSDK] Error listing payout methods:", error);
+      return [];
+    }
+  }
+  async addBankMethod(payload) {
+    const response = await fetch(`${this.baseUrl}/api/payout-methods/bank`, {
+      method: "POST",
+      headers: {
+        "Accept": "application/json",
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${this.token}`
+      },
+      body: JSON.stringify(payload)
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to add bank payout method: ${response.status}`);
+    }
+    return response.json();
+  }
+  async deleteMethod(id) {
+    const response = await fetch(`${this.baseUrl}/api/payout-methods/${id}`, {
+      method: "DELETE",
+      headers: {
+        "Accept": "application/json",
+        "Authorization": `Bearer ${this.token}`
+      }
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to delete payout method: ${response.status}`);
+    }
+  }
+};
+
+// packages/core/src/presentation/components/index.tsx
+var import_jsx_runtime = require("react/jsx-runtime");
+var WidgetButton = ({
+  children,
+  variant = "primary",
+  style,
+  ...props
+}) => {
+  const baseStyle = {
+    padding: "10px 20px",
+    borderRadius: "8px",
+    border: "none",
+    cursor: "pointer",
+    fontWeight: 600,
+    transition: "opacity 0.2s",
+    backgroundColor: variant === "primary" ? "#007bff" : "#6c757d",
+    color: "white",
+    ...style
+  };
+  return /* @__PURE__ */ (0, import_jsx_runtime.jsx)("button", { style: baseStyle, ...props, children });
+};
+var WidgetHeader = ({ title }) => /* @__PURE__ */ (0, import_jsx_runtime.jsx)("header", { style: {
+  padding: "16px",
+  borderBottom: "1px solid #eee",
+  display: "flex",
+  alignItems: "center",
+  justifyContent: "space-between"
+}, children: /* @__PURE__ */ (0, import_jsx_runtime.jsx)("h3", { style: { margin: 0, fontSize: "1.1rem" }, children: title }) });
+
+// packages/core/src/presentation/components/WidgetContainer.tsx
+var import_react3 = require("react");
+
+// packages/core/src/presentation/components/ui/LauncherIcon.tsx
+var import_lucide_react = require("lucide-react");
+var import_jsx_runtime2 = require("react/jsx-runtime");
+function LauncherIcon({ theme }) {
+  if (theme.launcherIcon === "none") return null;
+  if (theme.launcherIcon === "sparkles") return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.Sparkles, { size: 20 });
+  if (theme.launcherIcon === "credit") return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.CreditCard, { size: 20 });
+  if (theme.launcherIcon === "arrow") return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.MoveUpRight, { size: 20 });
+  return /* @__PURE__ */ (0, import_jsx_runtime2.jsx)(import_lucide_react.Gift, { size: 20 });
+}
+
+// packages/core/src/presentation/hooks/useActivityDetector.ts
+var import_react2 = require("react");
+
+// node_modules/.pnpm/zustand@5.0.12_@types+react@19.2.14_react@19.2.4/node_modules/zustand/esm/vanilla.mjs
+var createStoreImpl = (createState) => {
+  let state;
+  const listeners = /* @__PURE__ */ new Set();
+  const setState = (partial, replace) => {
+    const nextState = typeof partial === "function" ? partial(state) : partial;
+    if (!Object.is(nextState, state)) {
+      const previousState = state;
+      state = (replace != null ? replace : typeof nextState !== "object" || nextState === null) ? nextState : Object.assign({}, state, nextState);
+      listeners.forEach((listener) => listener(state, previousState));
+    }
+  };
+  const getState = () => state;
+  const getInitialState = () => initialState;
+  const subscribe = (listener) => {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+  };
+  const api = { setState, getState, getInitialState, subscribe };
+  const initialState = state = createState(setState, getState, api);
+  return api;
+};
+var createStore = ((createState) => createState ? createStoreImpl(createState) : createStoreImpl);
+
+// node_modules/.pnpm/zustand@5.0.12_@types+react@19.2.14_react@19.2.4/node_modules/zustand/esm/react.mjs
+var import_react = __toESM(require("react"), 1);
+var identity = (arg) => arg;
+function useStore(api, selector = identity) {
+  const slice = import_react.default.useSyncExternalStore(
+    api.subscribe,
+    import_react.default.useCallback(() => selector(api.getState()), [api, selector]),
+    import_react.default.useCallback(() => selector(api.getInitialState()), [api, selector])
+  );
+  import_react.default.useDebugValue(slice);
+  return slice;
+}
+var createImpl = (createState) => {
+  const api = createStore(createState);
+  const useBoundStore = (selector) => useStore(api, selector);
+  Object.assign(useBoundStore, api);
+  return useBoundStore;
+};
+var create = ((createState) => createState ? createImpl(createState) : createImpl);
+
+// packages/core/src/presentation/store/useWidgetStore.ts
+var useWidgetStore = create((set) => ({
+  isOpen: false,
+  isFocused: true,
+  // Default to true as the widget starts in some state
+  isIdle: false,
+  available: 0,
+  pending: 0,
+  mode: "light",
+  token: null,
+  partnerPayout: null,
+  isAddingPayoutFromAlert: false,
+  showPayoutSuccess: false,
+  toggle: () => set((state) => ({ isOpen: !state.isOpen })),
+  setOpen: (open) => set({ isOpen: open }),
+  setFocused: (focused) => set({ isFocused: focused }),
+  setIdle: (idle) => set({ isIdle: idle }),
+  setBalances: (available, pending) => set({ available, pending }),
+  setMode: (mode) => set({ mode }),
+  setToken: (token) => set({ token }),
+  setPartnerPayout: (payout) => set({ partnerPayout: payout }),
+  setIsAddingPayoutFromAlert: (val) => set({ isAddingPayoutFromAlert: val }),
+  setShowPayoutSuccess: (val) => set({ showPayoutSuccess: val })
+}));
+
+// packages/core/src/presentation/constants/WidgetConstants.ts
+var IDLE_TIMEOUT_MS = 60 * 1e3;
+
+// packages/core/src/presentation/hooks/useActivityDetector.ts
+function useActivityDetector() {
+  const { setFocused, setIdle } = useWidgetStore();
+  const idleTimerRef = (0, import_react2.useRef)(null);
+  (0, import_react2.useEffect)(() => {
+    const handleFocus = () => setFocused(true);
+    const handleBlur = () => setFocused(false);
+    const resetIdleTimer = () => {
+      setIdle(false);
+      if (idleTimerRef.current) {
+        clearTimeout(idleTimerRef.current);
+      }
+      idleTimerRef.current = setTimeout(() => {
+        setIdle(true);
+      }, IDLE_TIMEOUT_MS);
+    };
+    const handleInteraction = () => {
+      resetIdleTimer();
+    };
+    resetIdleTimer();
+    setFocused(document.hasFocus());
+    window.addEventListener("focus", handleFocus);
+    window.addEventListener("blur", handleBlur);
+    const activityEvents = ["mousemove", "keydown", "scroll", "touchstart", "mousedown"];
+    activityEvents.forEach((event) => {
+      window.addEventListener(event, handleInteraction, event === "scroll" ? true : void 0);
+    });
+    return () => {
+      window.removeEventListener("focus", handleFocus);
+      window.removeEventListener("blur", handleBlur);
+      activityEvents.forEach((event) => {
+        window.removeEventListener(event, handleInteraction, event === "scroll" ? true : void 0);
+      });
+      if (idleTimerRef.current) {
+        clearTimeout(idleTimerRef.current);
+      }
+    };
+  }, [setFocused, setIdle]);
+}
+
+// packages/core/src/presentation/components/WidgetContainer.tsx
+var import_lucide_react2 = require("lucide-react");
+var import_jsx_runtime3 = require("react/jsx-runtime");
+var WidgetContainer = ({
+  children,
+  theme: themeProp,
+  hostHeight: initialHostHeight = 800,
+  isMobile: initialIsMobile = false
+}) => {
+  useActivityDetector();
+  const { isOpen, toggle, mode: storeMode } = useWidgetStore();
+  const theme = themeProp || DEFAULT_THEME;
+  const [hostHeight, setHostHeight] = (0, import_react3.useState)(initialHostHeight);
+  const [isMobile, setIsMobile] = (0, import_react3.useState)(initialIsMobile);
+  const effectiveTheme = theme.allowUserThemeControl ? { ...theme, mode: storeMode } : { ...theme, mode: theme.mode || "light" };
+  const resolved = getResolvedTheme(effectiveTheme);
+  const containerRef = (0, import_react3.useRef)(null);
+  const buttonRef = (0, import_react3.useRef)(null);
+  (0, import_react3.useEffect)(() => {
+    const handler = (event) => {
+      if (event.data?.type === "FRUGA_HOST_RESIZE") {
+        setHostHeight(event.data.hostHeight);
+        setIsMobile(event.data.isHostMobile);
+      }
+      if (event.data?.type === "FRUGA_TOKEN_UPDATE") {
+        const { setToken } = useWidgetStore.getState();
+        setToken(event.data.token);
+      }
+      if (event.data?.type === "FRUGA_GET_BALANCE") {
+        const { available, pending } = useWidgetStore.getState();
+        console.log("FRUGA_GET_BALANCE", available, pending);
+        window.parent.postMessage({
+          type: "FRUGA_BALANCE_RESPONSE",
+          requestId: event.data.requestId,
+          available,
+          pending
+        }, "*");
+      }
+    };
+    window.addEventListener("message", handler);
+    return () => window.removeEventListener("message", handler);
+  }, []);
+  (0, import_react3.useEffect)(() => {
+    if (!containerRef.current) return;
+    const sendResize = () => {
+      if (!containerRef.current) return;
+      let expectedWidth = isOpen ? 450 : 100;
+      if (!isOpen && buttonRef.current) {
+        expectedWidth = buttonRef.current.offsetWidth + 40;
+      }
+      let expectedHeight = isOpen ? Math.max(200, hostHeight - 100) : 100;
+      if (isMobile && isOpen) {
+        expectedWidth = window.innerWidth;
+        expectedHeight = hostHeight;
+      }
+      window.parent.postMessage({
+        type: "FRUGA_RESIZE",
+        height: expectedHeight,
+        width: expectedWidth,
+        isFullscreen: isMobile && isOpen
+      }, "*");
+    };
+    const observer = new ResizeObserver(() => sendResize());
+    observer.observe(containerRef.current);
+    sendResize();
+    return () => observer.disconnect();
+  }, [isOpen, hostHeight, isMobile]);
+  return /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+    "div",
+    {
+      ref: containerRef,
+      className: resolved.mode === "dark" ? "dark" : "",
+      style: {
+        fontFamily: 'ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji"',
+        color: resolved.text,
+        display: "flex",
+        flexDirection: "column",
+        alignItems: "flex-end",
+        justifyContent: "flex-end",
+        padding: isMobile && isOpen ? "0" : "20px",
+        boxSizing: "border-box",
+        height: "100%",
+        margin: 0,
+        overscrollBehavior: "contain"
+      },
+      children: [
+        isOpen && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { style: {
+          width: isMobile ? "100vw" : "410px",
+          minWidth: isMobile ? "100vw" : "410px",
+          flexShrink: 0,
+          // Account for FAB (60px) + padding (20px) + gap (20px) = 100px
+          // height: isMobile ? '100vh' : `${Math.max(200, hostHeight - 200)}px`,
+          // Update the height of the widget container
+          maxHeight: isMobile ? "100vh" : `${Math.max(100, hostHeight - 100)}px`,
+          height: "100%",
+          marginBottom: isMobile ? "0" : "20px",
+          backgroundColor: resolved.accent,
+          borderRadius: isMobile ? "0" : "16px",
+          boxShadow: isMobile ? "none" : "0 20px 40px -10px rgba(0, 0, 0, 0.15), 0 0 1px rgba(0,0,0,0.1)",
+          display: "flex",
+          flexDirection: "column",
+          overflow: "hidden",
+          zIndex: 9998
+        }, children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(
+          "div",
+          {
+            className: "fruga-scrollbar",
+            style: {
+              flex: 1,
+              minHeight: 0,
+              backgroundColor: resolved.isLight ? "#f9f9f9" : "#111",
+              display: "flex",
+              flexDirection: "column",
+              boxShadow: isMobile ? "none" : "0 20px 40px -10px rgba(0, 0, 0, 0.15), 0 0 1px rgba(0,0,0,0.1)"
+            },
+            children
+          }
+        ) }),
+        /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(
+          "button",
+          {
+            ref: buttonRef,
+            onClick: toggle,
+            style: {
+              backgroundColor: resolved.accent,
+              color: resolved.accentText,
+              border: "none",
+              cursor: "pointer",
+              boxShadow: "0 12px 30px -5px rgba(0, 0, 0, 0.1), 0 0 1px rgba(0,0,0, 0.1)",
+              display: isOpen ? "none" : "flex",
+              alignItems: "center",
+              justifyContent: "center",
+              zIndex: 9999,
+              flexShrink: 0,
+              borderRadius: "20px",
+              padding: "10px 16px",
+              transition: "transform 0.3s ease-in-out"
+            },
+            className: "flex h-15 items-center gap-2 rounded-xl px-4 active:scale-[0.99]",
+            "aria-label": isOpen ? "Close widget" : "Open widget",
+            children: [
+              theme.launcherLabel && !isOpen ? /* @__PURE__ */ (0, import_jsx_runtime3.jsxs)(import_jsx_runtime3.Fragment, { children: [
+                theme.launcherLabel !== "none" && /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className: "text-sm font-semibold", children: theme.launcherLabel }),
+                /* @__PURE__ */ (0, import_jsx_runtime3.jsx)("div", { className: "flex h-6 w-5 shrink-0 items-center justify-center", children: /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(LauncherIcon, { theme: resolved }) })
+              ] }) : null,
+              isOpen ? /* @__PURE__ */ (0, import_jsx_runtime3.jsx)(import_lucide_react2.X, {}) : null
+            ]
+          }
+        )
+      ]
+    }
+  );
+};
+
+// packages/core/src/presentation/context/WidgetContext.tsx
+var import_jsx_runtime4 = require("react/jsx-runtime");
+var WidgetProvider = ({ children }) => {
+  return /* @__PURE__ */ (0, import_jsx_runtime4.jsx)(import_jsx_runtime4.Fragment, { children });
+};
+var useWidget = () => {
+  const { isOpen, toggle, setOpen } = useWidgetStore();
+  return { isOpen, toggle, setOpen };
+};
+
+// packages/core/src/presentation/hooks/useDebounce.ts
+var import_react4 = require("react");
+var useDebounce = (value, delay) => {
+  const [debouncedValue, setDebouncedValue] = (0, import_react4.useState)(value);
+  (0, import_react4.useEffect)(() => {
+    const handleTimeout = setTimeout(() => {
+      setDebouncedValue(value);
+    }, delay);
+    return () => {
+      clearTimeout(handleTimeout);
+    };
+  }, [value, delay]);
+  return debouncedValue;
+};
+
+// packages/core/src/infrastructure/storage/StorageService.ts
+var STORAGE_KEYS = {
+  BOOTSTRAP_DATA: "fruga_bootstrap",
+  BOOTSTRAP_CONFIG: "fruga_active_config"
+};
+var StorageService = class {
+  static set(key, value) {
+    if (typeof window === "undefined") return;
+    try {
+      window.localStorage.setItem(key, JSON.stringify(value));
+    } catch (error) {
+      console.warn(`[FrugaStorage] Failed to save key "${key}":`, error);
+    }
+  }
+  static get(key) {
+    if (typeof window === "undefined") return null;
+    try {
+      const item = window.localStorage.getItem(key);
+      return item ? JSON.parse(item) : null;
+    } catch (error) {
+      console.warn(`[FrugaStorage] Failed to load key "${key}":`, error);
+      return null;
+    }
+  }
+  static remove(key) {
+    if (typeof window === "undefined") return;
+    window.localStorage.removeItem(key);
+  }
+  static clear() {
+    if (typeof window === "undefined") return;
+    window.localStorage.clear();
+  }
+};
+
+// packages/core/src/infrastructure/config.ts
+var DEFAULT_API_URL = typeof process !== "undefined" && process.env.VITE_FRUGA_API_URL || "https://api-dev.fruga.co.uk";
+var getBaseUrl = (override) => {
+  if (override) return override;
+  return DEFAULT_API_URL;
+};
+
+// packages/core/src/infrastructure/helpers/date.ts
+var formatDate = (dateStr) => {
+  if (!dateStr) return "";
+  try {
+    const normalized = dateStr.includes("/") && !dateStr.includes("-") ? dateStr.split(" ")[0].split("/").reverse().join("-") : dateStr;
+    const date = new Date(normalized);
+    if (isNaN(date.getTime())) return dateStr;
+    const day = date.getDate().toString().padStart(2, "0");
+    const month = (date.getMonth() + 1).toString().padStart(2, "0");
+    const year = date.getFullYear();
+    return `${day}-${month}-${year}`;
+  } catch (e) {
+    return dateStr;
+  }
+};
+var normalizeDate = (dateStr) => {
+  try {
+    const normalized = dateStr.includes("/") && !dateStr.includes("-") ? dateStr.split(" ")[0].split("/").reverse().join("-") : dateStr;
+    const date = new Date(normalized);
+    return isNaN(date.getTime()) ? null : date;
+  } catch {
+    return null;
+  }
+};
+var isWithinDays = (dateStr, daysLimit = 30) => {
+  if (!dateStr) return false;
+  const date = normalizeDate(dateStr);
+  if (!date) return false;
+  const now = /* @__PURE__ */ new Date();
+  const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+  const targetDate = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+  const diffTime = targetDate.getTime() - today.getTime();
+  const diffDays = Math.ceil(diffTime / (1e3 * 60 * 60 * 24));
+  return diffDays >= 0 && diffDays <= daysLimit;
+};
+var getDaysRemaining = (dateStr) => {
+  if (!dateStr) return null;
+  const date = normalizeDate(dateStr);
+  if (!date) return null;
+  const now = /* @__PURE__ */ new Date();
+  const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
+  const targetDate = new Date(date.getFullYear(), date.getMonth(), date.getDate());
+  const diffTime = targetDate.getTime() - today.getTime();
+  const diffDays = Math.ceil(diffTime / (1e3 * 60 * 60 * 24));
+  return diffDays >= 0 ? diffDays : 0;
+};
+
+// packages/core/src/infrastructure/helpers/string.ts
+var truncateText = (str, maxLength = 40) => {
+  if (!str) return "";
+  if (str.length <= maxLength) return str;
+  return str.slice(0, maxLength) + "...";
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_API_URL,
+  DEFAULT_THEME,
+  DefaultTheme,
+  HttpActivityService,
+  HttpOffersService,
+  HttpPayoutService,
+  HttpWalletService,
+  STORAGE_KEYS,
+  StorageService,
+  WidgetButton,
+  WidgetContainer,
+  WidgetHeader,
+  WidgetProvider,
+  formatDate,
+  getBaseUrl,
+  getDaysRemaining,
+  getResolvedTheme,
+  isWithinDays,
+  truncateText,
+  useDebounce,
+  useWidget,
+  useWidgetStore
+});
+//# sourceMappingURL=index.js.map