@burdenoff/fe-libs 2026.510.126

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

@@ -0,0 +1,85 @@
+/**
+ * Keyboard Shortcuts Types
+ *
+ * Type definitions for keyboard shortcut management system
+ */
+/**
+ * Platform-specific key definitions
+ * Allows defining different keys for each platform
+ */
+export interface PlatformKeys {
+    mac?: string[];
+    windows?: string[];
+    linux?: string[];
+    /** Fallback keys if platform-specific not defined */
+    default?: string[];
+}
+export interface KeyboardShortcut {
+    /** Unique identifier for this shortcut */
+    id: string;
+    /**
+     * Key combination(s) that trigger this shortcut
+     * Can be a simple array: ['ctrl+k', 'cmd+k']
+     * Or platform-specific: { mac: ['cmd+k'], windows: ['ctrl+k'], linux: ['ctrl+k'] }
+     *
+     * For key sequences (like "g h" for "go home"):
+     * Use space-separated keys: ['g h', 'g w'] - press g, then h or w
+     * Sequences must be pressed within the sequence timeout (default 1000ms)
+     */
+    keys: string[] | PlatformKeys;
+    /** Human-readable description */
+    description: string;
+    /** Category for grouping shortcuts (e.g., 'navigation', 'editing') */
+    category?: string;
+    /** Action to execute when shortcut is triggered */
+    action: () => void;
+    /** Whether this shortcut is enabled */
+    enabled?: boolean;
+    /** Whether this is a global shortcut (works everywhere) */
+    global?: boolean;
+    /** Disable on mobile/tablet devices */
+    disableOnMobile?: boolean;
+    /**
+     * Whether this shortcut is a key sequence (e.g., "g h")
+     * If not specified, will be auto-detected based on space in key definition
+     */
+    isSequence?: boolean;
+}
+export interface ShortcutConfig {
+    shortcuts: KeyboardShortcut[];
+    enabled?: boolean;
+    preventDefault?: boolean;
+    stopPropagation?: boolean;
+}
+export interface ShortcutContext {
+    registerShortcut: (shortcut: KeyboardShortcut) => void;
+    unregisterShortcut: (id: string) => void;
+    toggleShortcuts: (enabled: boolean) => void;
+    getShortcuts: () => KeyboardShortcut[];
+}
+export type ModifierKey = "ctrl" | "alt" | "shift" | "meta" | "cmd";
+export type KeyCombination = string | string[];
+export interface UseKeyboardShortcutsReturn {
+    handleKeyDown: (event: KeyboardEvent) => void;
+}
+export interface UseHotkeysReturn {
+    register: (key: string, callback: () => void) => void;
+    unregister: (key: string) => void;
+}
+export interface UseShortcutHelpReturn {
+    isHelpVisible: boolean;
+    showHelp: () => void;
+    hideHelp: () => void;
+    toggleHelp: () => void;
+    shortcuts: KeyboardShortcut[];
+}
+export type PlatformType = "mac" | "windows" | "linux" | "unknown";
+export interface ParsedKeyCombo {
+    modifiers: Set<string>;
+    key: string;
+}
+/** Available modifier keys for shortcut definitions */
+export declare const MODIFIER_KEYS: readonly ModifierKey[];
+/** Available platform types */
+export declare const PLATFORM_TYPES: readonly PlatformType[];
+//# sourceMappingURL=types.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/shared/keyboard/types.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B,GAAG,CAAC,EAAE,MAAM,EAAE,CAAC;IACf,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;IACnB,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,qDAAqD;IACrD,OAAO,CAAC,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,gBAAgB;IAC/B,0CAA0C;IAC1C,EAAE,EAAE,MAAM,CAAC;IACX;;;;;;;;OAQG;IACH,IAAI,EAAE,MAAM,EAAE,GAAG,YAAY,CAAC;IAC9B,iCAAiC;IACjC,WAAW,EAAE,MAAM,CAAC;IACpB,sEAAsE;IACtE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,mDAAmD;IACnD,MAAM,EAAE,MAAM,IAAI,CAAC;IACnB,uCAAuC;IACvC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,2DAA2D;IAC3D,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB,uCAAuC;IACvC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,gBAAgB,EAAE,CAAC;IAC9B,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,eAAe,CAAC,EAAE,OAAO,CAAC;CAC3B;AAED,MAAM,WAAW,eAAe;IAC9B,gBAAgB,EAAE,CAAC,QAAQ,EAAE,gBAAgB,KAAK,IAAI,CAAC;IACvD,kBAAkB,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAC;IACzC,eAAe,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;IAC5C,YAAY,EAAE,MAAM,gBAAgB,EAAE,CAAC;CACxC;AAED,MAAM,MAAM,WAAW,GAAG,MAAM,GAAG,KAAK,GAAG,OAAO,GAAG,MAAM,GAAG,KAAK,CAAC;AACpE,MAAM,MAAM,cAAc,GAAG,MAAM,GAAG,MAAM,EAAE,CAAC;AAG/C,MAAM,WAAW,0BAA0B;IACzC,aAAa,EAAE,CAAC,KAAK,EAAE,aAAa,KAAK,IAAI,CAAC;CAC/C;AAED,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;IACtD,UAAU,EAAE,CAAC,GAAG,EAAE,MAAM,KAAK,IAAI,CAAC;CACnC;AAED,MAAM,WAAW,qBAAqB;IACpC,aAAa,EAAE,OAAO,CAAC;IACvB,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,UAAU,EAAE,MAAM,IAAI,CAAC;IACvB,SAAS,EAAE,gBAAgB,EAAE,CAAC;CAC/B;AAGD,MAAM,MAAM,YAAY,GAAG,KAAK,GAAG,SAAS,GAAG,OAAO,GAAG,SAAS,CAAC;AAEnE,MAAM,WAAW,cAAc;IAC7B,SAAS,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;IACvB,GAAG,EAAE,MAAM,CAAC;CACb;AAED,uDAAuD;AACvD,eAAO,MAAM,aAAa,EAAE,SAAS,WAAW,EAMtC,CAAC;AAEX,+BAA+B;AAC/B,eAAO,MAAM,cAAc,EAAE,SAAS,YAAY,EAKxC,CAAC"}

package/dist/shared/keyboard/types.js

@@ -0,0 +1,15 @@
+//#region src/shared/keyboard/types.ts
+var e = [
+	"ctrl",
+	"alt",
+	"shift",
+	"meta",
+	"cmd"
+], t = [
+	"mac",
+	"windows",
+	"linux",
+	"unknown"
+];
+//#endregion
+export { e as MODIFIER_KEYS, t as PLATFORM_TYPES };

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

@@ -0,0 +1,21 @@
+import { UseHotkeysReturn } from './types';
+/**
+ * Hook for dynamically registering hotkeys
+ *
+ * @example
+ * ```tsx
+ * const { register, unregister } = useHotkeys();
+ *
+ * useEffect(() => {
+ *   register('ctrl+s', () => save());
+ *   register('ctrl+p', () => print());
+ *
+ *   return () => {
+ *     unregister('ctrl+s');
+ *     unregister('ctrl+p');
+ *   };
+ * }, []);
+ * ```
+ */
+export declare function useHotkeys(enabled?: boolean): UseHotkeysReturn;
+//# sourceMappingURL=useHotkeys.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useHotkeys.d.ts","sourceRoot":"","sources":["../../../src/shared/keyboard/useHotkeys.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAGhD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,UAAU,CAAC,OAAO,UAAO,GAAG,gBAAgB,CAiC3D"}

package/dist/shared/keyboard/useHotkeys.js

@@ -0,0 +1,27 @@
+import { useKeyboardShortcuts as e } from "./useKeyboardShortcuts.js";
+import { useCallback as t, useState as n } from "react";
+//#region src/shared/keyboard/useHotkeys.ts
+function r(r = !0) {
+	let [i, a] = n(/* @__PURE__ */ new Map()), o = t((e, t) => {
+		a((n) => {
+			let r = new Map(n);
+			return r.set(e, t), r;
+		});
+	}, []), s = t((e) => {
+		a((t) => {
+			let n = new Map(t);
+			return n.delete(e), n;
+		});
+	}, []);
+	return e(Array.from(i.entries()).map(([e, t]) => ({
+		id: e,
+		keys: [e],
+		description: "",
+		action: t
+	})), { enabled: r }), {
+		register: o,
+		unregister: s
+	};
+}
+//#endregion
+export { r as useHotkeys };

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

@@ -0,0 +1,94 @@
+import { KeyboardShortcut, UseKeyboardShortcutsReturn, PlatformKeys } from './types';
+export interface UseKeyboardShortcutsOptions {
+    /** Whether shortcuts are enabled */
+    enabled?: boolean;
+    /** Whether to prevent default browser behavior */
+    preventDefault?: boolean;
+    /** Whether to stop event propagation */
+    stopPropagation?: boolean;
+    /** Whether to ignore shortcuts in input fields */
+    ignoreInputFields?: boolean;
+    /** Enable shortcuts on tablet devices (default: false) */
+    enableOnTablet?: boolean;
+    /** Timeout for key sequences in milliseconds (default: 1000) */
+    sequenceTimeout?: number;
+    /**
+     * Shortcut IDs that should always fire even inside input fields.
+     * Useful for global shortcuts like search (Cmd+K) or help (?).
+     * These bypass the ignoreInputFields check.
+     */
+    globalShortcutIds?: string[];
+}
+/**
+ * Hook for managing keyboard shortcuts with sequence support
+ *
+ * Features:
+ * - Platform-specific key definitions (Mac vs Windows/Linux)
+ * - Key sequence support (e.g., "g h" for "go home")
+ * - Automatic mobile/tablet detection and disabling
+ * - Input field detection (skip shortcuts in text inputs)
+ * - Configurable preventDefault and stopPropagation
+ *
+ * @example
+ * ```tsx
+ * const shortcuts = [
+ *   {
+ *     id: 'search',
+ *     keys: { mac: ['cmd+k'], windows: ['ctrl+k'], linux: ['ctrl+k'] },
+ *     description: 'Open search',
+ *     action: () => openSearch(),
+ *   },
+ *   {
+ *     id: 'go-home',
+ *     keys: ['g h'], // Key sequence: press g, then h
+ *     description: 'Go to home',
+ *     action: () => navigate('/'),
+ *   },
+ *   {
+ *     id: 'help',
+ *     keys: ['?'], // Single key
+ *     description: 'Show help',
+ *     action: () => showHelp(),
+ *   },
+ * ];
+ *
+ * useKeyboardShortcuts(shortcuts, {
+ *   enabled: true,
+ *   preventDefault: true,
+ * });
+ * ```
+ */
+export declare function useKeyboardShortcuts(shortcuts?: KeyboardShortcut[], options?: UseKeyboardShortcutsOptions): UseKeyboardShortcutsReturn;
+/**
+ * Hook for managing a single keyboard shortcut
+ *
+ * @example
+ * ```tsx
+ * useKeyboardShortcut('ctrl+k', () => {
+ *   openSearch();
+ * });
+ *
+ * // Platform-specific
+ * useKeyboardShortcut({ mac: ['cmd+k'], windows: ['ctrl+k'] }, () => {
+ *   openSearch();
+ * });
+ *
+ * // Key sequence
+ * useKeyboardShortcut('g h', () => {
+ *   navigate('/');
+ * });
+ * ```
+ */
+export declare function useKeyboardShortcut(keys: string | string[] | PlatformKeys, action: () => void, options?: Omit<UseKeyboardShortcutsOptions, "enabled"> & {
+    enabled?: boolean;
+}): void;
+/**
+ * Get the current platform type
+ * Useful for displaying platform-specific key labels in UI
+ */
+export { detectPlatform } from './utils';
+/**
+ * Check if current device supports keyboard shortcuts
+ */
+export { shouldEnableKeyboardShortcuts, isMobileDevice, isTabletDevice, } from './utils';
+//# sourceMappingURL=useKeyboardShortcuts.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useKeyboardShortcuts.d.ts","sourceRoot":"","sources":["../../../src/shared/keyboard/useKeyboardShortcuts.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAIH,OAAO,KAAK,EACV,gBAAgB,EAChB,0BAA0B,EAC1B,YAAY,EACb,MAAM,SAAS,CAAC;AAUjB,MAAM,WAAW,2BAA2B;IAC1C,oCAAoC;IACpC,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,kDAAkD;IAClD,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,wCAAwC;IACxC,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,kDAAkD;IAClD,iBAAiB,CAAC,EAAE,OAAO,CAAC;IAC5B,0DAA0D;IAC1D,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB,gEAAgE;IAChE,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,MAAM,EAAE,CAAC;CAC9B;AA4CD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wBAAgB,oBAAoB,CAClC,SAAS,GAAE,gBAAgB,EAAO,EAClC,OAAO,GAAE,2BAAgC,GACxC,0BAA0B,CAiQ5B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,GAAG,YAAY,EACtC,MAAM,EAAE,MAAM,IAAI,EAClB,OAAO,GAAE,IAAI,CAAC,2BAA2B,EAAE,SAAS,CAAC,GAAG;IACtD,OAAO,CAAC,EAAE,OAAO,CAAC;CACd,GACL,IAAI,CAYN;AAED;;;GAGG;AACH,OAAO,EAAE,cAAc,EAAE,MAAM,SAAS,CAAC;AAEzC;;GAEG;AACH,OAAO,EACL,6BAA6B,EAC7B,cAAc,EACd,cAAc,GACf,MAAM,SAAS,CAAC"}

package/dist/shared/keyboard/useKeyboardShortcuts.js

@@ -0,0 +1,105 @@
+import { detectPlatform as e, matchesKeyCombo as t, normalizeKey as n, normalizePlatformCombo as r, shouldEnableKeyboardShortcuts as i, shouldIgnoreShortcut as a } from "./utils.js";
+import { useCallback as o, useEffect as s, useMemo as c, useRef as l } from "react";
+//#region src/shared/keyboard/useKeyboardShortcuts.ts
+function u(t) {
+	if (Array.isArray(t)) return t;
+	switch (e()) {
+		case "mac": return t.mac || t.default || [];
+		case "windows": return t.windows || t.default || [];
+		case "linux": return t.linux || t.windows || t.default || [];
+		default: return t.default || t.windows || [];
+	}
+}
+function d(e) {
+	return e.includes(" ") && !e.includes("+");
+}
+function f(e) {
+	return e.split(" ").map((e) => e.trim().toLowerCase()).filter(Boolean);
+}
+function p(e = [], p = {}) {
+	let { enabled: m = !0, preventDefault: h = !0, stopPropagation: g = !0, ignoreInputFields: _ = !0, enableOnTablet: v = !1, sequenceTimeout: y = 1e3, globalShortcutIds: b = [] } = p, x = c(() => i({ enableOnTablet: v }), [v]), S = m && x, C = l(e), w = l([]), T = l(null);
+	s(() => {
+		C.current = e;
+	}, [e]);
+	let E = o(() => {
+		w.current = [], T.current &&= (clearTimeout(T.current), null);
+	}, []), D = o(() => {
+		T.current && clearTimeout(T.current), T.current = setTimeout(() => {
+			w.current = [];
+		}, y);
+	}, [y]), O = l(b);
+	s(() => {
+		O.current = b;
+	}, [b]);
+	let k = o((e) => {
+		if (!S) return;
+		let i = _ && a(e);
+		if (i && !(O.current.length > 0)) {
+			E();
+			return;
+		}
+		let o = n(e.key), s = [...w.current, o], c;
+		if (i || (c = C.current.find((e) => e.enabled === !1 || e.disableOnMobile && !x ? !1 : u(e.keys).some((t) => {
+			if (d(t) || e.isSequence) {
+				let e = f(t);
+				return !!(s.length <= e.length && s.every((t, n) => t === e[n]) && s.length === e.length);
+			}
+			return !1;
+		}))), c) {
+			h && e.preventDefault(), g && e.stopPropagation(), E();
+			try {
+				c.action();
+			} catch (e) {
+				console.error(`Error executing shortcut "${c.id}":`, e);
+			}
+			return;
+		}
+		if (!i && C.current.some((e) => e.enabled === !1 ? !1 : u(e.keys).some((t) => {
+			if (d(t) || e.isSequence) {
+				let e = f(t);
+				if (s.length < e.length) return s.every((t, n) => t === e[n]);
+			}
+			return !1;
+		}))) {
+			w.current = s, D(), h && e.preventDefault();
+			return;
+		}
+		if (E(), c = C.current.find((n) => n.enabled === !1 || n.disableOnMobile && !x || i && !O.current.includes(n.id) ? !1 : u(n.keys).some((i) => d(i) || n.isSequence ? !1 : t(e, r(i)))), c) {
+			h && e.preventDefault(), g && e.stopPropagation();
+			try {
+				c.action();
+			} catch (e) {
+				console.error(`Error executing shortcut "${c.id}":`, e);
+			}
+		}
+	}, [
+		S,
+		h,
+		g,
+		_,
+		x,
+		E,
+		D
+	]);
+	return s(() => {
+		if (S) return document.addEventListener("keydown", k), () => {
+			document.removeEventListener("keydown", k), E();
+		};
+	}, [
+		k,
+		S,
+		E
+	]), { handleKeyDown: k };
+}
+function m(e, t, n = {}) {
+	let r = typeof e == "string" ? [e] : e;
+	p([{
+		id: Array.isArray(r) ? r.join("|") : "platform-shortcut",
+		keys: r,
+		description: "",
+		action: t,
+		enabled: n.enabled !== !1
+	}], n);
+}
+//#endregion
+export { m as useKeyboardShortcut, p as useKeyboardShortcuts };

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

@@ -0,0 +1,27 @@
+import { KeyboardShortcut, UseShortcutHelpReturn } from './types';
+/**
+ * Hook for managing shortcut help dialog
+ *
+ * @example
+ * ```tsx
+ * const { isHelpVisible, showHelp, hideHelp, shortcuts } = useShortcutHelp(
+ *   allShortcuts,
+ *   { triggerKey: '?' }
+ * );
+ *
+ * return (
+ *   <>
+ *     {isHelpVisible && (
+ *       <ShortcutHelpDialog shortcuts={shortcuts} onClose={hideHelp} />
+ *     )}
+ *   </>
+ * );
+ * ```
+ */
+export declare function useShortcutHelp(shortcuts: KeyboardShortcut[], options?: {
+    /** Key to trigger help dialog (default: '?') */
+    triggerKey?: string;
+    /** Whether to enable automatic help trigger */
+    autoTrigger?: boolean;
+}): UseShortcutHelpReturn;
+//# sourceMappingURL=useShortcutHelp.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"useShortcutHelp.d.ts","sourceRoot":"","sources":["../../../src/shared/keyboard/useShortcutHelp.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAIH,OAAO,KAAK,EAAE,gBAAgB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAC;AAGvE;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,eAAe,CAC7B,SAAS,EAAE,gBAAgB,EAAE,EAC7B,OAAO,GAAE;IACP,gDAAgD;IAChD,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,+CAA+C;IAC/C,WAAW,CAAC,EAAE,OAAO,CAAC;CAClB,GACL,qBAAqB,CA2BvB"}

package/dist/shared/keyboard/useShortcutHelp.js

@@ -0,0 +1,21 @@
+import { useKeyboardShortcut as e } from "./useKeyboardShortcuts.js";
+import { useCallback as t, useState as n } from "react";
+//#region src/shared/keyboard/useShortcutHelp.ts
+function r(r, i = {}) {
+	let { triggerKey: a = "?", autoTrigger: o = !0 } = i, [s, c] = n(!1), l = t(() => {
+		c(!0);
+	}, []), u = t(() => {
+		c(!1);
+	}, []), d = t(() => {
+		c((e) => !e);
+	}, []);
+	return e(a, d, { enabled: o }), {
+		isHelpVisible: s,
+		showHelp: l,
+		hideHelp: u,
+		toggleHelp: d,
+		shortcuts: r
+	};
+}
+//#endregion
+export { r as useShortcutHelp };

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

@@ -0,0 +1,72 @@
+import { PlatformType, ParsedKeyCombo, PlatformKeys } from './types';
+/**
+ * Detect the current platform
+ */
+export declare function detectPlatform(): PlatformType;
+/**
+ * Detect if the device is mobile (phone or tablet)
+ */
+export declare function isMobileDevice(): boolean;
+/**
+ * Check if device is a tablet (larger touch device)
+ */
+export declare function isTabletDevice(): boolean;
+/**
+ * Check if keyboard shortcuts should be enabled
+ * Disabled on mobile phones, optionally enabled on tablets
+ */
+export declare function shouldEnableKeyboardShortcuts(options?: {
+    enableOnTablet?: boolean;
+}): boolean;
+/**
+ * Check if current platform is Mac
+ */
+export declare function isMac(): boolean;
+/**
+ * Normalize key name (lowercase, handle aliases)
+ */
+export declare function normalizeKey(key: string): string;
+/**
+ * Parse key combination string (e.g., 'ctrl+shift+k')
+ */
+export declare function parseKeyCombo(combo: string): ParsedKeyCombo;
+/**
+ * Check if a keyboard event matches a key combination
+ */
+export declare function matchesKeyCombo(event: KeyboardEvent, combo: string): boolean;
+/**
+ * Format key combination for display
+ */
+export declare function formatKeyCombo(combo: string): string;
+/**
+ * Convert platform-specific combo to cross-platform
+ * Example: 'cmd+k' becomes 'ctrl+k' on Windows/Linux
+ */
+export declare function normalizePlatformCombo(combo: string): string;
+/**
+ * Check if element should ignore keyboard shortcuts
+ * (e.g., input fields, textareas, content-editable)
+ */
+export declare function shouldIgnoreShortcut(event: KeyboardEvent): boolean;
+/**
+ * Get readable shortcut label
+ */
+export declare function getShortcutLabel(keys: string[]): string;
+/**
+ * Resolve platform-specific keys and format for display
+ */
+export declare function getDisplayKeysForPlatform(keys: string[] | PlatformKeys): string;
+/**
+ * Check if a key definition is a sequence (contains spaces, no +)
+ */
+export declare function isKeySequence(keyDef: string): boolean;
+/**
+ * Format a key sequence for display
+ * "g h" -> "G then H"
+ */
+export declare function formatKeySequence(keyDef: string): string;
+/**
+ * Format any shortcut (combo or sequence) for display
+ */
+export declare function formatShortcut(keyDef: string): string;
+//# sourceMappingURL=utils.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/shared/keyboard/utils.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAE1E;;GAEG;AACH,wBAAgB,cAAc,IAAI,YAAY,CA6B7C;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,OAAO,CA4BxC;AAED;;GAEG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAaxC;AAED;;;GAGG;AACH,wBAAgB,6BAA6B,CAAC,OAAO,CAAC,EAAE;IACtD,cAAc,CAAC,EAAE,OAAO,CAAC;CAC1B,GAAG,OAAO,CAYV;AAED;;GAEG;AACH,wBAAgB,KAAK,IAAI,OAAO,CAE/B;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAsBhD;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,CAqB3D;AA+BD;;GAEG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,aAAa,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CA2C5E;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAsCpD;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAU5D;AAED;;;GAGG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,aAAa,GAAG,OAAO,CAWlE;AAED;;GAEG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,MAAM,CAmBvD;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,MAAM,EAAE,GAAG,YAAY,GAC5B,MAAM,CAuBR;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAErD;AAED;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAGxD;AAED;;GAEG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAKrD"}

package/dist/shared/keyboard/utils.js

@@ -0,0 +1,165 @@
+//#region src/shared/keyboard/utils.ts
+function e() {
+	if (typeof window > "u") return "unknown";
+	let e = navigator.userAgentData;
+	if (e?.platform) {
+		let t = e.platform.toLowerCase();
+		if (t === "macos" || t.includes("mac")) return "mac";
+		if (t === "windows" || t.includes("win")) return "windows";
+		if (t === "linux" || t.includes("linux")) return "linux";
+	}
+	let t = window.navigator.platform?.toLowerCase() ?? "", n = window.navigator.userAgent.toLowerCase();
+	return t.includes("mac") || n.includes("mac") ? "mac" : t.includes("win") || n.includes("win") ? "windows" : t.includes("linux") || n.includes("linux") ? "linux" : "unknown";
+}
+function t() {
+	if (typeof window > "u") return !1;
+	let e = window.navigator.userAgent.toLowerCase(), t = [
+		"android",
+		"webos",
+		"iphone",
+		"ipad",
+		"ipod",
+		"blackberry",
+		"iemobile",
+		"opera mini",
+		"mobile",
+		"tablet"
+	].some((t) => e.includes(t)), n = "ontouchstart" in window || navigator.maxTouchPoints > 0, r = window.innerWidth < 768;
+	return t || n && r;
+}
+function n() {
+	if (typeof window > "u") return !1;
+	let e = window.navigator.userAgent.toLowerCase(), t = e.includes("ipad") || e.includes("android") && !e.includes("mobile"), n = "ontouchstart" in window || navigator.maxTouchPoints > 0, r = window.innerWidth >= 768 && window.innerWidth < 1024;
+	return t || n && r;
+}
+function r(e) {
+	let { enableOnTablet: r = !1 } = e || {};
+	return !(t() && !n() || n() && !r);
+}
+function i() {
+	return e() === "mac";
+}
+function a(e) {
+	if (!e) return "";
+	let t = e.toLowerCase().trim();
+	return {
+		command: "meta",
+		cmd: "meta",
+		control: "ctrl",
+		option: "alt",
+		return: "enter",
+		escape: "esc",
+		delete: "backspace",
+		space: " ",
+		spacebar: " ",
+		up: "arrowup",
+		down: "arrowdown",
+		left: "arrowleft",
+		right: "arrowright"
+	}[t] || t;
+}
+function o(e) {
+	let t = e.toLowerCase().split("+").map((e) => e.trim()), n = /* @__PURE__ */ new Set(), r = "", i = new Set([
+		"ctrl",
+		"alt",
+		"shift",
+		"meta",
+		"cmd"
+	]);
+	for (let e of t) {
+		let t = a(e);
+		i.has(t) ? n.add(t === "cmd" ? "meta" : t) : r = t;
+	}
+	return {
+		modifiers: n,
+		key: r
+	};
+}
+var s = new Set([
+	"?",
+	"!",
+	"@",
+	"#",
+	"$",
+	"%",
+	"^",
+	"&",
+	"*",
+	"(",
+	")",
+	"_",
+	"+",
+	"{",
+	"}",
+	"|",
+	":",
+	"\"",
+	"<",
+	">",
+	"~"
+]);
+function c(e, t) {
+	let n = o(t);
+	if (a(e.key) !== n.key) return !1;
+	let r = /* @__PURE__ */ new Set();
+	e.ctrlKey && r.add("ctrl"), e.altKey && r.add("alt"), e.shiftKey && r.add("shift"), e.metaKey && r.add("meta");
+	let i = s.has(n.key), c = new Set(n.modifiers), l = new Set(r);
+	if (i && !c.has("shift") && l.has("shift") && l.delete("shift"), c.size !== l.size) return !1;
+	for (let e of c) if (!l.has(e)) return !1;
+	return !0;
+}
+function l(t) {
+	let n = o(t), r = e(), i = [];
+	n.modifiers.has("ctrl") && i.push(r === "mac" ? "⌃" : "Ctrl"), n.modifiers.has("alt") && i.push(r === "mac" ? "⌥" : "Alt"), n.modifiers.has("shift") && i.push(r === "mac" ? "⇧" : "Shift"), n.modifiers.has("meta") && i.push(r === "mac" ? "⌘" : "Win");
+	let a = {
+		" ": "Space",
+		enter: "↵",
+		esc: "Esc",
+		backspace: "⌫",
+		delete: "⌦",
+		tab: "⇥",
+		arrowup: "↑",
+		arrowdown: "↓",
+		arrowleft: "←",
+		arrowright: "→"
+	}[n.key] || n.key.toUpperCase();
+	return i.push(a), i.join(r === "mac" ? "" : "+");
+}
+function u(t) {
+	return e() === "mac" ? t.replace(/\bctrl\b/gi, "meta") : t.replace(/\b(meta|cmd)\b/gi, "ctrl");
+}
+function d(e) {
+	let t = e.target;
+	if (!t) return !1;
+	let n = t.tagName.toLowerCase();
+	return t.isContentEditable || n === "input" || n === "textarea" || n === "select";
+}
+function f(t) {
+	if (t.length === 0) return "";
+	if (t.length === 1) return l(t[0]);
+	let n = e();
+	for (let e of t) {
+		let t = u(e);
+		if (n === "mac" && t.includes("meta") || n !== "mac" && t.includes("ctrl")) return l(e);
+	}
+	return l(t[0]);
+}
+function p(t) {
+	let n = e(), r;
+	if (Array.isArray(t)) r = t;
+	else switch (n) {
+		case "mac":
+			r = t.mac || t.default || [];
+			break;
+		case "windows":
+			r = t.windows || t.default || [];
+			break;
+		case "linux":
+			r = t.linux || t.windows || t.default || [];
+			break;
+		default: r = t.default || t.windows || [];
+	}
+	return f(r);
+}
+//#endregion
+export { e as detectPlatform, l as formatKeyCombo, p as getDisplayKeysForPlatform, f as getShortcutLabel, i as isMac, t as isMobileDevice, n as isTabletDevice, c as matchesKeyCombo, a as normalizeKey, u as normalizePlatformCombo, o as parseKeyCombo, r as shouldEnableKeyboardShortcuts, d as shouldIgnoreShortcut };

package/dist/shared/logger/ConsoleTransport.d.ts

@@ -0,0 +1,22 @@
+import { LogTransport, LogEntry, LogLevel } from './types';
+export interface ConsoleTransportOptions {
+    level?: LogLevel;
+    useColors?: boolean;
+    useIcons?: boolean;
+    showTimestamp?: boolean;
+    showLogger?: boolean;
+    showContext?: boolean;
+}
+export declare class ConsoleTransport implements LogTransport {
+    readonly name = "console";
+    level: LogLevel;
+    private useColors;
+    private useIcons;
+    private showTimestamp;
+    private showLogger;
+    private showContext;
+    constructor(options?: ConsoleTransportOptions);
+    log(entry: LogEntry): void;
+    private getConsoleMethod;
+}
+//# sourceMappingURL=ConsoleTransport.d.ts.map