zwave-js 14.3.3 → 14.3.4

package/build/cjs/lib/driver/Driver.js

@@ -5,6 +5,7 @@ var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
@@ -238,9 +239,11 @@ function checkOptions(options) {
     }
   }
 }
+__name(checkOptions, "checkOptions");
 function messageIsPing(msg) {
   return (0, import_serialapi9.containsCC)(msg) && msg.command instanceof import_cc.NoOperationCC;
 }
+__name(messageIsPing, "messageIsPing");
 function assertValidCCs(container) {
   if (container.command instanceof import_cc.InvalidCC) {
     if (typeof container.command.reason === "number") {
@@ -252,7 +255,11 @@ function assertValidCCs(container) {
     assertValidCCs(container.command);
   }
 }
+__name(assertValidCCs, "assertValidCCs");
 class Driver extends import_shared.TypedEventEmitter {
+  static {
+    __name(this, "Driver");
+  }
   port;
   constructor(port, ...optionsAndPresets) {
     super();
@@ -284,10 +291,10 @@ class Driver extends import_shared.TypedEventEmitter {
     });
     const self = this;
     this.messageEncodingContext = {
-      getHighestSecurityClass: (nodeId) => this.getHighestSecurityClass(nodeId),
-      hasSecurityClass: (nodeId, securityClass) => this.hasSecurityClass(nodeId, securityClass),
-      setSecurityClass: (nodeId, securityClass, granted) => this.setSecurityClass(nodeId, securityClass, granted),
-      getDeviceConfig: (nodeId) => this.getDeviceConfig(nodeId),
+      getHighestSecurityClass: /* @__PURE__ */ __name((nodeId) => this.getHighestSecurityClass(nodeId), "getHighestSecurityClass"),
+      hasSecurityClass: /* @__PURE__ */ __name((nodeId, securityClass) => this.hasSecurityClass(nodeId, securityClass), "hasSecurityClass"),
+      setSecurityClass: /* @__PURE__ */ __name((nodeId, securityClass, granted) => this.setSecurityClass(nodeId, securityClass, granted), "setSecurityClass"),
+      getDeviceConfig: /* @__PURE__ */ __name((nodeId) => this.getDeviceConfig(nodeId), "getDeviceConfig"),
       // These are evaluated lazily, so we cannot spread messageParsingContext unfortunately
       get securityManager() {
         return self.securityManager;
@@ -298,11 +305,11 @@ class Driver extends import_shared.TypedEventEmitter {
       get securityManagerLR() {
         return self.securityManagerLR;
       },
-      getSupportedCCVersion: (cc, nodeId, endpointIndex) => this.getSupportedCCVersion(cc, nodeId, endpointIndex)
+      getSupportedCCVersion: /* @__PURE__ */ __name((cc, nodeId, endpointIndex) => this.getSupportedCCVersion(cc, nodeId, endpointIndex), "getSupportedCCVersion")
     };
     this.immediateQueue = new import_Queue.TransactionQueue({
       name: "immediate",
-      mayStartNextTransaction: (t) => {
+      mayStartNextTransaction: /* @__PURE__ */ __name((t) => {
         if (this.controller.status === import_core.ControllerStatus.Unresponsive) {
           return t.message instanceof import_serialapi4.SoftResetRequest || t.message instanceof import_serialapi3.GetControllerVersionRequest;
         }
@@ -310,11 +317,11 @@ class Driver extends import_shared.TypedEventEmitter {
           return t.message instanceof import_serialapi4.SoftResetRequest;
         }
         return !this.queuePaused && this.controller.status === import_core.ControllerStatus.Ready;
-      }
+      }, "mayStartNextTransaction")
     });
     this.queue = new import_Queue.TransactionQueue({
       name: "normal",
-      mayStartNextTransaction: (t) => this.mayStartTransaction(t)
+      mayStartNextTransaction: /* @__PURE__ */ __name((t) => this.mayStartTransaction(t), "mayStartNextTransaction")
     });
     this.serialAPIQueue = new import_shared.AsyncQueue();
     this._queueIdle = false;
@@ -333,7 +340,7 @@ class Driver extends import_shared.TypedEventEmitter {
   }
   getMessageParsingContext() {
     return {
-      getDeviceConfig: (nodeId) => this.getDeviceConfig(nodeId),
+      getDeviceConfig: /* @__PURE__ */ __name((nodeId) => this.getDeviceConfig(nodeId), "getDeviceConfig"),
       sdkVersion: this._controller?.sdkVersion,
       requestStorage: this._requestStorage,
       ownNodeId: this.controller.ownNodeId,
@@ -871,8 +878,8 @@ class Driver extends import_shared.TypedEventEmitter {
     this._valueDB = new import_jsonl_db.JsonlDB(valueDBFile, {
       ...options,
       enableTimestamps: true,
-      reviver: (key, value) => (0, import_core.deserializeCacheValue)(value),
-      serializer: (key, value) => (0, import_core.serializeCacheValue)(value)
+      reviver: /* @__PURE__ */ __name((key, value) => (0, import_core.deserializeCacheValue)(value), "reviver"),
+      serializer: /* @__PURE__ */ __name((key, value) => (0, import_core.serializeCacheValue)(value), "serializer")
     });
     await this._valueDB.open();
     const metadataDBFile = import_node_path.default.join(this.cacheDir, `${homeId.toString(16)}.metadata.jsonl`);
@@ -1506,7 +1513,7 @@ class Driver extends import_shared.TypedEventEmitter {
     }
   }
   /** This is called when a node emits a `"notification"` event */
-  onNodeNotification = (endpoint, ccId, ccArgs) => {
+  onNodeNotification = /* @__PURE__ */ __name((endpoint, ccId, ccArgs) => {
     let prefix;
     let details;
     if (ccId === import_core.CommandClasses.Notification) {
@@ -1544,7 +1551,7 @@ class Driver extends import_shared.TypedEventEmitter {
       endpoint: endpoint.index,
       message: [prefix, ...details.map((d) => `  ${d}`)].join("\n")
     });
-  };
+  }, "onNodeNotification");
   /** Checks if there are any pending messages for the given node */
   hasPendingMessages(node) {
     if (this.hasPendingTransactions((t) => t.message.getNodeId() === node.id)) {
@@ -1770,7 +1777,7 @@ class Driver extends import_shared.TypedEventEmitter {
       return true;
     }
     this.controllerLog.print("Did not receive notification that Serial API has started, checking if it responds...");
-    const pollController = async () => {
+    const pollController = /* @__PURE__ */ __name(async () => {
       try {
         this.unpauseSendQueue();
         await this.sendMessage(new import_serialapi3.GetControllerVersionRequest(), {
@@ -1783,7 +1790,7 @@ class Driver extends import_shared.TypedEventEmitter {
       } catch {
         return false;
       }
-    };
+    }, "pollController");
     if (await pollController())
       return true;
     for (const backoff of [2, 5, 10, 15]) {
@@ -2190,7 +2197,7 @@ ${(0, import_shared.buffer2hex)(data)}`, "warn");
           version: 1
         });
       }
-      const isS2NonceReport = (t) => t.message.getNodeId() === nodeId && (0, import_serialapi9.containsCC)(t.message) && t.message.command instanceof import_cc.Security2CCNonceReport;
+      const isS2NonceReport = /* @__PURE__ */ __name((t) => t.message.getNodeId() === nodeId && (0, import_serialapi9.containsCC)(t.message) && t.message.command instanceof import_cc.Security2CCNonceReport, "isS2NonceReport");
       const message = e.code === import_core.ZWaveErrorCodes.Security2CC_CannotDecode ? "Message authentication failed" : "No SPAN is established yet";
       if (this.controller.bootstrappingS2NodeId === nodeId) {
         const securityManager = this.getSecurityManager2(nodeId);
@@ -2303,7 +2310,7 @@ ${(0, import_shared.buffer2hex)(data)}`, "warn");
     if (!this._controller || !this.mayRecoverUnresponsiveController()) {
       return false;
     }
-    const recoverByReopeningSerialport = async () => {
+    const recoverByReopeningSerialport = /* @__PURE__ */ __name(async () => {
       if (!this.serial)
         return;
       this.driverLog.print("Attempting to recover unresponsive controller by reopening the serial port...", "warn");
@@ -2314,7 +2321,7 @@ ${(0, import_shared.buffer2hex)(data)}`, "warn");
       this.driverLog.print("Serial port reopened. Returning to normal operation and hoping for the best...", "warn");
       this._controller?.setStatus(import_core.ControllerStatus.Ready);
       this._recoveryPhase = 0;
-    };
+    }, "recoverByReopeningSerialport");
     if (this._controller.status !== import_core.ControllerStatus.Unresponsive && !this.maySoftReset() || this._recoveryPhase === 2) {
       void recoverByReopeningSerialport().catch(import_shared.noop);
       return true;
@@ -2548,7 +2555,7 @@ ${(0, import_shared.buffer2hex)(data)}`, "warn");
         direction: "inbound"
       });
       const RXStateMachine = (0, import_TransportServiceMachine.createTransportServiceRXMachine)({
-        requestMissingSegment: async (offset) => {
+        requestMissingSegment: /* @__PURE__ */ __name(async (offset) => {
           this.controllerLog.logNode(command.nodeId, {
             message: `Transport Service RX session #${command.sessionId}: Segment with offset ${offset} missing - requesting it...`,
             level: "debug",
@@ -2563,8 +2570,8 @@ ${(0, import_shared.buffer2hex)(data)}`, "warn");
             maxSendAttempts: 1,
             priority: import_core.MessagePriority.Immediate
           });
-        },
-        sendSegmentsComplete: async () => {
+        }, "requestMissingSegment"),
+        sendSegmentsComplete: /* @__PURE__ */ __name(async () => {
           this.controllerLog.logNode(command.nodeId, {
             message: `Transport Service RX session #${command.sessionId} complete`,
             level: "debug",
@@ -2578,7 +2585,7 @@ ${(0, import_shared.buffer2hex)(data)}`, "warn");
             maxSendAttempts: 1,
             priority: import_core.MessagePriority.Immediate
           });
-        }
+        }, "sendSegmentsComplete")
       }, {
         // TODO: Figure out how to know which timeout is the correct one. For now use the larger one
         missingSegmentTimeout: import_cc.TransportServiceTimeouts.requestMissingSegmentR2,
@@ -2725,7 +2732,7 @@ ${handlers.length} left`);
       return false;
     }
     const expectedSecurityCC = (0, import_core.securityClassIsS2)(secClass) ? import_core.CommandClasses["Security 2"] : secClass === import_core.SecurityClass.S0_Legacy ? import_core.CommandClasses.Security : void 0;
-    const isCCConsideredSecure = (cmd) => {
+    const isCCConsideredSecure = /* @__PURE__ */ __name((cmd) => {
       if (cmd instanceof import_cc.SecurityCC) {
         switch (cmd.ccCommand) {
           // Cannot be sent encapsulated:
@@ -2757,7 +2764,7 @@ ${handlers.length} left`);
         }
       }
       return cmd.ccId === expectedSecurityCC;
-    };
+    }, "isCCConsideredSecure");
     let requiresSecurity = (0, import_core.securityClassIsS2)(secClass);
     const isSecure = isCCConsideredSecure(cc);
     while (true) {
@@ -2860,16 +2867,16 @@ ${handlers.length} left`);
         let reply;
         if (supervisionSessionId != void 0) {
           const endpoint = node.getEndpoint(msg.command.endpointIndex) ?? node;
-          reply = (status) => endpoint.createAPI(import_core.CommandClasses.Supervision, false).withOptions({ s2MulticastOutOfSync }).sendReport({
+          reply = /* @__PURE__ */ __name((status) => endpoint.createAPI(import_core.CommandClasses.Supervision, false).withOptions({ s2MulticastOutOfSync }).sendReport({
             sessionId: supervisionSessionId,
             moreUpdatesFollow: false,
             status,
             requestWakeUpOnDemand: this.shouldRequestWakeupOnDemand(node),
             encapsulationFlags,
             lowPriority: this.shouldUseLowPriorityForSupervisionReport(node, encapsulationFlags)
-          });
+          }), "reply");
         } else {
-          reply = () => Promise.resolve();
+          reply = /* @__PURE__ */ __name(() => Promise.resolve(), "reply");
         }
         if (supervisionSessionId == void 0 && s2MulticastOutOfSync) {
           node.commandClasses["Security 2"].sendMOS().catch(() => {
@@ -3264,12 +3271,12 @@ ${handlers.length} left`);
       msg.callbackId = this.getNextCallbackId();
     }
     const machine = (0, import_SerialAPICommandMachine.createSerialAPICommandMachine)(msg, await msg.serializeAsync(this.getEncodingContext()), {
-      sendData: (data) => this.writeSerial(data),
-      sendDataAbort: () => this.abortSendData(),
-      notifyUnsolicited: (msg2) => {
+      sendData: /* @__PURE__ */ __name((data) => this.writeSerial(data), "sendData"),
+      sendDataAbort: /* @__PURE__ */ __name(() => this.abortSendData(), "sendDataAbort"),
+      notifyUnsolicited: /* @__PURE__ */ __name((msg2) => {
         void this.handleUnsolicitedMessage(msg2);
-      },
-      notifyRetry: (lastError, message, attempts, maxAttempts, delay) => {
+      }, "notifyUnsolicited"),
+      notifyRetry: /* @__PURE__ */ __name((lastError, message, attempts, maxAttempts, delay) => {
         let errorReason;
         switch (lastError) {
           case "response timeout":
@@ -3296,13 +3303,13 @@ ${handlers.length} left`);
             break;
         }
         this.controllerLog.print(`${errorReason} after ${attempts}/${maxAttempts} attempts. Scheduling next try in ${delay} ms.`, "warn");
-      },
+      }, "notifyRetry"),
       timestamp: import_core.highResTimestamp,
-      logOutgoingMessage: (msg2) => {
+      logOutgoingMessage: /* @__PURE__ */ __name((msg2) => {
         this.driverLog.logMessage(msg2, {
           direction: "outbound"
         });
-      }
+      }, "logOutgoingMessage")
     }, (0, import_shared.pick)(this._options, ["timeouts", "attempts"]));
     const result = (0, import_deferred_promise.createDeferredPromise)();
     if (msg.functionType === import_serial.FunctionType.SoftReset && this.controller.sdkVersionGte("7.19.0")) {
@@ -3598,17 +3605,17 @@ ${handlers.length} left`);
       const promise = (0, import_deferred_promise.createDeferredPromise)();
       const entry = {
         predicate,
-        handler: (msg) => promise.resolve(msg),
+        handler: /* @__PURE__ */ __name((msg) => promise.resolve(msg), "handler"),
         timeout: void 0
       };
       this.awaitedMessageHeaders.push(entry);
-      const removeEntry = () => {
+      const removeEntry = /* @__PURE__ */ __name(() => {
         if (entry.timeout)
           clearTimeout(entry.timeout);
         const index = this.awaitedMessageHeaders.indexOf(entry);
         if (index !== -1)
           this.awaitedMessageHeaders.splice(index, 1);
-      };
+      }, "removeEntry");
       entry.timeout = setTimeout(() => {
         removeEntry();
         reject(new import_core.ZWaveError(`Received no matching serial frame within the provided timeout!`, import_core.ZWaveErrorCodes.Controller_Timeout));
@@ -3633,17 +3640,17 @@ ${handlers.length} left`);
       const entry = {
         predicate,
         refreshPredicate,
-        handler: (msg) => promise.resolve(msg),
+        handler: /* @__PURE__ */ __name((msg) => promise.resolve(msg), "handler"),
         timeout: void 0
       };
       this.awaitedMessages.push(entry);
-      const removeEntry = () => {
+      const removeEntry = /* @__PURE__ */ __name(() => {
         if (entry.timeout)
           clearTimeout(entry.timeout);
         const index = this.awaitedMessages.indexOf(entry);
         if (index !== -1)
           this.awaitedMessages.splice(index, 1);
-      };
+      }, "removeEntry");
       entry.timeout = setTimeout(() => {
         removeEntry();
         reject(new import_core.ZWaveError(`Received no matching message within the provided timeout!`, import_core.ZWaveErrorCodes.Controller_Timeout));
@@ -3664,17 +3671,17 @@ ${handlers.length} left`);
       const promise = (0, import_deferred_promise.createDeferredPromise)();
       const entry = {
         predicate,
-        handler: (cc) => promise.resolve(cc),
+        handler: /* @__PURE__ */ __name((cc) => promise.resolve(cc), "handler"),
         timeout: void 0
       };
       this.awaitedCommands.push(entry);
-      const removeEntry = () => {
+      const removeEntry = /* @__PURE__ */ __name(() => {
         if (entry.timeout)
           clearTimeout(entry.timeout);
         const index = this.awaitedCommands.indexOf(entry);
         if (index !== -1)
           this.awaitedCommands.splice(index, 1);
-      };
+      }, "removeEntry");
       entry.timeout = setTimeout(() => {
         removeEntry();
         reject(new import_core.ZWaveError(`Received no matching command within the provided timeout!`, import_core.ZWaveErrorCodes.Controller_NodeTimeout));
@@ -3692,17 +3699,17 @@ ${handlers.length} left`);
   registerCommandHandler(predicate, handler) {
     const entry = {
       predicate,
-      handler: (cc) => handler(cc),
+      handler: /* @__PURE__ */ __name((cc) => handler(cc), "handler"),
       timeout: void 0
     };
     this.awaitedCommands.push(entry);
-    const removeEntry = () => {
+    const removeEntry = /* @__PURE__ */ __name(() => {
       if (entry.timeout)
         clearTimeout(entry.timeout);
       const index = this.awaitedCommands.indexOf(entry);
       if (index !== -1)
         this.awaitedCommands.splice(index, 1);
-    };
+    }, "removeEntry");
     return {
       unregister: removeEntry
     };
@@ -3826,7 +3833,7 @@ ${handlers.length} left`);
     const dropQueued = [];
     let stopActive;
     const requeue = [];
-    const reduceTransaction = (transaction, source) => {
+    const reduceTransaction = /* @__PURE__ */ __name((transaction, source) => {
       const reducerResult = reducer(transaction, source);
       switch (reducerResult.type) {
         case "drop":
@@ -3871,7 +3878,7 @@ ${handlers.length} left`);
           }
           break;
       }
-    };
+    }, "reduceTransaction");
     for (const transaction of queue.transactions) {
       reduceTransaction(transaction, "queue");
     }
@@ -3987,13 +3994,13 @@ ${handlers.length} left`);
     if (this.sendNodeToSleepTimers.has(node.id)) {
       clearTimeout(this.sendNodeToSleepTimers.get(node.id));
     }
-    const sendNodeToSleep = (node2) => {
+    const sendNodeToSleep = /* @__PURE__ */ __name((node2) => {
       this.sendNodeToSleepTimers.delete(node2.id);
       if (!this.hasPendingMessages(node2)) {
         void node2.sendNoMoreInformation().catch(() => {
         });
       }
-    };
+    }, "sendNodeToSleep");
     if (node.supportsCC(import_core.CommandClasses["Wake Up"]) && !this.hasPendingMessages(node)) {
       const wakeUpInterval = node.getValue(import_cc.WakeUpCCValues.wakeUpInterval.id);
       if (wakeUpInterval !== 0) {
@@ -4224,17 +4231,17 @@ ${handlers.length} left`);
       const promise = (0, import_deferred_promise.createDeferredPromise)();
       const entry = {
         predicate,
-        handler: (chunk) => promise.resolve(chunk),
+        handler: /* @__PURE__ */ __name((chunk) => promise.resolve(chunk), "handler"),
         timeout: void 0
       };
       this.awaitedBootloaderChunks.push(entry);
-      const removeEntry = () => {
+      const removeEntry = /* @__PURE__ */ __name(() => {
         if (entry.timeout)
           clearTimeout(entry.timeout);
         const index = this.awaitedBootloaderChunks.indexOf(entry);
         if (index !== -1)
           this.awaitedBootloaderChunks.splice(index, 1);
-      };
+      }, "removeEntry");
       entry.timeout = setTimeout(() => {
         removeEntry();
         reject(new import_core.ZWaveError(`Received no matching chunk within the provided timeout!`, import_core.ZWaveErrorCodes.Controller_Timeout));
@@ -4294,7 +4301,7 @@ ${handlers.length} left`);
     };
     this._powerlevelTestNodeContext = context;
     const interval = 50;
-    const sendFrame = async () => {
+    const sendFrame = /* @__PURE__ */ __name(async () => {
       const result = await this.sendTestFrame(testNodeId, powerlevel);
       if (result === import_core.TransmitStatus.OK) {
         context.acknowledgedFrames++;
@@ -4306,7 +4313,7 @@ ${handlers.length} left`);
         context.timeout = void 0;
         ret.resolve(context.acknowledgedFrames);
       }
-    };
+    }, "sendFrame");
     context.timeout = setTimeout(sendFrame, interval);
     return ret;
   }