@zwave-js/cc 15.23.0 → 15.23.3

package/build/cjs/cc/DoorLockCC.d.ts

@@ -1,6 +1,6 @@
 import { Duration, type EndpointId, type GetValueDB, type MaybeNotKnown, type MessageOrCCLogEntry, type SupervisionResult, type WithAddress } from "@zwave-js/core";
 import { Bytes } from "@zwave-js/shared";
-import { POLL_VALUE, PhysicalCCAPI, type PollValueImplementation, SET_VALUE, type SetValueImplementation } from "../lib/API.js";
+import { POLL_VALUE, PhysicalCCAPI, type PollValueImplementation, SET_VALUE, SET_VALUE_HOOKS, type SetValueImplementation, type SetValueImplementationHooksFactory } from "../lib/API.js";
 import { type CCRaw, CommandClass, type InterviewContext, type PersistValuesContext, type RefreshValuesContext, type RefreshValuesOptions } from "../lib/CommandClass.js";
 import { type DoorHandleStatus, DoorLockCommand, DoorLockMode, DoorLockOperationType } from "../lib/_Types.js";
 import type { CCEncodingContext, CCParsingContext } from "../lib/traits.js";
@@ -16,6 +16,7 @@ export declare function shouldAutoCreateHoldAndReleaseConfigValue(ctx: GetValueD
 export declare class DoorLockCCAPI extends PhysicalCCAPI {
     supportsCommand(cmd: DoorLockCommand): MaybeNotKnown<boolean>;
     protected get [SET_VALUE](): SetValueImplementation;
+    protected [SET_VALUE_HOOKS]: SetValueImplementationHooksFactory;
     protected get [POLL_VALUE](): PollValueImplementation;
     getCapabilities(): Promise<Pick<DoorLockCCCapabilitiesReport, "autoRelockSupported" | "blockToBlockSupported" | "boltSupported" | "doorSupported" | "holdAndReleaseSupported" | "latchSupported" | "supportedDoorLockModes" | "supportedInsideHandles" | "supportedOperationTypes" | "supportedOutsideHandles" | "twistAssistSupported"> | undefined>;
     get(): Promise<Pick<DoorLockCCOperationReport, "boltStatus" | "currentMode" | "doorStatus" | "duration" | "insideHandlesCanOpenDoor" | "latchStatus" | "lockTimeout" | "outsideHandlesCanOpenDoor" | "targetMode"> | undefined>;
@@ -63,7 +64,7 @@ export interface DoorLockCCOperationSetOptions {
 }
 export declare class DoorLockCCOperationSet extends DoorLockCC {
     constructor(options: WithAddress<DoorLockCCOperationSetOptions>);
-    static from(_raw: CCRaw, _ctx: CCParsingContext): DoorLockCCOperationSet;
+    static from(raw: CCRaw, ctx: CCParsingContext): DoorLockCCOperationSet;
     mode: DoorLockMode;
     serialize(ctx: CCEncodingContext): Promise<Bytes>;
     toLogEntry(ctx?: GetValueDB): MessageOrCCLogEntry;
@@ -82,6 +83,7 @@ export interface DoorLockCCOperationReportOptions {
 export declare class DoorLockCCOperationReport extends DoorLockCC {
     constructor(options: WithAddress<DoorLockCCOperationReportOptions>);
     static from(raw: CCRaw, ctx: CCParsingContext): DoorLockCCOperationReport;
+    serialize(ctx: CCEncodingContext): Promise<Bytes>;
     persistValues(ctx: PersistValuesContext): boolean;
     readonly currentMode: DoorLockMode;
     readonly targetMode?: DoorLockMode;
@@ -109,6 +111,7 @@ export interface DoorLockCCConfigurationReportOptions {
 export declare class DoorLockCCConfigurationReport extends DoorLockCC {
     constructor(options: WithAddress<DoorLockCCConfigurationReportOptions>);
     static from(raw: CCRaw, ctx: CCParsingContext): DoorLockCCConfigurationReport;
+    serialize(ctx: CCEncodingContext): Promise<Bytes>;
     readonly operationType: DoorLockOperationType;
     readonly outsideHandlesCanOpenDoorConfiguration: DoorHandleStatus;
     readonly insideHandlesCanOpenDoorConfiguration: DoorHandleStatus;
@@ -138,7 +141,7 @@ export type DoorLockCCConfigurationSetOptions = ({
 };
 export declare class DoorLockCCConfigurationSet extends DoorLockCC {
     constructor(options: WithAddress<DoorLockCCConfigurationSetOptions>);
-    static from(_raw: CCRaw, _ctx: CCParsingContext): DoorLockCCConfigurationSet;
+    static from(raw: CCRaw, ctx: CCParsingContext): DoorLockCCConfigurationSet;
     operationType: DoorLockOperationType;
     outsideHandlesCanOpenDoorConfiguration: DoorHandleStatus;
     insideHandlesCanOpenDoorConfiguration: DoorHandleStatus;
@@ -177,6 +180,7 @@ export declare class DoorLockCCCapabilitiesReport extends DoorLockCC {
     readonly holdAndReleaseSupported: boolean;
     readonly twistAssistSupported: boolean;
     readonly blockToBlockSupported: boolean;
+    serialize(ctx: CCEncodingContext): Promise<Bytes>;
     toLogEntry(ctx?: GetValueDB): MessageOrCCLogEntry;
 }
 export declare class DoorLockCCCapabilitiesGet extends DoorLockCC {

package/build/cjs/cc/DoorLockCC.js

@@ -165,13 +165,7 @@ let DoorLockCCAPI = (() => {
           if (typeof value !== "number") {
             (0, import_API.throwWrongValueType)(this.ccId, property, "number", typeof value);
           }
-          const result = await this.set(value);
-          if ((0, import_core.supervisedCommandSucceeded)(result)) {
-            this.getValueDB().setValue(import_CCValues_generated.DoorLockCCValues.currentMode.endpoint(this.endpoint.index), value);
-          } else {
-            this.schedulePoll({ property }, value);
-          }
-          return result;
+          return this.set(value);
         } else if (typeof property === "string" && configurationSetParameters.includes(property)) {
           const config = {
             [property]: value
@@ -202,6 +196,44 @@ let DoorLockCCAPI = (() => {
         }
       };
     }
+    [import_API.SET_VALUE_HOOKS] = ((0, import_tslib.__runInitializers)(this, _instanceExtraInitializers), ({ property }, value) => {
+      if (property === "targetMode" && typeof value === "number") {
+        const targetMode = value;
+        const currentModeValueId = import_CCValues_generated.DoorLockCCValues.currentMode.endpoint(this.endpoint.index);
+        return {
+          isSplitStateTargetValue: true,
+          supervisionDelayedUpdates: true,
+          optimisticallyUpdateRelatedValues: /* @__PURE__ */ __name((_supervisedAndSuccessful) => {
+            this.tryGetValueDB()?.setValue(currentModeValueId, targetMode);
+          }, "optimisticallyUpdateRelatedValues"),
+          supervisionOnSuccess: /* @__PURE__ */ __name(() => {
+            this.tryGetValueDB()?.setValue(currentModeValueId, targetMode);
+          }, "supervisionOnSuccess"),
+          supervisionOnFailure: /* @__PURE__ */ __name(async () => {
+            try {
+              await this.get();
+            } catch {
+            }
+          }, "supervisionOnFailure"),
+          verifyChanges: /* @__PURE__ */ __name(async (result) => {
+            switch (result?.status) {
+              case import_core.SupervisionStatus.Success:
+              case import_core.SupervisionStatus.Working:
+                return;
+              case import_core.SupervisionStatus.Fail:
+              case import_core.SupervisionStatus.NoSupport:
+                try {
+                  await this.get();
+                } catch {
+                }
+                return;
+              default:
+                this.schedulePoll({ property: "currentMode" }, targetMode);
+            }
+          }, "verifyChanges")
+        };
+      }
+    });
     get [import_API.POLL_VALUE]() {
       return async function({ property }) {
         switch (property) {
@@ -314,10 +346,6 @@ let DoorLockCCAPI = (() => {
         ]);
       }
     }
-    constructor() {
-      super(...arguments);
-      (0, import_tslib.__runInitializers)(this, _instanceExtraInitializers);
-    }
   };
   return DoorLockCCAPI2 = _classThis;
 })();
@@ -562,8 +590,13 @@ let DoorLockCCOperationSet = (() => {
       }
       this.mode = options.mode;
     }
-    static from(_raw, _ctx) {
-      throw new import_core.ZWaveError(`${this.name}: deserialization not implemented`, import_core.ZWaveErrorCodes.Deserialization_NotImplemented);
+    static from(raw, ctx) {
+      (0, import_core.validatePayload)(raw.payload.length >= 1);
+      const mode = raw.payload[0];
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        mode
+      });
     }
     mode;
     serialize(ctx) {
@@ -656,6 +689,32 @@ let DoorLockCCOperationReport = (() => {
         duration
       });
     }
+    serialize(ctx) {
+      const handles = [
+        ...this.insideHandlesCanOpenDoor,
+        ...this.outsideHandlesCanOpenDoor
+      ].map((val, i) => val ? 1 << i : 0).reduce((acc, cur) => acc | cur, 0);
+      const doorCondition = (this.doorStatus === "closed" ? 1 : 0) | (this.boltStatus === "unlocked" ? 2 : 0) | (this.latchStatus === "closed" ? 4 : 0);
+      let lockTimeoutMinutes = 254;
+      let lockTimeoutSeconds = 254;
+      if (this.lockTimeout != void 0) {
+        lockTimeoutMinutes = Math.floor(this.lockTimeout / 60);
+        lockTimeoutSeconds = this.lockTimeout % 60;
+      }
+      const payload = [
+        this.currentMode,
+        handles,
+        doorCondition,
+        lockTimeoutMinutes,
+        lockTimeoutSeconds
+      ];
+      if (this.targetMode != void 0) {
+        payload.push(this.targetMode);
+        payload.push((this.duration ?? import_core.Duration.default()).serializeReport());
+      }
+      this.payload = import_shared.Bytes.from(payload);
+      return super.serialize(ctx);
+    }
     persistValues(ctx) {
       if (!super.persistValues(ctx))
         return false;
@@ -815,6 +874,35 @@ let DoorLockCCConfigurationReport = (() => {
         blockToBlock
       });
     }
+    serialize(ctx) {
+      const handles = [
+        ...this.insideHandlesCanOpenDoorConfiguration,
+        ...this.outsideHandlesCanOpenDoorConfiguration
+      ].map((val, i) => val ? 1 << i : 0).reduce((acc, cur) => acc | cur, 0);
+      let lockTimeoutMinutes;
+      let lockTimeoutSeconds;
+      if (this.operationType === import_Types.DoorLockOperationType.Timed && this.lockTimeoutConfiguration != void 0) {
+        lockTimeoutMinutes = Math.floor(this.lockTimeoutConfiguration / 60);
+        lockTimeoutSeconds = this.lockTimeoutConfiguration % 60;
+      } else {
+        lockTimeoutMinutes = lockTimeoutSeconds = 254;
+      }
+      const flags = (this.twistAssist ? 1 : 0) | (this.blockToBlock ? 2 : 0);
+      this.payload = import_shared.Bytes.from([
+        this.operationType,
+        handles,
+        lockTimeoutMinutes,
+        lockTimeoutSeconds
+      ]);
+      if (this.autoRelockTime != void 0 || this.holdAndReleaseTime != void 0 || this.twistAssist != void 0 || this.blockToBlock != void 0) {
+        const extended = import_shared.Bytes.alloc(5);
+        extended.writeUInt16BE((this.autoRelockTime ?? 0) & 65535, 0);
+        extended.writeUInt16BE((this.holdAndReleaseTime ?? 0) & 65535, 2);
+        extended[4] = flags;
+        this.payload = import_shared.Bytes.concat([this.payload, extended]);
+      }
+      return super.serialize(ctx);
+    }
     operationType;
     outsideHandlesCanOpenDoorConfiguration;
     insideHandlesCanOpenDoorConfiguration;
@@ -929,8 +1017,51 @@ let DoorLockCCConfigurationSet = (() => {
       this.twistAssist = options.twistAssist;
       this.blockToBlock = options.blockToBlock;
     }
-    static from(_raw, _ctx) {
-      throw new import_core.ZWaveError(`${this.name}: deserialization not implemented`, import_core.ZWaveErrorCodes.Deserialization_NotImplemented);
+    static from(raw, ctx) {
+      (0, import_core.validatePayload)(raw.payload.length >= 4);
+      const operationType = raw.payload[0];
+      const outsideHandlesCanOpenDoorConfiguration = [
+        !!(raw.payload[1] & 16),
+        !!(raw.payload[1] & 32),
+        !!(raw.payload[1] & 64),
+        !!(raw.payload[1] & 128)
+      ];
+      const insideHandlesCanOpenDoorConfiguration = [
+        !!(raw.payload[1] & 1),
+        !!(raw.payload[1] & 2),
+        !!(raw.payload[1] & 4),
+        !!(raw.payload[1] & 8)
+      ];
+      let lockTimeoutConfiguration;
+      if (operationType === import_Types.DoorLockOperationType.Timed) {
+        const lockTimeoutMinutes = raw.payload[2];
+        const lockTimeoutSeconds = raw.payload[3];
+        if (lockTimeoutMinutes <= 253 && lockTimeoutSeconds <= 59) {
+          lockTimeoutConfiguration = lockTimeoutSeconds + lockTimeoutMinutes * 60;
+        }
+      }
+      let autoRelockTime;
+      let holdAndReleaseTime;
+      let twistAssist;
+      let blockToBlock;
+      if (raw.payload.length >= 9) {
+        autoRelockTime = raw.payload.readUInt16BE(4);
+        holdAndReleaseTime = raw.payload.readUInt16BE(6);
+        const flags = raw.payload[8];
+        twistAssist = !!(flags & 1);
+        blockToBlock = !!(flags & 2);
+      }
+      return new this({
+        nodeId: ctx.sourceNodeId,
+        operationType,
+        outsideHandlesCanOpenDoorConfiguration,
+        insideHandlesCanOpenDoorConfiguration,
+        lockTimeoutConfiguration,
+        autoRelockTime,
+        holdAndReleaseTime,
+        twistAssist,
+        blockToBlock
+      });
     }
     operationType;
     outsideHandlesCanOpenDoorConfiguration;
@@ -1100,6 +1231,24 @@ let DoorLockCCCapabilitiesReport = (() => {
     holdAndReleaseSupported;
     twistAssistSupported;
     blockToBlockSupported;
+    serialize(ctx) {
+      const operationTypeMask = (0, import_core.encodeBitMask)(this.supportedOperationTypes, void 0, 0);
+      const modeList = import_shared.Bytes.from(this.supportedDoorLockModes);
+      const handles = [
+        ...this.supportedInsideHandles,
+        ...this.supportedOutsideHandles
+      ].map((val, i) => val ? 1 << i : 0).reduce((acc, cur) => acc | cur, 0);
+      const componentStatus = (this.doorSupported ? 1 : 0) | (this.boltSupported ? 2 : 0) | (this.latchSupported ? 4 : 0);
+      const featureFlags = (this.blockToBlockSupported ? 1 : 0) | (this.twistAssistSupported ? 2 : 0) | (this.holdAndReleaseSupported ? 4 : 0) | (this.autoRelockSupported ? 8 : 0);
+      this.payload = import_shared.Bytes.concat([
+        [operationTypeMask.length & 31],
+        operationTypeMask,
+        [modeList.length],
+        modeList,
+        [handles, componentStatus, featureFlags]
+      ]);
+      return super.serialize(ctx);
+    }
     toLogEntry(ctx) {
       return {
         ...super.toLogEntry(ctx),