dualsense-ts 2.2.48 → 3.1.3

package/src/hid/node_hid_provider.ts

@@ -0,0 +1,108 @@
+import { HID, devices } from "node-hid";
+
+import {
+  HIDProvider,
+  DualsenseHIDState,
+  InputId,
+  mapAxis,
+  mapTrigger,
+} from "./hid_provider";
+
+export class NodeHIDProvider extends HIDProvider {
+  private device?: HID;
+  public wireless: boolean = false;
+
+  connect(): void {
+    this.disconnect();
+
+    const controllers = devices(HIDProvider.vendorId, HIDProvider.productId);
+    if (controllers.length === 0 || !controllers[0].path) {
+      return this.onError(
+        new Error(`No controllers (${devices().length} other devices)`)
+      );
+    }
+
+    if (controllers[0].interface === -1) this.wireless = true;
+
+    this.device = new HID(controllers[0].path);
+    this.device.on("data", (arg: Buffer) => {
+      this.onData(this.process(arg));
+    });
+    this.device.on("error", (err: Error) => {
+      this.onError(err);
+    });
+  }
+
+  get connected(): boolean {
+    return this.device !== undefined;
+  }
+
+  disconnect(): void {
+    if (this.device) {
+      this.device.removeAllListeners();
+      this.device.close();
+      this.device = undefined;
+      this.wireless = false;
+    }
+  }
+
+  process(buffer: Buffer): DualsenseHIDState {
+    // Bluetooth buffer starts with an extra byte
+    const report = buffer.subarray(this.wireless ? 2 : 1);
+
+    const mainButtons = report.readUint8(7);
+    const miscButtons = report.readUint8(8);
+    const lastButtons = report.readUint8(9);
+    const dpad = (mainButtons << 4) >> 4;
+
+    return {
+      [InputId.LeftAnalogX]: mapAxis(report.readUint8(0)),
+      [InputId.LeftAnalogY]: -mapAxis(report.readUint8(1)),
+      [InputId.RightAnalogX]: mapAxis(report.readUint8(2)),
+      [InputId.RightAnalogY]: -mapAxis(report.readUint8(3)),
+      [InputId.LeftTrigger]: mapTrigger(report.readUint8(4)),
+      [InputId.RightTrigger]: mapTrigger(report.readUint8(5)),
+      // 6 is a sequence byte
+      [InputId.Triangle]: (mainButtons & 128) > 0,
+      [InputId.Circle]: (mainButtons & 64) > 0,
+      [InputId.Cross]: (mainButtons & 32) > 0,
+      [InputId.Square]: (mainButtons & 16) > 0,
+      [InputId.Dpad]: dpad,
+      [InputId.Up]: dpad < 2 || dpad === 7,
+      [InputId.Down]: dpad > 2 && dpad < 6,
+      [InputId.Left]: dpad > 4 && dpad < 8,
+      [InputId.Right]: dpad > 0 && dpad < 4,
+      [InputId.LeftTriggerButton]: (miscButtons & 4) > 0,
+      [InputId.RightTriggerButton]: (miscButtons & 8) > 0,
+      [InputId.LeftBumper]: (miscButtons & 1) > 0,
+      [InputId.RightBumper]: (miscButtons & 2) > 0,
+      [InputId.Create]: (miscButtons & 16) > 0,
+      [InputId.Options]: (miscButtons & 32) > 0,
+      [InputId.LeftAnalogButton]: (miscButtons & 64) > 0,
+      [InputId.RightAnalogButton]: (miscButtons & 128) > 0,
+      [InputId.Playstation]: (lastButtons & 1) > 0,
+      [InputId.TouchButton]: (lastButtons & 2) > 0,
+      [InputId.Mute]: (lastButtons & 4) > 0,
+      // The other 5 bits are unused
+      // 5 reserved bytes
+      [InputId.GyroX]: report.readUint16LE(15),
+      [InputId.GyroY]: report.readUint16LE(17),
+      [InputId.GyroZ]: report.readUint16LE(19),
+      [InputId.AccelX]: report.readUint16LE(21),
+      [InputId.AccelY]: report.readUint16LE(23),
+      [InputId.AccelZ]: report.readUint16LE(25),
+      // 4 bytes for sensor timestamp (32LE)
+      // 1 reserved byte
+      [InputId.TouchId0]: report.readUint8(32) & 0x7f,
+      [InputId.TouchContact0]: (report.readUint8(32) & 0x80) === 0,
+      [InputId.TouchX0]: mapAxis((report.readUint16LE(33) << 20) >> 20, 1920),
+      [InputId.TouchY0]: mapAxis(report.readUint16LE(34) >> 4, 1080),
+      [InputId.TouchId1]: report.readUint8(36) & 0x7f,
+      [InputId.TouchContact1]: (report.readUint8(36) & 0x80) === 0,
+      [InputId.TouchX1]: mapAxis((report.readUint16LE(37) << 20) >> 20, 1920),
+      [InputId.TouchY1]: mapAxis(report.readUint16LE(38) >> 4, 1080),
+      // 12 reserved bytes
+      [InputId.Status]: (report.readUint8(53) & 4) > 0,
+    };
+  }
+}

package/src/hid/platform_hid_provider.ts

@@ -0,0 +1,4 @@
+import { NodeHIDProvider } from './node_hid_provider'
+import { WebHIDProvider } from './web_hid_provider'
+
+export const PlatformHIDProvider = typeof window === 'undefined' ? NodeHIDProvider : WebHIDProvider;

package/src/hid/web_hid_provider.ts

@@ -0,0 +1,116 @@
+import {
+  HIDProvider,
+  DualsenseHIDState,
+  InputId,
+  mapAxis,
+  mapTrigger,
+} from "./hid_provider";
+
+export class WebHIDProvider extends HIDProvider {
+  private device?: HIDDevice;
+  public wireless: boolean = true; // TODO: Not sure what to check
+
+  connect(): void {
+    this.disconnect();
+
+    navigator.hid
+      .requestDevice({
+        filters: [
+          { vendorId: HIDProvider.vendorId, productId: HIDProvider.productId },
+        ],
+      })
+      .then((devices: HIDDevice[]) => {
+        if (devices.length === 0) {
+          return this.onError(new Error(`No controllers available`));
+        }
+
+        devices[0]
+          .open()
+          .then(() => {
+            this.device = devices[0];
+            this.device.addEventListener("inputreport", ({ data }) => {
+              this.onData(this.process(data));
+            });
+          })
+          .catch((err: Error) => {
+            this.onError(err);
+          });
+      })
+      .catch((err: Error) => {
+        this.onError(err);
+      });
+  }
+
+  get connected(): boolean {
+    return this.device !== undefined;
+  }
+
+  disconnect(): void {
+    if (this.device) {
+      this.device.close().finally(() => {
+        this.device = undefined;
+        this.wireless = false;
+      });
+    }
+  }
+
+  process(buffer: DataView): DualsenseHIDState {
+    // Bluetooth buffer starts with an extra byte
+    const report = new DataView(buffer.buffer, this.wireless ? 2 : 1);
+
+    const mainButtons = report.getUint8(7);
+    const miscButtons = report.getUint8(8);
+    const lastButtons = report.getUint8(9);
+    const dpad = (mainButtons << 4) >> 4;
+
+    return {
+      [InputId.LeftAnalogX]: mapAxis(report.getUint8(0)),
+      [InputId.LeftAnalogY]: -mapAxis(report.getUint8(1)),
+      [InputId.RightAnalogX]: mapAxis(report.getUint8(2)),
+      [InputId.RightAnalogY]: -mapAxis(report.getUint8(3)),
+      [InputId.LeftTrigger]: mapTrigger(report.getUint8(4)),
+      [InputId.RightTrigger]: mapTrigger(report.getUint8(5)),
+      [InputId.Triangle]: (mainButtons & 128) > 0,
+      [InputId.Circle]: (mainButtons & 64) > 0,
+      [InputId.Cross]: (mainButtons & 32) > 0,
+      [InputId.Square]: (mainButtons & 16) > 0,
+      [InputId.Dpad]: dpad,
+      [InputId.Up]: dpad < 2 || dpad === 7,
+      [InputId.Down]: dpad > 2 && dpad < 6,
+      [InputId.Left]: dpad > 4 && dpad < 8,
+      [InputId.Right]: dpad > 0 && dpad < 4,
+      [InputId.LeftTriggerButton]: (miscButtons & 4) > 0,
+      [InputId.RightTriggerButton]: (miscButtons & 8) > 0,
+      [InputId.LeftBumper]: (miscButtons & 1) > 0,
+      [InputId.RightBumper]: (miscButtons & 2) > 0,
+      [InputId.Create]: (miscButtons & 16) > 0,
+      [InputId.Options]: (miscButtons & 32) > 0,
+      [InputId.LeftAnalogButton]: (miscButtons & 64) > 0,
+      [InputId.RightAnalogButton]: (miscButtons & 128) > 0,
+      [InputId.Playstation]: (lastButtons & 1) > 0,
+      [InputId.TouchButton]: (lastButtons & 2) > 0,
+      [InputId.Mute]: (lastButtons & 4) > 0,
+      [InputId.GyroX]: report.getUint16(15, true),
+      [InputId.GyroY]: report.getUint16(17, true),
+      [InputId.GyroZ]: report.getUint16(19, true),
+      [InputId.AccelX]: report.getUint16(21, true),
+      [InputId.AccelY]: report.getUint16(23, true),
+      [InputId.AccelZ]: report.getUint16(25, true),
+      [InputId.TouchId0]: report.getUint8(32) & 0x7f,
+      [InputId.TouchContact0]: (report.getUint8(32) & 0x80) === 0,
+      [InputId.TouchX0]: mapAxis(
+        (report.getUint16(33, true) << 20) >> 20,
+        1920
+      ),
+      [InputId.TouchY0]: mapAxis(report.getUint16(34, true) >> 4, 1080),
+      [InputId.TouchId1]: report.getUint8(36) & 0x7f,
+      [InputId.TouchContact1]: (report.getUint8(36) & 0x80) === 0,
+      [InputId.TouchX1]: mapAxis(
+        (report.getUint16(37, true) << 20) >> 20,
+        1920
+      ),
+      [InputId.TouchY1]: mapAxis(report.getUint16(38, true) >> 4, 1080),
+      [InputId.Status]: (report.getUint8(53) & 4) > 0,
+    };
+  }
+}

package/src/{hid/ids.ts → id.ts}

@@ -1,4 +1,6 @@
-// Names for real controller inputs
+/**
+ * IDs for real and virtual controller inputs.
+ */
 export const enum InputId {
   Options = "Options",
   Create = "Create",
@@ -52,4 +54,7 @@ export const enum InputId {
   AccelX = "AccelX",
   AccelY = "AccelY",
   AccelZ = "AccelZ",
+
+  // For placeholder inputs
+  Unknown = "Unknown",
 }

package/src/index.ts

@@ -2,7 +2,9 @@
  * @file Automatically generated by barrelsby.
  */
 
+export * from "./comparators";
 export * from "./dualsense";
+export * from "./id";
 export * from "./input";
 export * from "./math";
 export * from "./elements/index";

package/src/input.ts

@@ -1,93 +1,177 @@
-import { EventEmitter } from "events";
-import { inspect } from "util";
+import { InputId } from "./id";
+import {
+  VirtualComparator,
+  ThresholdComparator,
+  BasicComparator,
+} from "./comparators";
+
+export { InputId } from "./id";
 
 export interface InputParams {
   name?: string;
   icon?: string;
   threshold?: number;
-  parent?: Input<unknown>;
 }
 
-const InputDefaults: Omit<Required<InputParams>, "parent"> = {
-  name: "???",
-  icon: "???",
-  threshold: 0,
-};
+export type InputChangeType = "change" | "press" | "release";
+export type InputEventType = InputChangeType | "input";
 
-// Private properties
-const InputAdopt = Symbol("InputAdopt");
-const InputChildless = Symbol("InputChildless");
-const InputParent = Symbol("InputParent");
-const InputSetComparison = Symbol("InputSetComparison");
-const InputChangedPrimitive = Symbol("InputChangedPrimitive");
-const InputChangedThreshold = Symbol("InputChangedThreshold");
-const InputChangedVirtual = Symbol("InputChangedVirtual");
-
-// Optional abstract properties
-export const InputChanged = Symbol("InputChanged");
+export type InputCallback<Instance> = (
+  input: Instance,
+  changed: Instance | Input<unknown>
+) => unknown | Promise<unknown>;
+
+/**
+ * Private utilities
+ */
 
-// Utilities
+export const InputSetComparator = Symbol("InputSetComparator");
+export const InputChanged = Symbol("InputChanged");
 export const InputSet = Symbol("InputSet");
 export const InputName = Symbol("InputName");
 export const InputIcon = Symbol("InputIcon");
 
-export type InputEvent = "change" | "input" | "press" | "release";
-
-export declare interface Input<Type> {
-  on(
-    event: InputEvent,
-    listener: (
-      input: Input<Type>,
-      changed: Input<unknown>
-    ) => unknown | Promise<unknown>
-  ): this;
-  emit(
-    event: InputEvent,
-    ...args: [Input<Type>, Input<unknown> | Input<Type>]
-  ): boolean;
-}
+/**
+ * Private properties
+ */
+
+const InputOns = Symbol("InputOns");
+const InputOnces = Symbol("InputOnces");
+const InputAdopt = Symbol("InputAdopt");
+const InputParents = Symbol("InputParents");
+const InputComparator = Symbol("InputComparator");
 
 /**
  * Input manages the state of a single device input,
  * a virtual input, or a group of Input children.
  */
-export abstract class Input<Type>
-  extends EventEmitter
-  implements AsyncIterator<Input<Type>>
-{
-  public readonly id: symbol;
+export abstract class Input<Type> implements AsyncIterator<Input<Type>> {
+  public readonly id: InputId = InputId.Unknown;
 
   /**
-   * Timestamp of the last received input that changed the state.
+   * For numeric inputs, ignore state changes smaller than this threshold.
    */
-  public lastChange: number = Date.now();
+  public threshold: number = 0;
 
   /**
-   * Timestamp of the last received input, even if it didn't change the state.
+   * Provide the type and default value for the input.
    */
-  public lastInput: number = Date.now();
+  public abstract state: Type;
 
   /**
-   * For numeric inputs, ignore state changes smaller than this threshold.
+   * Stores event listeners.
    */
-  public threshold: number = 0;
+  private [InputOns] = new Map<InputEventType, InputCallback<this>[]>();
 
   /**
-   * Provide the type and default value for the input.
+   * Stores callbacks waiting for one-time events.
    */
-  public abstract state: Type;
+  private [InputOnces] = new Map<InputChangeType, InputCallback<this>[]>();
+
+  constructor(params: InputParams = {}) {
+    const { name, icon, threshold } = {
+      icon: "???",
+      name: "Nameless Input",
+      threshold: 0,
+      ...params,
+    };
+
+    this[InputName] = name;
+    this[InputIcon] = icon;
+    this.threshold = threshold;
+
+    setTimeout(() => {
+      this[InputSetComparator]();
+      Object.values(this).forEach((value) => {
+        if (value === this) return;
+        if (value instanceof Input) value[InputAdopt](this as Input<unknown>);
+      });
+    });
+  }
 
   /**
    * Implement a function that returns true if the user is actively engaged with the input.
    */
   public abstract get active(): boolean;
 
+  /**
+   * Register a callback to recieve state updates from this Input.
+   */
+  public on(event: InputEventType, listener: InputCallback<this>): this {
+    const listeners = this[InputOns].get(event);
+    if (!listeners) {
+      this[InputOns].set(event, []);
+      return this.on(event, listener);
+    }
+    listeners.push(listener);
+    return this;
+  }
+
+  /**
+   * Register a callback to recieve the next specified update.
+   */
+  public once(event: InputChangeType, listener: InputCallback<this>): this {
+    const listeners = this[InputOnces].get(event);
+    if (!listeners) {
+      this[InputOnces].set(event, []);
+      return this.once(event, listener);
+    }
+    listeners.push(listener);
+    return this;
+  }
+
+  /**
+   * Notify listeners and parents of a state change.
+   */
+  private emit(event: InputEventType, changed: Input<unknown> | this): void {
+    const listeners = this[InputOns].get(event) || [];
+    listeners.forEach((callback) => {
+      callback(this, changed);
+    });
+
+    if (event !== "input") {
+      this.emitOnce(event, changed);
+      this[InputParents].forEach((input) => {
+        input.emit(event, changed as Input<unknown>);
+      });
+    }
+  }
+
+  /**
+   * Notify one-time listeners of a state change.
+   */
+  private emitOnce(
+    event: InputChangeType,
+    changed: this | Input<unknown> = this
+  ): void {
+    const listeners = this[InputOnces].get(event) || [];
+    this[InputOnces].set(event, []);
+    listeners.forEach((callback) => {
+      callback(this, changed as Input<unknown>);
+    });
+  }
+
+  /**
+   * Register a callback to recieve state updates from this Input.
+   */
+  public addEventListener(
+    event: InputEventType,
+    listener: InputCallback<this>,
+    { once }: { once: boolean } = { once: false }
+  ): this {
+    if (once) {
+      if (event === "input") {
+        throw new Error("Can't listen once to `input` events");
+      }
+      return this.once(event, listener);
+    }
+    return this.on(event, listener);
+  }
+
   /**
    * Resolves on the next change to this input's state.
    */
-  public next(
-    type: "press" | "release" | "change" = "change"
-  ): Promise<IteratorResult<this>> {
+  public next(type: InputChangeType = "change"): Promise<IteratorResult<this>> {
     return new Promise<IteratorResult<this>>((resolve) => {
       this.once(type, () => {
         resolve({ value: this, done: false });
@@ -107,46 +191,16 @@ export abstract class Input<Type>
   }
 
   /**
-   * Render a convenient debugging string.
+   * Render a debugging string.
    */
   public toString(): string {
     return `${this[InputIcon]} [${this.active ? "X" : "_"}]`;
   }
 
-  constructor(params?: InputParams) {
-    super();
-
-    const { icon, name, parent, threshold } = {
-      ...InputDefaults,
-      ...(params || {}),
-    };
-    this[InputName] = name;
-    this[InputIcon] = icon;
-    this[InputParent] = parent;
-
-    this.threshold = threshold;
-    this.id = Symbol(this[InputName]);
-
-    this[InputChanged] = this[InputSetComparison]();
-    setImmediate(() => {
-      this[InputAdopt]();
-      this[InputChanged] = this[InputSetComparison]();
-    });
-  }
-
   /**
-   * Optionally, implement a function that returns true if the provided state is worth an event
+   * Returns true if the provided state is worth an event
    */
-  [InputChanged]: (state: Type, newState: Type) => boolean;
-
-  // TODO Support params for nested inputs
-  [inspect.custom](): string {
-    return `${this[InputName]} ${this[InputIcon]}: ${JSON.stringify(
-      this.state instanceof Input && this.state.id === this.id
-        ? "virtual"
-        : this.state
-    )}`;
-  }
+  [InputComparator]: (state: Type, newState: Type) => boolean = BasicComparator;
 
   [Symbol.asyncIterator](): AsyncIterator<this> {
     return this;
@@ -168,62 +222,32 @@ export abstract class Input<Type>
   readonly [InputName]: string;
 
   /**
-   * A short name for this input
+   * A short name for this input.
    */
   readonly [InputIcon]: string;
 
   /**
-   * The Input's parent, if any
+   * Other Inputs that contain this one.
    */
-  [InputParent]?: Input<unknown>;
-
-  [InputChildless]: boolean = true;
+  private [InputParents] = new Set<Input<unknown>>();
 
   /**
-   * Cascade events from nested Inputs.
-   * And decide if this is the root Input.
+   * Links Inputs to bubble up events.
    */
-  [InputAdopt](): void {
-    Object.values(this).forEach((value) => {
-      if (value === this) return;
-      if (value instanceof Input) {
-        this[InputChildless] = false;
-        if (!value[InputChildless]) return;
-        value.on("change", (that, value) => {
-          that;
-          this.emit("change", this, value);
-        });
-        value.on("input", (that, value) => {
-          that;
-          this.emit("input", this, value);
-        });
-      }
-    });
+  [InputAdopt](parent: Input<unknown>): void {
+    this[InputParents].add(parent);
   }
 
-  [InputChangedVirtual](): boolean {
-    return true;
-  }
-
-  [InputChangedPrimitive](state: Type, newState: Type): boolean {
-    return state !== newState;
-  }
-
-  [InputChangedThreshold](state: number, newState: number): boolean {
-    return Math.abs(state - newState) > this.threshold;
-  }
-
-  // Sets a default comparison type for the Input based on the generic type.
-  [InputSetComparison](): (state: Type, newState: Type) => boolean {
+  /**
+   * Sets a default comparison type for the Input by discovering the generic type.
+   */
+  [InputSetComparator](): void {
     if (typeof this.state === "number") {
-      return this[InputChangedThreshold] as unknown as (
-        state: Type,
-        newState: Type
-      ) => boolean;
+      this[InputComparator] = ThresholdComparator.bind(this, this.threshold);
     } else if (this.state instanceof Input) {
-      return this[InputChangedVirtual];
+      this[InputComparator] = VirtualComparator;
     } else {
-      return this[InputChangedPrimitive];
+      this[InputComparator] = BasicComparator;
     }
   }
 
@@ -231,18 +255,12 @@ export abstract class Input<Type>
    * Update the input's state and trigger all necessary callbacks.
    */
   [InputSet](state: Type): void {
-    this.lastInput = Date.now();
-    if (this[InputChanged](this.state, state)) {
+    if (this[InputComparator](this.state, state)) {
       this.state = state;
-      this.lastChange = Date.now();
-      this.emit("change", this, this);
-      if (typeof state === "boolean") {
-        state
-          ? this.emit("press", this, this)
-          : this.emit("release", this, this);
-      }
+      this.emit("change", this);
+      if (typeof state === "boolean")
+        this.emit(state ? "press" : "release", this);
     }
-
-    this.emit("input", this, this);
+    this.emit("input", this);
   }
 }

package/src/readme.spec.ts

@@ -21,7 +21,7 @@ describe("README.md example snippets", () => {
 
   it("should support callbacks", (done) => {
     expect(controller.triangle.active).toEqual(false);
-    setImmediate(() => {
+    setTimeout(() => {
       controller.triangle[InputSet](true);
     });
 
@@ -29,10 +29,8 @@ describe("README.md example snippets", () => {
       expect(input.active).toEqual(true);
     });
 
-    controller.triangle.removeAllListeners();
-
     expect(controller.dpad.up.active).toEqual(false);
-    setImmediate(() => {
+    setTimeout(() => {
       controller.dpad.up[InputSet](true);
     });
 
@@ -44,13 +42,13 @@ describe("README.md example snippets", () => {
   });
 
   it("should provide promises", async () => {
-    setImmediate(() => {
+    setTimeout(() => {
       controller.dpad.up[InputSet](true);
     });
     const { active } = await controller.dpad.up.promise();
     expect(active).toEqual(true);
 
-    setImmediate(() => {
+    setTimeout(() => {
       controller.dpad.up[InputSet](false);
     });
     const { left, up, down, right } = await controller.dpad.promise();
@@ -64,7 +62,7 @@ describe("README.md example snippets", () => {
     let state = true;
     let iterations = 5;
 
-    setImmediate(() => {
+    setTimeout(() => {
       controller.dpad.up[InputSet](state);
     });
     for await (const { left, right, up, down } of controller.dpad) {
@@ -75,7 +73,7 @@ describe("README.md example snippets", () => {
       iterations--;
       state = !state;
       if (iterations === 0) break;
-      setImmediate(() => {
+      setTimeout(() => {
         controller.dpad.up[InputSet](state);
       });
     }