@zwave-js/cc 15.1.0 → 15.1.2

package/build/cjs/cc/MultiChannelCC.js

@@ -47,8 +47,8 @@ __export(MultiChannelCC_exports, {
 });
 module.exports = __toCommonJS(MultiChannelCC_exports);
 var __validateArgs = __toESM(require("./MultiChannelCC._validateArgs.js"), 1);
-var import_safe = require("@zwave-js/core/safe");
-var import_safe2 = require("@zwave-js/shared/safe");
+var import_core = require("@zwave-js/core");
+var import_shared = require("@zwave-js/shared");
 var import_arrays = require("alcalzone-shared/arrays");
 var import_API = require("../lib/API.js");
 var import_CommandClass = require("../lib/CommandClass.js");
@@ -131,7 +131,7 @@ function areEndpointsUnnecessary(ctx, nodeId, endpointIndizes) {
 }
 __name(areEndpointsUnnecessary, "areEndpointsUnnecessary");
 let MultiChannelCCAPI = (() => {
-  let _classDecorators = [(0, import_CommandClassDecorators.API)(import_safe.CommandClasses["Multi Channel"])];
+  let _classDecorators = [(0, import_CommandClassDecorators.API)(import_core.CommandClasses["Multi Channel"])];
   let _classDescriptor;
   let _classExtraInitializers = [];
   let _classThis;
@@ -210,8 +210,8 @@ let MultiChannelCCAPI = (() => {
       });
       const response = await this.host.sendCommand(cc, this.commandOptions);
       if (response) {
-        const generic = (0, import_safe.getGenericDeviceClass)(response.genericDeviceClass);
-        const specific = (0, import_safe.getSpecificDeviceClass)(response.genericDeviceClass, response.specificDeviceClass);
+        const generic = (0, import_core.getGenericDeviceClass)(response.genericDeviceClass);
+        const specific = (0, import_core.getSpecificDeviceClass)(response.genericDeviceClass, response.specificDeviceClass);
         return {
           isDynamic: response.isDynamic,
           wasRemoved: response.wasRemoved,
@@ -281,7 +281,7 @@ let MultiChannelCCAPI = (() => {
   return MultiChannelCCAPI2 = _classThis;
 })();
 let MultiChannelCC = (() => {
-  let _classDecorators = [(0, import_CommandClassDecorators.commandClass)(import_safe.CommandClasses["Multi Channel"]), (0, import_CommandClassDecorators.implementedVersion)(4), (0, import_CommandClassDecorators.ccValues)(import_CCValues_generated.MultiChannelCCValues)];
+  let _classDecorators = [(0, import_CommandClassDecorators.commandClass)(import_core.CommandClasses["Multi Channel"]), (0, import_CommandClassDecorators.implementedVersion)(4), (0, import_CommandClassDecorators.ccValues)(import_CCValues_generated.MultiChannelCCValues)];
   let _classDescriptor;
   let _classExtraInitializers = [];
   let _classThis;
@@ -318,6 +318,7 @@ let MultiChannelCC = (() => {
     static encapsulateV1(cc) {
       const ret = new MultiChannelCCV1CommandEncapsulation({
         nodeId: cc.nodeId,
+        endpointIndex: cc.endpointIndex,
         encapsulated: cc
       });
       ret.encapsulationFlags = cc.encapsulationFlags;
@@ -346,8 +347,8 @@ let MultiChannelCC = (() => {
       if (ccVersion === 1)
         return this.interviewV1(ctx);
       const endpoint = node.getEndpoint(this.endpointIndex);
-      const api = import_API.CCAPI.create(import_safe.CommandClasses["Multi Channel"], ctx, endpoint).withOptions({
-        priority: import_safe.MessagePriority.NodeQuery
+      const api = import_API.CCAPI.create(import_core.CommandClasses["Multi Channel"], ctx, endpoint).withOptions({
+        priority: import_core.MessagePriority.NodeQuery
       });
       const valueDB = this.getValueDB(ctx);
       ctx.logNode(node.id, {
@@ -466,7 +467,7 @@ is dynamic end point:  ${caps.isDynamic}
 supported CCs:`;
           for (const cc of caps.supportedCCs) {
             logMessage += `
-  \xB7 ${(0, import_safe.getCCName)(cc)}`;
+  \xB7 ${(0, import_core.getCCName)(cc)}`;
           }
           ctx.logNode(node.id, {
             endpoint: this.endpointIndex,
@@ -506,20 +507,29 @@ supported CCs:`;
     async interviewV1(ctx) {
       const node = this.getNode(ctx);
       const endpoint = this.getEndpoint(ctx);
-      const api = import_API.CCAPI.create(import_safe.CommandClasses["Multi Channel"], ctx, endpoint);
+      const removeEndpoints = ctx.getDeviceConfig?.(node.id)?.compat?.removeEndpoints;
+      if (removeEndpoints === "*") {
+        ctx.logNode(node.id, {
+          endpoint: this.endpointIndex,
+          message: `Skipping ${this.ccName} interview b/c all endpoints are ignored by the device config file...`,
+          direction: "none"
+        });
+        return;
+      }
+      const api = import_API.CCAPI.create(import_core.CommandClasses["Multi Channel"], ctx, endpoint);
       const valueDB = this.getValueDB(ctx);
       const supportedCCs = [...node.getCCs()].filter(([, info]) => info.isSupported).map(([cc]) => cc).filter((cc) => !import_CommandClass.CommandClass.createInstanceUnchecked(node, cc)?.skipEndpointInterview());
       const endpointCounts = /* @__PURE__ */ new Map();
       for (const ccId of supportedCCs) {
         ctx.logNode(node.id, {
-          message: `Querying endpoint count for CommandClass ${(0, import_safe.getCCName)(ccId)}...`,
+          message: `Querying endpoint count for CommandClass ${(0, import_core.getCCName)(ccId)}...`,
           direction: "outbound"
         });
         const endpointCount = await api.getEndpointCountV1(ccId);
         if (endpointCount != void 0) {
           endpointCounts.set(ccId, endpointCount);
           ctx.logNode(node.id, {
-            message: `CommandClass ${(0, import_safe.getCCName)(ccId)} has ${endpointCount} endpoints`,
+            message: `CommandClass ${(0, import_core.getCCName)(ccId)} has ${endpointCount} endpoints`,
             direction: "inbound"
           });
         }
@@ -529,10 +539,22 @@ supported CCs:`;
       this.setValue(ctx, import_CCValues_generated.MultiChannelCCValues.aggregatedEndpointCount, 0);
       this.setValue(ctx, import_CCValues_generated.MultiChannelCCValues.individualEndpointCount, numEndpoints);
       this.setValue(ctx, import_CCValues_generated.MultiChannelCCValues.endpointsHaveIdenticalCapabilities, false);
+      if (removeEndpoints?.length) {
+        ctx.logNode(node.id, {
+          endpoint: this.endpointIndex,
+          message: `The following endpoints are ignored through the config file: ${removeEndpoints.join(", ")}`,
+          direction: "none"
+        });
+      }
+      const allEndpoints = [];
       for (let endpoint2 = 1; endpoint2 <= numEndpoints; endpoint2++) {
-        const endpointCCs = [...endpointCounts.entries()].filter(([, ccEndpoints]) => ccEndpoints >= endpoint2).map(([ccId]) => ccId);
-        valueDB.setValue(import_CCValues_generated.MultiChannelCCValues.endpointCCs.endpoint(endpoint2), endpointCCs);
+        if (!removeEndpoints?.includes(endpoint2)) {
+          const endpointCCs = [...endpointCounts.entries()].filter(([, ccEndpoints]) => ccEndpoints >= endpoint2).map(([ccId]) => ccId);
+          valueDB.setValue(import_CCValues_generated.MultiChannelCCValues.endpointCCs.endpoint(endpoint2), endpointCCs);
+          allEndpoints.push(endpoint2);
+        }
       }
+      this.setValue(ctx, import_CCValues_generated.MultiChannelCCValues.endpointIndizes, allEndpoints);
       this.setInterviewComplete(ctx, true);
     }
   };
@@ -566,7 +588,7 @@ let MultiChannelCCEndPointReport = (() => {
       this.aggregatedCount = options.aggregatedCount;
     }
     static from(raw, ctx) {
-      (0, import_safe.validatePayload)(raw.payload.length >= 2);
+      (0, import_core.validatePayload)(raw.payload.length >= 2);
       const countIsDynamic = !!(raw.payload[0] & 128);
       const identicalCapabilities = !!(raw.payload[0] & 64);
       const individualCount = raw.payload[1] & 127;
@@ -587,7 +609,7 @@ let MultiChannelCCEndPointReport = (() => {
     individualCount;
     aggregatedCount;
     serialize(ctx) {
-      this.payload = import_safe2.Bytes.from([
+      this.payload = import_shared.Bytes.from([
         (this.countIsDynamic ? 128 : 0) | (this.identicalCapabilities ? 64 : 0),
         this.individualCount & 127,
         this.aggregatedCount ?? 0
@@ -665,10 +687,10 @@ let MultiChannelCCCapabilityReport = (() => {
       this.wasRemoved = options.wasRemoved;
     }
     static from(raw, ctx) {
-      (0, import_safe.validatePayload)(raw.payload.length >= 1);
+      (0, import_core.validatePayload)(raw.payload.length >= 1);
       const endpointIndex = raw.payload[0] & 127;
       const isDynamic = !!(raw.payload[0] & 128);
-      const NIF = (0, import_safe.parseApplicationNodeInformation)(raw.payload.subarray(1));
+      const NIF = (0, import_core.parseApplicationNodeInformation)(raw.payload.subarray(1));
       const genericDeviceClass = NIF.genericDeviceClass;
       const specificDeviceClass = NIF.specificDeviceClass;
       const supportedCCs = NIF.supportedCCs;
@@ -707,11 +729,11 @@ let MultiChannelCCCapabilityReport = (() => {
     isDynamic;
     wasRemoved;
     serialize(ctx) {
-      this.payload = import_safe2.Bytes.concat([
-        import_safe2.Bytes.from([
+      this.payload = import_shared.Bytes.concat([
+        import_shared.Bytes.from([
           this.endpointIndex & 127 | (this.isDynamic ? 128 : 0)
         ]),
-        (0, import_safe.encodeApplicationNodeInformation)(this)
+        (0, import_core.encodeApplicationNodeInformation)(this)
       ]);
       return super.serialize(ctx);
     }
@@ -720,11 +742,11 @@ let MultiChannelCCCapabilityReport = (() => {
         ...super.toLogEntry(ctx),
         message: {
           "endpoint index": this.endpointIndex,
-          "generic device class": (0, import_safe.getGenericDeviceClass)(this.genericDeviceClass).label,
-          "specific device class": (0, import_safe.getSpecificDeviceClass)(this.genericDeviceClass, this.specificDeviceClass).label,
+          "generic device class": (0, import_core.getGenericDeviceClass)(this.genericDeviceClass).label,
+          "specific device class": (0, import_core.getSpecificDeviceClass)(this.genericDeviceClass, this.specificDeviceClass).label,
           "is dynamic end point": this.isDynamic,
           "supported CCs": this.supportedCCs.map((cc) => `
-\xB7 ${(0, import_safe.getCCName)(cc)}`).join("")
+\xB7 ${(0, import_core.getCCName)(cc)}`).join("")
         }
       };
     }
@@ -760,7 +782,7 @@ let MultiChannelCCCapabilityGet = (() => {
       this.requestedEndpoint = options.requestedEndpoint;
     }
     static from(raw, ctx) {
-      (0, import_safe.validatePayload)(raw.payload.length >= 1);
+      (0, import_core.validatePayload)(raw.payload.length >= 1);
       const requestedEndpoint = raw.payload[0] & 127;
       return new this({
         nodeId: ctx.sourceNodeId,
@@ -769,7 +791,7 @@ let MultiChannelCCCapabilityGet = (() => {
     }
     requestedEndpoint;
     serialize(ctx) {
-      this.payload = import_safe2.Bytes.from([this.requestedEndpoint & 127]);
+      this.payload = import_shared.Bytes.from([this.requestedEndpoint & 127]);
       return super.serialize(ctx);
     }
     toLogEntry(ctx) {
@@ -809,7 +831,7 @@ let MultiChannelCCEndPointFindReport = (() => {
       this.reportsToFollow = options.reportsToFollow;
     }
     static from(raw, ctx) {
-      (0, import_safe.validatePayload)(raw.payload.length >= 3);
+      (0, import_core.validatePayload)(raw.payload.length >= 3);
       const reportsToFollow = raw.payload[0];
       const genericClass = raw.payload[1];
       const specificClass = raw.payload[2];
@@ -827,13 +849,13 @@ let MultiChannelCCEndPointFindReport = (() => {
     foundEndpoints;
     reportsToFollow;
     serialize(ctx) {
-      this.payload = import_safe2.Bytes.concat([
-        import_safe2.Bytes.from([
+      this.payload = import_shared.Bytes.concat([
+        import_shared.Bytes.from([
           this.reportsToFollow,
           this.genericClass,
           this.specificClass
         ]),
-        import_safe2.Bytes.from(this.foundEndpoints.map((e) => e & 127))
+        import_shared.Bytes.from(this.foundEndpoints.map((e) => e & 127))
       ]);
       return super.serialize(ctx);
     }
@@ -854,8 +876,8 @@ let MultiChannelCCEndPointFindReport = (() => {
       return {
         ...super.toLogEntry(ctx),
         message: {
-          "generic device class": (0, import_safe.getGenericDeviceClass)(this.genericClass).label,
-          "specific device class": (0, import_safe.getSpecificDeviceClass)(this.genericClass, this.specificClass).label,
+          "generic device class": (0, import_core.getGenericDeviceClass)(this.genericClass).label,
+          "specific device class": (0, import_core.getSpecificDeviceClass)(this.genericClass, this.specificClass).label,
           "found endpoints": this.foundEndpoints.join(", "),
           "# of reports to follow": this.reportsToFollow
         }
@@ -890,7 +912,7 @@ let MultiChannelCCEndPointFind = (() => {
       this.specificClass = options.specificClass;
     }
     static from(raw, ctx) {
-      (0, import_safe.validatePayload)(raw.payload.length >= 2);
+      (0, import_core.validatePayload)(raw.payload.length >= 2);
       const genericClass = raw.payload[0];
       const specificClass = raw.payload[1];
       return new this({
@@ -902,15 +924,15 @@ let MultiChannelCCEndPointFind = (() => {
     genericClass;
     specificClass;
     serialize(ctx) {
-      this.payload = import_safe2.Bytes.from([this.genericClass, this.specificClass]);
+      this.payload = import_shared.Bytes.from([this.genericClass, this.specificClass]);
       return super.serialize(ctx);
     }
     toLogEntry(ctx) {
       return {
         ...super.toLogEntry(ctx),
         message: {
-          "generic device class": (0, import_safe.getGenericDeviceClass)(this.genericClass).label,
-          "specific device class": (0, import_safe.getSpecificDeviceClass)(this.genericClass, this.specificClass).label
+          "generic device class": (0, import_core.getGenericDeviceClass)(this.genericClass).label,
+          "specific device class": (0, import_core.getSpecificDeviceClass)(this.genericClass, this.specificClass).label
         }
       };
     }
@@ -943,12 +965,12 @@ let MultiChannelCCAggregatedMembersReport = (() => {
       this.members = options.members;
     }
     static from(raw, ctx) {
-      (0, import_safe.validatePayload)(raw.payload.length >= 2);
+      (0, import_core.validatePayload)(raw.payload.length >= 2);
       const aggregatedEndpointIndex = raw.payload[0] & 127;
       const bitMaskLength = raw.payload[1];
-      (0, import_safe.validatePayload)(raw.payload.length >= 2 + bitMaskLength);
+      (0, import_core.validatePayload)(raw.payload.length >= 2 + bitMaskLength);
       const bitMask = raw.payload.subarray(2, 2 + bitMaskLength);
-      const members = (0, import_safe.parseBitMask)(bitMask);
+      const members = (0, import_core.parseBitMask)(bitMask);
       return new this({
         nodeId: ctx.sourceNodeId,
         aggregatedEndpointIndex,
@@ -994,11 +1016,11 @@ let MultiChannelCCAggregatedMembersGet = (() => {
       this.requestedEndpoint = options.requestedEndpoint;
     }
     static from(_raw, _ctx) {
-      throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+      throw new import_core.ZWaveError(`${this.name}: deserialization not implemented`, import_core.ZWaveErrorCodes.Deserialization_NotImplemented);
     }
     requestedEndpoint;
     serialize(ctx) {
-      this.payload = import_safe2.Bytes.from([this.requestedEndpoint & 127]);
+      this.payload = import_shared.Bytes.from([this.requestedEndpoint & 127]);
       return super.serialize(ctx);
     }
     toLogEntry(ctx) {
@@ -1067,7 +1089,7 @@ let MultiChannelCCCommandEncapsulation = (() => {
       this.destination = options.destination;
     }
     static async from(raw, ctx) {
-      (0, import_safe.validatePayload)(raw.payload.length >= 2);
+      (0, import_core.validatePayload)(raw.payload.length >= 2);
       let endpointIndex;
       let destination;
       if (ctx.getDeviceConfig?.(ctx.sourceNodeId)?.compat?.treatDestinationEndpointAsSource) {
@@ -1078,7 +1100,7 @@ let MultiChannelCCCommandEncapsulation = (() => {
         const isBitMask = !!(raw.payload[1] & 128);
         destination = raw.payload[1] & 127;
         if (isBitMask) {
-          destination = (0, import_safe.parseBitMask)(import_safe2.Bytes.from([destination]));
+          destination = (0, import_core.parseBitMask)(import_shared.Bytes.from([destination]));
         }
       }
       const encapsulated = await import_CommandClass.CommandClass.parse(raw.payload.subarray(2), ctx);
@@ -1098,9 +1120,9 @@ let MultiChannelCCCommandEncapsulation = (() => {
           this.endpointIndex = this.destination;
         }
       }
-      const destination = typeof this.destination === "number" ? this.destination & 127 : (0, import_safe.encodeBitMask)(this.destination, 7)[0] | 128;
-      this.payload = import_safe2.Bytes.concat([
-        import_safe2.Bytes.from([this.endpointIndex & 127, destination]),
+      const destination = typeof this.destination === "number" ? this.destination & 127 : (0, import_core.encodeBitMask)(this.destination, 7)[0] | 128;
+      this.payload = import_shared.Bytes.concat([
+        import_shared.Bytes.from([this.endpointIndex & 127, destination]),
         await this.encapsulated.serialize(ctx)
       ]);
       return super.serialize(ctx);
@@ -1146,7 +1168,7 @@ let MultiChannelCCV1Report = (() => {
       this.endpointCount = options.endpointCount;
     }
     static from(raw, ctx) {
-      (0, import_safe.validatePayload)(raw.payload.length === 2);
+      (0, import_core.validatePayload)(raw.payload.length === 2);
       const requestedCC = raw.payload[0];
       const endpointCount = raw.payload[1];
       return new this({
@@ -1157,11 +1179,18 @@ let MultiChannelCCV1Report = (() => {
     }
     requestedCC;
     endpointCount;
+    serialize(ctx) {
+      this.payload = import_shared.Bytes.from([
+        this.requestedCC,
+        this.endpointCount
+      ]);
+      return super.serialize(ctx);
+    }
     toLogEntry(ctx) {
       return {
         ...super.toLogEntry(ctx),
         message: {
-          CC: (0, import_safe.getCCName)(this.requestedCC),
+          CC: (0, import_core.getCCName)(this.requestedCC),
           "# of endpoints": this.endpointCount
         }
       };
@@ -1197,18 +1226,23 @@ let MultiChannelCCV1Get = (() => {
       super(options);
       this.requestedCC = options.requestedCC;
     }
-    static from(_raw, _ctx) {
-      throw new import_safe.ZWaveError(`${this.name}: deserialization not implemented`, import_safe.ZWaveErrorCodes.Deserialization_NotImplemented);
+    static from(raw, ctx) {
+      (0, import_core.validatePayload)(raw.payload.length === 1);
+      const requestedCC = raw.payload[0];
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        requestedCC
+      });
     }
     requestedCC;
     serialize(ctx) {
-      this.payload = import_safe2.Bytes.from([this.requestedCC]);
+      this.payload = import_shared.Bytes.from([this.requestedCC]);
       return super.serialize(ctx);
     }
     toLogEntry(ctx) {
       return {
         ...super.toLogEntry(ctx),
-        message: { CC: (0, import_safe.getCCName)(this.requestedCC) }
+        message: { CC: (0, import_core.getCCName)(this.requestedCC) }
       };
     }
   };
@@ -1250,10 +1284,24 @@ let MultiChannelCCV1CommandEncapsulation = (() => {
     constructor(options) {
       super(options);
       this.encapsulated = options.encapsulated;
-      this.endpointIndex = this.encapsulated.endpointIndex;
+      this.encapsulated.encapsulatingCC = this;
+      let cur = this;
+      while (cur) {
+        if ((0, import_EncapsulatingCommandClass.isMultiEncapsulatingCommandClass)(cur)) {
+          for (const cc of cur.encapsulated) {
+            cc.endpointIndex = this.endpointIndex;
+          }
+          break;
+        } else if ((0, import_EncapsulatingCommandClass.isEncapsulatingCommandClass)(cur)) {
+          cur.encapsulated.endpointIndex = this.endpointIndex;
+          cur = cur.encapsulated;
+        } else {
+          break;
+        }
+      }
     }
     static async from(raw, ctx) {
-      (0, import_safe.validatePayload)(raw.payload.length >= 1);
+      (0, import_core.validatePayload)(raw.payload.length >= 1);
       const endpointIndex = raw.payload[0];
       const isV2withV1Header = raw.payload.length >= 2 && raw.payload[1] === 0;
       const encapsulated = await import_CommandClass.CommandClass.parse(raw.payload.subarray(isV2withV1Header ? 2 : 1), ctx);
@@ -1265,8 +1313,8 @@ let MultiChannelCCV1CommandEncapsulation = (() => {
     }
     encapsulated;
     async serialize(ctx) {
-      this.payload = import_safe2.Bytes.concat([
-        import_safe2.Bytes.from([this.endpointIndex]),
+      this.payload = import_shared.Bytes.concat([
+        import_shared.Bytes.from([this.endpointIndex]),
         await this.encapsulated.serialize(ctx)
       ]);
       return super.serialize(ctx);