@redis-ui/components 47.4.0 → 47.5.1

package/dist/node_modules/@tanstack/hotkeys/dist/hotkey-manager.cjs

@@ -0,0 +1,363 @@
+const require_constants = require("./constants.cjs");
+const require_parse = require("./parse.cjs");
+const require_format = require("./format.cjs");
+const require_match = require("./match.cjs");
+const require_manager_utils = require("./manager.utils.cjs");
+const require_store = require("../../store/dist/store.cjs");
+//#region ../../node_modules/@tanstack/hotkeys/dist/hotkey-manager.js
+var registrationIdCounter = 0;
+/**
+* Generates a unique ID for hotkey registrations.
+*/
+function generateId() {
+	return `hotkey_${++registrationIdCounter}`;
+}
+/**
+* Singleton manager for hotkey registrations.
+*
+* This class provides a centralized way to register and manage keyboard hotkeys.
+* It uses a single event listener for efficiency, regardless of how many hotkeys
+* are registered.
+*
+* @example
+* ```ts
+* const manager = HotkeyManager.getInstance()
+*
+* const unregister = manager.register('Mod+S', (event, context) => {
+*   console.log('Save triggered!')
+* })
+*
+* // Later, to unregister:
+* unregister()
+* ```
+*/
+var HotkeyManager = class HotkeyManager {
+	static #instance = null;
+	#platform;
+	#targetListeners = /* @__PURE__ */ new Map();
+	#targetRegistrations = /* @__PURE__ */ new Map();
+	constructor() {
+		this.registrations = new require_store.Store(/* @__PURE__ */ new Map());
+		this.#platform = require_constants.detectPlatform();
+	}
+	/**
+	* Gets the singleton instance of HotkeyManager.
+	*/
+	static getInstance() {
+		if (!HotkeyManager.#instance) HotkeyManager.#instance = new HotkeyManager();
+		return HotkeyManager.#instance;
+	}
+	/**
+	* Resets the singleton instance. Useful for testing.
+	*/
+	static resetInstance() {
+		if (HotkeyManager.#instance) {
+			HotkeyManager.#instance.destroy();
+			HotkeyManager.#instance = null;
+		}
+	}
+	/**
+	* Registers a hotkey handler and returns a handle for updating the registration.
+	*
+	* The returned handle allows updating the callback and options without
+	* re-registering, which is useful for avoiding stale closures in React.
+	*
+	* @param hotkey - The hotkey string (e.g., 'Mod+S') or RawHotkey object
+	* @param callback - The function to call when the hotkey is pressed
+	* @param options - Options for the hotkey behavior
+	* @returns A handle for managing the registration
+	*
+	* @example
+	* ```ts
+	* const handle = manager.register('Mod+S', callback)
+	*
+	* // Update callback without re-registering (avoids stale closures)
+	* handle.callback = newCallback
+	*
+	* // Update options
+	* handle.setOptions({ enabled: false })
+	*
+	* // Unregister when done
+	* handle.unregister()
+	* ```
+	*/
+	register(hotkey, callback, options = {}) {
+		if (typeof document === "undefined" && !options.target) {
+			let currentCallback = callback;
+			return {
+				id: generateId(),
+				unregister: () => {},
+				get callback() {
+					return currentCallback;
+				},
+				set callback(newCallback) {
+					currentCallback = newCallback;
+				},
+				setOptions: () => {},
+				get isActive() {
+					return false;
+				}
+			};
+		}
+		const id = generateId();
+		const platform = options.platform ?? this.#platform;
+		const parsedHotkey = typeof hotkey === "string" ? require_parse.parseHotkey(hotkey, platform) : require_parse.rawHotkeyToParsedHotkey(hotkey, platform);
+		const hotkeyStr = typeof hotkey === "string" ? hotkey : require_format.formatHotkey(parsedHotkey);
+		const target = options.target ?? document;
+		const conflictBehavior = options.conflictBehavior ?? "warn";
+		const conflictingRegistration = this.#findConflictingRegistration(hotkeyStr, target);
+		if (conflictingRegistration) require_manager_utils.handleConflict(conflictingRegistration.id, hotkeyStr, conflictBehavior, (id) => this.#unregister(id));
+		const resolvedIgnoreInputs = options.ignoreInputs ?? require_manager_utils.getDefaultIgnoreInputs(parsedHotkey);
+		const registration = {
+			id,
+			hotkey: hotkeyStr,
+			parsedHotkey,
+			callback,
+			options: {
+				...require_manager_utils.defaultHotkeyOptions,
+				requireReset: false,
+				...options,
+				platform,
+				ignoreInputs: resolvedIgnoreInputs
+			},
+			hasFired: false,
+			triggerCount: 0,
+			target
+		};
+		this.registrations.setState((prev) => new Map(prev).set(id, registration));
+		if (!this.#targetRegistrations.has(target)) this.#targetRegistrations.set(target, /* @__PURE__ */ new Set());
+		this.#targetRegistrations.get(target).add(id);
+		this.#ensureListenersForTarget(target);
+		const manager = this;
+		return {
+			get id() {
+				return id;
+			},
+			unregister: () => {
+				manager.#unregister(id);
+			},
+			get callback() {
+				return manager.registrations.state.get(id)?.callback ?? callback;
+			},
+			set callback(newCallback) {
+				const reg = manager.registrations.state.get(id);
+				if (reg) reg.callback = newCallback;
+			},
+			setOptions: (newOptions) => {
+				manager.registrations.setState((prev) => {
+					const reg = prev.get(id);
+					if (reg) {
+						const next = new Map(prev);
+						next.set(id, {
+							...reg,
+							options: {
+								...reg.options,
+								...newOptions
+							}
+						});
+						return next;
+					}
+					return prev;
+				});
+			},
+			get isActive() {
+				return manager.registrations.state.has(id);
+			}
+		};
+	}
+	/**
+	* Unregisters a hotkey by its registration ID.
+	*/
+	#unregister(id) {
+		const registration = this.registrations.state.get(id);
+		if (!registration) return;
+		const target = registration.target;
+		this.registrations.setState((prev) => {
+			const next = new Map(prev);
+			next.delete(id);
+			return next;
+		});
+		const targetRegs = this.#targetRegistrations.get(target);
+		if (targetRegs) {
+			targetRegs.delete(id);
+			if (targetRegs.size === 0) this.#removeListenersForTarget(target);
+		}
+	}
+	/**
+	* Ensures event listeners are attached for a specific target.
+	*/
+	#ensureListenersForTarget(target) {
+		if (typeof document === "undefined") return;
+		if (this.#targetListeners.has(target)) return;
+		const keydownHandler = this.#createTargetKeyDownHandler(target);
+		const keyupHandler = this.#createTargetKeyUpHandler(target);
+		target.addEventListener("keydown", keydownHandler);
+		target.addEventListener("keyup", keyupHandler);
+		this.#targetListeners.set(target, {
+			keydown: keydownHandler,
+			keyup: keyupHandler
+		});
+	}
+	/**
+	* Removes event listeners for a specific target.
+	*/
+	#removeListenersForTarget(target) {
+		if (typeof document === "undefined") return;
+		const listeners = this.#targetListeners.get(target);
+		if (!listeners) return;
+		target.removeEventListener("keydown", listeners.keydown);
+		target.removeEventListener("keyup", listeners.keyup);
+		this.#targetListeners.delete(target);
+		this.#targetRegistrations.delete(target);
+	}
+	/**
+	* Processes keyboard events for a specific target and event type.
+	*/
+	#processTargetEvent(event, target, eventType) {
+		const targetRegs = this.#targetRegistrations.get(target);
+		if (!targetRegs) return;
+		for (const id of targetRegs) {
+			const registration = this.registrations.state.get(id);
+			if (!registration) continue;
+			if (!require_manager_utils.isEventForTarget(event, target)) continue;
+			if (!registration.options.enabled) continue;
+			if (registration.options.ignoreInputs !== false) {
+				if (require_manager_utils.shouldIgnoreInputEvent(event, target, registration.target)) continue;
+			}
+			if (eventType === "keydown") {
+				if (registration.options.eventType !== "keydown") continue;
+				if (require_match.matchesKeyboardEvent(event, registration.parsedHotkey, registration.options.platform)) {
+					if (registration.options.preventDefault) event.preventDefault();
+					if (registration.options.stopPropagation) event.stopPropagation();
+					if (!registration.options.requireReset || !registration.hasFired) {
+						this.#executeHotkeyCallback(registration, event);
+						if (registration.options.requireReset) registration.hasFired = true;
+					}
+				}
+			} else {
+				if (registration.options.eventType === "keyup") {
+					if (require_match.matchesKeyboardEvent(event, registration.parsedHotkey, registration.options.platform)) this.#executeHotkeyCallback(registration, event);
+				}
+				if (registration.options.requireReset && registration.hasFired) {
+					if (this.#shouldResetRegistration(registration, event)) registration.hasFired = false;
+				}
+			}
+		}
+	}
+	/**
+	* Executes a hotkey callback with proper event handling.
+	*/
+	#executeHotkeyCallback(registration, event) {
+		if (registration.options.preventDefault) event.preventDefault();
+		if (registration.options.stopPropagation) event.stopPropagation();
+		registration.triggerCount++;
+		this.registrations.setState((prev) => new Map(prev));
+		const context = {
+			hotkey: registration.hotkey,
+			parsedHotkey: registration.parsedHotkey
+		};
+		registration.callback(event, context);
+	}
+	/**
+	* Creates a keydown handler for a specific target.
+	*/
+	#createTargetKeyDownHandler(target) {
+		return (event) => {
+			this.#processTargetEvent(event, target, "keydown");
+		};
+	}
+	/**
+	* Creates a keyup handler for a specific target.
+	*/
+	#createTargetKeyUpHandler(target) {
+		return (event) => {
+			this.#processTargetEvent(event, target, "keyup");
+		};
+	}
+	/**
+	* Finds an existing registration with the same hotkey and target.
+	*/
+	#findConflictingRegistration(hotkey, target) {
+		for (const registration of this.registrations.state.values()) if (registration.hotkey === hotkey && registration.target === target) return registration;
+		return null;
+	}
+	/**
+	* Determines if a registration should be reset based on the keyup event.
+	*/
+	#shouldResetRegistration(registration, event) {
+		const parsed = registration.parsedHotkey;
+		const releasedKey = require_constants.normalizeKeyName(event.key);
+		const parsedKeyNormalized = parsed.key.length === 1 ? parsed.key.toUpperCase() : parsed.key;
+		if ((releasedKey.length === 1 ? releasedKey.toUpperCase() : releasedKey) === parsedKeyNormalized) return true;
+		if (parsed.ctrl && releasedKey === "Control") return true;
+		if (parsed.shift && releasedKey === "Shift") return true;
+		if (parsed.alt && releasedKey === "Alt") return true;
+		if (parsed.meta && releasedKey === "Meta") return true;
+		return false;
+	}
+	/**
+	* Triggers a registration's callback programmatically from devtools.
+	* Creates a synthetic KeyboardEvent and invokes the callback.
+	*
+	* @param id - The registration ID to trigger
+	* @returns True if the registration was found and triggered
+	*/
+	triggerRegistration(id) {
+		const registration = this.registrations.state.get(id);
+		if (!registration) return false;
+		const parsed = registration.parsedHotkey;
+		const syntheticEvent = new KeyboardEvent(registration.options.eventType ?? "keydown", {
+			key: parsed.key,
+			ctrlKey: parsed.ctrl,
+			shiftKey: parsed.shift,
+			altKey: parsed.alt,
+			metaKey: parsed.meta,
+			bubbles: true,
+			cancelable: true
+		});
+		registration.triggerCount++;
+		this.registrations.setState((prev) => new Map(prev));
+		registration.callback(syntheticEvent, {
+			hotkey: registration.hotkey,
+			parsedHotkey: registration.parsedHotkey
+		});
+		return true;
+	}
+	/**
+	* Gets the number of registered hotkeys.
+	*/
+	getRegistrationCount() {
+		return this.registrations.state.size;
+	}
+	/**
+	* Checks if a specific hotkey is registered.
+	*
+	* @param hotkey - The hotkey string to check
+	* @param target - Optional target element to match (if provided, both hotkey and target must match)
+	* @returns True if a matching registration exists
+	*/
+	isRegistered(hotkey, target) {
+		for (const registration of this.registrations.state.values()) if (registration.hotkey === hotkey) {
+			if (target === void 0 || registration.target === target) return true;
+		}
+		return false;
+	}
+	/**
+	* Destroys the manager and removes all listeners.
+	*/
+	destroy() {
+		for (const target of this.#targetListeners.keys()) this.#removeListenersForTarget(target);
+		this.registrations.setState(() => /* @__PURE__ */ new Map());
+		this.#targetListeners.clear();
+		this.#targetRegistrations.clear();
+	}
+};
+/**
+* Gets the singleton HotkeyManager instance.
+* Convenience function for accessing the manager.
+*/
+function getHotkeyManager() {
+	return HotkeyManager.getInstance();
+}
+//#endregion
+exports.getHotkeyManager = getHotkeyManager;