@matter/node 0.11.0-alpha.0-20241005-e3e4e4a7a

package/dist/cjs/behaviors/window-covering/WindowCoveringServer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WindowCoveringServer.d.ts","sourceRoot":"","sources":["../../../../src/behaviors/window-covering/WindowCoveringServer.ts"],"names":[],"mappings":"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"}

package/dist/cjs/behaviors/window-covering/WindowCoveringServer.js

@@ -0,0 +1,555 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var WindowCoveringServer_exports = {};
+__export(WindowCoveringServer_exports, {
+  CalibrationMode: () => CalibrationMode,
+  MovementDirection: () => MovementDirection,
+  MovementType: () => MovementType,
+  WindowCoveringServer: () => WindowCoveringServer,
+  WindowCoveringServerLogic: () => WindowCoveringServerLogic
+});
+module.exports = __toCommonJS(WindowCoveringServer_exports);
+var import_window_covering = require("#clusters/window-covering");
+var import_general = require("#general");
+var import_types = require("#types");
+var import_WindowCoveringBehavior = require("./WindowCoveringBehavior.js");
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+const logger = import_general.Logger.get("WindowCoveringServer");
+const WindowCoveringServerBase = import_WindowCoveringBehavior.WindowCoveringBehavior.with(
+  import_window_covering.WindowCovering.Feature.Lift,
+  import_window_covering.WindowCovering.Feature.Tilt,
+  import_window_covering.WindowCovering.Feature.PositionAwareLift,
+  import_window_covering.WindowCovering.Feature.PositionAwareTilt,
+  import_window_covering.WindowCovering.Feature.AbsolutePosition
+);
+var MovementType = /* @__PURE__ */ ((MovementType2) => {
+  MovementType2[MovementType2["Lift"] = 0] = "Lift";
+  MovementType2[MovementType2["Tilt"] = 1] = "Tilt";
+  return MovementType2;
+})(MovementType || {});
+var CalibrationMode = /* @__PURE__ */ ((CalibrationMode2) => {
+  CalibrationMode2[CalibrationMode2["Enabled"] = 0] = "Enabled";
+  CalibrationMode2[CalibrationMode2["Running"] = 1] = "Running";
+  CalibrationMode2[CalibrationMode2["Disabled"] = 2] = "Disabled";
+  return CalibrationMode2;
+})(CalibrationMode || {});
+var MovementDirection = /* @__PURE__ */ ((MovementDirection2) => {
+  MovementDirection2[MovementDirection2["Open"] = 0] = "Open";
+  MovementDirection2[MovementDirection2["Close"] = 1] = "Close";
+  MovementDirection2[MovementDirection2["DefinedByPosition"] = 2] = "DefinedByPosition";
+  return MovementDirection2;
+})(MovementDirection || {});
+const WC_PERCENT100THS_MIN_OPEN = 0;
+const WC_PERCENT100THS_MAX_CLOSED = 1e4;
+const WC_PERCENT100THS_COEFFICIENT = 100;
+class WindowCoveringServerLogic extends WindowCoveringServerBase {
+  initialize() {
+    this.internal.inMaintenanceMode = !!this.state.mode.maintenanceMode;
+    this.internal.calibrationMode = this.state.mode.calibrationMode && !this.state.mode.maintenanceMode ? 0 /* Enabled */ : 2 /* Disabled */;
+    this.reactTo(this.events.mode$Changing, this.#handleModeChanging);
+    const configStatus = this.state.configStatus;
+    configStatus.operational = !this.internal.inMaintenanceMode && !this.state.mode.calibrationMode;
+    if (this.features.lift) {
+      if (this.features.positionAwareLift) {
+        configStatus.liftPositionAware = true;
+      }
+    }
+    if (this.features.tilt) {
+      if (this.features.positionAwareTilt) {
+        configStatus.tiltPositionAware = true;
+      }
+    }
+    if (!(0, import_general.isDeepEqual)(configStatus, this.state.configStatus)) {
+      this.state.configStatus = configStatus;
+    }
+    if (this.features.tilt) {
+      this.state.targetPositionTiltPercent100ths = this.state.currentPositionTiltPercent100ths;
+    }
+    if (this.features.lift) {
+      this.state.targetPositionLiftPercent100ths = this.state.currentPositionLiftPercent100ths;
+    }
+    this.reactTo(this.events.currentPositionLiftPercent100ths$Changing, this.#syncLiftCurrentPositions);
+    this.reactTo(this.events.currentPositionTiltPercent100ths$Changing, this.#syncTiltCurrentPositions);
+    this.reactTo(this.events.targetPositionLiftPercent100ths$Changing, this.#handleLiftTargetPositionChanging);
+    this.reactTo(this.events.targetPositionTiltPercent100ths$Changing, this.#handleTiltTargetPositionChanging);
+    this.reactTo(this.events.operationalStatus$Changing, this.#handleOperationalStatusChanging);
+  }
+  /**
+   * Sync the mode attribute with the configStatus attribute and the internal state.
+   */
+  #handleModeChanging(mode) {
+    if (mode.maintenanceMode && mode.calibrationMode) {
+      mode.calibrationMode = false;
+    }
+    if (mode.maintenanceMode && !this.state.supportsMaintenanceMode) {
+      throw new import_types.StatusResponseError("Maintenance mode not supported", import_types.StatusCode.ConstraintError);
+    }
+    this.internal.inMaintenanceMode = !!mode.maintenanceMode;
+    if (mode.calibrationMode) {
+      if (!this.state.supportsCalibration) {
+        throw new import_types.StatusResponseError("Calibration not supported", import_types.StatusCode.ConstraintError);
+      }
+      if (this.internal.calibrationMode === 1 /* Running */) {
+      } else {
+        this.internal.calibrationMode = 0 /* Enabled */;
+      }
+    } else {
+      this.internal.calibrationMode = 2 /* Disabled */;
+    }
+    const configStatus = this.state.configStatus;
+    configStatus.operational = !mode.maintenanceMode || mode.calibrationMode && !this.state.supportsCalibration;
+    configStatus.liftMovementReversed = !!mode.motorDirectionReversed;
+    if ((0, import_general.isDeepEqual)(configStatus, this.state.configStatus)) {
+      this.asAdmin(() => {
+        this.state.configStatus = configStatus;
+      });
+    }
+    logger.debug(
+      `Mode changed to ${import_general.Logger.toJSON(mode)} and config status to ${import_general.Logger.toJSON(configStatus)} and internal calibration mode to ${this.internal.calibrationMode}`
+    );
+  }
+  /** Update the global operational status based on the lift or tilt status. */
+  #handleOperationalStatusChanging(operationalStatus) {
+    const globalStatus = operationalStatus.lift !== import_window_covering.WindowCovering.MovementStatus.Stopped ? operationalStatus.lift : operationalStatus.tilt;
+    operationalStatus.global = globalStatus;
+    logger.debug(
+      `Operational status changed to ${import_general.Logger.toJSON(operationalStatus)} with new global status ${globalStatus}`
+    );
+    this.state.operationalStatus = operationalStatus;
+  }
+  /** Update the operational state when the target lift position changes. */
+  #handleLiftTargetPositionChanging(percent100ths) {
+    if (this.features.positionAwareLift) {
+      this.state.operationalStatus.lift = this.#computeOperationalState(
+        percent100ths,
+        this.state.currentPositionLiftPercent100ths
+      );
+    }
+  }
+  /** Update the operational state when the target tilt position changes. */
+  #handleTiltTargetPositionChanging(percent100ths) {
+    if (this.features.positionAwareTilt) {
+      this.state.operationalStatus.tilt = this.#computeOperationalState(
+        percent100ths,
+        this.state.currentPositionTiltPercent100ths
+      );
+    }
+  }
+  /** Sync the current lift position attributes and the operational state. */
+  #syncLiftCurrentPositions(percent100ths) {
+    if (this.features.positionAwareLift) {
+      this.state.currentPositionLiftPercentage = percent100ths === null ? percent100ths : Math.floor(percent100ths / WC_PERCENT100THS_COEFFICIENT);
+      if (this.state.operationalStatus.lift !== import_window_covering.WindowCovering.MovementStatus.Stopped && percent100ths === this.state.targetPositionLiftPercent100ths) {
+        this.state.operationalStatus.lift = import_window_covering.WindowCovering.MovementStatus.Stopped;
+        logger.debug("Lift movement stopped, target value reached");
+      }
+    }
+    if (this.features.absolutePosition) {
+      this.state.currentPositionLift = percent100ths === null ? null : this.#percent100thsToLift(percent100ths);
+    }
+    logger.debug(
+      `Syncing lift position ${this.state.currentPositionLiftPercent100ths === null ? null : (this.state.currentPositionLiftPercent100ths / 100).toFixed(2)} to ${this.state.currentPositionLiftPercentage}% (${this.state.currentPositionLift})`
+    );
+  }
+  /** Sync the current tilt position attributes and the operational state. */
+  #syncTiltCurrentPositions(percent100ths) {
+    if (this.features.positionAwareTilt) {
+      this.state.currentPositionTiltPercentage = percent100ths === null ? percent100ths : Math.floor(percent100ths / WC_PERCENT100THS_COEFFICIENT);
+      if (this.state.operationalStatus.tilt !== import_window_covering.WindowCovering.MovementStatus.Stopped && percent100ths === this.state.targetPositionTiltPercent100ths) {
+        this.state.operationalStatus.tilt = import_window_covering.WindowCovering.MovementStatus.Stopped;
+        logger.debug("Tilt movement stopped, target value reached");
+      }
+    }
+    if (this.features.absolutePosition) {
+      this.state.currentPositionTilt = percent100ths === null ? null : this.#percent100thsToTilt(percent100ths);
+    }
+    logger.debug(
+      `Syncing tilt position ${this.state.currentPositionTiltPercent100ths === null ? null : (this.state.currentPositionTiltPercent100ths / 100).toFixed(2)} to ${this.state.currentPositionTiltPercentage}% (${this.state.currentPositionTilt})`
+    );
+  }
+  /** Compute the operational state based on the current and target position. */
+  #computeOperationalState(target, current) {
+    if (current === null || target === null) {
+      return import_window_covering.WindowCovering.MovementStatus.Stopped;
+    } else if (current === target) {
+      return import_window_covering.WindowCovering.MovementStatus.Stopped;
+    } else if (current < target) {
+      return import_window_covering.WindowCovering.MovementStatus.Closing;
+    } else {
+      return import_window_covering.WindowCovering.MovementStatus.Opening;
+    }
+  }
+  /**
+   * Asserts if the device can be controlled or not because of an active Maintenance mode or a calibration is
+   * required but not supported.
+   */
+  #assertMotionLockStatus() {
+    if (this.internal.inMaintenanceMode) {
+      throw new import_types.StatusResponseError("Device is in maintenance mode", import_types.StatusCode.Busy);
+    }
+    switch (this.internal.calibrationMode) {
+      case 0 /* Enabled */:
+        if (!this.state.supportsCalibration) {
+          throw new import_types.StatusResponseError("Calibration not implemented", import_types.StatusCode.Failure);
+        }
+        break;
+      case 1 /* Running */:
+        break;
+      case 2 /* Disabled */:
+        break;
+    }
+    if (!this.state.configStatus.operational) {
+      throw new import_types.StatusResponseError("Device is not operational", import_types.StatusCode.Failure);
+    }
+  }
+  /**
+   * Calibrate the device.  The default implementation takes no action. Override to implement calibration if
+   * necessary.
+   *
+   * @protected
+   */
+  executeCalibration() {
+  }
+  /**
+   * Perform actual "movement".  Override to initiate movement of your device.
+   *
+   * The default implementation logs and immediately updates current position to the target positions.  This is
+   * probably not desirable for a real device so do not invoke `super.handleMovement()` from your implementation.
+   *
+   * @param type Which element should move, Lift or Tilt
+   * @param reversed If the motor is configured reversed
+   * @param direction The direction of the movement (Open, Close, DefinedByPosition)
+   * @param targetPercent100ths Optionally the target position in percent 100ths. It depends on the used feature set
+   * of the cluster if this is provided or not.
+   *
+   * @protected
+   */
+  async handleMovement(type, reversed, direction, targetPercent100ths) {
+    switch (type) {
+      case 0 /* Lift */:
+        if (this.features.positionAwareLift) {
+          if (targetPercent100ths === void 0) {
+            throw new import_general.ImplementationError("Target position must be defined for position aware lift");
+          }
+          this.state.currentPositionLiftPercent100ths = targetPercent100ths;
+        }
+        break;
+      case 1 /* Tilt */:
+        if (this.features.positionAwareTilt) {
+          if (targetPercent100ths === void 0) {
+            throw new import_general.ImplementationError("Target position must be defined for position aware lift");
+          }
+          this.state.currentPositionTiltPercent100ths = targetPercent100ths;
+        }
+        break;
+    }
+    const directionInfo = direction === 2 /* DefinedByPosition */ ? ` in direction by position` : ` in direction ${direction === 1 /* Close */ ? "Close" : "Open"}`;
+    const targetInfo = targetPercent100ths === void 0 ? "" : ` to target position ${(targetPercent100ths / 100).toFixed(2)}`;
+    logger.debug(
+      `Moving the device ${type === 0 /* Lift */ ? "Lift" : "Tilt"}${directionInfo} (reversed=${reversed})${targetInfo}`
+    );
+  }
+  /**
+   * Handle a movement. If calibration is supported and needed then {@link executeCalibration} runs before the actual
+   * movement. The method increases the numberOfActuations* attribute and updates the operational status.
+   *
+   * Actual movement occurs in {@link handleMovement} as a worker. Thus this method returns before actual movement
+   * completes.
+   */
+  #prepareMovement(type, direction, targetPercent100ths) {
+    if (this.state.supportsCalibration && this.internal.calibrationMode === 0 /* Enabled */) {
+      return this.env.runtime.add(this.#executeCalibrationAndMove(type, direction, targetPercent100ths));
+    }
+    if (type === 0 /* Lift */ && this.state.configStatus.liftMovementReversed) {
+      logger.debug("Lift movement is reversed");
+    }
+    switch (type) {
+      case 0 /* Lift */:
+        this.state.numberOfActuationsLift = (this.state.numberOfActuationsLift ?? 0) + 1;
+        if (this.features.positionAwareLift && direction === 2 /* DefinedByPosition */ && targetPercent100ths !== void 0 && this.state.currentPositionLiftPercent100ths !== null) {
+          direction = targetPercent100ths > this.state.currentPositionLiftPercent100ths ? 1 /* Close */ : 0 /* Open */;
+        }
+        if (direction !== 2 /* DefinedByPosition */) {
+          this.state.operationalStatus.lift = direction === 1 /* Close */ ? import_window_covering.WindowCovering.MovementStatus.Closing : import_window_covering.WindowCovering.MovementStatus.Opening;
+        }
+        break;
+      case 1 /* Tilt */:
+        this.state.numberOfActuationsTilt = (this.state.numberOfActuationsTilt ?? 0) + 1;
+        if (this.features.positionAwareLift && direction === 2 /* DefinedByPosition */ && targetPercent100ths !== void 0 && this.state.currentPositionTiltPercent100ths !== null) {
+          direction = targetPercent100ths > this.state.currentPositionTiltPercent100ths ? 1 /* Close */ : 0 /* Open */;
+        }
+        if (direction !== 2 /* DefinedByPosition */) {
+          this.state.operationalStatus.tilt = direction === 1 /* Close */ ? import_window_covering.WindowCovering.MovementStatus.Closing : import_window_covering.WindowCovering.MovementStatus.Opening;
+        }
+        break;
+    }
+    this.env.runtime.add(
+      this.handleMovement(
+        type,
+        type === 0 /* Lift */ && !!this.state.configStatus.liftMovementReversed,
+        direction,
+        targetPercent100ths
+      )
+    );
+  }
+  #executeCalibrationAndMove(type, direction, targetPercent100ths) {
+    let calibration;
+    if (this.internal.calibrationMode === 0 /* Enabled */ && this.state.supportsCalibration) {
+      this.internal.calibrationMode = 1 /* Running */;
+      calibration = this.executeCalibration();
+    }
+    return import_general.MaybePromise.then(calibration, () => {
+      this.internal.calibrationMode = 2 /* Disabled */;
+      return this.#prepareMovement(type, direction, targetPercent100ths);
+    });
+  }
+  /**
+   * Stop device movement.  Sets the target position to the current position and updates operational state. Override
+   * to implement the actual stop movement logic.
+   *
+   * If you update the current positions you can include the default logic via "super.handleStopMovement()".
+   *
+   * @protected
+   */
+  handleStopMovement() {
+    if (this.features.positionAwareLift) {
+      this.state.targetPositionLiftPercent100ths = this.state.currentPositionLiftPercent100ths;
+    }
+    if (this.features.positionAwareTilt) {
+      this.state.targetPositionTiltPercent100ths = this.state.currentPositionTiltPercent100ths;
+    }
+    if (!this.features.positionAwareLift && !this.features.positionAwareTilt) {
+      this.state.operationalStatus = {
+        global: import_window_covering.WindowCovering.MovementStatus.Stopped,
+        lift: import_window_covering.WindowCovering.MovementStatus.Stopped,
+        tilt: import_window_covering.WindowCovering.MovementStatus.Stopped
+      };
+    }
+  }
+  #triggerLiftMotion(direction, targetPercent100ths) {
+    this.#prepareMovement(0, direction, targetPercent100ths);
+  }
+  #triggerTiltMotion(direction, targetPercent100ths) {
+    this.#prepareMovement(1, direction, targetPercent100ths);
+  }
+  /**
+   * Move the WindowCovering up or open. For position aware devices the target position is set to 0%. The method calls
+   * the handleMovement method to actually move the device.
+   */
+  upOrOpen() {
+    this.#assertMotionLockStatus();
+    let targetLiftPercent100ths;
+    let targetTiltPercent100ths;
+    if (this.features.positionAwareLift) {
+      this.state.targetPositionLiftPercent100ths = targetLiftPercent100ths = WC_PERCENT100THS_MIN_OPEN;
+    }
+    if (this.features.positionAwareTilt) {
+      this.state.targetPositionTiltPercent100ths = targetTiltPercent100ths = WC_PERCENT100THS_MIN_OPEN;
+    }
+    if (this.features.lift) {
+      this.#triggerLiftMotion(0 /* Open */, targetLiftPercent100ths);
+    }
+    if (this.features.tilt) {
+      this.#triggerTiltMotion(0 /* Open */, targetTiltPercent100ths);
+    }
+  }
+  /**
+   * Move the WindowCovering down or close. For position aware devices the target position is set to 100%. The method
+   * calls the handleMovement method to actually move the device.
+   */
+  downOrClose() {
+    this.#assertMotionLockStatus();
+    let targetLiftPercent100ths;
+    let targetTiltPercent100ths;
+    if (this.features.positionAwareLift) {
+      this.state.targetPositionLiftPercent100ths = targetLiftPercent100ths = WC_PERCENT100THS_MAX_CLOSED;
+    }
+    if (this.features.positionAwareTilt) {
+      this.state.targetPositionTiltPercent100ths = targetTiltPercent100ths = WC_PERCENT100THS_MAX_CLOSED;
+    }
+    if (this.features.lift) {
+      this.#triggerLiftMotion(1 /* Close */, targetLiftPercent100ths);
+    }
+    if (this.features.tilt) {
+      this.#triggerTiltMotion(1 /* Close */, targetTiltPercent100ths);
+    }
+  }
+  /**
+   * Stop any movement of the WindowCovering. The method calls the handleStopMovement method to actually stop the
+   * movement of the device.
+   */
+  stopMotion() {
+    this.#assertMotionLockStatus();
+    return this.handleStopMovement();
+  }
+  /**
+   * Move the WindowCovering to a specific lift value. The default implementation calculates the % value for the
+   * target position. The method calls the handleMovement method to actually move the device to the defined position.
+   */
+  goToLiftValue({ liftValue }) {
+    this.#assertMotionLockStatus();
+    this.state.targetPositionLiftPercent100ths = this.#liftToPercent100ths(liftValue);
+    this.#triggerLiftMotion(2 /* DefinedByPosition */, this.state.targetPositionLiftPercent100ths);
+  }
+  /**
+   * Move the WindowCovering to a specific tilt value. The method calls the handleMovement method to actually move the
+   * device to the defined position.
+   */
+  goToLiftPercentage({ liftPercent100thsValue }) {
+    this.#assertMotionLockStatus();
+    if (this.features.positionAwareLift) {
+      this.state.targetPositionLiftPercent100ths = liftPercent100thsValue;
+      this.#triggerLiftMotion(
+        2 /* DefinedByPosition */,
+        this.state.targetPositionLiftPercent100ths ?? void 0
+      );
+    } else {
+      if (liftPercent100thsValue === 0) {
+        this.upOrOpen();
+      } else {
+        this.downOrClose();
+      }
+    }
+  }
+  /**
+   * Move the WindowCovering to a specific tilt value. The default implementation calculates the % value for the target
+   * position. The method calls the handleMovement method to actually move the device to the defined position.
+   */
+  goToTiltValue({ tiltValue }) {
+    this.#assertMotionLockStatus();
+    this.state.targetPositionTiltPercent100ths = this.#tiltToPercent100ths(tiltValue);
+    this.#triggerTiltMotion(2 /* DefinedByPosition */, this.state.targetPositionTiltPercent100ths);
+  }
+  /**
+   * Move the WindowCovering to a specific tilt value. The method calls the handleMovement method to actually move the
+   * device to the defined position.
+   */
+  goToTiltPercentage({ tiltPercent100thsValue }) {
+    this.#assertMotionLockStatus();
+    if (this.features.positionAwareTilt) {
+      this.state.targetPositionTiltPercent100ths = tiltPercent100thsValue ?? null;
+      this.#triggerTiltMotion(
+        2 /* DefinedByPosition */,
+        this.state.targetPositionTiltPercent100ths ?? void 0
+      );
+    } else {
+      if (tiltPercent100thsValue === 0) {
+        this.upOrOpen();
+      } else {
+        this.downOrClose();
+      }
+    }
+  }
+  /**
+   * ConvertValue: Converts values from one range to another
+   * * Range In  -> from  inputLowValue to   inputHighValue
+   * * Range Out -> from outputLowValue to outputHighValue
+   */
+  #convertValue(inputLowValue, inputHighValue, outputLowValue, outputHighValue, value) {
+    let inputMin = inputLowValue;
+    let inputMax = inputHighValue;
+    let outputMin = outputLowValue;
+    let outputMax = outputHighValue;
+    if (inputLowValue > inputHighValue) {
+      inputMin = inputHighValue;
+      inputMax = inputLowValue;
+    }
+    if (outputLowValue > outputHighValue) {
+      outputMin = outputHighValue;
+      outputMax = outputLowValue;
+    }
+    const inputRange = inputMax - inputMin;
+    const outputRange = outputMax - outputMin;
+    if (value < inputMin) {
+      return outputMin;
+    }
+    if (value > inputMax) {
+      return outputMax;
+    }
+    if (inputRange > 0) {
+      return Math.round(outputMin + outputRange * (value - inputMin) / inputRange);
+    }
+    return outputMax;
+  }
+  #valueToPercent100ths(limits, absolute) {
+    return this.#convertValue(
+      limits.open,
+      limits.closed,
+      WC_PERCENT100THS_MIN_OPEN,
+      WC_PERCENT100THS_MAX_CLOSED,
+      absolute
+    );
+  }
+  #percent100thsToValue(limits, relative) {
+    return this.#convertValue(
+      WC_PERCENT100THS_MIN_OPEN,
+      WC_PERCENT100THS_MAX_CLOSED,
+      limits.open,
+      limits.closed,
+      relative
+    );
+  }
+  #liftToPercent100ths(lift) {
+    return this.#valueToPercent100ths(
+      { open: this.state.installedOpenLimitLift, closed: this.state.installedClosedLimitLift },
+      lift
+    );
+  }
+  #percent100thsToLift(percent100ths) {
+    return this.#percent100thsToValue(
+      { open: this.state.installedOpenLimitLift, closed: this.state.installedClosedLimitLift },
+      percent100ths
+    );
+  }
+  #tiltToPercent100ths(tilt) {
+    return this.#valueToPercent100ths(
+      { open: this.state.installedOpenLimitTilt, closed: this.state.installedClosedLimitTilt },
+      tilt
+    );
+  }
+  #percent100thsToTilt(percent100ths) {
+    return this.#percent100thsToValue(
+      { open: this.state.installedOpenLimitTilt, closed: this.state.installedClosedLimitTilt },
+      percent100ths
+    );
+  }
+}
+((WindowCoveringServerLogic2) => {
+  class Internal {
+    /** Status of the Device Calibration mode. */
+    calibrationMode = 2 /* Disabled */;
+    /** Status of the Device Maintenance mode. */
+    inMaintenanceMode = false;
+  }
+  WindowCoveringServerLogic2.Internal = Internal;
+  class State extends WindowCoveringServerBase.State {
+    /** Does the device supports calibration? */
+    supportsCalibration = false;
+    /** Does the device supports maintenance mode? */
+    supportsMaintenanceMode = true;
+  }
+  WindowCoveringServerLogic2.State = State;
+})(WindowCoveringServerLogic || (WindowCoveringServerLogic = {}));
+class WindowCoveringServer extends WindowCoveringServerLogic.for((0, import_types.ClusterType)(import_window_covering.WindowCovering.Base)) {
+}
+//# sourceMappingURL=WindowCoveringServer.js.map

package/dist/cjs/behaviors/window-covering/WindowCoveringServer.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/behaviors/window-covering/WindowCoveringServer.ts"],
+  "mappings": "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",
+  "names": ["MovementType", "CalibrationMode", "MovementDirection", "WindowCoveringServerLogic"]
+}

package/dist/cjs/behaviors/window-covering/index.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/*** THIS FILE WILL BE REGENERATED IF YOU DO NOT REMOVE THIS MESSAGE ***/
+export * from "./WindowCoveringInterface.js";
+export * from "./WindowCoveringBehavior.js";
+export * from "./WindowCoveringServer.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/behaviors/window-covering/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/behaviors/window-covering/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,yEAAyE;AAEzE,cAAc,8BAA8B,CAAC;AAC7C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,2BAA2B,CAAC"}

package/dist/cjs/behaviors/window-covering/index.js

@@ -0,0 +1,26 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var window_covering_exports = {};
+module.exports = __toCommonJS(window_covering_exports);
+__reExport(window_covering_exports, require("./WindowCoveringInterface.js"), module.exports);
+__reExport(window_covering_exports, require("./WindowCoveringBehavior.js"), module.exports);
+__reExport(window_covering_exports, require("./WindowCoveringServer.js"), module.exports);
+/**
+ * @license
+ * Copyright 2022-2024 Matter.js Authors
+ * SPDX-License-Identifier: Apache-2.0
+ */
+//# sourceMappingURL=index.js.map

package/dist/cjs/behaviors/window-covering/index.js.map

@@ -0,0 +1,6 @@
+{
+  "version": 3,
+  "sources": ["../../../../src/behaviors/window-covering/index.ts"],
+  "mappings": ";;;;;;;;;;;;;;;AAAA;AAAA;AAQA,oCAAc,yCARd;AASA,oCAAc,wCATd;AAUA,oCAAc,sCAVd;AAAA;AAAA;AAAA;AAAA;AAAA;",
+  "names": []
+}