dualsense-ts 2.2.48 → 3.0.0

package/src/comparators.ts

@@ -0,0 +1,26 @@
+/**
+ * Input state change checker that always returns true.
+ */
+export function VirtualComparator(): boolean {
+  return true;
+}
+
+/**
+ * Input state change checker that considers a numeric threshold.
+ */
+export function ThresholdComparator(
+  threshold: number,
+  state: unknown,
+  newState: unknown
+): boolean {
+  if (typeof state !== "number" || typeof newState !== "number")
+    throw new Error("Bad threshold comparison");
+  return Math.abs(state - newState) > threshold;
+}
+
+/**
+ * Input state change checker for most values.
+ */
+export function BasicComparator(state: unknown, newState: unknown): boolean {
+  return state !== newState;
+}

package/src/dualsense.ts

@@ -8,12 +8,19 @@ import {
   Touchpad,
 } from "./elements";
 import { Input, InputSet, InputParams } from "./input";
-import { DualsenseHID, InputId } from "./hid";
+import {
+  DualsenseHIDState,
+  DualsenseHID,
+  PlatformHIDProvider,
+  InputId,
+} from "./hid";
 
 export interface DualsenseParams extends InputParams {
+  /**
+   * Sets the source of HID events for the controller interface.
+   */
   hid?: DualsenseHID | null;
 
-  // Input param overrides
   ps?: InputParams;
   mute?: InputParams;
   options?: InputParams;
@@ -28,6 +35,9 @@ export interface DualsenseParams extends InputParams {
   touchpad?: InputParams;
 }
 
+/**
+ * Represents a Dualsense controller.
+ */
 export class Dualsense extends Input<Dualsense> {
   public readonly state: Dualsense = this;
 
@@ -49,12 +59,11 @@ export class Dualsense extends Input<Dualsense> {
 
   public readonly touchpad: Touchpad;
 
-  public readonly hid: DualsenseHID | null = null;
+  public readonly hid: DualsenseHID;
 
   public get active(): boolean {
     return Object.values(this).some(
-      (input: unknown) =>
-        input instanceof Input && input !== this && input.active
+      (input) => input !== this && input instanceof Input && input.active
     );
   }
 
@@ -122,61 +131,55 @@ export class Dualsense extends Input<Dualsense> {
       ...(params.touchpad || {}),
     });
 
-    const { hid } = params;
-    if (hid !== null) this.hid = hid ? hid : new DualsenseHID();
+    this.hid = params.hid || new DualsenseHID(new PlatformHIDProvider());
+    this.hid.register((state: DualsenseHIDState) => {
+      this.processHID(state);
+    });
 
-    if (this.hid) {
-      this.hid.on("input", () => {
-        this.processHID();
-      });
-    }
+    if (params.hid !== null) this.hid.provider.connect();
   }
 
-  private processHID() {
-    if (!this.hid) return;
-    this.ps[InputSet](this.hid.state[InputId.Playstation]);
-    this.options[InputSet](this.hid.state[InputId.Options]);
-    this.create[InputSet](this.hid.state[InputId.Create]);
-
-    this.mute[InputSet](this.hid.state[InputId.Mute]);
-    this.mute.status[InputSet](this.hid.state[InputId.Status]);
-
-    this.triangle[InputSet](this.hid.state[InputId.Triangle]);
-    this.circle[InputSet](this.hid.state[InputId.Circle]);
-    this.cross[InputSet](this.hid.state[InputId.Cross]);
-    this.square[InputSet](this.hid.state[InputId.Square]);
-
-    this.dpad.up[InputSet](this.hid.state[InputId.Up]);
-    this.dpad.down[InputSet](this.hid.state[InputId.Down]);
-    this.dpad.right[InputSet](this.hid.state[InputId.Right]);
-    this.dpad.left[InputSet](this.hid.state[InputId.Left]);
-
-    this.touchpad.button[InputSet](this.hid.state[InputId.TouchButton]);
-    this.touchpad.left.x[InputSet](this.hid.state[InputId.TouchX0]);
-    this.touchpad.left.y[InputSet](this.hid.state[InputId.TouchY0]);
-    this.touchpad.left.contact[InputSet](this.hid.state[InputId.TouchContact0]);
-    this.touchpad.left.tracker[InputSet](this.hid.state[InputId.TouchId0]);
-    this.touchpad.right.x[InputSet](this.hid.state[InputId.TouchX1]);
-    this.touchpad.right.y[InputSet](this.hid.state[InputId.TouchY1]);
-    this.touchpad.right.contact[InputSet](
-      this.hid.state[InputId.TouchContact1]
-    );
-    this.touchpad.right.tracker[InputSet](this.hid.state[InputId.TouchId1]);
-
-    this.left.analog.x[InputSet](this.hid.state[InputId.LeftAnalogX]);
-    this.left.analog.y[InputSet](this.hid.state[InputId.LeftAnalogY]);
-    this.left.bumper[InputSet](this.hid.state[InputId.LeftBumper]);
-    this.left.trigger[InputSet](this.hid.state[InputId.LeftTrigger]);
-    this.left.trigger.button[InputSet](
-      this.hid.state[InputId.LeftTriggerButton]
-    );
-
-    this.right.analog.x[InputSet](this.hid.state[InputId.RightAnalogX]);
-    this.right.analog.y[InputSet](this.hid.state[InputId.RightAnalogY]);
-    this.right.bumper[InputSet](this.hid.state[InputId.RightBumper]);
-    this.right.trigger[InputSet](this.hid.state[InputId.RightTrigger]);
-    this.right.trigger.button[InputSet](
-      this.hid.state[InputId.RightTriggerButton]
-    );
+  /**
+   * Distributes input values to various elements.
+   */
+  private processHID(state: DualsenseHIDState): void {
+    this.ps[InputSet](state[InputId.Playstation]);
+    this.options[InputSet](state[InputId.Options]);
+    this.create[InputSet](state[InputId.Create]);
+
+    this.mute[InputSet](state[InputId.Mute]);
+    this.mute.status[InputSet](state[InputId.Status]);
+
+    this.triangle[InputSet](state[InputId.Triangle]);
+    this.circle[InputSet](state[InputId.Circle]);
+    this.cross[InputSet](state[InputId.Cross]);
+    this.square[InputSet](state[InputId.Square]);
+
+    this.dpad.up[InputSet](state[InputId.Up]);
+    this.dpad.down[InputSet](state[InputId.Down]);
+    this.dpad.right[InputSet](state[InputId.Right]);
+    this.dpad.left[InputSet](state[InputId.Left]);
+
+    this.touchpad.button[InputSet](state[InputId.TouchButton]);
+    this.touchpad.left.x[InputSet](state[InputId.TouchX0]);
+    this.touchpad.left.y[InputSet](state[InputId.TouchY0]);
+    this.touchpad.left.contact[InputSet](state[InputId.TouchContact0]);
+    this.touchpad.left.tracker[InputSet](state[InputId.TouchId0]);
+    this.touchpad.right.x[InputSet](state[InputId.TouchX1]);
+    this.touchpad.right.y[InputSet](state[InputId.TouchY1]);
+    this.touchpad.right.contact[InputSet](state[InputId.TouchContact1]);
+    this.touchpad.right.tracker[InputSet](state[InputId.TouchId1]);
+
+    this.left.analog.x[InputSet](state[InputId.LeftAnalogX]);
+    this.left.analog.y[InputSet](state[InputId.LeftAnalogY]);
+    this.left.bumper[InputSet](state[InputId.LeftBumper]);
+    this.left.trigger[InputSet](state[InputId.LeftTrigger]);
+    this.left.trigger.button[InputSet](state[InputId.LeftTriggerButton]);
+
+    this.right.analog.x[InputSet](state[InputId.RightAnalogX]);
+    this.right.analog.y[InputSet](state[InputId.RightAnalogY]);
+    this.right.bumper[InputSet](state[InputId.RightBumper]);
+    this.right.trigger[InputSet](state[InputId.RightTrigger]);
+    this.right.trigger.button[InputSet](state[InputId.RightTriggerButton]);
   }
 }

package/src/elements/analog.ts

@@ -22,7 +22,7 @@ export interface AnalogParams extends InputParams {
  * - Pushed all the way down and to the left, the stick's coordinates are [-1, -1]
  */
 export class Analog extends Input<Analog> {
-  public readonly state: Analog = this;
+  public readonly state: this = this;
 
   /**
    * The left/right position of the input.
@@ -41,13 +41,19 @@ export class Analog extends Input<Analog> {
     super(params);
     const { button, x, y, threshold } = params || {};
 
-    this.button = new Momentary(button || { icon: "3", name: "Button" });
-    this.x = new Axis(
-      x || { icon: "↔", name: "X", threshold: threshold || 0.07 }
-    );
-    this.y = new Axis(
-      y || { icon: "↕", name: "Y", threshold: threshold || 0.07 }
-    );
+    this.button = new Momentary({ icon: "3", name: "Button", ...button });
+    this.x = new Axis({
+      icon: "↔",
+      name: "X",
+      threshold: threshold || 0.01,
+      ...x,
+    });
+    this.y = new Axis({
+      icon: "↕",
+      name: "Y",
+      threshold: threshold || 0.01,
+      ...y,
+    });
   }
 
   /**

package/src/elements/dpad.ts

@@ -9,20 +9,21 @@ export interface DpadParams extends InputParams {
 }
 
 export class Dpad extends Input<Dpad> {
-  public readonly state: Dpad = this;
+  public readonly state: this = this;
 
   public readonly up: Momentary;
   public readonly down: Momentary;
   public readonly left: Momentary;
   public readonly right: Momentary;
 
-  constructor(params?: DpadParams) {
+  constructor(params: DpadParams = {}) {
     super(params);
+    const { up, down, left, right } = params
 
-    this.up = new Momentary(params?.up || { icon: "⮉", name: "Up" });
-    this.down = new Momentary(params?.down || { icon: "⮋", name: "Down" });
-    this.left = new Momentary(params?.left || { icon: "⮈", name: "Left" });
-    this.right = new Momentary(params?.right || { icon: "⮊", name: "Right" });
+    this.up = new Momentary(params?.up || { icon: "⮉", name: "Up", ...up});
+    this.down = new Momentary(params?.down || { icon: "⮋", name: "Down", ...down});
+    this.left = new Momentary(params?.left || { icon: "⮈", name: "Left", ...left });
+    this.right = new Momentary(params?.right || { icon: "⮊", name: "Right", ...right });
   }
 
   public get active(): boolean {

package/src/elements/touch.ts

@@ -6,7 +6,7 @@ import { Increment } from "./increment";
  * with [0,0] representing the center of the touchpad.
  */
 export class Touch extends Analog {
-  public readonly state: Touch = this;
+  public readonly state: this = this;
   public readonly contact = this.button;
   public readonly tracker: Increment = new Increment();
 

package/src/elements/touchpad.ts

@@ -3,7 +3,7 @@ import { Touch } from "./touch";
 import { Input, InputParams } from "../input";
 
 export class Touchpad extends Input<Touchpad> {
-  public readonly state: Touchpad = this;
+  public readonly state: this = this;
 
   public get active(): boolean {
     return this.left.contact.active;

package/src/elements/trigger.ts

@@ -6,7 +6,7 @@ import { Momentary } from "./momentary";
 export class Trigger extends Input<Magnitude> {
   public state: Magnitude = 0;
 
-  public button: Momentary = new Momentary({});
+  public button: Momentary = new Momentary();
 
   public get active(): boolean {
     return this.state > 0;

package/src/elements/unisense.ts

@@ -12,29 +12,30 @@ export interface UnisenseParams extends InputParams {
 
 // The name "Dualsense" clearly implies a composition of two Unisense elements 🤔
 export class Unisense extends Input<Unisense> {
-  public readonly state: Unisense = this;
+  public readonly state: this = this;
 
   public readonly trigger: Trigger;
   public readonly bumper: Momentary;
   public readonly analog: Analog;
   public readonly haptic: Haptic;
 
-  constructor(params?: UnisenseParams) {
+  constructor(params: UnisenseParams = {}) {
     super(params);
+    const { trigger, bumper, analog } = params;
 
-    this.trigger = new Trigger(
-      params?.trigger || {
-        icon: "2",
-        name: "Trigger",
-        threshold: (1 / 255) * 3,
-      }
-    );
-    this.bumper = new Momentary(
-      params?.bumper || { icon: "1", name: "Bumper" }
-    );
-    this.analog = new Analog(
-      params?.analog || { icon: "⨁", name: "Analog", threshold: 0.07 }
-    );
+    this.trigger = new Trigger({
+      icon: "2",
+      name: "Trigger",
+      threshold: 1 / 255,
+      ...trigger,
+    });
+    this.bumper = new Momentary({ icon: "1", name: "Bumper", ...bumper });
+    this.analog = new Analog({
+      icon: "⨁",
+      name: "Analog",
+      threshold: 1 / 128,
+      ...analog,
+    });
     this.haptic = new Haptic();
   }
 

package/src/hid/dualsense_hid.ts

@@ -1,63 +1,13 @@
-import { HID, devices } from "node-hid";
-import { EventEmitter } from "events";
+import { HIDProvider, DualsenseHIDState, InputId } from "./hid_provider";
 
-import { InputId } from "./ids";
+export type HIDCallback = (state: DualsenseHIDState) => void;
 
-export interface DualsenseHIDState {
-  [InputId.LeftAnalogX]: number;
-  [InputId.LeftAnalogY]: number;
-  [InputId.RightAnalogX]: number;
-  [InputId.RightAnalogY]: number;
-  [InputId.LeftTrigger]: number;
-  [InputId.RightTrigger]: number;
-  [InputId.Triangle]: boolean;
-  [InputId.Circle]: boolean;
-  [InputId.Cross]: boolean;
-  [InputId.Square]: boolean;
-  [InputId.Dpad]: number;
-  [InputId.Up]: boolean;
-  [InputId.Down]: boolean;
-  [InputId.Left]: boolean;
-  [InputId.Right]: boolean;
-  [InputId.RightAnalogButton]: boolean;
-  [InputId.LeftAnalogButton]: boolean;
-  [InputId.Options]: boolean;
-  [InputId.Create]: boolean;
-  [InputId.RightTriggerButton]: boolean;
-  [InputId.LeftTriggerButton]: boolean;
-  [InputId.RightBumper]: boolean;
-  [InputId.LeftBumper]: boolean;
-  [InputId.Playstation]: boolean;
-  [InputId.TouchButton]: boolean;
-  [InputId.Mute]: boolean;
-  [InputId.Status]: boolean;
-  [InputId.TouchX0]: number;
-  [InputId.TouchY0]: number;
-  [InputId.TouchContact0]: boolean;
-  [InputId.TouchId0]: number;
-  [InputId.TouchX1]: number;
-  [InputId.TouchY1]: number;
-  [InputId.TouchContact1]: boolean;
-  [InputId.TouchId1]: number;
-  [InputId.GyroX]: number;
-  [InputId.GyroY]: number;
-  [InputId.GyroZ]: number;
-  [InputId.AccelX]: number;
-  [InputId.AccelY]: number;
-  [InputId.AccelZ]: number;
-}
-
-// Maps a HID input of 0...n to -1...1
-export function mapAxis(value: number, max: number = 255): number {
-  return (2 / max) * Math.max(0, Math.min(max, value)) - 1;
-}
-
-// Maps a HID input of 0...255 to 0...1
-export function mapTrigger(value: number): number {
-  return (1 / 255) * Math.max(0, Math.min(255, value));
-}
+/**
+ * Coordinates a HIDProvider and tracks the latest HID state.
+ */
+export class DualsenseHID {
+  private readonly subscribers = new Set<HIDCallback>();
 
-export class DualsenseHID extends EventEmitter {
   public state: DualsenseHIDState = {
     [InputId.LeftAnalogX]: 0,
     [InputId.LeftAnalogY]: 0,
@@ -102,116 +52,35 @@ export class DualsenseHID extends EventEmitter {
     [InputId.AccelZ]: 0,
   };
 
-  private device: HID;
-  private wireless: boolean = false;
-
-  static readonly vendorId: number = 1356;
-  static readonly productId: number = 3302;
-
-  constructor() {
-    super();
-    this.device = this.connect();
+  constructor(readonly provider: HIDProvider) {
+    provider.onData = this.set.bind(this);
+    provider.onError = this.handleError.bind(this);
   }
 
   /**
-   * Unpacks a Dualsense HID report.
+   * Register a handler for HID state updates.
    */
-  private process(buffer: Buffer): void {
-    // Bluetooth buffer starts with an extra byte
-    const report = buffer.subarray(this.wireless ? 2 : 1);
+  public register(callback: (state: DualsenseHIDState) => void): void {
+    this.subscribers.add(callback);
+  }
 
-    const { state } = this;
-    state[InputId.LeftAnalogX] = mapAxis(report.readUint8(0));
-    state[InputId.LeftAnalogY] = -mapAxis(report.readUint8(1));
-    state[InputId.RightAnalogX] = mapAxis(report.readUint8(2));
-    state[InputId.RightAnalogY] = -mapAxis(report.readUint8(3));
-    state[InputId.LeftTrigger] = mapTrigger(report.readUint8(4));
-    state[InputId.RightTrigger] = mapTrigger(report.readUint8(5));
-    // 6 is a sequence byte
-    const mainButtons = report.readUint8(7);
-    state[InputId.Triangle] = (mainButtons & 128) > 0;
-    state[InputId.Circle] = (mainButtons & 64) > 0;
-    state[InputId.Cross] = (mainButtons & 32) > 0;
-    state[InputId.Square] = (mainButtons & 16) > 0;
-    state[InputId.Dpad] = (mainButtons << 4) >> 4;
-    state[InputId.Up] = state[InputId.Dpad] < 2 || state[InputId.Dpad] === 7;
-    state[InputId.Down] = state[InputId.Dpad] > 2 && state[InputId.Dpad] < 6;
-    state[InputId.Left] = state[InputId.Dpad] > 4 && state[InputId.Dpad] < 8;
-    state[InputId.Right] = state[InputId.Dpad] > 0 && state[InputId.Dpad] < 4;
-    const miscButtons = report.readUint8(8);
-    state[InputId.LeftTriggerButton] = (miscButtons & 4) > 0;
-    state[InputId.RightTriggerButton] = (miscButtons & 8) > 0;
-    state[InputId.LeftBumper] = (miscButtons & 1) > 0;
-    state[InputId.RightBumper] = (miscButtons & 2) > 0;
-    state[InputId.Create] = (miscButtons & 16) > 0;
-    state[InputId.Options] = (miscButtons & 32) > 0;
-    state[InputId.LeftAnalogButton] = (miscButtons & 64) > 0;
-    state[InputId.RightAnalogButton] = (miscButtons & 128) > 0;
-    const lastButtons = report.readUint8(9);
-    state[InputId.Playstation] = (lastButtons & 1) > 0;
-    state[InputId.TouchButton] = (lastButtons & 2) > 0;
-    state[InputId.Mute] = (lastButtons & 4) > 0;
-    // The other 5 bits are unused
-    // 5 reserved bytes
-    state[InputId.GyroX] = report.readUint16LE(15);
-    state[InputId.GyroY] = report.readUint16LE(17);
-    state[InputId.GyroZ] = report.readUint16LE(19);
-    state[InputId.AccelX] = report.readUint16LE(21);
-    state[InputId.AccelY] = report.readUint16LE(23);
-    state[InputId.AccelZ] = report.readUint16LE(25);
-    // 4 bytes for sensor timestamp (32LE)
-    // 1 reserved byte
-    state[InputId.TouchId0] = report.readUint8(32) & 0x7f;
-    state[InputId.TouchContact0] = (report.readUint8(32) & 0x80) === 0;
-    state[InputId.TouchX0] = mapAxis(
-      (report.readUint16LE(33) << 20) >> 20,
-      1920
-    );
-    state[InputId.TouchY0] = mapAxis(report.readUint16LE(34) >> 4, 1080);
-    state[InputId.TouchId1] = report.readUint8(36) & 0x7f;
-    state[InputId.TouchContact1] = (report.readUint8(36) & 0x80) === 0;
-    state[InputId.TouchX1] = mapAxis(
-      (report.readUint16LE(37) << 20) >> 20,
-      1920
-    );
-    state[InputId.TouchY1] = mapAxis(report.readUint16LE(38) >> 4, 1080);
-    // 12 reserved bytes
-    state[InputId.Status] = (report.readUint8(53) & 4) > 0;
+  /**
+   * Cancel a previously registered handler.
+   */
+  public unregister(callback: (state: DualsenseHIDState) => void): void {
+    this.subscribers.delete(callback);
+  }
 
-    this.emit("input", state);
+  private set(state: DualsenseHIDState): void {
+    this.state = state;
+    this.subscribers.forEach((callback) => callback(state));
   }
 
   private handleError(error: unknown): void {
     console.error(error);
     setTimeout(() => {
-      this.device = this.connect();
+      this.provider.disconnect();
+      this.provider.connect();
     }, 50);
   }
-
-  private disconnect(): void {
-    if (this.device) {
-      try {
-        this.device.removeAllListeners();
-        this.device.close();
-      } catch (e) {
-        console.error(e);
-      }
-    }
-  }
-
-  private connect(): HID {
-    this.disconnect();
-
-    const controllers = devices(DualsenseHID.vendorId, DualsenseHID.productId);
-    if (controllers.length === 0 || !controllers[0].path) {
-      throw new Error(`No controllers (${devices().length} other devices)`);
-    }
-
-    if (controllers[0].interface === -1) this.wireless = true;
-
-    const controller = new HID(controllers[0].path);
-    controller.on("data", this.process.bind(this));
-    controller.on("error", this.handleError.bind(this));
-    return controller;
-  }
 }

package/src/hid/{dualsense_hid.spec.ts → hid_provider.spec.ts}

@@ -1,4 +1,4 @@
-import { mapAxis, mapTrigger } from "./dualsense_hid";
+import { mapAxis, mapTrigger } from "./hid_provider";
 
 describe("Dualsense HID", () => {
   it("should map axis values betwen -1 and 1", () => {

package/src/hid/hid_provider.ts

@@ -0,0 +1,100 @@
+import { InputId } from "../id";
+
+export * from "../id";
+
+/**
+ * Maps a HID input of 0...n to -1...1
+ */
+export function mapAxis(value: number, max: number = 255): number {
+  return (2 / max) * Math.max(0, Math.min(max, value)) - 1;
+}
+
+/**
+ * Maps a HID input of 0...255 to 0...1
+ */
+export function mapTrigger(value: number): number {
+  return (1 / 255) * Math.max(0, Math.min(255, value));
+}
+
+/**
+ * Describes an observation of the input state of a Dualsense controller.
+ */
+export interface DualsenseHIDState {
+  [InputId.LeftAnalogX]: number;
+  [InputId.LeftAnalogY]: number;
+  [InputId.RightAnalogX]: number;
+  [InputId.RightAnalogY]: number;
+  [InputId.LeftTrigger]: number;
+  [InputId.RightTrigger]: number;
+  [InputId.Triangle]: boolean;
+  [InputId.Circle]: boolean;
+  [InputId.Cross]: boolean;
+  [InputId.Square]: boolean;
+  [InputId.Dpad]: number;
+  [InputId.Up]: boolean;
+  [InputId.Down]: boolean;
+  [InputId.Left]: boolean;
+  [InputId.Right]: boolean;
+  [InputId.RightAnalogButton]: boolean;
+  [InputId.LeftAnalogButton]: boolean;
+  [InputId.Options]: boolean;
+  [InputId.Create]: boolean;
+  [InputId.RightTriggerButton]: boolean;
+  [InputId.LeftTriggerButton]: boolean;
+  [InputId.RightBumper]: boolean;
+  [InputId.LeftBumper]: boolean;
+  [InputId.Playstation]: boolean;
+  [InputId.TouchButton]: boolean;
+  [InputId.Mute]: boolean;
+  [InputId.Status]: boolean;
+  [InputId.TouchX0]: number;
+  [InputId.TouchY0]: number;
+  [InputId.TouchContact0]: boolean;
+  [InputId.TouchId0]: number;
+  [InputId.TouchX1]: number;
+  [InputId.TouchY1]: number;
+  [InputId.TouchContact1]: boolean;
+  [InputId.TouchId1]: number;
+  [InputId.GyroX]: number;
+  [InputId.GyroY]: number;
+  [InputId.GyroZ]: number;
+  [InputId.AccelX]: number;
+  [InputId.AccelY]: number;
+  [InputId.AccelZ]: number;
+}
+
+/**
+ * Supports a connection to a physical or logical Dualsense device.
+ */
+export abstract class HIDProvider {
+  static readonly vendorId: number = 1356;
+  static readonly productId: number = 3302;
+
+  public onData: (state: DualsenseHIDState) => void = () => {};
+  public onError: (error: Error) => void = () => {};
+
+  /**
+   * Search for a controller and connect to it.
+   */
+  abstract connect(): void;
+
+  /**
+   * Stop accepting input from the controller.
+   */
+  abstract disconnect(): void;
+
+  /**
+   * Returns true if a device is currently connected and working.
+   */
+  abstract get connected(): boolean;
+
+  /**
+   * Returns true if a device is connected wirelessly.
+   */
+  abstract get wireless(): boolean;
+
+  /**
+   * Converts the HID report to a usable state entity.
+   */
+  abstract process(input: unknown): DualsenseHIDState;
+}

package/src/hid/index.ts

@@ -4,4 +4,7 @@
 
 export * from "./command";
 export * from "./dualsense_hid";
-export * from "./ids";
+export * from "./hid_provider";
+export * from "./node_hid_provider";
+export * from "./platform_hid_provider";
+export * from "./web_hid_provider";