@burdenoff/fe-libs 2026.510.126

package/dist/shared/hooks/useReferralAttribution.js

@@ -0,0 +1,113 @@
+import { graphqlFetch as e } from "../graphql/fetch.js";
+import { useAuth as t } from "../providers/shell/AuthProvider.js";
+import { useActiveContext as n } from "../providers/shell/ActiveContextProvider.js";
+import { useAppShell as r } from "../providers/shell/AppShellContext.js";
+import { useEffect as i, useMemo as a, useRef as o } from "react";
+import { useLocation as s } from "react-router-dom";
+//#region src/shared/hooks/useReferralAttribution.ts
+var c = "boff-referral-attribution", l = [
+	"ref",
+	"refCode",
+	"affiliate",
+	"affiliateCode"
+];
+function u() {
+	if (typeof window > "u") return null;
+	try {
+		let e = window.localStorage.getItem(c);
+		return e ? JSON.parse(e) : null;
+	} catch {
+		return null;
+	}
+}
+function d(e) {
+	if (!(typeof window > "u")) {
+		if (!e) {
+			window.localStorage.removeItem(c);
+			return;
+		}
+		window.localStorage.setItem(c, JSON.stringify(e));
+	}
+}
+function f(e) {
+	let t = new URLSearchParams(e);
+	for (let e of l) {
+		let n = t.get(e)?.trim();
+		if (n) return n.toUpperCase();
+	}
+	return null;
+}
+function p() {
+	let c = s(), { productSlug: l } = r(), { user: p, tokens: m } = t(), { organizationId: h } = n(), g = o(null), _ = o(null), v = a(() => f(c.search) ?? u()?.code ?? null, [c.search]);
+	i(() => {
+		if (!v || c.pathname.startsWith("/auth/")) return;
+		let t = `${c.pathname}${c.search}${c.hash}`, n = u(), r = n?.code === v ? n : {
+			code: v,
+			anonymousId: crypto.randomUUID(),
+			sessionId: crypto.randomUUID()
+		}, i = `${r.code}:${r.sessionId}:${t}`;
+		g.current !== i && (g.current = i, d(r), e({
+			gateway: "global",
+			baseUrl: void 0,
+			authToken: m?.accessToken,
+			organizationId: h ?? void 0,
+			query: "mutation TrackAffiliateTouchpoint($input: TrackAffiliateTouchpointInput!) {\n        trackAffiliateTouchpoint(input: $input) {\n          accepted\n          journey { id anonymousId sessionId }\n          code { id code }\n        }\n      }",
+			variables: { input: {
+				code: r.code,
+				anonymousId: r.anonymousId,
+				sessionId: r.sessionId,
+				productSlug: l,
+				currentPath: t,
+				referrerUrl: typeof document < "u" && document.referrer || void 0,
+				touchpointKind: t.includes("/checkout") ? "CHECKOUT" : "PRODUCT_APP_ROUTE",
+				mode: "app"
+			} }
+		}).then((e) => {
+			let t = e.data?.trackAffiliateTouchpoint;
+			t?.accepted && d({
+				...r,
+				journeyId: t.journey?.id ?? r.journeyId,
+				anonymousId: t.journey?.anonymousId ?? r.anonymousId,
+				sessionId: t.journey?.sessionId ?? r.sessionId,
+				codeId: t.code?.id ?? r.codeId
+			});
+		}).catch(() => {}));
+	}, [
+		v,
+		c.hash,
+		c.pathname,
+		c.search,
+		h,
+		l,
+		m?.accessToken
+	]), i(() => {
+		if (!p?.id) return;
+		let t = u();
+		if (!t?.journeyId || t.identifiedUserId === p.id) return;
+		let n = `${t.journeyId}:${p.id}`;
+		_.current !== n && (_.current = n, e({
+			gateway: "global",
+			baseUrl: void 0,
+			authToken: m?.accessToken,
+			organizationId: h ?? void 0,
+			query: "mutation IdentifyAffiliateJourney($input: IdentifyAffiliateJourneyInput!) {\n        identifyAffiliateJourney(input: $input) { id }\n      }",
+			variables: { input: {
+				journeyId: t.journeyId,
+				anonymousId: t.anonymousId,
+				sessionId: t.sessionId,
+				identifiedUserId: p.id
+			} }
+		}).then(() => {
+			d({
+				...t,
+				identifiedUserId: p.id
+			});
+		}).catch(() => {}));
+	}, [
+		h,
+		m?.accessToken,
+		p?.id
+	]);
+}
+//#endregion
+export { p as useReferralAttribution };

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

@@ -0,0 +1,44 @@
+/**
+ * Synchronizes state with sessionStorage, providing persistent storage for the current session.
+ * Data persists only for the duration of the page session (until the tab is closed).
+ * Automatically serializes/deserializes JSON values.
+ *
+ * @template T - The type of the stored value
+ * @param key - The sessionStorage key
+ * @param initialValue - The initial value if no stored value exists
+ * @returns A tuple containing [storedValue, setValue, removeValue]
+ *
+ * @example
+ * ```tsx
+ * function WizardForm() {
+ *   const [formData, setFormData, clearFormData] = useSessionStorage('wizardForm', {
+ *     step: 1,
+ *     data: {}
+ *   });
+ *
+ *   const nextStep = () => {
+ *     setFormData(prev => ({ ...prev, step: prev.step + 1 }));
+ *   };
+ *
+ *   return (
+ *     <div>
+ *       <p>Step {formData.step}</p>
+ *       <button onClick={nextStep}>Next</button>
+ *       <button onClick={clearFormData}>Reset</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * function TemporaryFilter() {
+ *   const [filter, setFilter] = useSessionStorage('searchFilter', '');
+ *
+ *   // Filter persists across page refreshes but not after closing the tab
+ *   return <input value={filter} onChange={(e) => setFilter(e.target.value)} />;
+ * }
+ * ```
+ */
+export declare function useSessionStorage<T>(key: string, initialValue: T): [T, (value: T | ((prev: T) => T)) => void, () => void];
+//# sourceMappingURL=useSessionStorage.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useSessionStorage.d.ts","sourceRoot":"","sources":["../../../src/shared/hooks/useSessionStorage.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH,wBAAgB,iBAAiB,CAAC,CAAC,EACjC,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/useSessionStorage.js

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

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

@@ -0,0 +1,37 @@
+/**
+ * Throttles a function call, ensuring it's only called once within the specified delay period.
+ * Useful for rate-limiting event handlers like scroll, resize, or mousemove.
+ *
+ * @template T - The function type to be throttled
+ * @param callback - The function to throttle
+ * @param delay - The minimum time in milliseconds between function calls (default: 300ms)
+ * @returns A throttled version of the callback function
+ *
+ * @example
+ * ```tsx
+ * function ScrollComponent() {
+ *   const handleScroll = useThrottle(() => {
+ *     console.log('Scrolled');
+ *   }, 100);
+ *
+ *   return <div onScroll={handleScroll}>Content</div>;
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * function ResizeObserver() {
+ *   const handleResize = useThrottle((width: number, height: number) => {
+ *     console.log('Window resized:', width, height);
+ *   }, 200);
+ *
+ *   useEffect(() => {
+ *     const listener = () => handleResize(window.innerWidth, window.innerHeight);
+ *     window.addEventListener('resize', listener);
+ *     return () => window.removeEventListener('resize', listener);
+ *   }, [handleResize]);
+ * }
+ * ```
+ */
+export declare function useThrottle<TArgs extends unknown[]>(callback: (...args: TArgs) => void, delay?: number): (...args: TArgs) => void;
+//# sourceMappingURL=useThrottle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useThrottle.d.ts","sourceRoot":"","sources":["../../../src/shared/hooks/useThrottle.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH,wBAAgB,WAAW,CAAC,KAAK,SAAS,OAAO,EAAE,EACjD,QAAQ,EAAE,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,IAAI,EAClC,KAAK,GAAE,MAAY,GAClB,CAAC,GAAG,IAAI,EAAE,KAAK,KAAK,IAAI,CAe1B"}

package/dist/shared/hooks/useThrottle.js

@@ -0,0 +1,11 @@
+import { useCallback as e, useRef as t } from "react";
+//#region src/shared/hooks/useThrottle.ts
+function n(n, r = 300) {
+	let i = t(Date.now());
+	return e((...e) => {
+		let t = Date.now();
+		t - i.current >= r && (n(...e), i.current = t);
+	}, [n, r]);
+}
+//#endregion
+export { n as useThrottle };

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

@@ -0,0 +1,152 @@
+/**
+ * Manages a boolean state with convenient toggle and set functions.
+ * Simplifies the common pattern of toggling boolean values.
+ *
+ * @param initialValue - The initial boolean value (default: false)
+ * @returns A tuple containing [value, toggle, setValue]
+ *
+ * @example
+ * ```tsx
+ * function Modal() {
+ *   const [isOpen, toggle, setIsOpen] = useToggle(false);
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={toggle}>Toggle Modal</button>
+ *       <button onClick={() => setIsOpen(true)}>Open Modal</button>
+ *       <button onClick={() => setIsOpen(false)}>Close Modal</button>
+ *       {isOpen && <ModalContent onClose={() => setIsOpen(false)} />}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * function Accordion({ title, children }: AccordionProps) {
+ *   const [isExpanded, toggleExpanded] = useToggle(false);
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={toggleExpanded}>
+ *         {title} {isExpanded ? '▼' : '▶'}
+ *       </button>
+ *       {isExpanded && <div>{children}</div>}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * function PasswordInput() {
+ *   const [showPassword, toggleShowPassword, setShowPassword] = useToggle(false);
+ *   const [password, setPassword] = useState('');
+ *
+ *   return (
+ *     <div>
+ *       <input
+ *         type={showPassword ? 'text' : 'password'}
+ *         value={password}
+ *         onChange={(e) => setPassword(e.target.value)}
+ *       />
+ *       <button onClick={toggleShowPassword}>
+ *         {showPassword ? 'Hide' : 'Show'}
+ *       </button>
+ *       <button onClick={() => setShowPassword(false)}>Always Hide</button>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useToggle(initialValue?: boolean): [boolean, () => void, (value: boolean) => void];
+/**
+ * Alternative version with more descriptive return object instead of tuple.
+ * Useful when you prefer named properties over array destructuring.
+ *
+ * @param initialValue - The initial boolean value (default: false)
+ * @returns Object with value, toggle, setTrue, setFalse, and setValue functions
+ *
+ * @example
+ * ```tsx
+ * function Sidebar() {
+ *   const sidebar = useToggleObject(true);
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={sidebar.toggle}>Toggle Sidebar</button>
+ *       <button onClick={sidebar.setTrue}>Open Sidebar</button>
+ *       <button onClick={sidebar.setFalse}>Close Sidebar</button>
+ *       {sidebar.value && <SidebarContent />}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * function LoadingButton() {
+ *   const loading = useToggleObject(false);
+ *
+ *   const handleClick = async () => {
+ *     loading.setTrue();
+ *     try {
+ *       await performAction();
+ *     } finally {
+ *       loading.setFalse();
+ *     }
+ *   };
+ *
+ *   return (
+ *     <button onClick={handleClick} disabled={loading.value}>
+ *       {loading.value ? 'Loading...' : 'Click Me'}
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+export declare function useToggleObject(initialValue?: boolean): {
+    value: boolean;
+    toggle: () => void;
+    setTrue: () => void;
+    setFalse: () => void;
+    setValue: (value: boolean) => void;
+};
+/**
+ * Advanced version with conditional toggle based on a predicate function.
+ * Only toggles if the predicate returns true.
+ *
+ * @param initialValue - The initial boolean value
+ * @param predicate - Function that determines if toggle should occur
+ * @returns Tuple with [value, conditionalToggle, setValue]
+ *
+ * @example
+ * ```tsx
+ * function ConditionalFeature() {
+ *   const [hasPermission, setHasPermission] = useState(true);
+ *   const [isEnabled, toggle, setEnabled] = useConditionalToggle(
+ *     false,
+ *     () => hasPermission
+ *   );
+ *
+ *   return (
+ *     <div>
+ *       <label>
+ *         <input
+ *           type="checkbox"
+ *           checked={hasPermission}
+ *           onChange={(e) => setHasPermission(e.target.checked)}
+ *         />
+ *         Has Permission
+ *       </label>
+ *       <button onClick={toggle}>
+ *         Toggle Feature (only works with permission)
+ *       </button>
+ *       <p>Feature is {isEnabled ? 'enabled' : 'disabled'}</p>
+ *     </div>
+ *   );
+ * }
+ * ```
+ */
+export declare function useConditionalToggle(initialValue: boolean | undefined, predicate: () => boolean): [boolean, () => void, (value: boolean) => void];
+//# sourceMappingURL=useToggle.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useToggle.d.ts","sourceRoot":"","sources":["../../../src/shared/hooks/useToggle.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4DG;AACH,wBAAgB,SAAS,CACvB,YAAY,GAAE,OAAe,GAC5B,CAAC,OAAO,EAAE,MAAM,IAAI,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC,CAcjD;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH,wBAAgB,eAAe,CAAC,YAAY,GAAE,OAAe,GAAG;IAC9D,KAAK,EAAE,OAAO,CAAC;IACf,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,OAAO,EAAE,MAAM,IAAI,CAAC;IACpB,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC;CACpC,CAaA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,wBAAgB,oBAAoB,CAClC,YAAY,EAAE,OAAO,YAAQ,EAC7B,SAAS,EAAE,MAAM,OAAO,GACvB,CAAC,OAAO,EAAE,MAAM,IAAI,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,IAAI,CAAC,CAcjD"}

package/dist/shared/hooks/useToggle.js

@@ -0,0 +1,38 @@
+import { useCallback as e, useState as t } from "react";
+//#region src/shared/hooks/useToggle.ts
+function n(n = !1) {
+	let [r, i] = t(n);
+	return [
+		r,
+		e(() => {
+			i((e) => !e);
+		}, []),
+		e((e) => {
+			i(e);
+		}, [])
+	];
+}
+function r(t = !1) {
+	let [r, i, a] = n(t);
+	return {
+		value: r,
+		toggle: i,
+		setTrue: e(() => a(!0), [a]),
+		setFalse: e(() => a(!1), [a]),
+		setValue: a
+	};
+}
+function i(n = !1, r) {
+	let [i, a] = t(n);
+	return [
+		i,
+		e(() => {
+			r() && a((e) => !e);
+		}, [r]),
+		e((e) => {
+			a(e);
+		}, [])
+	];
+}
+//#endregion
+export { i as useConditionalToggle, n as useToggle, r as useToggleObject };

package/dist/shared/index.d.ts

@@ -0,0 +1,13 @@
+export * from './components';
+export * from './config';
+export * from './events';
+export * from './graphql';
+export * from './hooks';
+export * from './providers';
+export * from './tours';
+export * from './types';
+export * from './utils';
+export * from './feature-flags';
+export * from './native';
+export declare const FE_SHARED_VERSION = "1.0.0";
+//# sourceMappingURL=index.d.ts.map

package/dist/shared/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/shared/index.ts"],"names":[],"mappings":"AAQA,cAAc,cAAc,CAAC;AAC7B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,WAAW,CAAC;AAC1B,cAAc,SAAS,CAAC;AACxB,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,SAAS,CAAC;AACxB,cAAc,iBAAiB,CAAC;AAChC,cAAc,UAAU,CAAC;AAEzB,eAAO,MAAM,iBAAiB,UAAU,CAAC"}

package/dist/shared/keyboard/globalShortcuts.d.ts

@@ -0,0 +1,58 @@
+import { KeyboardShortcut } from './types';
+/**
+ * Global shortcuts configuration structure
+ */
+export interface GlobalShortcutsConfig {
+    navigation: KeyboardShortcut[];
+    ui: KeyboardShortcut[];
+}
+/**
+ * Handlers required for global shortcuts
+ */
+export interface GlobalShortcutHandlers {
+    /** Navigate to home/dashboard */
+    goHome: () => void;
+    /** Open global search */
+    openSearch: () => void;
+    /** Toggle sidebar collapse */
+    toggleSidebar: () => void;
+    /** Toggle dark/light theme */
+    toggleTheme: () => void;
+    /** Show keyboard shortcuts help */
+    showHelp: () => void;
+    /** Open settings (optional) */
+    openSettings?: () => void;
+}
+/**
+ * Create global shortcuts configuration with handlers
+ *
+ * @param handlers - Object containing action handlers
+ * @returns Array of keyboard shortcuts
+ *
+ * @example
+ * ```typescript
+ * const shortcuts = createGlobalShortcuts({
+ *   goHome: () => navigate('/'),
+ *   openSearch: () => setSearchOpen(true),
+ *   toggleSidebar: () => setSidebarCollapsed(!collapsed),
+ *   toggleTheme: () => setColorMode(mode === 'light' ? 'dark' : 'light'),
+ *   showHelp: () => setHelpOpen(true),
+ *   openSettings: () => navigate('/settings'),
+ * });
+ * ```
+ */
+export declare function createGlobalShortcuts(handlers: GlobalShortcutHandlers): KeyboardShortcut[];
+/**
+ * Get global shortcuts grouped by category
+ */
+export declare function getGlobalShortcutsByCategory(shortcuts: KeyboardShortcut[]): Record<string, KeyboardShortcut[]>;
+/**
+ * Merge global and product shortcuts
+ * Global shortcuts take precedence for duplicate IDs
+ */
+export declare function mergeShortcuts(globalShortcuts: KeyboardShortcut[], productShortcuts: KeyboardShortcut[]): KeyboardShortcut[];
+/**
+ * Default global shortcut categories in display order
+ */
+export declare const GLOBAL_SHORTCUT_CATEGORIES: readonly ["Navigation", "Search", "UI", "Help"];
+//# sourceMappingURL=globalShortcuts.d.ts.map

package/dist/shared/keyboard/globalShortcuts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"globalShortcuts.d.ts","sourceRoot":"","sources":["../../../src/shared/keyboard/globalShortcuts.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAgB,MAAM,SAAS,CAAC;AAE9D;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,UAAU,EAAE,gBAAgB,EAAE,CAAC;IAC/B,EAAE,EAAE,gBAAgB,EAAE,CAAC;CACxB;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,iCAAiC;IACjC,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,yBAAyB;IACzB,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,8BAA8B;IAC9B,aAAa,EAAE,MAAM,IAAI,CAAC;IAC1B,8BAA8B;IAC9B,WAAW,EAAE,MAAM,IAAI,CAAC;IACxB,mCAAmC;IACnC,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,+BAA+B;IAC/B,YAAY,CAAC,EAAE,MAAM,IAAI,CAAC;CAC3B;AAgBD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,sBAAsB,GAC/B,gBAAgB,EAAE,CA2DpB;AAED;;GAEG;AACH,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,gBAAgB,EAAE,GAC5B,MAAM,CAAC,MAAM,EAAE,gBAAgB,EAAE,CAAC,CAYpC;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,eAAe,EAAE,gBAAgB,EAAE,EACnC,gBAAgB,EAAE,gBAAgB,EAAE,GACnC,gBAAgB,EAAE,CASpB;AAED;;GAEG;AACH,eAAO,MAAM,0BAA0B,iDAK7B,CAAC"}

package/dist/shared/keyboard/globalShortcuts.js

@@ -0,0 +1,79 @@
+//#region src/shared/keyboard/globalShortcuts.ts
+function e(e, t) {
+	let n = t || e.replace("cmd", "ctrl").replace("meta", "ctrl");
+	return {
+		mac: [e],
+		windows: [n],
+		linux: [n]
+	};
+}
+function t(t) {
+	let n = [
+		{
+			id: "global-nav-home",
+			keys: ["g h"],
+			description: "Go to Home",
+			category: "Navigation",
+			action: t.goHome,
+			global: !0
+		},
+		{
+			id: "global-search",
+			keys: e("cmd+k"),
+			description: "Open Search",
+			category: "Search",
+			action: t.openSearch,
+			global: !0
+		},
+		{
+			id: "global-toggle-sidebar",
+			keys: e("cmd+\\", "ctrl+\\"),
+			description: "Toggle Sidebar",
+			category: "UI",
+			action: t.toggleSidebar,
+			global: !0
+		},
+		{
+			id: "global-toggle-theme",
+			keys: e("cmd+shift+d", "ctrl+shift+d"),
+			description: "Toggle Dark Mode",
+			category: "UI",
+			action: t.toggleTheme,
+			global: !0
+		},
+		{
+			id: "global-help",
+			keys: e("cmd+/", "ctrl+/"),
+			description: "Show Keyboard Shortcuts",
+			category: "Help",
+			action: t.showHelp,
+			global: !0
+		}
+	];
+	return t.openSettings && n.push({
+		id: "global-nav-settings",
+		keys: ["g ,"],
+		description: "Go to Settings",
+		category: "Navigation",
+		action: t.openSettings,
+		global: !0
+	}), n;
+}
+function n(e) {
+	return e.reduce((e, t) => {
+		let n = t.category || "Other";
+		return e[n] || (e[n] = []), e[n].push(t), e;
+	}, {});
+}
+function r(e, t) {
+	let n = new Set(e.map((e) => e.id)), r = t.filter((e) => !n.has(e.id));
+	return [...e, ...r];
+}
+var i = [
+	"Navigation",
+	"Search",
+	"UI",
+	"Help"
+];
+//#endregion
+export { i as GLOBAL_SHORTCUT_CATEGORIES, t as createGlobalShortcuts, n as getGlobalShortcutsByCategory, r as mergeShortcuts };

package/dist/shared/keyboard/index.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Keyboard Shortcuts Module
+ *
+ * Comprehensive keyboard shortcut management system
+ *
+ * Features:
+ * - Cross-platform key combination support
+ * - Dynamic shortcut registration
+ * - Shortcut help dialog support
+ * - Input field detection
+ * - Platform-specific key formatting
+ *
+ * @example
+ * ```tsx
+ * import { useKeyboardShortcuts, useHotkeys, formatKeyCombo } from '@burdenoff/fe-libs/shared/keyboard';
+ *
+ * // Method 1: Static shortcuts
+ * const shortcuts = [
+ *   { id: 'search', keys: ['ctrl+k', 'cmd+k'], description: 'Search', action: () => openSearch() },
+ *   { id: 'help', keys: ['?'], description: 'Help', action: () => showHelp() },
+ * ];
+ * useKeyboardShortcuts(shortcuts);
+ *
+ * // Method 2: Dynamic hotkeys
+ * const { register, unregister } = useHotkeys();
+ * register('ctrl+s', () => save());
+ *
+ * // Method 3: Single shortcut
+ * useKeyboardShortcut('esc', () => closeDialog());
+ * ```
+ */
+export type { KeyboardShortcut, ShortcutConfig, ShortcutContext, ModifierKey, KeyCombination, UseKeyboardShortcutsReturn, UseHotkeysReturn, UseShortcutHelpReturn, PlatformType, ParsedKeyCombo, PlatformKeys, } from './types';
+export { MODIFIER_KEYS, PLATFORM_TYPES } from './types';
+export { useKeyboardShortcuts, useKeyboardShortcut, shouldEnableKeyboardShortcuts, } from './useKeyboardShortcuts';
+export { useHotkeys } from './useHotkeys';
+export { useShortcutHelp } from './useShortcutHelp';
+export { detectPlatform, isMac, normalizeKey, parseKeyCombo, matchesKeyCombo, formatKeyCombo, normalizePlatformCombo, shouldIgnoreShortcut, getShortcutLabel, getDisplayKeysForPlatform, isMobileDevice, isTabletDevice, } from './utils';
+export { createGlobalShortcuts, getGlobalShortcutsByCategory, mergeShortcuts, GLOBAL_SHORTCUT_CATEGORIES, } from './globalShortcuts';
+export type { GlobalShortcutsConfig, GlobalShortcutHandlers, } from './globalShortcuts';
+//# sourceMappingURL=index.d.ts.map

package/dist/shared/keyboard/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/shared/keyboard/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AAGH,YAAY,EACV,gBAAgB,EAChB,cAAc,EACd,eAAe,EACf,WAAW,EACX,cAAc,EACd,0BAA0B,EAC1B,gBAAgB,EAChB,qBAAqB,EACrB,YAAY,EACZ,cAAc,EACd,YAAY,GACb,MAAM,SAAS,CAAC;AACjB,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAGxD,OAAO,EACL,oBAAoB,EACpB,mBAAmB,EACnB,6BAA6B,GAC9B,MAAM,wBAAwB,CAAC;AAChC,OAAO,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1C,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAC;AAGpD,OAAO,EACL,cAAc,EACd,KAAK,EACL,YAAY,EACZ,aAAa,EACb,eAAe,EACf,cAAc,EACd,sBAAsB,EACtB,oBAAoB,EACpB,gBAAgB,EAChB,yBAAyB,EACzB,cAAc,EACd,cAAc,GACf,MAAM,SAAS,CAAC;AAGjB,OAAO,EACL,qBAAqB,EACrB,4BAA4B,EAC5B,cAAc,EACd,0BAA0B,GAC3B,MAAM,mBAAmB,CAAC;AAE3B,YAAY,EACV,qBAAqB,EACrB,sBAAsB,GACvB,MAAM,mBAAmB,CAAC"}