@sensslen/node-gamepad 1.0.4 → 1.0.5-beta.3

package/IConfig.d.ts

@@ -1,29 +1,34 @@
 import { IDeviceSpec } from './IDeviceSpec';
-export interface IConfig extends IDeviceSpec {
-    joysticks?: {
-        name: string;
-        x: {
-            pin: number;
-        };
-        y: {
-            pin: number;
-        };
-    }[];
-    buttons?: {
-        value: string;
-        pin: number;
-        name: string;
-    }[];
-    status?: {
-        name: string;
+export interface IJoyStickConfig {
+    name: string;
+    x: {
         pin: number;
-        states: {
-            value: number;
-            state: string;
-        }[];
-    }[];
-    scale?: {
+    };
+    y: {
         pin: number;
-        name: string;
-    }[];
+    };
+}
+export interface IButtonConfig {
+    value: string;
+    pin: number;
+    name: string;
+}
+export interface IStatusConfig {
+    name: string;
+    pin: number;
+    states: IStateMappingConfig[];
+}
+export interface IStateMappingConfig {
+    value: number;
+    state: string;
+}
+export interface IScaleConfig {
+    pin: number;
+    name: string;
+}
+export interface IConfig extends IDeviceSpec {
+    joysticks?: IJoyStickConfig[];
+    buttons?: IButtonConfig[];
+    status?: IStatusConfig[];
+    scales?: IScaleConfig[];
 }

package/NodeGamepad.d.ts

@@ -1,13 +1,13 @@
 /// <reference types="node" />
 import { HID } from 'node-hid';
-import { EventEmitter } from 'events';
 import { IConfig } from './IConfig';
+import { EventEmitter } from 'events';
 import { ILogger } from './ILogger';
 export declare class NodeGamepad extends EventEmitter {
     private config;
     private logger?;
     protected _usb?: HID;
-    private _stopped;
+    private _running;
     private _joystickStates;
     private _buttonStates;
     private _statusStates;
@@ -17,18 +17,22 @@ export declare class NodeGamepad extends EventEmitter {
     constructor(config: IConfig, logger?: ILogger | undefined);
     start(): void;
     stop(): void;
-    rumble(_duration: number): void;
+    rumble(_intensity: number, _duration: number): void;
     private logDebug;
     private log;
     private connect;
     private stopConnectionProcess;
     private registerProgramExitEvents;
-    private stopUsbRead;
+    private closeUsbDevice;
     private toIDeviceSpec;
     private onControllerFrame;
     private processJoysticks;
+    private processJoystick;
     private processButtons;
+    private processButton;
     private processScales;
-    private processStatus;
+    private processScale;
+    private processStates;
+    private processState;
     private getStateName;
 }

package/NodeGamepad.js

@@ -26,26 +26,30 @@ var NodeGamepad = /** @class */ (function (_super) {
         _this.config = config;
         _this.logger = logger;
         _this._usb = undefined;
-        _this._stopped = false;
+        _this._running = false;
         _this._joystickStates = {};
         _this._buttonStates = {};
         _this._statusStates = {};
         _this._scaleStates = {};
-        _this._connectionRetryTimeoutInMs = 100;
+        _this._connectionRetryTimeoutInMs = 500;
         return _this;
     }
     NodeGamepad.prototype.start = function () {
+        if (this._running) {
+            return;
+        }
         this.log("Starting connection procedure to device:".concat(JSON.stringify(this.toIDeviceSpec(this.config))));
         this.registerProgramExitEvents();
+        this._running = true;
         this.connect();
     };
     NodeGamepad.prototype.stop = function () {
-        this._stopped = true;
+        this._running = false;
         this.stopConnectionProcess();
-        this.stopUsbRead();
+        this.closeUsbDevice();
     };
-    NodeGamepad.prototype.rumble = function (_duration) {
-        // do nothing here intentionally. gamepads supporting rumbling do need to override this method
+    NodeGamepad.prototype.rumble = function (_intensity, _duration) {
+        // todo
     };
     NodeGamepad.prototype.logDebug = function (toLog) {
         var _a;
@@ -60,7 +64,7 @@ var NodeGamepad = /** @class */ (function (_super) {
     };
     NodeGamepad.prototype.connect = function () {
         var _this = this;
-        if (this._stopped) {
+        if (!this._running) {
             return;
         }
         var deviceList = (0, node_hid_1.devices)(this.config.vendorID, this.config.productID);
@@ -87,10 +91,10 @@ var NodeGamepad = /** @class */ (function (_super) {
             this._usb.on('data', function (data) { return _this.onControllerFrame(data); });
             this._usb.on('error', function (error) {
                 _this.log("Error occurred:".concat(JSON.stringify(error)));
+                _this.emit('disconnected');
+                _this.closeUsbDevice();
                 setTimeout(function () {
                     _this.log('reconnecting');
-                    _this.emit('disconnected');
-                    _this.stopUsbRead();
                     _this.connect();
                 }, 0);
             });
@@ -99,6 +103,7 @@ var NodeGamepad = /** @class */ (function (_super) {
             var typedError = error;
             this.log("Connecting failed: ".concat(typedError.message));
             this.log('trying again later.');
+            this.closeUsbDevice();
             this._connectRetryTimeout = setTimeout(function () { return _this.connect(); }, this._connectionRetryTimeoutInMs);
         }
     };
@@ -115,7 +120,7 @@ var NodeGamepad = /** @class */ (function (_super) {
             _this.stop();
         });
     };
-    NodeGamepad.prototype.stopUsbRead = function () {
+    NodeGamepad.prototype.closeUsbDevice = function () {
         if (this._usb) {
             this._usb.close();
             this._usb = undefined;
@@ -132,66 +137,86 @@ var NodeGamepad = /** @class */ (function (_super) {
         this.logDebug(JSON.stringify(data));
         this.processJoysticks(data);
         this.processButtons(data);
-        this.processStatus(data);
+        this.processStates(data);
         this.processScales(data);
     };
     NodeGamepad.prototype.processJoysticks = function (data) {
         var _this = this;
         var _a;
         (_a = this.config.joysticks) === null || _a === void 0 ? void 0 : _a.forEach(function (joystick) {
-            var oldState = _this._joystickStates[joystick.name];
-            var newState = {
-                x: data[joystick.x.pin],
-                y: data[joystick.y.pin],
-            };
-            if (oldState === undefined || oldState.x !== newState.x || oldState.y !== newState.y) {
-                _this.emit(joystick.name + ':move', newState);
+            if (data.length > joystick.x.pin || data.length > joystick.y.pin) {
+                _this.processJoystick(joystick, data);
             }
-            _this._joystickStates[joystick.name] = newState;
         });
     };
+    NodeGamepad.prototype.processJoystick = function (joystick, data) {
+        var oldState = this._joystickStates[joystick.name];
+        var newState = {
+            x: data[joystick.x.pin],
+            y: data[joystick.y.pin],
+        };
+        if (oldState === undefined || oldState.x !== newState.x || oldState.y !== newState.y) {
+            this.emit(joystick.name + ':move', newState);
+        }
+        this._joystickStates[joystick.name] = newState;
+    };
     NodeGamepad.prototype.processButtons = function (data) {
         var _this = this;
         var _a;
         (_a = this.config.buttons) === null || _a === void 0 ? void 0 : _a.forEach(function (button) {
-            var oldState = _this._buttonStates[button.name];
-            var newState = (0, mathjs_1.evaluate)(button.value, { value: data[button.pin] });
-            if (oldState == undefined) {
-                if (newState) {
-                    _this.emit(button.name + ':press');
-                }
-            }
-            else if (oldState !== newState) {
-                var emitEvent = newState ? "".concat(button.name, ":press") : "".concat(button.name, ":release");
-                _this.emit(emitEvent);
+            if (data.length > button.pin) {
+                _this.processButton(data, button);
             }
-            _this._buttonStates[button.name] = newState;
         });
     };
+    NodeGamepad.prototype.processButton = function (data, config) {
+        var oldState = this._buttonStates[config.name];
+        var newState = (0, mathjs_1.evaluate)(config.value, { value: data[config.pin] });
+        if (oldState == undefined) {
+            if (newState) {
+                this.emit(config.name + ':press');
+            }
+        }
+        else if (oldState !== newState) {
+            var emitEvent = newState ? "".concat(config.name, ":press") : "".concat(config.name, ":release");
+            this.emit(emitEvent);
+        }
+        this._buttonStates[config.name] = newState;
+    };
     NodeGamepad.prototype.processScales = function (data) {
         var _this = this;
         var _a;
-        (_a = this.config.scale) === null || _a === void 0 ? void 0 : _a.forEach(function (scale) {
-            var oldState = _this._scaleStates[scale.name];
-            var newState = data[scale.pin];
-            if (oldState !== newState) {
-                _this.emit(scale.name + ':change', newState);
+        (_a = this.config.scales) === null || _a === void 0 ? void 0 : _a.forEach(function (scale) {
+            if (data.length > scale.pin) {
+                _this.processScale(scale, data);
             }
-            _this._scaleStates[scale.name] = newState;
         });
     };
-    NodeGamepad.prototype.processStatus = function (data) {
+    NodeGamepad.prototype.processScale = function (config, data) {
+        var oldState = this._scaleStates[config.name];
+        var newState = data[config.pin];
+        if (oldState !== newState) {
+            this.emit(config.name + ':change', newState);
+        }
+        this._scaleStates[config.name] = newState;
+    };
+    NodeGamepad.prototype.processStates = function (data) {
         var _this = this;
         var _a;
         (_a = this.config.status) === null || _a === void 0 ? void 0 : _a.forEach(function (status) {
-            var oldState = _this._statusStates[status.name];
-            var newState = data[status.pin];
-            if (oldState !== newState) {
-                _this.emit(status.name + ':change', _this.getStateName(status.states, newState));
+            if (data.length > status.pin) {
+                _this.processState(status, data);
             }
-            _this._statusStates[status.name] = newState;
         });
     };
+    NodeGamepad.prototype.processState = function (config, data) {
+        var oldState = this._statusStates[config.name];
+        var newState = data[config.pin];
+        if (oldState !== newState) {
+            this.emit(config.name + ':change', this.getStateName(config.states, newState));
+        }
+        this._statusStates[config.name] = newState;
+    };
     NodeGamepad.prototype.getStateName = function (states, value) {
         for (var _i = 0, states_1 = states; _i < states_1.length; _i++) {
             var state = states_1[_i];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sensslen/node-gamepad",
-  "version": "1.0.4",
+  "version": "1.0.5-beta.3",
   "description": "node-gamepad is a package for node that allows you to effortlessly interface your node applications with a variety of gamepad controllers. This is a port of node-gamepad library to typescript by also removing some of the restrictions implied by this library (namely allowing gamepads to be subcleassed and also improving usb interaction)",
   "homepage": "https://github.com/sensslen/node-gamepad",
   "bugs": {
@@ -8,7 +8,7 @@
   },
   "repository": {
     "type": "git",
-    "url": "git@github.com:carldanley/node-gamepad.git"
+    "url": "git@github.com:sensslen/node-gamepad.git"
   },
   "license": "MIT",
   "author": {

package/test.d.ts

@@ -1 +0,0 @@
-export {};