@zwave-js/cc 14.3.10 → 15.0.0-beta.1

package/build/cjs/cc/MultiChannelCC.js

@@ -43,7 +43,7 @@ __export(MultiChannelCC_exports, {
   MultiChannelCCV1CommandEncapsulation: () => MultiChannelCCV1CommandEncapsulation,
   MultiChannelCCV1Get: () => MultiChannelCCV1Get,
   MultiChannelCCV1Report: () => MultiChannelCCV1Report,
-  MultiChannelCCValues: () => MultiChannelCCValues
+  MultiChannelCCValues: () => import_CCValues_generated.MultiChannelCCValues
 });
 module.exports = __toCommonJS(MultiChannelCC_exports);
 var __validateArgs = __toESM(require("./MultiChannelCC._validateArgs.js"), 1);
@@ -56,6 +56,7 @@ var import_CommandClassDecorators = require("../lib/CommandClassDecorators.js");
 var import_EncapsulatingCommandClass = require("../lib/EncapsulatingCommandClass.js");
 var import_Values = require("../lib/Values.js");
 var import_Types = require("../lib/_Types.js");
+var import_CCValues_generated = require("./_CCValues.generated.js");
 var __runInitializers = function(thisArg, initializers, value) {
   var useValue = arguments.length > 2;
   for (var i = 0; i < initializers.length; i++) {
@@ -97,39 +98,10 @@ var __esDecorate = function(ctor, descriptorIn, decorators, contextIn, initializ
   done = true;
 };
 const { validateArgs_MultiChannelCCAPI_getEndpointCapabilities, validateArgs_MultiChannelCCAPI_findEndpoints, validateArgs_MultiChannelCCAPI_getAggregatedMembers, validateArgs_MultiChannelCCAPI_getEndpointCountV1 } = __validateArgs;
-const MultiChannelCCValues = Object.freeze({
-  ...import_Values.V.defineStaticCCValues(import_safe.CommandClasses["Multi Channel"], {
-    ...import_Values.V.staticProperty("endpointIndizes", void 0, {
-      internal: true,
-      supportsEndpoints: false
-    }),
-    ...import_Values.V.staticPropertyWithName("individualEndpointCount", "individualCount", void 0, {
-      internal: true,
-      supportsEndpoints: false
-    }),
-    ...import_Values.V.staticPropertyWithName("aggregatedEndpointCount", "aggregatedCount", void 0, {
-      internal: true,
-      supportsEndpoints: false
-    }),
-    ...import_Values.V.staticPropertyWithName("endpointCountIsDynamic", "countIsDynamic", void 0, {
-      internal: true,
-      supportsEndpoints: false
-    }),
-    ...import_Values.V.staticPropertyWithName("endpointsHaveIdenticalCapabilities", "identicalCapabilities", void 0, {
-      internal: true,
-      supportsEndpoints: false
-    }),
-    ...import_Values.V.staticPropertyWithName("endpointCCs", "commandClasses", void 0, { internal: true }),
-    ...import_Values.V.staticPropertyWithName("endpointDeviceClass", "deviceClass", void 0, { internal: true })
-  }),
-  ...import_Values.V.defineDynamicCCValues(import_safe.CommandClasses["Multi Channel"], {
-    ...import_Values.V.dynamicPropertyAndKeyWithName("aggregatedEndpointMembers", "members", (endpointIndex) => endpointIndex, ({ property, propertyKey }) => property === "members" && typeof propertyKey === "number", void 0, { internal: true })
-  })
-});
 function areEndpointsUnnecessary(ctx, nodeId, endpointIndizes) {
   const deviceClasses = /* @__PURE__ */ new Map();
   for (const endpoint of endpointIndizes) {
-    const devClassValueId = MultiChannelCCValues.endpointDeviceClass.endpoint(endpoint);
+    const devClassValueId = import_CCValues_generated.MultiChannelCCValues.endpointDeviceClass.endpoint(endpoint);
     const deviceClass = ctx.getValueDB(nodeId).getValue(devClassValueId);
     if (deviceClass) {
       deviceClasses.set(endpoint, {
@@ -309,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)(MultiChannelCCValues)];
+  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 _classDescriptor;
   let _classExtraInitializers = [];
   let _classThis;
@@ -473,10 +445,10 @@ endpoint count (aggregated): ${multiResponse.aggregatedEndpointCount}`;
             message: `all endpoints identical, skipping capability query for endpoint #${endpoint2}...`,
             direction: "none"
           });
-          const devClass = valueDB.getValue(MultiChannelCCValues.endpointDeviceClass.endpoint(allEndpoints[0]));
-          valueDB.setValue(MultiChannelCCValues.endpointDeviceClass.endpoint(endpoint2), devClass);
-          const ep1Caps = valueDB.getValue(MultiChannelCCValues.endpointCCs.endpoint(allEndpoints[0]));
-          valueDB.setValue(MultiChannelCCValues.endpointCCs.endpoint(endpoint2), [...ep1Caps]);
+          const devClass = valueDB.getValue(import_CCValues_generated.MultiChannelCCValues.endpointDeviceClass.endpoint(allEndpoints[0]));
+          valueDB.setValue(import_CCValues_generated.MultiChannelCCValues.endpointDeviceClass.endpoint(endpoint2), devClass);
+          const ep1Caps = valueDB.getValue(import_CCValues_generated.MultiChannelCCValues.endpointCCs.endpoint(allEndpoints[0]));
+          valueDB.setValue(import_CCValues_generated.MultiChannelCCValues.endpointCCs.endpoint(endpoint2), [...ep1Caps]);
           continue;
         }
         ctx.logNode(node.id, {
@@ -528,7 +500,7 @@ supported CCs:`;
           });
         }
       }
-      this.setValue(ctx, MultiChannelCCValues.endpointIndizes, allEndpoints);
+      this.setValue(ctx, import_CCValues_generated.MultiChannelCCValues.endpointIndizes, allEndpoints);
       this.setInterviewComplete(ctx, true);
     }
     async interviewV1(ctx) {
@@ -553,13 +525,13 @@ supported CCs:`;
         }
       }
       const numEndpoints = Math.max(...endpointCounts.values());
-      this.setValue(ctx, MultiChannelCCValues.endpointCountIsDynamic, false);
-      this.setValue(ctx, MultiChannelCCValues.aggregatedEndpointCount, 0);
-      this.setValue(ctx, MultiChannelCCValues.individualEndpointCount, numEndpoints);
-      this.setValue(ctx, MultiChannelCCValues.endpointsHaveIdenticalCapabilities, false);
+      this.setValue(ctx, import_CCValues_generated.MultiChannelCCValues.endpointCountIsDynamic, false);
+      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);
       for (let endpoint2 = 1; endpoint2 <= numEndpoints; endpoint2++) {
         const endpointCCs = [...endpointCounts.entries()].filter(([, ccEndpoints]) => ccEndpoints >= endpoint2).map(([ccId]) => ccId);
-        valueDB.setValue(MultiChannelCCValues.endpointCCs.endpoint(endpoint2), endpointCCs);
+        valueDB.setValue(import_CCValues_generated.MultiChannelCCValues.endpointCCs.endpoint(endpoint2), endpointCCs);
       }
       this.setInterviewComplete(ctx, true);
     }
@@ -567,7 +539,7 @@ supported CCs:`;
   return MultiChannelCC2 = _classThis;
 })();
 let MultiChannelCCEndPointReport = (() => {
-  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.EndPointReport), (0, import_CommandClassDecorators.ccValueProperty)("countIsDynamic", MultiChannelCCValues.endpointCountIsDynamic), (0, import_CommandClassDecorators.ccValueProperty)("identicalCapabilities", MultiChannelCCValues.endpointsHaveIdenticalCapabilities), (0, import_CommandClassDecorators.ccValueProperty)("individualCount", MultiChannelCCValues.individualEndpointCount), (0, import_CommandClassDecorators.ccValueProperty)("aggregatedCount", MultiChannelCCValues.aggregatedEndpointCount)];
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.EndPointReport), (0, import_CommandClassDecorators.ccValueProperty)("countIsDynamic", import_CCValues_generated.MultiChannelCCValues.endpointCountIsDynamic), (0, import_CommandClassDecorators.ccValueProperty)("identicalCapabilities", import_CCValues_generated.MultiChannelCCValues.endpointsHaveIdenticalCapabilities), (0, import_CommandClassDecorators.ccValueProperty)("individualCount", import_CCValues_generated.MultiChannelCCValues.individualEndpointCount), (0, import_CommandClassDecorators.ccValueProperty)("aggregatedCount", import_CCValues_generated.MultiChannelCCValues.aggregatedEndpointCount)];
   let _classDescriptor;
   let _classExtraInitializers = [];
   let _classThis;
@@ -714,8 +686,8 @@ let MultiChannelCCCapabilityReport = (() => {
     persistValues(ctx) {
       if (!super.persistValues(ctx))
         return false;
-      const deviceClassValue = MultiChannelCCValues.endpointDeviceClass;
-      const ccsValue = MultiChannelCCValues.endpointCCs;
+      const deviceClassValue = import_CCValues_generated.MultiChannelCCValues.endpointDeviceClass;
+      const ccsValue = import_CCValues_generated.MultiChannelCCValues.endpointCCs;
       if (this.wasRemoved) {
         this.removeValue(ctx, deviceClassValue);
         this.removeValue(ctx, ccsValue);
@@ -874,12 +846,8 @@ let MultiChannelCCEndPointFindReport = (() => {
     expectMoreMessages() {
       return this.reportsToFollow > 0;
     }
-    /** @deprecated Use {@link mergePartialCCsAsync} instead */
     mergePartialCCs(partials, _ctx) {
       this.foundEndpoints = [...partials, this].map((report) => report.foundEndpoints).reduce((prev, cur) => prev.concat(...cur), []);
-    }
-    mergePartialCCsAsync(partials, _ctx) {
-      this.foundEndpoints = [...partials, this].map((report) => report.foundEndpoints).reduce((prev, cur) => prev.concat(...cur), []);
       return Promise.resolve();
     }
     toLogEntry(ctx) {
@@ -950,7 +918,7 @@ let MultiChannelCCEndPointFind = (() => {
   return MultiChannelCCEndPointFind2 = _classThis;
 })();
 let MultiChannelCCAggregatedMembersReport = (() => {
-  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.AggregatedMembersReport), (0, import_CommandClassDecorators.ccValueProperty)("members", MultiChannelCCValues.aggregatedEndpointMembers, (self) => [self.aggregatedEndpointIndex])];
+  let _classDecorators = [(0, import_CommandClassDecorators.CCCommand)(import_Types.MultiChannelCommand.AggregatedMembersReport), (0, import_CommandClassDecorators.ccValueProperty)("members", import_CCValues_generated.MultiChannelCCValues.aggregatedEndpointMembers, (self) => [self.aggregatedEndpointIndex])];
   let _classDescriptor;
   let _classExtraInitializers = [];
   let _classThis;
@@ -1098,31 +1066,7 @@ let MultiChannelCCCommandEncapsulation = (() => {
       }
       this.destination = options.destination;
     }
-    /** @deprecated Use {@link fromAsync} instead */
-    static from(raw, ctx) {
-      (0, import_safe.validatePayload)(raw.payload.length >= 2);
-      let endpointIndex;
-      let destination;
-      if (ctx.getDeviceConfig?.(ctx.sourceNodeId)?.compat?.treatDestinationEndpointAsSource) {
-        endpointIndex = raw.payload[1] & 127;
-        destination = 0;
-      } else {
-        endpointIndex = raw.payload[0] & 127;
-        const isBitMask = !!(raw.payload[1] & 128);
-        destination = raw.payload[1] & 127;
-        if (isBitMask) {
-          destination = (0, import_safe.parseBitMask)(import_safe2.Bytes.from([destination]));
-        }
-      }
-      const encapsulated = import_CommandClass.CommandClass.parse(raw.payload.subarray(2), ctx);
-      return new this({
-        nodeId: ctx.sourceNodeId,
-        endpointIndex,
-        destination,
-        encapsulated
-      });
-    }
-    static async fromAsync(raw, ctx) {
+    static async from(raw, ctx) {
       (0, import_safe.validatePayload)(raw.payload.length >= 2);
       let endpointIndex;
       let destination;
@@ -1137,7 +1081,7 @@ let MultiChannelCCCommandEncapsulation = (() => {
           destination = (0, import_safe.parseBitMask)(import_safe2.Bytes.from([destination]));
         }
       }
-      const encapsulated = await import_CommandClass.CommandClass.parseAsync(raw.payload.subarray(2), ctx);
+      const encapsulated = await import_CommandClass.CommandClass.parse(raw.payload.subarray(2), ctx);
       return new this({
         nodeId: ctx.sourceNodeId,
         endpointIndex,
@@ -1148,8 +1092,7 @@ let MultiChannelCCCommandEncapsulation = (() => {
     encapsulated;
     /** The destination end point (0-127) or an array of destination end points (1-7) */
     destination;
-    /** @deprecated Use {@link serializeAsync} instead */
-    serialize(ctx) {
+    async serialize(ctx) {
       if (ctx.getDeviceConfig?.(this.nodeId)?.compat?.treatDestinationEndpointAsSource) {
         if (typeof this.destination === "number") {
           this.endpointIndex = this.destination;
@@ -1158,24 +1101,10 @@ let MultiChannelCCCommandEncapsulation = (() => {
       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]),
-        // eslint-disable-next-line @typescript-eslint/no-deprecated
-        this.encapsulated.serialize(ctx)
+        await this.encapsulated.serialize(ctx)
       ]);
       return super.serialize(ctx);
     }
-    async serializeAsync(ctx) {
-      if (ctx.getDeviceConfig?.(this.nodeId)?.compat?.treatDestinationEndpointAsSource) {
-        if (typeof this.destination === "number") {
-          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]),
-        await this.encapsulated.serializeAsync(ctx)
-      ]);
-      return super.serializeAsync(ctx);
-    }
     toLogEntry(ctx) {
       return {
         ...super.toLogEntry(ctx),
@@ -1323,23 +1252,11 @@ let MultiChannelCCV1CommandEncapsulation = (() => {
       this.encapsulated = options.encapsulated;
       this.endpointIndex = this.encapsulated.endpointIndex;
     }
-    /** @deprecated Use {@link fromAsync} instead */
-    static from(raw, ctx) {
+    static async from(raw, ctx) {
       (0, import_safe.validatePayload)(raw.payload.length >= 1);
       const endpointIndex = raw.payload[0];
       const isV2withV1Header = raw.payload.length >= 2 && raw.payload[1] === 0;
-      const encapsulated = import_CommandClass.CommandClass.parse(raw.payload.subarray(isV2withV1Header ? 2 : 1), ctx);
-      return new this({
-        nodeId: ctx.sourceNodeId,
-        endpointIndex,
-        encapsulated
-      });
-    }
-    static async fromAsync(raw, ctx) {
-      (0, import_safe.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.parseAsync(raw.payload.subarray(isV2withV1Header ? 2 : 1), ctx);
+      const encapsulated = await import_CommandClass.CommandClass.parse(raw.payload.subarray(isV2withV1Header ? 2 : 1), ctx);
       return new this({
         nodeId: ctx.sourceNodeId,
         endpointIndex,
@@ -1347,22 +1264,13 @@ let MultiChannelCCV1CommandEncapsulation = (() => {
       });
     }
     encapsulated;
-    /** @deprecated Use {@link serializeAsync} instead */
-    serialize(ctx) {
+    async serialize(ctx) {
       this.payload = import_safe2.Bytes.concat([
         import_safe2.Bytes.from([this.endpointIndex]),
-        // eslint-disable-next-line @typescript-eslint/no-deprecated
-        this.encapsulated.serialize(ctx)
+        await this.encapsulated.serialize(ctx)
       ]);
       return super.serialize(ctx);
     }
-    async serializeAsync(ctx) {
-      this.payload = import_safe2.Bytes.concat([
-        import_safe2.Bytes.from([this.endpointIndex]),
-        await this.encapsulated.serializeAsync(ctx)
-      ]);
-      return super.serializeAsync(ctx);
-    }
     computeEncapsulationOverhead() {
       return super.computeEncapsulationOverhead() + 1;
     }