@burdenoff/fe-libs 2026.510.126

package/dist/shared/hooks/useLocalStorage.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Synchronizes state with localStorage, providing persistent storage across sessions.
+ * Automatically serializes/deserializes JSON values.
+ *
+ * @template T - The type of the stored value
+ * @param key - The localStorage key
+ * @param initialValue - The initial value if no stored value exists
+ * @returns A tuple containing [storedValue, setValue, removeValue]
+ *
+ * @example
+ * ```tsx
+ * function ThemeSelector() {
+ *   const [theme, setTheme, resetTheme] = useLocalStorage('theme', 'light');
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={() => setTheme('dark')}>Dark</button>
+ *       <button onClick={() => setTheme('light')}>Light</button>
+ *       <button onClick={resetTheme}>Reset</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * function UserPreferences() {
+ *   const [prefs, setPrefs] = useLocalStorage('preferences', {
+ *     notifications: true,
+ *     autoSave: false
+ *   });
+ *
+ *   // Update with function
+ *   const toggleNotifications = () => {
+ *     setPrefs(prev => ({ ...prev, notifications: !prev.notifications }));
+ *   };
+ * }
+ * ```
+ */
+export declare function useLocalStorage<T>(key: string, initialValue: T): [T, (value: T | ((prev: T) => T)) => void, () => void];
+//# sourceMappingURL=useLocalStorage.d.ts.map

package/dist/shared/hooks/useLocalStorage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLocalStorage.d.ts","sourceRoot":"","sources":["../../../src/shared/hooks/useLocalStorage.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,eAAe,CAAC,CAAC,EAC/B,GAAG,EAAE,MAAM,EACX,YAAY,EAAE,CAAC,GACd,CAAC,CAAC,EAAE,CAAC,KAAK,EAAE,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,KAAK,IAAI,EAAE,MAAM,IAAI,CAAC,CA2DxD"}

package/dist/shared/hooks/useLocalStorage.js

@@ -0,0 +1,33 @@
+import { useCallback as e, useState as t } from "react";
+//#region src/shared/hooks/useLocalStorage.ts
+function n(n, r) {
+	let [i, a] = t(() => {
+		if (typeof window > "u") return r;
+		try {
+			let e = window.localStorage.getItem(n);
+			return e ? JSON.parse(e) : r;
+		} catch (e) {
+			return console.error(`Error reading localStorage key "${n}":`, e), r;
+		}
+	});
+	return [
+		i,
+		e((e) => {
+			try {
+				let t = e instanceof Function ? e(i) : e;
+				a(t), typeof window < "u" && window.localStorage.setItem(n, JSON.stringify(t));
+			} catch (e) {
+				console.error(`Error setting localStorage key "${n}":`, e);
+			}
+		}, [n, i]),
+		e(() => {
+			try {
+				typeof window < "u" && window.localStorage.removeItem(n), a(r);
+			} catch (e) {
+				console.error(`Error removing localStorage key "${n}":`, e);
+			}
+		}, [n, r])
+	];
+}
+//#endregion
+export { n as useLocalStorage };

package/dist/shared/hooks/useMediaQuery.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Evaluates a CSS media query and returns whether it matches.
+ * Automatically updates when the match status changes.
+ *
+ * @param query - The media query string to evaluate
+ * @returns Whether the media query currently matches
+ *
+ * @example
+ * ```tsx
+ * function ResponsiveComponent() {
+ *   const isMobile = useMediaQuery('(max-width: 768px)');
+ *   const prefersDark = useMediaQuery('(prefers-color-scheme: dark)');
+ *   const isLandscape = useMediaQuery('(orientation: landscape)');
+ *   const prefersReducedMotion = useMediaQuery('(prefers-reduced-motion: reduce)');
+ *
+ *   return (
+ *     <div>
+ *       {isMobile ? <MobileView /> : <DesktopView />}
+ *       {prefersDark && <DarkModeStyles />}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * function PrintableDocument() {
+ *   const isPrinting = useMediaQuery('print');
+ *
+ *   return isPrinting ? <PrintLayout /> : <ScreenLayout />;
+ * }
+ * ```
+ */
+export declare function useMediaQuery(query: string): boolean;
+//# sourceMappingURL=useMediaQuery.d.ts.map

package/dist/shared/hooks/useMediaQuery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useMediaQuery.d.ts","sourceRoot":"","sources":["../../../src/shared/hooks/useMediaQuery.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,OAAO,CAsCpD"}

package/dist/shared/hooks/useMediaQuery.js

@@ -0,0 +1,14 @@
+import { useEffect as e, useState as t } from "react";
+//#region src/shared/hooks/useMediaQuery.ts
+function n(n) {
+	let [r, i] = t(() => typeof window > "u" ? !1 : window.matchMedia(n).matches);
+	return e(() => {
+		if (typeof window > "u") return;
+		let e = window.matchMedia(n), t = (e) => {
+			i(e.matches);
+		};
+		return t(e), e.addEventListener ? (e.addEventListener("change", t), () => e.removeEventListener("change", t)) : (e.addListener(t), () => e.removeListener(t));
+	}, [n]), r;
+}
+//#endregion
+export { n as useMediaQuery };

package/dist/shared/hooks/useOnClickOutside.d.ts

@@ -0,0 +1,76 @@
+import { RefObject } from 'react';
+/**
+ * Detects clicks outside of a specified element and triggers a callback.
+ * Useful for closing dropdowns, modals, and popovers when clicking outside.
+ *
+ * @template T - The HTML element type (extends HTMLElement)
+ * @param callback - Function to call when a click outside is detected
+ * @returns A ref to attach to the element
+ *
+ * @example
+ * ```tsx
+ * function Dropdown() {
+ *   const [isOpen, setIsOpen] = useState(false);
+ *   const dropdownRef = useOnClickOutside<HTMLDivElement>(() => setIsOpen(false));
+ *
+ *   return (
+ *     <div ref={dropdownRef}>
+ *       <button onClick={() => setIsOpen(!isOpen)}>Toggle</button>
+ *       {isOpen && (
+ *         <div className="dropdown-menu">
+ *           <p>Dropdown content</p>
+ *         </div>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * function Modal({ onClose }: { onClose: () => void }) {
+ *   const modalRef = useOnClickOutside<HTMLDivElement>(onClose);
+ *
+ *   return (
+ *     <div className="modal-overlay">
+ *       <div ref={modalRef} className="modal-content">
+ *         <h2>Modal Title</h2>
+ *         <p>Modal content</p>
+ *       </div>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useOnClickOutside<T extends HTMLElement = HTMLElement>(callback: (event: MouseEvent | TouchEvent) => void): RefObject<T | null>;
+/**
+ * Alternative version that accepts an existing ref instead of creating one.
+ * Useful when you need to attach the ref to multiple elements or use it elsewhere.
+ *
+ * @template T - The HTML element type (extends HTMLElement)
+ * @param ref - The ref object to monitor
+ * @param callback - Function to call when a click outside is detected
+ *
+ * @example
+ * ```tsx
+ * function Popover() {
+ *   const [isOpen, setIsOpen] = useState(false);
+ *   const popoverRef = useRef<HTMLDivElement>(null);
+ *
+ *   useOnClickOutsideWithRef(popoverRef, () => setIsOpen(false));
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={() => setIsOpen(true)}>Open</button>
+ *       {isOpen && (
+ *         <div ref={popoverRef} className="popover">
+ *           Content
+ *         </div>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useOnClickOutsideWithRef<T extends HTMLElement = HTMLElement>(ref: RefObject<T>, callback: (event: MouseEvent | TouchEvent) => void): void;
+//# sourceMappingURL=useOnClickOutside.d.ts.map

package/dist/shared/hooks/useOnClickOutside.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useOnClickOutside.d.ts","sourceRoot":"","sources":["../../../src/shared/hooks/useOnClickOutside.ts"],"names":[],"mappings":"AAAA,OAAO,EAAqB,KAAK,SAAS,EAAE,MAAM,OAAO,CAAC;AAE1D;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0CG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,EACnE,QAAQ,EAAE,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,KAAK,IAAI,GACjD,SAAS,CAAC,CAAC,GAAG,IAAI,CAAC,CAuBrB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,SAAS,WAAW,GAAG,WAAW,EAC1E,GAAG,EAAE,SAAS,CAAC,CAAC,CAAC,EACjB,QAAQ,EAAE,CAAC,KAAK,EAAE,UAAU,GAAG,UAAU,KAAK,IAAI,GACjD,IAAI,CAgBN"}

package/dist/shared/hooks/useOnClickOutside.js

@@ -0,0 +1,25 @@
+import { useEffect as e, useRef as t } from "react";
+//#region src/shared/hooks/useOnClickOutside.ts
+function n(n) {
+	let r = t(null);
+	return e(() => {
+		let e = (e) => {
+			r.current && !r.current.contains(e.target) && n(e);
+		};
+		return document.addEventListener("mousedown", e), document.addEventListener("touchstart", e), () => {
+			document.removeEventListener("mousedown", e), document.removeEventListener("touchstart", e);
+		};
+	}, [n]), r;
+}
+function r(t, n) {
+	e(() => {
+		let e = (e) => {
+			t.current && !t.current.contains(e.target) && n(e);
+		};
+		return document.addEventListener("mousedown", e), document.addEventListener("touchstart", e), () => {
+			document.removeEventListener("mousedown", e), document.removeEventListener("touchstart", e);
+		};
+	}, [t, n]);
+}
+//#endregion
+export { n as useOnClickOutside, r as useOnClickOutsideWithRef };

package/dist/shared/hooks/usePWA.d.ts

@@ -0,0 +1,57 @@
+interface PWAState {
+    /** Whether the app can be installed */
+    canInstall: boolean;
+    /** Whether the app is already installed */
+    isInstalled: boolean;
+    /** Whether the app is running in standalone mode (installed PWA) */
+    isStandalone: boolean;
+    /** Whether the service worker is registered */
+    isServiceWorkerReady: boolean;
+    /** Whether there's a new version available */
+    hasUpdate: boolean;
+}
+interface UsePWAReturn extends PWAState {
+    /** Trigger the install prompt */
+    install: () => Promise<boolean>;
+    /** Update the service worker */
+    update: () => void;
+    /** Dismiss the install prompt */
+    dismissInstall: () => void;
+}
+interface UsePWAOptions {
+    /**
+     * Auto-activate a waiting service worker and reload the page so users
+     * always run the latest deployed code. Defaults to true.
+     */
+    autoUpdate?: boolean;
+    /**
+     * How often (ms) to poll the SW registration for an updated worker.
+     * Defaults to 60_000 (1 minute). Set to 0 to disable polling.
+     */
+    updateCheckIntervalMs?: number;
+}
+/**
+ * usePWA Hook
+ *
+ * Manages PWA installation state and service worker updates.
+ *
+ * @example
+ * ```tsx
+ * function InstallBanner() {
+ *   const { canInstall, isInstalled, install, dismissInstall } = usePWA();
+ *
+ *   if (!canInstall || isInstalled) return null;
+ *
+ *   return (
+ *     <div className="install-banner">
+ *       <p>Install for a better experience!</p>
+ *       <button onClick={install}>Install</button>
+ *       <button onClick={dismissInstall}>Not now</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function usePWA(options?: UsePWAOptions): UsePWAReturn;
+export {};
+//# sourceMappingURL=usePWA.d.ts.map

package/dist/shared/hooks/usePWA.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePWA.d.ts","sourceRoot":"","sources":["../../../src/shared/hooks/usePWA.ts"],"names":[],"mappings":"AAWA,UAAU,QAAQ;IAChB,uCAAuC;IACvC,UAAU,EAAE,OAAO,CAAC;IACpB,2CAA2C;IAC3C,WAAW,EAAE,OAAO,CAAC;IACrB,oEAAoE;IACpE,YAAY,EAAE,OAAO,CAAC;IACtB,+CAA+C;IAC/C,oBAAoB,EAAE,OAAO,CAAC;IAC9B,8CAA8C;IAC9C,SAAS,EAAE,OAAO,CAAC;CACpB;AAED,UAAU,YAAa,SAAQ,QAAQ;IACrC,iCAAiC;IACjC,OAAO,EAAE,MAAM,OAAO,CAAC,OAAO,CAAC,CAAC;IAChC,gCAAgC;IAChC,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,iCAAiC;IACjC,cAAc,EAAE,MAAM,IAAI,CAAC;CAC5B;AAED,UAAU,aAAa;IACrB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB;;;OAGG;IACH,qBAAqB,CAAC,EAAE,MAAM,CAAC;CAChC;AAED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,MAAM,CAAC,OAAO,GAAE,aAAkB,GAAG,YAAY,CA2LhE"}

package/dist/shared/hooks/usePWA.js

@@ -0,0 +1,68 @@
+import { useCallback as e, useEffect as t, useState as n } from "react";
+//#region src/shared/hooks/usePWA.ts
+function r(r = {}) {
+	let { autoUpdate: i = !0, updateCheckIntervalMs: a = 6e4 } = r, [o, s] = n(null), [c, l] = n(!1), [u, d] = n(!1), [f, p] = n(!1), [m, h] = n(!1), [g, _] = n(!1), [v, y] = n(null);
+	return t(() => {
+		let e = setTimeout(() => {
+			let e = window.matchMedia("(display-mode: standalone)").matches || window.navigator.standalone === !0;
+			p(e), d(e);
+		}, 0);
+		return () => clearTimeout(e);
+	}, []), t(() => {
+		if (!("serviceWorker" in navigator)) return;
+		let e = !1, t, n, r = !1, o = () => {
+			navigator.serviceWorker.addEventListener("controllerchange", () => {
+				r || (r = !0, window.location.reload());
+			});
+		};
+		return navigator.serviceWorker.register("/sw.js").then((r) => {
+			e || (y(r), h(!0), i && r.waiting && navigator.serviceWorker.controller && (o(), r.waiting.postMessage("skipWaiting")), r.addEventListener("updatefound", () => {
+				let e = r.installing;
+				e && e.addEventListener("statechange", () => {
+					e.state === "installed" && navigator.serviceWorker.controller && (_(!0), i && (o(), e.postMessage("skipWaiting")));
+				});
+			}), a > 0 && (t = setInterval(() => {
+				r.update().catch(() => void 0);
+			}, a)), n = () => {
+				document.visibilityState === "visible" && r.update().catch(() => void 0);
+			}, document.addEventListener("visibilitychange", n));
+		}).catch((e) => {
+			console.error("[PWA] Service worker registration failed:", e);
+		}), () => {
+			e = !0, t && clearInterval(t), n && document.removeEventListener("visibilitychange", n);
+		};
+	}, [i, a]), t(() => {
+		let e = (e) => {
+			e.preventDefault(), s(e), l(!0);
+		}, t = () => {
+			d(!0), l(!1), s(null);
+		};
+		return window.addEventListener("beforeinstallprompt", e), window.addEventListener("appinstalled", t), () => {
+			window.removeEventListener("beforeinstallprompt", e), window.removeEventListener("appinstalled", t);
+		};
+	}, []), {
+		canInstall: c,
+		isInstalled: u,
+		isStandalone: f,
+		isServiceWorkerReady: m,
+		hasUpdate: g,
+		install: e(async () => {
+			if (!o) return !1;
+			try {
+				await o.prompt();
+				let { outcome: e } = await o.userChoice;
+				return e === "accepted" && (d(!0), l(!1)), s(null), e === "accepted";
+			} catch (e) {
+				return console.error("[PWA] Install failed:", e), !1;
+			}
+		}, [o]),
+		update: e(() => {
+			v?.waiting && (v.waiting.postMessage("skipWaiting"), window.location.reload());
+		}, [v]),
+		dismissInstall: e(() => {
+			l(!1), localStorage.setItem("pwa-install-dismissed", Date.now().toString());
+		}, [])
+	};
+}
+//#endregion
+export { r as usePWA };

package/dist/shared/hooks/usePrevious.d.ts

@@ -0,0 +1,157 @@
+/**
+ * Tracks the previous value of a state or prop.
+ * Returns undefined on the first render, then returns the previous value on subsequent renders.
+ *
+ * @template T - The type of the value being tracked
+ * @param value - The current value to track
+ * @returns The previous value, or undefined on first render
+ *
+ * @example
+ * ```tsx
+ * function Counter() {
+ *   const [count, setCount] = useState(0);
+ *   const prevCount = usePrevious(count);
+ *
+ *   return (
+ *     <div>
+ *       <p>Current count: {count}</p>
+ *       <p>Previous count: {prevCount ?? 'N/A'}</p>
+ *       <button onClick={() => setCount(count + 1)}>Increment</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * function SearchResults({ query }: { query: string }) {
+ *   const prevQuery = usePrevious(query);
+ *   const [results, setResults] = useState([]);
+ *
+ *   useEffect(() => {
+ *     if (query !== prevQuery) {
+ *       console.log(`Query changed from "${prevQuery}" to "${query}"`);
+ *       fetchResults(query).then(setResults);
+ *     }
+ *   }, [query, prevQuery]);
+ *
+ *   return <ResultsList results={results} />;
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * function Animation({ isVisible }: { isVisible: boolean }) {
+ *   const wasVisible = usePrevious(isVisible);
+ *
+ *   const animationClass = useMemo(() => {
+ *     if (isVisible && !wasVisible) return 'fade-in';
+ *     if (!isVisible && wasVisible) return 'fade-out';
+ *     return '';
+ *   }, [isVisible, wasVisible]);
+ *
+ *   return <div className={animationClass}>Content</div>;
+ * }
+ * ```
+ */
+export declare function usePrevious<T>(value: T): T | undefined;
+/**
+ * Tracks the previous value with a custom comparison function.
+ * Only updates the previous value when the comparison function returns false.
+ *
+ * @template T - The type of the value being tracked
+ * @param value - The current value to track
+ * @param compare - Function that returns true if values should be considered equal
+ * @returns The previous distinct value
+ *
+ * @example
+ * ```tsx
+ * function UserProfile({ user }: { user: User }) {
+ *   // Only update previous user when the ID changes
+ *   const prevUser = usePreviousDistinct(
+ *     user,
+ *     (prev, next) => prev?.id === next?.id
+ *   );
+ *
+ *   useEffect(() => {
+ *     if (prevUser && prevUser.id !== user.id) {
+ *       console.log(`User changed from ${prevUser.name} to ${user.name}`);
+ *     }
+ *   }, [user, prevUser]);
+ *
+ *   return <div>{user.name}</div>;
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * function ArrayComponent({ items }: { items: string[] }) {
+ *   // Only track when array length changes
+ *   const prevItems = usePreviousDistinct(
+ *     items,
+ *     (prev, next) => prev?.length === next?.length
+ *   );
+ *
+ *   if (prevItems && prevItems.length !== items.length) {
+ *     console.log(`Array length changed from ${prevItems.length} to ${items.length}`);
+ *   }
+ *
+ *   return <ul>{items.map(item => <li key={item}>{item}</li>)}</ul>;
+ * }
+ * ```
+ */
+export declare function usePreviousDistinct<T>(value: T, compare: (prev: T | undefined, next: T) => boolean): T | undefined;
+/**
+ * Tracks multiple previous values in a history array.
+ * Useful for implementing undo/redo or tracking value changes over time.
+ *
+ * @template T - The type of the value being tracked
+ * @param value - The current value to track
+ * @param maxHistory - Maximum number of previous values to keep (default: 10)
+ * @returns Array of previous values, most recent first
+ *
+ * @example
+ * ```tsx
+ * function DrawingCanvas() {
+ *   const [drawing, setDrawing] = useState<Point[]>([]);
+ *   const history = usePreviousHistory(drawing, 20);
+ *
+ *   const undo = () => {
+ *     if (history.length > 0) {
+ *       setDrawing(history[0]);
+ *     }
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <Canvas points={drawing} />
+ *       <button onClick={undo} disabled={history.length === 0}>
+ *         Undo ({history.length})
+ *       </button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * function TextEditor() {
+ *   const [text, setText] = useState('');
+ *   const history = usePreviousHistory(text, 50);
+ *
+ *   const showHistory = () => {
+ *     console.log('Recent changes:', history);
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <textarea value={text} onChange={(e) => setText(e.target.value)} />
+ *       <button onClick={showHistory}>Show History</button>
+ *       <p>History size: {history.length}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function usePreviousHistory<T>(value: T, maxHistory?: number): T[];
+//# sourceMappingURL=usePrevious.d.ts.map

package/dist/shared/hooks/usePrevious.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"usePrevious.d.ts","sourceRoot":"","sources":["../../../src/shared/hooks/usePrevious.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuDG;AACH,wBAAgB,WAAW,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS,CAWtD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,mBAAmB,CAAC,CAAC,EACnC,KAAK,EAAE,CAAC,EACR,OAAO,EAAE,CAAC,IAAI,EAAE,CAAC,GAAG,SAAS,EAAE,IAAI,EAAE,CAAC,KAAK,OAAO,GACjD,CAAC,GAAG,SAAS,CAWf;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,UAAU,GAAE,MAAW,GAAG,CAAC,EAAE,CAU5E"}

package/dist/shared/hooks/usePrevious.js

@@ -0,0 +1,22 @@
+import { useEffect as e, useRef as t } from "react";
+//#region src/shared/hooks/usePrevious.ts
+function n(n) {
+	let r = t(void 0);
+	return e(() => {
+		r.current = n;
+	}, [n]), r.current;
+}
+function r(n, r) {
+	let i = t(void 0);
+	return e(() => {
+		r(i.current, n) || (i.current = n);
+	}, [n, r]), i.current;
+}
+function i(n, r = 10) {
+	let i = t([]);
+	return e(() => {
+		i.current = [n, ...i.current].slice(0, r);
+	}, [n, r]), i.current.slice(1);
+}
+//#endregion
+export { n as usePrevious, r as usePreviousDistinct, i as usePreviousHistory };

package/dist/shared/hooks/useQuotaErrorToast.d.ts

@@ -0,0 +1,50 @@
+import { QuotaExhaustedExtensions } from '../utils/quotaErrors';
+/**
+ * Global error event the host shell can dispatch when any GraphQL response
+ * carries a QUOTA_EXHAUSTED error. The hook listens for it and surfaces a
+ * toast through the shell's GlobalUiProvider — this avoids every MFE having
+ * to wire its own error link/handler for a global concern.
+ */
+export declare const QUOTA_EXHAUSTED_EVENT = "burdenoff:quota-exhausted";
+export interface QuotaExhaustedEventDetail {
+    /** The raw error object surfaced by Apollo (or any GraphQL client). */
+    error?: unknown;
+    /** Pre-extracted extensions, if the dispatcher already parsed the error. */
+    extensions?: QuotaExhaustedExtensions;
+}
+export interface UseQuotaErrorToastOptions {
+    /** Toast cooldown in ms — suppresses duplicate toasts inside this window. */
+    cooldownMs?: number;
+    /** Override the default toast message builder. */
+    buildMessage?: (ext: QuotaExhaustedExtensions | null) => string;
+}
+/**
+ * `useQuotaErrorToast` — install a global listener that surfaces a toast
+ * whenever a `QUOTA_EXHAUSTED` GraphQL error is observed anywhere in the app.
+ *
+ * Mount once per shell (e.g. inside the AppShellProvider). Returns a manual
+ * `report(error)` callback that MFEs can call directly when their mutation
+ * fails so the toast shows immediately without waiting for the global event.
+ *
+ * @example
+ * ```tsx
+ * function AppShell() {
+ *   useQuotaErrorToast();
+ *   return <Routes>{/* ... *\/}</Routes>;
+ * }
+ *
+ * // From a mutation handler
+ * const { report } = useQuotaErrorToast();
+ * try { await mutate(); } catch (e) { if (!report(e)) throw e; }
+ * ```
+ */
+export declare function useQuotaErrorToast(options?: UseQuotaErrorToastOptions): {
+    report: (err: unknown) => boolean;
+};
+/**
+ * Dispatch the global `QUOTA_EXHAUSTED` event. Call from an Apollo error link
+ * (or any GraphQL client error handler) so a host shell that mounts
+ * `useQuotaErrorToast` will surface a toast.
+ */
+export declare function dispatchQuotaExhausted(detail: QuotaExhaustedEventDetail): void;
+//# sourceMappingURL=useQuotaErrorToast.d.ts.map

package/dist/shared/hooks/useQuotaErrorToast.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useQuotaErrorToast.d.ts","sourceRoot":"","sources":["../../../src/shared/hooks/useQuotaErrorToast.ts"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,wBAAwB,EAC9B,MAAM,sBAAsB,CAAC;AAE9B;;;;;GAKG;AACH,eAAO,MAAM,qBAAqB,8BAA8B,CAAC;AAEjE,MAAM,WAAW,yBAAyB;IACxC,uEAAuE;IACvE,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,4EAA4E;IAC5E,UAAU,CAAC,EAAE,wBAAwB,CAAC;CACvC;AAED,MAAM,WAAW,yBAAyB;IACxC,6EAA6E;IAC7E,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,kDAAkD;IAClD,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,wBAAwB,GAAG,IAAI,KAAK,MAAM,CAAC;CACjE;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,GAAE,yBAA8B,GAAG;IAC3E,MAAM,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,OAAO,CAAC;CACnC,CAwCA;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,yBAAyB,GAChC,IAAI,CAON"}

package/dist/shared/hooks/useQuotaErrorToast.js

@@ -0,0 +1,32 @@
+import { buildQuotaExhaustedMessage as e, extractQuotaExhaustedExtensions as t } from "../utils/quotaErrors.js";
+import { useGlobalUi as n } from "../providers/shell/GlobalUiProvider.js";
+import { useCallback as r, useEffect as i, useRef as a } from "react";
+//#region src/shared/hooks/useQuotaErrorToast.ts
+var o = "burdenoff:quota-exhausted";
+function s(s = {}) {
+	let { cooldownMs: c = 4e3, buildMessage: l = e } = s, { showToast: u } = n(), d = a(0), f = r((e) => {
+		let t = Date.now();
+		t - d.current < c || (d.current = t, u(l(e), "warning", 6e3));
+	}, [
+		l,
+		c,
+		u
+	]), p = r((e) => {
+		let n = t(e);
+		return n ? (f(n), !0) : !1;
+	}, [f]);
+	return i(() => {
+		let e = (e) => {
+			let n = e.detail;
+			f(n?.extensions ?? t(n?.error));
+		};
+		return window.addEventListener(o, e), () => {
+			window.removeEventListener(o, e);
+		};
+	}, [f]), { report: p };
+}
+function c(e) {
+	typeof window > "u" || window.dispatchEvent(new CustomEvent(o, { detail: e }));
+}
+//#endregion
+export { o as QUOTA_EXHAUSTED_EVENT, c as dispatchQuotaExhausted, s as useQuotaErrorToast };

package/dist/shared/hooks/useReferralAttribution.d.ts

@@ -0,0 +1,2 @@
+export declare function useReferralAttribution(): void;
+//# sourceMappingURL=useReferralAttribution.d.ts.map

package/dist/shared/hooks/useReferralAttribution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useReferralAttribution.d.ts","sourceRoot":"","sources":["../../../src/shared/hooks/useReferralAttribution.ts"],"names":[],"mappings":"AAkDA,wBAAgB,sBAAsB,IAAI,IAAI,CAsJ7C"}