@sensslen/node-gamepad 1.0.9-beta.213 → 1.0.9-beta.217

package/NodeGamepad.d.ts

@@ -1,11 +1,10 @@
-import { HID } from 'node-hid';
 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 _usb?;
     private _running;
     private _joystickStates;
     private _buttonStates;

package/NodeGamepad.js

@@ -1,157 +1,137 @@
 "use strict";
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-    return function (d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NodeGamepad = void 0;
-var node_hid_1 = require("node-hid");
-var events_1 = require("events");
-var mathjs_1 = require("mathjs");
-var NodeGamepad = /** @class */ (function (_super) {
-    __extends(NodeGamepad, _super);
-    function NodeGamepad(config, logger) {
-        var _this = _super.call(this) || this;
-        _this.config = config;
-        _this.logger = logger;
-        _this._usb = undefined;
-        _this._running = false;
-        _this._joystickStates = {};
-        _this._buttonStates = {};
-        _this._statusStates = {};
-        _this._scaleStates = {};
-        _this._connectionRetryTimeoutInMs = 500;
-        return _this;
-    }
-    NodeGamepad.prototype.start = function () {
+const node_hid_1 = require("node-hid");
+const events_1 = require("events");
+const mathjs_1 = require("mathjs");
+class NodeGamepad extends events_1.EventEmitter {
+    constructor(config, logger) {
+        super();
+        this.config = config;
+        this.logger = logger;
+        this._usb = undefined;
+        this._running = false;
+        this._joystickStates = {};
+        this._buttonStates = {};
+        this._statusStates = {};
+        this._scaleStates = {};
+        this._connectionRetryTimeoutInMs = 500;
+    }
+    start() {
         if (this._running) {
             return;
         }
-        this.log("Starting connection procedure to device:".concat(JSON.stringify(this.toIDeviceSpec(this.config))));
+        this.log(`Starting connection procedure to device:${JSON.stringify(this.toIDeviceSpec(this.config))}`);
         this.registerProgramExitEvents();
         this._running = true;
         this.connect();
-    };
-    NodeGamepad.prototype.stop = function () {
+    }
+    stop() {
         this._running = false;
         this.stopConnectionProcess();
         this.closeUsbDevice();
-    };
-    NodeGamepad.prototype.rumble = function (_intensity, _duration) {
+    }
+    rumble(_intensity, _duration) {
         // todo
-    };
-    NodeGamepad.prototype.logDebug = function (toLog) {
+    }
+    logDebug(toLog) {
         var _a;
         if ((_a = this.logger) === null || _a === void 0 ? void 0 : _a.debug) {
-            this.logger.debug("NodeGamepad (Debug):".concat(toLog));
+            this.logger.debug(`NodeGamepad (Debug):${toLog}`);
         }
-    };
-    NodeGamepad.prototype.log = function (toLog) {
+    }
+    log(toLog) {
         if (this.logger) {
-            this.logger.info("NodeGamepad:".concat(toLog));
+            this.logger.info(`NodeGamepad:${toLog}`);
         }
-    };
-    NodeGamepad.prototype.connect = function () {
-        var _this = this;
+    }
+    connect() {
         if (!this._running) {
             return;
         }
-        var deviceList = (0, node_hid_1.devices)(this.config.vendorID, this.config.productID);
+        let deviceList = (0, node_hid_1.devices)(this.config.vendorID, this.config.productID);
         if (this.config.serialNumber) {
-            deviceList = deviceList.filter(function (d) { return d.serialNumber === _this.config.serialNumber; });
+            deviceList = deviceList.filter((d) => d.serialNumber === this.config.serialNumber);
         }
         if (deviceList.length < 1) {
             this.logDebug('Device not found, trying again later');
-            this._connectRetryTimeout = setTimeout(function () { return _this.connect(); }, this._connectionRetryTimeoutInMs);
+            this._connectRetryTimeout = setTimeout(() => this.connect(), this._connectionRetryTimeoutInMs);
             return;
         }
-        var deviceToConnectTo = deviceList[0];
+        const deviceToConnectTo = deviceList[0];
         if ((deviceToConnectTo === null || deviceToConnectTo === void 0 ? void 0 : deviceToConnectTo.path) === undefined) {
             this.logDebug('Failed to connect. Checking again later.');
-            this._connectRetryTimeout = setTimeout(function () { return _this.connect(); }, this._connectionRetryTimeoutInMs);
+            this._connectRetryTimeout = setTimeout(() => this.connect(), this._connectionRetryTimeoutInMs);
             return;
         }
-        this.logDebug("connecting to:".concat(JSON.stringify(deviceToConnectTo)));
+        this.logDebug(`connecting to:${JSON.stringify(deviceToConnectTo)}`);
         try {
             this._usb = new node_hid_1.HID(deviceToConnectTo.path);
             this.log('connected');
             this.emit('connected');
             this._connectRetryTimeout = undefined;
-            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.connect();
+            this._usb.on('data', (data) => this.onControllerFrame(data));
+            this._usb.on('error', (error) => {
+                this.log(`Error occurred:${JSON.stringify(error)}`);
+                this.emit('disconnected');
+                this.closeUsbDevice();
+                setTimeout(() => {
+                    this.log('reconnecting');
+                    this.connect();
                 }, 0);
             });
         }
         catch (error) {
-            var typedError = error;
-            this.log("Connecting failed: ".concat(typedError.message));
+            const typedError = error;
+            this.log(`Connecting failed: ${typedError.message}`);
             this.log('trying again later.');
             this.closeUsbDevice();
-            this._connectRetryTimeout = setTimeout(function () { return _this.connect(); }, this._connectionRetryTimeoutInMs);
+            this._connectRetryTimeout = setTimeout(() => this.connect(), this._connectionRetryTimeoutInMs);
         }
-    };
-    NodeGamepad.prototype.stopConnectionProcess = function () {
+    }
+    stopConnectionProcess() {
         if (this._connectRetryTimeout) {
             clearTimeout(this._connectRetryTimeout);
             this._connectRetryTimeout = undefined;
         }
-    };
-    NodeGamepad.prototype.registerProgramExitEvents = function () {
-        var _this = this;
-        process.on('exit', function () {
-            _this.logDebug('exit encontered, cleaning up');
-            _this.stop();
+    }
+    registerProgramExitEvents() {
+        process.on('exit', () => {
+            this.logDebug('exit encontered, cleaning up');
+            this.stop();
         });
-    };
-    NodeGamepad.prototype.closeUsbDevice = function () {
+    }
+    closeUsbDevice() {
         if (this._usb) {
             this._usb.close();
             this._usb = undefined;
         }
-    };
-    NodeGamepad.prototype.toIDeviceSpec = function (spec) {
+    }
+    toIDeviceSpec(spec) {
         return {
             vendorID: spec.vendorID,
             productID: spec.productID,
             serialNumber: spec.serialNumber,
         };
-    };
-    NodeGamepad.prototype.onControllerFrame = function (data) {
+    }
+    onControllerFrame(data) {
         this.logDebug(JSON.stringify(data));
         this.processJoysticks(data);
         this.processButtons(data);
         this.processStates(data);
         this.processScales(data);
-    };
-    NodeGamepad.prototype.processJoysticks = function (data) {
-        var _this = this;
+    }
+    processJoysticks(data) {
         var _a;
-        (_a = this.config.joysticks) === null || _a === void 0 ? void 0 : _a.forEach(function (joystick) {
+        (_a = this.config.joysticks) === null || _a === void 0 ? void 0 : _a.forEach((joystick) => {
             if (data.length > joystick.x.pin || data.length > joystick.y.pin) {
-                _this.processJoystick(joystick, data);
+                this.processJoystick(joystick, data);
             }
         });
-    };
-    NodeGamepad.prototype.processJoystick = function (joystick, data) {
-        var oldState = this._joystickStates[joystick.name];
-        var newState = {
+    }
+    processJoystick(joystick, data) {
+        const oldState = this._joystickStates[joystick.name];
+        const newState = {
             x: data[joystick.x.pin],
             y: data[joystick.y.pin],
         };
@@ -159,74 +139,69 @@ var NodeGamepad = /** @class */ (function (_super) {
             this.emit(joystick.name + ':move', newState);
         }
         this._joystickStates[joystick.name] = newState;
-    };
-    NodeGamepad.prototype.processButtons = function (data) {
-        var _this = this;
+    }
+    processButtons(data) {
         var _a;
-        (_a = this.config.buttons) === null || _a === void 0 ? void 0 : _a.forEach(function (button) {
+        (_a = this.config.buttons) === null || _a === void 0 ? void 0 : _a.forEach((button) => {
             if (data.length > button.pin) {
-                _this.processButton(data, button);
+                this.processButton(data, button);
             }
         });
-    };
-    NodeGamepad.prototype.processButton = function (data, config) {
-        var oldState = this._buttonStates[config.name];
-        var newState = (0, mathjs_1.evaluate)(config.value, { value: data[config.pin] });
+    }
+    processButton(data, config) {
+        const oldState = this._buttonStates[config.name];
+        const 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");
+            const emitEvent = newState ? `${config.name}:press` : `${config.name}:release`;
             this.emit(emitEvent);
         }
         this._buttonStates[config.name] = newState;
-    };
-    NodeGamepad.prototype.processScales = function (data) {
-        var _this = this;
+    }
+    processScales(data) {
         var _a;
-        (_a = this.config.scales) === null || _a === void 0 ? void 0 : _a.forEach(function (scale) {
+        (_a = this.config.scales) === null || _a === void 0 ? void 0 : _a.forEach((scale) => {
             if (data.length > scale.pin) {
-                _this.processScale(scale, data);
+                this.processScale(scale, data);
             }
         });
-    };
-    NodeGamepad.prototype.processScale = function (config, data) {
-        var oldState = this._scaleStates[config.name];
-        var newState = data[config.pin];
+    }
+    processScale(config, data) {
+        const oldState = this._scaleStates[config.name];
+        const 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;
+    }
+    processStates(data) {
         var _a;
-        (_a = this.config.status) === null || _a === void 0 ? void 0 : _a.forEach(function (status) {
+        (_a = this.config.status) === null || _a === void 0 ? void 0 : _a.forEach((status) => {
             if (data.length > status.pin) {
-                _this.processState(status, data);
+                this.processState(status, data);
             }
         });
-    };
-    NodeGamepad.prototype.processState = function (config, data) {
-        var oldState = this._statusStates[config.name];
-        var newState = data[config.pin];
+    }
+    processState(config, data) {
+        const oldState = this._statusStates[config.name];
+        const 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];
+    }
+    getStateName(states, value) {
+        for (const state of states) {
             if (state.value === value) {
                 return state.state;
             }
         }
-        return "unknown state:".concat(value);
-    };
-    return NodeGamepad;
-}(events_1.EventEmitter));
+        return `unknown state:${value}`;
+    }
+}
 exports.NodeGamepad = NodeGamepad;
 //# sourceMappingURL=NodeGamepad.js.map

package/index.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.NodeGamepad = void 0;
-var NodeGamepad_1 = require("./NodeGamepad");
+const NodeGamepad_1 = require("./NodeGamepad");
 Object.defineProperty(exports, "NodeGamepad", { enumerable: true, get: function () { return NodeGamepad_1.NodeGamepad; } });
 //# sourceMappingURL=index.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sensslen/node-gamepad",
-  "version": "1.0.9-beta.213",
+  "version": "1.0.9-beta.217",
   "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": {