@homebridge/dbus-native 0.6.0 → 0.7.1

package/index.d.ts

@@ -0,0 +1,32 @@
+import { EventEmitter } from "events";
+import { Socket } from "net";
+
+export function systemBus(): MessageBus;
+
+export class MessageBus {
+  connection: BusConnection;
+  public invoke(message: any, callback: (error: { name: string, message: any } | undefined, value: any) => void): void;
+  public getService(name: string): DBusService;
+}
+
+export class BusConnection extends EventEmitter {
+  public stream: Socket;
+}
+
+export class DBusService {
+  public name: string;
+  public bus: MessageBus;
+  public getObject(name: string, callback: (error: null | Error, obj?: DBusObject) => void): DBusObject;
+  public getInterface(objName: string, ifaceName: string, callback: (error: null | Error, iface?: DBusInterface) => void): void;
+}
+
+export class DBusObject {
+  public name: string;
+  public service: DBusService;
+  public as(name: string): DBusInterface;
+}
+
+export class DBusInterface extends EventEmitter implements Record<string, any> {
+  public $parent: DBusObject;
+  public $name: string; // string interface name
+}

package/lib/dbus-buffer.js

@@ -1,4 +1,4 @@
-const Long = require('@homebridge/long');
+const Long = require('long');
 const parseSignature = require('./signature');
 
 // Buffer + position + global start position ( used in alignment )

package/lib/marshall.js

@@ -1,7 +1,7 @@
 const assert = require('assert');
 
 const parseSignature = require('./signature');
-const put = require('@homebridge/put');
+const put = require('./put');
 const Marshallers = require('./marshallers');
 const align = require('./align').align;
 

package/lib/marshallers.js

@@ -1,7 +1,7 @@
 const Buffer = require('safe-buffer').Buffer;
 const align = require('./align').align;
 const parseSignature = require('../lib/signature');
-const Long = require('@homebridge/long');
+const Long = require('long');
 /**
  * MakeSimpleMarshaller
  * @param signature - the signature of the data you want to check

package/lib/put.js

@@ -0,0 +1,101 @@
+const assert = require('assert');
+
+module.exports = Put;
+function Put() {
+  if (!(this instanceof Put)) return new Put();
+
+  var words = [];
+  var len = 0;
+
+  this.put = function (buf) {
+    words.push({ buffer: buf });
+    len += buf.length;
+    return this;
+  };
+
+  this.word8 = function (x) {
+    words.push({ bytes: 1, value: x });
+    len += 1;
+    return this;
+  };
+
+  this.floatle = function (x) {
+    words.push({ bytes: 'float', endian: 'little', value: x });
+    len += 4;
+    return this;
+  };
+
+  [8, 16, 24, 32, 64].forEach(
+    function (bits) {
+      this['word' + bits + 'be'] = function (x) {
+        words.push({ endian: 'big', bytes: bits / 8, value: x });
+        len += bits / 8;
+        return this;
+      };
+
+      this['word' + bits + 'le'] = function (x) {
+        words.push({ endian: 'little', bytes: bits / 8, value: x });
+        len += bits / 8;
+        return this;
+      };
+    }.bind(this)
+  );
+
+  this.pad = function (bytes) {
+    assert(
+      Number.isInteger(bytes),
+      'pad(bytes) must be supplied with an integer!'
+    );
+    words.push({ endian: 'big', bytes: bytes, value: 0 });
+    len += bytes;
+    return this;
+  };
+
+  this.length = function () {
+    return len;
+  };
+
+  this.buffer = function () {
+    var buf = Buffer.alloc(len);
+    var offset = 0;
+    words.forEach(function (word) {
+      if (word.buffer) {
+        word.buffer.copy(buf, offset, 0);
+        offset += word.buffer.length;
+      } else if (word.bytes === 'float') {
+        // s * f * 2^e
+        var v = Math.abs(word.value);
+        var s = (word.value >= 0) * 1;
+        var e = Math.ceil(Math.log(v) / Math.LN2);
+        var f = v / (1 << e);
+        console.dir([s, e, f]);
+
+        console.log(word.value);
+
+        // s:1, e:7, f:23
+        // [seeeeeee][efffffff][ffffffff][ffffffff]
+        buf[offset++] = (s << 7) & ~~(e / 2);
+        buf[offset++] = ((e & 1) << 7) & ~~(f / (1 << 16));
+        buf[offset++] = 0;
+        buf[offset++] = 0;
+        offset += 4;
+      } else {
+        var big = word.endian === 'big';
+        var ix = big ? [(word.bytes - 1) * 8, -8] : [0, 8];
+
+        for (var i = ix[0]; big ? i >= 0 : i < word.bytes * 8; i += ix[1]) {
+          if (i >= 32) {
+            buf[offset++] = Math.floor(word.value / Math.pow(2, i)) & 0xff;
+          } else {
+            buf[offset++] = (word.value >> i) & 0xff;
+          }
+        }
+      }
+    });
+    return buf;
+  };
+
+  this.write = function (stream) {
+    stream.write(this.buffer());
+  };
+}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@homebridge/dbus-native",
   "author": "Andrey Sidorov <sidorares@yandex.com>",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "keywords": [
     "dbus",
     "dcop",
@@ -15,7 +15,8 @@
     "bin/dbus2js.js",
     "lib/*",
     "index.js",
-    "package.json"
+    "package.json",
+    "index.d.ts"
   ],
   "directories": {
     "lib": "lib",
@@ -38,11 +39,10 @@
     "dbus2js": "bin/dbus2js.js"
   },
   "dependencies": {
-    "@homebridge/long": "^5.2.1",
-    "@homebridge/put": "^0.0.8",
     "event-stream": "^4.0.1",
     "hexy": "^0.3.5",
-    "minimist": "^1.2.6",
+    "long": "^5.3.2",
+    "minimist": "^1.2.8",
     "safe-buffer": "^5.1.2",
     "xml2js": "^0.6.2"
   },
@@ -52,16 +52,16 @@
     }
   },
   "devDependencies": {
-    "@types/minimist": "^1.2.2",
-    "eslint": "^8.57.0",
-    "eslint-config-prettier": "^9.1.0",
-    "eslint-plugin-markdown": "^4.0.1",
-    "eslint-plugin-prettier": "^5.1.3",
-    "husky": "^9.0.11",
-    "lint-staged": "^15.2.2",
-    "mocha": "^10.0.0",
-    "nyc": "^15.1.0",
-    "prettier": "^3.2.5"
+    "@types/minimist": "^1.2.5",
+    "eslint": "^8.57.1",
+    "eslint-config-prettier": "^10.1.5",
+    "eslint-plugin-markdown": "^5.1.0",
+    "eslint-plugin-prettier": "^5.4.1",
+    "husky": "^9.1.7",
+    "lint-staged": "^16.1.0",
+    "mocha": "^11.5.0",
+    "nyc": "^17.1.0",
+    "prettier": "^3.5.3"
   },
   "scripts": {
     "lint": "npm run lint:docs && npm run lint:code",