@vizejs/composable 0.426.3 → 0.427.0

package/dist/use-gamepad.d.mts

@@ -0,0 +1,242 @@
+import { FrameScheduler } from "./use-raf-fn.mjs";
+import { ComputedRef, MaybeRefOrGetter, Ref, ShallowRef } from "vue";
+
+//#region src/use-gamepad.d.ts
+/** Button indices of the W3C "standard" gamepad mapping. */
+declare const standardGamepadButtons: {
+  readonly faceBottom: 0;
+  readonly faceRight: 1;
+  readonly faceLeft: 2;
+  readonly faceTop: 3;
+  readonly leftBumper: 4;
+  readonly rightBumper: 5;
+  readonly leftTrigger: 6;
+  readonly rightTrigger: 7;
+  readonly select: 8;
+  readonly start: 9;
+  readonly leftStick: 10;
+  readonly rightStick: 11;
+  readonly dpadUp: 12;
+  readonly dpadDown: 13;
+  readonly dpadLeft: 14;
+  readonly dpadRight: 15;
+  readonly home: 16;
+};
+/** Axis indices of the W3C "standard" gamepad mapping. */
+declare const standardGamepadAxes: {
+  readonly leftStickX: 0;
+  readonly leftStickY: 1;
+  readonly rightStickX: 2;
+  readonly rightStickY: 3;
+};
+/** Minimal `GamepadButton` read by {@link useGamepad}. */
+interface GamepadButtonLike {
+  /** Whether the button is pressed. */
+  readonly pressed: boolean;
+  /** Whether the button is touched (defaults to `pressed` when absent). */
+  readonly touched?: boolean;
+  /** Analog value in `[0, 1]`. */
+  readonly value: number;
+}
+/** Minimal `GamepadHapticActuator` used for vibration. */
+interface GamepadVibrationActuatorLike {
+  /** Play a haptic effect. */
+  playEffect(type: string, params: GamepadVibrationParams): Promise<unknown>;
+}
+/** Minimal live `Gamepad` object read by {@link useGamepad}. */
+interface GamepadLike {
+  /** Device identifier string. */
+  readonly id: string;
+  /** Slot index in `navigator.getGamepads()`. */
+  readonly index: number;
+  /** Whether the pad is still connected. */
+  readonly connected: boolean;
+  /** Layout mapping (`"standard"` or `""`). */
+  readonly mapping: string;
+  /** Last update timestamp. */
+  readonly timestamp: number;
+  /** Button states. */
+  readonly buttons: ArrayLike<GamepadButtonLike>;
+  /** Axis values in `[-1, 1]`. */
+  readonly axes: ArrayLike<number>;
+  /** Haptic actuator, when the pad supports vibration. */
+  readonly vibrationActuator?: GamepadVibrationActuatorLike | null;
+}
+/** Window-like capability used by {@link useGamepad}. */
+interface GamepadHost {
+  /** Navigator exposing `getGamepads()`. */
+  readonly navigator: {
+    /** Read the current pads (live objects, `null` for empty slots). */getGamepads(): ArrayLike<GamepadLike | null>;
+  };
+  /** Subscribe to `gamepadconnected` / `gamepaddisconnected`. */
+  addEventListener(type: string, listener: () => void): void;
+  /** Unsubscribe from `gamepadconnected` / `gamepaddisconnected`. */
+  removeEventListener(type: string, listener: () => void): void;
+}
+/** Parameters of a `dual-rumble` vibration effect. */
+interface GamepadVibrationParams {
+  /** Effect duration in milliseconds. */
+  readonly duration: number;
+  /** Delay before the effect starts, in milliseconds. */
+  readonly startDelay?: number;
+  /** Low-frequency motor magnitude in `[0, 1]`. */
+  readonly strongMagnitude?: number;
+  /** High-frequency motor magnitude in `[0, 1]`. */
+  readonly weakMagnitude?: number;
+}
+/** Plain, copied state of one button. */
+interface GamepadButtonState {
+  /** Whether the button is pressed. */
+  readonly pressed: boolean;
+  /** Whether the button is touched. */
+  readonly touched: boolean;
+  /** Analog value in `[0, 1]`. */
+  readonly value: number;
+}
+/** Immutable copy of a pad taken at one poll; never a live `Gamepad`. */
+interface GamepadSnapshot {
+  /** Device identifier string. */
+  readonly id: string;
+  /** Slot index. */
+  readonly index: number;
+  /** Whether the pad was connected when copied. */
+  readonly connected: boolean;
+  /** Layout mapping (`"standard"` or `""`). */
+  readonly mapping: string;
+  /** Update timestamp of the copied state. */
+  readonly timestamp: number;
+  /** Copied button states. */
+  readonly buttons: readonly GamepadButtonState[];
+  /** Copied axis values. */
+  readonly axes: readonly number[];
+  /** Whether the pad exposes a vibration actuator. */
+  readonly vibration: boolean;
+}
+/** Binds a mapping key to a button; the mapped value is a {@link GamepadButtonState}. */
+interface GamepadButtonBinding {
+  /** Button index (see {@link standardGamepadButtons}). */
+  readonly button: number;
+}
+/** Binds a mapping key to an axis; the mapped value is a number. */
+interface GamepadAxisBinding {
+  /** Axis index (see {@link standardGamepadAxes}). */
+  readonly axis: number;
+  /** Values with a magnitude below this become `0`; the rest is rescaled to `[-1, 1]`. */
+  readonly deadzone?: number;
+  /** Negate the axis value. */
+  readonly invert?: boolean;
+}
+/** Named bindings from which a typed per-pad state is derived. */
+type GamepadMapping = Readonly<Record<string, GamepadButtonBinding | GamepadAxisBinding>>;
+/** Typed state produced by a {@link GamepadMapping}: axes map to numbers, buttons to states. */
+type MappedGamepad<Mapping extends GamepadMapping> = { readonly [Key in keyof Mapping]: Mapping[Key] extends {
+  readonly axis: number;
+} ? number : GamepadButtonState };
+/** One connected pad: its snapshot plus the mapped state. */
+interface ConnectedGamepad<Mapping extends GamepadMapping = Record<never, never>> extends GamepadSnapshot {
+  /** State derived from the `mapping` option. */
+  readonly mapped: MappedGamepad<Mapping>;
+}
+/** Options for {@link useGamepad}. */
+interface UseGamepadOptions<Mapping extends GamepadMapping = Record<never, never>> {
+  /**
+   * Window-like host providing `navigator.getGamepads()` and connection events.
+   *
+   * @default window when `navigator.getGamepads` exists
+   */
+  readonly host?: MaybeRefOrGetter<GamepadHost | null | undefined>;
+  /**
+   * Named bindings applied to every pad; the keys and value kinds type `mapped`.
+   *
+   * @default {}
+   */
+  readonly mapping?: Mapping;
+  /**
+   * Frame host driving the polling loop.
+   *
+   * @default globalThis animation-frame functions
+   */
+  readonly scheduler?: FrameScheduler;
+  /**
+   * Start polling immediately.
+   *
+   * @default true
+   */
+  readonly immediate?: boolean;
+}
+/** Reactive state and actions returned by {@link useGamepad}. */
+interface GamepadControls<Mapping extends GamepadMapping = Record<never, never>> {
+  /** Whether the Gamepad API is available. */
+  readonly supported: ComputedRef<boolean>;
+  /** Connected pads, copied on every poll that saw a change. */
+  readonly gamepads: Readonly<ShallowRef<readonly ConnectedGamepad<Mapping>[]>>;
+  /** Whether polling is running. */
+  readonly isActive: Readonly<Ref<boolean>>;
+  /** Most recent vibration failure. */
+  readonly error: Readonly<ShallowRef<unknown>>;
+  /** Stop polling. Idempotent. */
+  readonly pause: () => void;
+  /** Resume polling. Idempotent. */
+  readonly resume: () => void;
+  /** Read the pads once, outside the frame loop. */
+  readonly refresh: () => void;
+  /**
+   * Play a vibration effect on the pad at `index`.
+   *
+   * @returns Whether the effect played; failures land in `error`.
+   */
+  readonly vibrate: (index: number, params: GamepadVibrationParams, type?: string) => Promise<boolean>;
+}
+/**
+ * Copy a live pad into an immutable {@link GamepadSnapshot}.
+ *
+ * @param pad Live `Gamepad` (or compatible) object.
+ * @returns The copied state.
+ */
+declare function snapshotGamepad(pad: GamepadLike): GamepadSnapshot;
+/**
+ * Derive typed named state from a snapshot. Missing buttons read as released
+ * and missing axes as `0`; axis dead zones are applied and rescaled.
+ *
+ * @example
+ * ```ts
+ * const state = mapGamepad(pad, { jump: { button: 0 }, moveX: { axis: 0, deadzone: 0.1 } });
+ * state.jump.pressed; state.moveX; // boolean, number
+ * ```
+ *
+ * @param snapshot Copied pad state.
+ * @param mapping Named button and axis bindings.
+ * @throws `RangeError` tagged `VIZE_COMPOSE_GAMEPAD_INVALID_MAPPING` for a
+ * negative or fractional index or a dead zone outside `[0, 1)`.
+ * @returns State keyed like `mapping`.
+ */
+declare function mapGamepad<const Mapping extends GamepadMapping>(snapshot: Pick<GamepadSnapshot, "buttons" | "axes">, mapping: Mapping): MappedGamepad<Mapping>;
+/**
+ * Track connected gamepads as immutable snapshots, polled on animation
+ * frames, with optional typed named bindings.
+ *
+ * Pads are re-read every frame while active and on `gamepadconnected` /
+ * `gamepaddisconnected`; `gamepads` is replaced only when a pad's timestamp
+ * or connection changed. Entries are plain copies, so they are safe to keep
+ * or serialize. The frame loop and listeners stop with the owning reactive
+ * scope; outside a scope call `pause()`.
+ *
+ * Server rendering: no frames or listeners, `supported` is false and
+ * `gamepads` is empty.
+ * Inside a component the host is resolved after mounting, so hydration
+ * renders this server state first.
+ *
+ * @example
+ * ```ts
+ * const { gamepads } = useGamepad({ mapping: { jump: { button: 0 }, moveX: { axis: 0, deadzone: 0.1 } } });
+ * const player = computed(() => gamepads.value[0]?.mapped);
+ * ```
+ *
+ * @param options Host, mapping, and scheduler.
+ * @default options {}
+ * @throws `RangeError` tagged `VIZE_COMPOSE_GAMEPAD_INVALID_MAPPING` for an invalid mapping.
+ * @returns Pad state and polling controls.
+ */
+declare function useGamepad<const Mapping extends GamepadMapping = Record<never, never>>(options?: UseGamepadOptions<Mapping>): GamepadControls<Mapping>;
+//#endregion
+export { ConnectedGamepad, GamepadAxisBinding, GamepadButtonBinding, GamepadButtonLike, GamepadButtonState, GamepadControls, GamepadHost, GamepadLike, GamepadMapping, GamepadSnapshot, GamepadVibrationActuatorLike, GamepadVibrationParams, MappedGamepad, UseGamepadOptions, mapGamepad, snapshotGamepad, standardGamepadAxes, standardGamepadButtons, useGamepad };

package/dist/use-gamepad.mjs

@@ -0,0 +1,218 @@
+import { tryOnScopeDispose } from "./scope.mjs";
+import { useRafFn } from "./use-raf-fn.mjs";
+import { computed, hasInjectionContext, readonly, shallowReadonly, shallowRef, toValue, watch, watchPostEffect } from "vue";
+//#region src/use-gamepad.ts
+/** Button indices of the W3C "standard" gamepad mapping. */
+const standardGamepadButtons = {
+	faceBottom: 0,
+	faceRight: 1,
+	faceLeft: 2,
+	faceTop: 3,
+	leftBumper: 4,
+	rightBumper: 5,
+	leftTrigger: 6,
+	rightTrigger: 7,
+	select: 8,
+	start: 9,
+	leftStick: 10,
+	rightStick: 11,
+	dpadUp: 12,
+	dpadDown: 13,
+	dpadLeft: 14,
+	dpadRight: 15,
+	home: 16
+};
+/** Axis indices of the W3C "standard" gamepad mapping. */
+const standardGamepadAxes = {
+	leftStickX: 0,
+	leftStickY: 1,
+	rightStickX: 2,
+	rightStickY: 3
+};
+function browserGamepadHost() {
+	if (typeof window === "undefined") return void 0;
+	return typeof window.navigator.getGamepads === "function" ? window : void 0;
+}
+function invalidMapping(message) {
+	return /* @__PURE__ */ new RangeError(`[VIZE_COMPOSE_GAMEPAD_INVALID_MAPPING] ${message}`);
+}
+function isAxisBinding(binding) {
+	return "axis" in binding;
+}
+function checkIndex(index, key) {
+	if (!Number.isInteger(index) || index < 0) throw invalidMapping(`"${key}" index must be a non-negative integer; received ${index}`);
+}
+/**
+* Copy a live pad into an immutable {@link GamepadSnapshot}.
+*
+* @param pad Live `Gamepad` (or compatible) object.
+* @returns The copied state.
+*/
+function snapshotGamepad(pad) {
+	return {
+		id: pad.id,
+		index: pad.index,
+		connected: pad.connected,
+		mapping: pad.mapping,
+		timestamp: pad.timestamp,
+		buttons: Array.from(pad.buttons, (button) => ({
+			pressed: button.pressed,
+			touched: button.touched ?? button.pressed,
+			value: button.value
+		})),
+		axes: Array.from(pad.axes),
+		vibration: pad.vibrationActuator != null
+	};
+}
+/**
+* Derive typed named state from a snapshot. Missing buttons read as released
+* and missing axes as `0`; axis dead zones are applied and rescaled.
+*
+* @example
+* ```ts
+* const state = mapGamepad(pad, { jump: { button: 0 }, moveX: { axis: 0, deadzone: 0.1 } });
+* state.jump.pressed; state.moveX; // boolean, number
+* ```
+*
+* @param snapshot Copied pad state.
+* @param mapping Named button and axis bindings.
+* @throws `RangeError` tagged `VIZE_COMPOSE_GAMEPAD_INVALID_MAPPING` for a
+* negative or fractional index or a dead zone outside `[0, 1)`.
+* @returns State keyed like `mapping`.
+*/
+function mapGamepad(snapshot, mapping) {
+	const result = {};
+	for (const [key, binding] of Object.entries(mapping)) if (isAxisBinding(binding)) {
+		checkIndex(binding.axis, key);
+		const deadzone = binding.deadzone ?? 0;
+		if (!(deadzone >= 0 && deadzone < 1)) throw invalidMapping(`"${key}" deadzone must be in [0, 1); received ${deadzone}`);
+		const raw = snapshot.axes[binding.axis] ?? 0;
+		const magnitude = Math.abs(raw);
+		const value = magnitude < deadzone ? 0 : Math.sign(raw) * (magnitude - deadzone) / (1 - deadzone);
+		result[key] = binding.invert ?? false ? 0 - value : value;
+	} else {
+		checkIndex(binding.button, key);
+		result[key] = snapshot.buttons[binding.button] ?? {
+			pressed: false,
+			touched: false,
+			value: 0
+		};
+	}
+	return result;
+}
+/**
+* Track connected gamepads as immutable snapshots, polled on animation
+* frames, with optional typed named bindings.
+*
+* Pads are re-read every frame while active and on `gamepadconnected` /
+* `gamepaddisconnected`; `gamepads` is replaced only when a pad's timestamp
+* or connection changed. Entries are plain copies, so they are safe to keep
+* or serialize. The frame loop and listeners stop with the owning reactive
+* scope; outside a scope call `pause()`.
+*
+* Server rendering: no frames or listeners, `supported` is false and
+* `gamepads` is empty.
+* Inside a component the host is resolved after mounting, so hydration
+* renders this server state first.
+*
+* @example
+* ```ts
+* const { gamepads } = useGamepad({ mapping: { jump: { button: 0 }, moveX: { axis: 0, deadzone: 0.1 } } });
+* const player = computed(() => gamepads.value[0]?.mapped);
+* ```
+*
+* @param options Host, mapping, and scheduler.
+* @default options {}
+* @throws `RangeError` tagged `VIZE_COMPOSE_GAMEPAD_INVALID_MAPPING` for an invalid mapping.
+* @returns Pad state and polling controls.
+*/
+function useGamepad(options = {}) {
+	const gamepads = shallowRef([]);
+	const error = shallowRef(void 0);
+	const mapping = options.mapping;
+	if (mapping !== void 0) mapGamepad({
+		buttons: [],
+		axes: []
+	}, mapping);
+	const hydrated = shallowRef(!hasInjectionContext());
+	if (!hydrated.value) watchPostEffect(() => {
+		hydrated.value = true;
+	});
+	const resolveHost = () => {
+		if (!hydrated.value) return void 0;
+		return options.host === void 0 ? browserGamepadHost() : toValue(options.host) ?? void 0;
+	};
+	const readPads = (host) => Array.from(host.navigator.getGamepads()).filter((pad) => pad !== null && pad.connected);
+	const refresh = () => {
+		const host = resolveHost();
+		const pads = host ? readPads(host) : [];
+		const previous = gamepads.value;
+		if (pads.length === previous.length && pads.every((pad, position) => previous[position]?.index === pad.index && previous[position]?.id === pad.id && previous[position]?.timestamp === pad.timestamp)) return;
+		gamepads.value = pads.map((pad) => {
+			const snapshot = snapshotGamepad(pad);
+			const mapped = mapGamepad(snapshot, mapping ?? {});
+			return {
+				...snapshot,
+				mapped
+			};
+		});
+	};
+	const loop = useRafFn(refresh, {
+		immediate: false,
+		runOnServer: true,
+		...options.scheduler === void 0 ? {} : { scheduler: options.scheduler }
+	});
+	const wanted = shallowRef(options.immediate ?? true);
+	const resume = () => {
+		wanted.value = true;
+		if (resolveHost()) loop.resume();
+	};
+	const pause = () => {
+		wanted.value = false;
+		loop.pause();
+	};
+	watch(resolveHost, (host, _previous, onCleanup) => {
+		if (!host) {
+			loop.pause();
+			gamepads.value = [];
+			return;
+		}
+		host.addEventListener("gamepadconnected", refresh);
+		host.addEventListener("gamepaddisconnected", refresh);
+		onCleanup(() => {
+			host.removeEventListener("gamepadconnected", refresh);
+			host.removeEventListener("gamepaddisconnected", refresh);
+		});
+		refresh();
+		if (wanted.value) loop.resume();
+	}, {
+		immediate: true,
+		flush: "sync"
+	});
+	const vibrate = async (index, params, type = "dual-rumble") => {
+		const host = resolveHost();
+		const actuator = host ? readPads(host).find((pad) => pad.index === index)?.vibrationActuator : void 0;
+		if (!actuator) return false;
+		try {
+			await actuator.playEffect(type, params);
+			error.value = void 0;
+			return true;
+		} catch (cause) {
+			error.value = cause;
+			return false;
+		}
+	};
+	tryOnScopeDispose(pause);
+	return {
+		supported: computed(() => resolveHost() !== void 0),
+		gamepads: shallowReadonly(gamepads),
+		isActive: loop.isActive,
+		error: readonly(error),
+		pause,
+		resume,
+		refresh,
+		vibrate
+	};
+}
+//#endregion
+export { mapGamepad, snapshotGamepad, standardGamepadAxes, standardGamepadButtons, useGamepad };

package/dist/use-hid.d.mts

@@ -0,0 +1,160 @@
+import { ComputedRef, MaybeRefOrGetter, ShallowRef } from "vue";
+
+//#region src/use-hid.d.ts
+/** Device filter for `requestDevice`. */
+interface HIDDeviceFilter {
+  /** USB vendor id. */
+  readonly vendorId?: number;
+  /** USB product id. */
+  readonly productId?: number;
+  /** HID usage page. */
+  readonly usagePage?: number;
+  /** HID usage. */
+  readonly usage?: number;
+}
+/** Minimal `HIDDevice` used by {@link useHID}. */
+interface HIDDeviceLike extends EventTarget {
+  /** Whether the device is open. */
+  readonly opened: boolean;
+  /** USB vendor id. */
+  readonly vendorId: number;
+  /** USB product id. */
+  readonly productId: number;
+  /** Product name. */
+  readonly productName: string;
+  /** Open the device. */
+  open(): Promise<void>;
+  /** Close the device. */
+  close(): Promise<void>;
+  /** Send an output report. */
+  sendReport(reportId: number, data: BufferSource): Promise<void>;
+  /** Send a feature report. */
+  sendFeatureReport(reportId: number, data: BufferSource): Promise<void>;
+  /** Read a feature report. */
+  receiveFeatureReport(reportId: number): Promise<DataView>;
+}
+/** `navigator.hid`-like capability used by {@link useHID}. */
+interface HIDHost extends EventTarget {
+  /** Devices the page already has access to. */
+  getDevices(): Promise<HIDDeviceLike[]>;
+  /** Prompt the user for devices. */
+  requestDevice(options: {
+    readonly filters: HIDDeviceFilter[];
+  }): Promise<HIDDeviceLike[]>;
+}
+/** Plain, reactive-friendly description of a granted device. */
+interface HIDDeviceInfo {
+  /** The live device, for passing back to the actions. */
+  readonly device: HIDDeviceLike;
+  /** USB vendor id. */
+  readonly vendorId: number;
+  /** USB product id. */
+  readonly productId: number;
+  /** Product name. */
+  readonly productName: string;
+  /** Whether the device was open when the list was refreshed. */
+  readonly opened: boolean;
+}
+/** An input report received from an open device. */
+interface HIDInputReport {
+  /** Device that sent the report. */
+  readonly device: HIDDeviceLike;
+  /** Report id (`0` when the device does not use report ids). */
+  readonly reportId: number;
+  /** Report payload. */
+  readonly data: DataView;
+}
+/** Options for {@link useHID}. */
+interface UseHIDOptions {
+  /**
+   * `navigator.hid`-like capability.
+   *
+   * @default window.navigator.hid when it exists
+   */
+  readonly host?: MaybeRefOrGetter<HIDHost | null | undefined>;
+  /**
+   * Receives input reports from every device opened through {@link HIDControls.open}.
+   *
+   * @default undefined
+   */
+  readonly onInputReport?: (report: HIDInputReport) => void;
+}
+/** Reactive state and actions returned by {@link useHID}. */
+interface HIDControls {
+  /** Whether WebHID is available. */
+  readonly supported: ComputedRef<boolean>;
+  /** Granted devices, refreshed on `connect` / `disconnect`, open and close. */
+  readonly devices: Readonly<ShallowRef<readonly HIDDeviceInfo[]>>;
+  /** Most recent failure. */
+  readonly error: Readonly<ShallowRef<unknown>>;
+  /**
+   * Prompt the user for devices (requires user activation).
+   *
+   * @returns The chosen devices (empty when cancelled or failed).
+   */
+  readonly requestDevice: (filters?: HIDDeviceFilter[]) => Promise<readonly HIDDeviceLike[]>;
+  /**
+   * Refresh `devices`.
+   *
+   * @returns The granted devices.
+   */
+  readonly getDevices: () => Promise<readonly HIDDeviceInfo[]>;
+  /**
+   * Open a device and start forwarding its input reports.
+   *
+   * @returns Whether the device is open.
+   */
+  readonly open: (device: HIDDeviceLike) => Promise<boolean>;
+  /**
+   * Stop forwarding reports and close a device.
+   *
+   * @returns Whether the device closed.
+   */
+  readonly close: (device: HIDDeviceLike) => Promise<boolean>;
+  /**
+   * Send an output report.
+   *
+   * @returns Whether the report was sent.
+   */
+  readonly sendReport: (device: HIDDeviceLike, reportId: number, data: BufferSource) => Promise<boolean>;
+  /**
+   * Send a feature report.
+   *
+   * @returns Whether the report was sent.
+   */
+  readonly sendFeatureReport: (device: HIDDeviceLike, reportId: number, data: BufferSource) => Promise<boolean>;
+  /**
+   * Read a feature report.
+   *
+   * @returns The report, or `undefined` on failure.
+   */
+  readonly receiveFeatureReport: (device: HIDDeviceLike, reportId: number) => Promise<DataView | undefined>;
+}
+/**
+ * Talk to human-interface devices with the WebHID API.
+ *
+ * `devices` lists granted devices as plain snapshots and follows the host's
+ * `connect` / `disconnect` events. Devices opened through `open()` forward
+ * `inputreport` events to `onInputReport`. Every action resolves to a
+ * boolean or value and records failures in `error`. Report listeners are
+ * removed and opened devices closed when the owning reactive scope stops;
+ * outside a scope call `close()` per device.
+ *
+ * Server rendering: `supported` is false and `devices` is empty.
+ * Inside a component the host is resolved after mounting, so hydration
+ * renders this server state first.
+ *
+ * @example
+ * ```ts
+ * const hid = useHID({ onInputReport: ({ reportId, data }) => read(reportId, data) });
+ * const [device] = await hid.requestDevice([{ vendorId: 0x054c }]);
+ * if (device) await hid.open(device);
+ * ```
+ *
+ * @param options Host and input report callback.
+ * @default options {}
+ * @returns HID state and actions.
+ */
+declare function useHID(options?: UseHIDOptions): HIDControls;
+//#endregion
+export { HIDControls, HIDDeviceFilter, HIDDeviceInfo, HIDDeviceLike, HIDHost, HIDInputReport, UseHIDOptions, useHID };