@zwave-js/cc 14.0.0-beta.1 → 14.0.0-beta.4

package/build/esm/cc/ColorSwitchCC.js

@@ -0,0 +1,1149 @@
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var ColorSwitchCCSupportedReport_1, ColorSwitchCCReport_1, ColorSwitchCCGet_1, ColorSwitchCCSet_1, ColorSwitchCCStartLevelChange_1, ColorSwitchCCStopLevelChange_1;
+function __assertType(argName, typeName, boundHasError) {
+    const { ZWaveError, ZWaveErrorCodes } = require("@zwave-js/core");
+    if (boundHasError()) {
+        throw new ZWaveError(typeName ? `${argName} is not a ${typeName}` : `${argName} has the wrong type`, ZWaveErrorCodes.Argument_Invalid);
+    }
+}
+const __assertType__ColorComponent = $o => {
+    function su__1__2__3__4__5__6__7__8__9_eu($o) {
+        return ![0, 1, 2, 3, 4, 5, 6, 7, 8].includes($o) ? {} : null;
+    }
+    return su__1__2__3__4__5__6__7__8__9_eu($o);
+};
+const __assertType__ColorSwitchCCSetOptions = $o => {
+    function _undefined($o) {
+        return $o !== undefined ? {} : null;
+    }
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function su__undefined__number_eu($o) {
+        const conditions = [_undefined, _number];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (!error)
+                return null;
+        }
+        return {};
+    }
+    function _2($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("warmWhite" in $o && $o["warmWhite"] !== undefined) {
+            const error = su__undefined__number_eu($o["warmWhite"]);
+            if (error)
+                return error;
+        }
+        if ("coldWhite" in $o && $o["coldWhite"] !== undefined) {
+            const error = su__undefined__number_eu($o["coldWhite"]);
+            if (error)
+                return error;
+        }
+        if ("red" in $o && $o["red"] !== undefined) {
+            const error = su__undefined__number_eu($o["red"]);
+            if (error)
+                return error;
+        }
+        if ("green" in $o && $o["green"] !== undefined) {
+            const error = su__undefined__number_eu($o["green"]);
+            if (error)
+                return error;
+        }
+        if ("blue" in $o && $o["blue"] !== undefined) {
+            const error = su__undefined__number_eu($o["blue"]);
+            if (error)
+                return error;
+        }
+        if ("amber" in $o && $o["amber"] !== undefined) {
+            const error = su__undefined__number_eu($o["amber"]);
+            if (error)
+                return error;
+        }
+        if ("cyan" in $o && $o["cyan"] !== undefined) {
+            const error = su__undefined__number_eu($o["cyan"]);
+            if (error)
+                return error;
+        }
+        if ("purple" in $o && $o["purple"] !== undefined) {
+            const error = su__undefined__number_eu($o["purple"]);
+            if (error)
+                return error;
+        }
+        if ("index" in $o && $o["index"] !== undefined) {
+            const error = su__undefined__number_eu($o["index"]);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    function _string($o) {
+        return typeof $o !== "string" ? {} : null;
+    }
+    function _13($o) {
+        return !($o instanceof require("@zwave-js/core").Duration) ? {} : null;
+    }
+    function su__string__13_eu($o) {
+        const conditions = [_string, _13];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (!error)
+                return null;
+        }
+        return {};
+    }
+    function _3($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("duration" in $o && $o["duration"] !== undefined) {
+            const error = su__string__13_eu($o["duration"]);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    function si__2__3_ei($o) {
+        const conditions = [_2, _3];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    function _5($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("0" in $o && $o["0"] !== undefined) {
+            const error = su__undefined__number_eu($o["0"]);
+            if (error)
+                return error;
+        }
+        if ("1" in $o && $o["1"] !== undefined) {
+            const error = su__undefined__number_eu($o["1"]);
+            if (error)
+                return error;
+        }
+        if ("2" in $o && $o["2"] !== undefined) {
+            const error = su__undefined__number_eu($o["2"]);
+            if (error)
+                return error;
+        }
+        if ("3" in $o && $o["3"] !== undefined) {
+            const error = su__undefined__number_eu($o["3"]);
+            if (error)
+                return error;
+        }
+        if ("4" in $o && $o["4"] !== undefined) {
+            const error = su__undefined__number_eu($o["4"]);
+            if (error)
+                return error;
+        }
+        if ("5" in $o && $o["5"] !== undefined) {
+            const error = su__undefined__number_eu($o["5"]);
+            if (error)
+                return error;
+        }
+        if ("6" in $o && $o["6"] !== undefined) {
+            const error = su__undefined__number_eu($o["6"]);
+            if (error)
+                return error;
+        }
+        if ("7" in $o && $o["7"] !== undefined) {
+            const error = su__undefined__number_eu($o["7"]);
+            if (error)
+                return error;
+        }
+        if ("8" in $o && $o["8"] !== undefined) {
+            const error = su__undefined__number_eu($o["8"]);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    function si__5__3_ei($o) {
+        const conditions = [_5, _3];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    function _7($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("hexColor" in $o && $o["hexColor"] !== undefined) {
+            const error = _string($o["hexColor"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        return null;
+    }
+    function si__7__3_ei($o) {
+        const conditions = [_7, _3];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    function su_si__2__3_ei_si__5__3_ei_si__7__3_ei_eu($o) {
+        const conditions = [si__2__3_ei, si__5__3_ei, si__7__3_ei];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (!error)
+                return null;
+        }
+        return {};
+    }
+    return su_si__2__3_ei_si__5__3_ei_si__7__3_ei_eu($o);
+};
+const __assertType__ColorSwitchCCStartLevelChangeOptions = $o => {
+    function su__8__9__10__11__12__13__14__15__16_eu($o) {
+        return ![0, 1, 2, 3, 4, 5, 6, 7, 8].includes($o) ? {} : null;
+    }
+    function _18($o) {
+        return $o !== "up" ? {} : null;
+    }
+    function _19($o) {
+        return $o !== "down" ? {} : null;
+    }
+    function su__18__19_eu($o) {
+        const conditions = [_18, _19];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (!error)
+                return null;
+        }
+        return {};
+    }
+    function _2($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("colorComponent" in $o && $o["colorComponent"] !== undefined) {
+            const error = su__8__9__10__11__12__13__14__15__16_eu($o["colorComponent"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("direction" in $o && $o["direction"] !== undefined) {
+            const error = su__18__19_eu($o["direction"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        return null;
+    }
+    function _true($o) {
+        return $o !== true ? {} : null;
+    }
+    function _number($o) {
+        return typeof $o !== "number" ? {} : null;
+    }
+    function _3($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("ignoreStartLevel" in $o && $o["ignoreStartLevel"] !== undefined) {
+            const error = _true($o["ignoreStartLevel"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("startLevel" in $o && $o["startLevel"] !== undefined) {
+            const error = _number($o["startLevel"]);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    function _string($o) {
+        return typeof $o !== "string" ? {} : null;
+    }
+    function _22($o) {
+        return !($o instanceof require("@zwave-js/core").Duration) ? {} : null;
+    }
+    function su__string__22_eu($o) {
+        const conditions = [_string, _22];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (!error)
+                return null;
+        }
+        return {};
+    }
+    function _4($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("duration" in $o && $o["duration"] !== undefined) {
+            const error = su__string__22_eu($o["duration"]);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    function si__2__3__4_ei($o) {
+        const conditions = [_2, _3, _4];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    function _false($o) {
+        return $o !== false ? {} : null;
+    }
+    function _6($o) {
+        if (typeof $o !== "object" || $o === null || Array.isArray($o))
+            return {};
+        if ("ignoreStartLevel" in $o && $o["ignoreStartLevel"] !== undefined) {
+            const error = _false($o["ignoreStartLevel"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        if ("startLevel" in $o && $o["startLevel"] !== undefined) {
+            const error = _number($o["startLevel"]);
+            if (error)
+                return error;
+        }
+        else
+            return {};
+        return null;
+    }
+    function si__2__6__4_ei($o) {
+        const conditions = [_2, _6, _4];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (error)
+                return error;
+        }
+        return null;
+    }
+    function su_si__2__3__4_ei_si__2__6__4_ei_eu($o) {
+        const conditions = [si__2__3__4_ei, si__2__6__4_ei];
+        for (const condition of conditions) {
+            const error = condition($o);
+            if (!error)
+                return null;
+        }
+        return {};
+    }
+    return su_si__2__3__4_ei_si__2__6__4_ei_eu($o);
+};
+import { CommandClasses, Duration, MessagePriority, ValueMetadata, ZWaveError, ZWaveErrorCodes, isUnsupervisedOrSucceeded, parseBitMask, supervisedCommandSucceeded, validatePayload, } from "@zwave-js/core";
+import { encodeBitMask } from "@zwave-js/core/safe";
+import { Bytes } from "@zwave-js/shared/safe";
+import { getEnumMemberName, isEnumMember, keysOf, pick, } from "@zwave-js/shared/safe";
+import { clamp } from "alcalzone-shared/math/index.js";
+import { isObject } from "alcalzone-shared/typeguards/index.js";
+import { CCAPI, POLL_VALUE, SET_VALUE, throwMissingPropertyKey, throwUnsupportedProperty, throwUnsupportedPropertyKey, throwWrongValueType, } from "../lib/API.js";
+import { CommandClass, getEffectiveCCVersion, } from "../lib/CommandClass.js";
+import { API, CCCommand, ccValue, ccValues, commandClass, expectedCCResponse, implementedVersion, useSupervision, } from "../lib/CommandClassDecorators.js";
+import { V } from "../lib/Values.js";
+import { ColorComponent, ColorComponentMap, ColorSwitchCommand, LevelChangeDirection, } from "../lib/_Types.js";
+const hexColorRegex = /^#?(?<red>[0-9a-f]{2})(?<green>[0-9a-f]{2})(?<blue>[0-9a-f]{2})$/i;
+const colorTableKeys = [
+    ...keysOf(ColorComponent),
+    ...keysOf(ColorComponentMap),
+];
+function colorTableKeyToComponent(key) {
+    if (/^\d+$/.test(key)) {
+        return parseInt(key, 10);
+    }
+    else if (key in ColorComponentMap) {
+        return ColorComponentMap[key];
+    }
+    else if (key in ColorComponent) {
+        return ColorComponent[key];
+    }
+    throw new ZWaveError(`Invalid color key ${key}!`, ZWaveErrorCodes.Argument_Invalid);
+}
+function colorComponentToTableKey(component) {
+    for (const [key, comp] of Object.entries(ColorComponentMap)) {
+        if (comp === component)
+            return key;
+    }
+}
+export const ColorSwitchCCValues = Object.freeze({
+    ...V.defineStaticCCValues(CommandClasses["Color Switch"], {
+        ...V.staticProperty("supportedColorComponents", undefined, {
+            internal: true,
+        }),
+        ...V.staticProperty("supportsHexColor", undefined, {
+            internal: true,
+        }),
+        // The compound color (static)
+        ...V.staticPropertyWithName("currentColor", "currentColor", {
+            ...ValueMetadata.ReadOnly,
+            label: `Current color`,
+        }),
+        ...V.staticPropertyWithName("targetColor", "targetColor", {
+            ...ValueMetadata.Any,
+            label: `Target color`,
+            valueChangeOptions: ["transitionDuration"],
+        }),
+        ...V.staticProperty("duration", {
+            ...ValueMetadata.ReadOnlyDuration,
+            label: "Remaining duration",
+        }),
+        // The compound color as HEX
+        ...V.staticProperty("hexColor", {
+            ...ValueMetadata.Color,
+            minLength: 6,
+            maxLength: 7, // to allow #rrggbb
+            label: `RGB Color`,
+            valueChangeOptions: ["transitionDuration"],
+        }),
+    }),
+    ...V.defineDynamicCCValues(CommandClasses["Color Switch"], {
+        // The individual color channels (dynamic)
+        ...V.dynamicPropertyAndKeyWithName("currentColorChannel", "currentColor", (component) => component, ({ property, propertyKey }) => property === "currentColor" && typeof propertyKey === "number", (component) => {
+            const colorName = getEnumMemberName(ColorComponent, component);
+            return {
+                ...ValueMetadata.ReadOnlyUInt8,
+                label: `Current value (${colorName})`,
+                description: `The current value of the ${colorName} channel.`,
+            };
+        }),
+        ...V.dynamicPropertyAndKeyWithName("targetColorChannel", "targetColor", (component) => component, ({ property, propertyKey }) => property === "targetColor" && typeof propertyKey === "number", (component) => {
+            const colorName = getEnumMemberName(ColorComponent, component);
+            return {
+                ...ValueMetadata.UInt8,
+                label: `Target value (${colorName})`,
+                description: `The target value of the ${colorName} channel.`,
+                valueChangeOptions: ["transitionDuration"],
+            };
+        }),
+    }),
+});
+let ColorSwitchCCAPI = class ColorSwitchCCAPI extends CCAPI {
+    supportsCommand(cmd) {
+        switch (cmd) {
+            case ColorSwitchCommand.SupportedGet:
+            case ColorSwitchCommand.Get:
+                return this.isSinglecast();
+            case ColorSwitchCommand.Set:
+            case ColorSwitchCommand.StartLevelChange:
+            case ColorSwitchCommand.StopLevelChange:
+                return true; // These are mandatory
+        }
+        return super.supportsCommand(cmd);
+    }
+    async getSupported() {
+        this.assertSupportsCommand(ColorSwitchCommand, ColorSwitchCommand.SupportedGet);
+        const cc = new ColorSwitchCCSupportedGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        return response?.supportedColorComponents;
+    }
+    async get(component) {
+        __assertType("component", "ColorComponent", __assertType__ColorComponent.bind(void 0, component));
+        this.assertSupportsCommand(ColorSwitchCommand, ColorSwitchCommand.Get);
+        const cc = new ColorSwitchCCGet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            colorComponent: component,
+        });
+        const response = await this.host.sendCommand(cc, this.commandOptions);
+        if (response) {
+            return pick(response, ["currentValue", "targetValue", "duration"]);
+        }
+    }
+    async set(options) {
+        __assertType("options", "ColorSwitchCCSetOptions", __assertType__ColorSwitchCCSetOptions.bind(void 0, options));
+        this.assertSupportsCommand(ColorSwitchCommand, ColorSwitchCommand.Set);
+        const cc = new ColorSwitchCCSet({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            ...options,
+        });
+        const result = await this.host.sendCommand(cc, this.commandOptions);
+        if (isUnsupervisedOrSucceeded(result)) {
+            // If the command did not fail, assume that it succeeded and update the values accordingly
+            // TODO: The API methods should not modify the value DB directly, but to do so
+            // this requires a nicer way of synchronizing hexColor with the others
+            if (this.isSinglecast()) {
+                // Update each color component separately and record the changes to the compound value
+                this.updateCurrentColor(this.getValueDB(), cc.colorTable);
+            }
+            else if (this.isMulticast()) {
+                // Figure out which nodes were affected by this command
+                const affectedNodes = this.endpoint.node.physicalNodes.filter((node) => node
+                    .getEndpoint(this.endpoint.index)
+                    ?.supportsCC(this.ccId));
+                // and optimistically update the currentColor
+                for (const node of affectedNodes) {
+                    const valueDB = this.host.tryGetValueDB(node.id);
+                    if (valueDB) {
+                        this.updateCurrentColor(valueDB, cc.colorTable);
+                    }
+                }
+            }
+        }
+        return result;
+    }
+    /** Updates the current color for a given node by merging in the given changes */
+    updateCurrentColor(valueDB, colorTable) {
+        let updatedRGB = false;
+        const currentColorValueId = ColorSwitchCCValues.currentColor.endpoint(this.endpoint.index);
+        const targetColorValueId = ColorSwitchCCValues.targetColor.endpoint(this.endpoint.index);
+        const currentCompoundColor = valueDB.getValue(currentColorValueId) ?? {};
+        const targetCompoundColor = valueDB.getValue(targetColorValueId) ?? {};
+        for (const [key, value] of Object.entries(colorTable)) {
+            const component = colorTableKeyToComponent(key);
+            if (component === ColorComponent.Red
+                || component === ColorComponent.Green
+                || component === ColorComponent.Blue) {
+                updatedRGB = true;
+            }
+            valueDB.setValue(ColorSwitchCCValues.currentColorChannel(component).endpoint(this.endpoint.index), value);
+            // Update the compound value
+            if (key in ColorComponentMap) {
+                currentCompoundColor[key] = value;
+                targetCompoundColor[key] = value;
+            }
+        }
+        // And store the updated compound values
+        valueDB.setValue(currentColorValueId, currentCompoundColor);
+        valueDB.setValue(targetColorValueId, targetCompoundColor);
+        // and hex color if necessary
+        const supportsHex = valueDB.getValue(ColorSwitchCCValues.supportsHexColor.endpoint(this.endpoint.index));
+        if (supportsHex && updatedRGB) {
+            const hexValueId = ColorSwitchCCValues.hexColor.endpoint(this.endpoint.index);
+            const [r, g, b] = [
+                ColorComponent.Red,
+                ColorComponent.Green,
+                ColorComponent.Blue,
+            ].map((c) => valueDB.getValue(ColorSwitchCCValues.currentColorChannel(c).endpoint(this.endpoint.index)) ?? 0);
+            const hexValue = (r << 16) | (g << 8) | b;
+            valueDB.setValue(hexValueId, hexValue.toString(16).padStart(6, "0"));
+        }
+    }
+    async startLevelChange(options) {
+        __assertType("options", "ColorSwitchCCStartLevelChangeOptions", __assertType__ColorSwitchCCStartLevelChangeOptions.bind(void 0, options));
+        this.assertSupportsCommand(ColorSwitchCommand, ColorSwitchCommand.StartLevelChange);
+        const cc = new ColorSwitchCCStartLevelChange({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            ...options,
+        });
+        return this.host.sendCommand(cc, this.commandOptions);
+    }
+    async stopLevelChange(colorComponent) {
+        __assertType("colorComponent", "ColorComponent", __assertType__ColorComponent.bind(void 0, colorComponent));
+        this.assertSupportsCommand(ColorSwitchCommand, ColorSwitchCommand.StopLevelChange);
+        const cc = new ColorSwitchCCStopLevelChange({
+            nodeId: this.endpoint.nodeId,
+            endpointIndex: this.endpoint.index,
+            colorComponent,
+        });
+        return this.host.sendCommand(cc, this.commandOptions);
+    }
+    get [SET_VALUE]() {
+        return async function ({ property, propertyKey }, value, options) {
+            if (property === "targetColor") {
+                const duration = Duration.from(options?.transitionDuration);
+                if (propertyKey != undefined) {
+                    // Single color component, only accepts numbers
+                    if (typeof propertyKey !== "number") {
+                        throwUnsupportedPropertyKey(this.ccId, property, propertyKey);
+                    }
+                    else if (typeof value !== "number") {
+                        throwWrongValueType(this.ccId, property, "number", typeof value);
+                    }
+                    const result = await this.set({
+                        [propertyKey]: value,
+                        duration,
+                    });
+                    if (this.isSinglecast()
+                        && !supervisedCommandSucceeded(result)) {
+                        // Verify the current value after a (short) delay, unless the command was supervised and successful
+                        this.schedulePoll({ property, propertyKey }, value, {
+                            duration,
+                            transition: "fast",
+                        });
+                    }
+                    return result;
+                }
+                else {
+                    // Set the compound color object
+                    // Ensure the value is an object with only valid keys
+                    if (!isObject(value)
+                        || !Object.keys(value).every((key) => key in ColorComponentMap)) {
+                        throw new ZWaveError(`${CommandClasses[this.ccId]}: "${property}" must be set to an object which specifies each color channel`, ZWaveErrorCodes.Argument_Invalid);
+                    }
+                    // Ensure that each property is numeric
+                    for (const [key, val] of Object.entries(value)) {
+                        if (typeof val !== "number") {
+                            throwWrongValueType(this.ccId, `${property}.${key}`, "number", typeof val);
+                        }
+                    }
+                    // GH#2527: strip unsupported color components, because some devices don't react otherwise
+                    if (this.isSinglecast()) {
+                        const supportedColors = this.tryGetValueDB()?.getValue(ColorSwitchCCValues.supportedColorComponents
+                            .endpoint(this.endpoint.index));
+                        if (supportedColors) {
+                            value = pick(value, supportedColors
+                                .map((c) => colorComponentToTableKey(c))
+                                .filter((c) => !!c));
+                        }
+                    }
+                    // Avoid sending empty commands
+                    if (Object.keys(value).length === 0)
+                        return;
+                    return this.set({ ...value, duration });
+                    // We're not going to poll each color component separately
+                }
+            }
+            else if (property === "hexColor") {
+                // No property key, this is the hex color #rrggbb
+                if (typeof value !== "string") {
+                    throwWrongValueType(this.ccId, property, "string", typeof value);
+                }
+                const duration = Duration.from(options?.transitionDuration);
+                return this.set({ hexColor: value, duration });
+            }
+            else {
+                throwUnsupportedProperty(this.ccId, property);
+            }
+        };
+    }
+    isSetValueOptimistic(_valueId) {
+        return false; // Color Switch CC handles updating the value DB itself
+    }
+    get [POLL_VALUE]() {
+        return async function ({ property, propertyKey }) {
+            if (propertyKey == undefined) {
+                throwMissingPropertyKey(this.ccId, property);
+            }
+            else if (typeof propertyKey !== "number") {
+                throwUnsupportedPropertyKey(this.ccId, property, propertyKey);
+            }
+            switch (property) {
+                case "currentColor":
+                    return (await this.get(propertyKey))?.currentValue;
+                case "targetColor":
+                    return (await this.get(propertyKey))?.targetValue;
+                case "duration":
+                    return (await this.get(propertyKey))?.duration;
+                default:
+                    throwUnsupportedProperty(this.ccId, property);
+            }
+        };
+    }
+};
+ColorSwitchCCAPI = __decorate([
+    API(CommandClasses["Color Switch"])
+], ColorSwitchCCAPI);
+export { ColorSwitchCCAPI };
+let ColorSwitchCC = class ColorSwitchCC extends CommandClass {
+    async interview(ctx) {
+        const node = this.getNode(ctx);
+        const endpoint = this.getEndpoint(ctx);
+        const api = CCAPI.create(CommandClasses["Color Switch"], ctx, endpoint).withOptions({
+            priority: MessagePriority.NodeQuery,
+        });
+        ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `Interviewing ${this.ccName}...`,
+            direction: "none",
+        });
+        ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: "querying supported colors...",
+            direction: "outbound",
+        });
+        const supportedColors = await api.getSupported();
+        if (!supportedColors) {
+            ctx.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: "Querying supported colors timed out, skipping interview...",
+                level: "warn",
+            });
+            return;
+        }
+        ctx.logNode(node.id, {
+            endpoint: this.endpointIndex,
+            message: `received supported colors:${supportedColors
+                .map((c) => `\n· ${getEnumMemberName(ColorComponent, c)}`)
+                .join("")}`,
+            direction: "outbound",
+        });
+        // Create metadata for the separate color channels
+        for (const color of supportedColors) {
+            const currentColorChannelValue = ColorSwitchCCValues
+                .currentColorChannel(color);
+            this.setMetadata(ctx, currentColorChannelValue);
+            const targetColorChannelValue = ColorSwitchCCValues
+                .targetColorChannel(color);
+            this.setMetadata(ctx, targetColorChannelValue);
+        }
+        // And the compound one
+        const currentColorValue = ColorSwitchCCValues.currentColor;
+        this.setMetadata(ctx, currentColorValue);
+        const targetColorValue = ColorSwitchCCValues.targetColor;
+        this.setMetadata(ctx, targetColorValue);
+        // Create the collective HEX color values
+        const supportsHex = [
+            ColorComponent.Red,
+            ColorComponent.Green,
+            ColorComponent.Blue,
+        ].every((c) => supportedColors.includes(c));
+        this.setValue(ctx, ColorSwitchCCValues.supportsHexColor, supportsHex);
+        if (supportsHex) {
+            const hexColorValue = ColorSwitchCCValues.hexColor;
+            this.setMetadata(ctx, hexColorValue);
+        }
+        // Query all color components
+        await this.refreshValues(ctx);
+        // Remember that the interview is complete
+        this.setInterviewComplete(ctx, true);
+    }
+    async refreshValues(ctx) {
+        const node = this.getNode(ctx);
+        const endpoint = this.getEndpoint(ctx);
+        const api = CCAPI.create(CommandClasses["Color Switch"], ctx, endpoint).withOptions({
+            priority: MessagePriority.NodeQuery,
+        });
+        const supportedColors = this.getValue(ctx, ColorSwitchCCValues.supportedColorComponents) ?? [];
+        for (const color of supportedColors) {
+            // Some devices report invalid colors, but the CC API checks
+            // for valid values and throws otherwise.
+            if (!isEnumMember(ColorComponent, color))
+                continue;
+            const colorName = getEnumMemberName(ColorComponent, color);
+            ctx.logNode(node.id, {
+                endpoint: this.endpointIndex,
+                message: `querying current color state (${colorName})`,
+                direction: "outbound",
+            });
+            await api.get(color);
+        }
+    }
+    translatePropertyKey(ctx, property, propertyKey) {
+        if ((property === "currentColor" || property === "targetColor")
+            && typeof propertyKey === "number") {
+            const translated = ColorComponent[propertyKey];
+            if (translated)
+                return translated;
+        }
+        return super.translatePropertyKey(ctx, property, propertyKey);
+    }
+};
+ColorSwitchCC = __decorate([
+    commandClass(CommandClasses["Color Switch"]),
+    implementedVersion(3),
+    ccValues(ColorSwitchCCValues)
+], ColorSwitchCC);
+export { ColorSwitchCC };
+let ColorSwitchCCSupportedReport = ColorSwitchCCSupportedReport_1 = class ColorSwitchCCSupportedReport extends ColorSwitchCC {
+    constructor(options) {
+        super(options);
+        this.supportedColorComponents = options.supportedColorComponents;
+    }
+    static from(raw, ctx) {
+        // Docs say 'variable length', but the table shows 2 bytes.
+        validatePayload(raw.payload.length >= 2);
+        const supportedColorComponents = parseBitMask(raw.payload.subarray(0, 2), ColorComponent["Warm White"]);
+        return new ColorSwitchCCSupportedReport_1({
+            nodeId: ctx.sourceNodeId,
+            supportedColorComponents,
+        });
+    }
+    supportedColorComponents;
+    serialize(ctx) {
+        this.payload = encodeBitMask(this.supportedColorComponents, 15, // fixed 2 bytes
+        ColorComponent["Warm White"]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "supported color components": this.supportedColorComponents
+                    .map((c) => `\n· ${getEnumMemberName(ColorComponent, c)}`)
+                    .join(""),
+            },
+        };
+    }
+};
+__decorate([
+    ccValue(ColorSwitchCCValues.supportedColorComponents)
+], ColorSwitchCCSupportedReport.prototype, "supportedColorComponents", void 0);
+ColorSwitchCCSupportedReport = ColorSwitchCCSupportedReport_1 = __decorate([
+    CCCommand(ColorSwitchCommand.SupportedReport)
+], ColorSwitchCCSupportedReport);
+export { ColorSwitchCCSupportedReport };
+let ColorSwitchCCSupportedGet = class ColorSwitchCCSupportedGet extends ColorSwitchCC {
+};
+ColorSwitchCCSupportedGet = __decorate([
+    CCCommand(ColorSwitchCommand.SupportedGet),
+    expectedCCResponse(ColorSwitchCCSupportedReport)
+], ColorSwitchCCSupportedGet);
+export { ColorSwitchCCSupportedGet };
+let ColorSwitchCCReport = ColorSwitchCCReport_1 = class ColorSwitchCCReport extends ColorSwitchCC {
+    constructor(options) {
+        super(options);
+        this.colorComponent = options.colorComponent;
+        this.currentValue = options.currentValue;
+        this.targetValue = options.targetValue;
+        this.duration = Duration.from(options.duration);
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 2);
+        const colorComponent = raw.payload[0];
+        const currentValue = raw.payload[1];
+        let targetValue;
+        let duration;
+        if (raw.payload.length >= 4) {
+            targetValue = raw.payload[2];
+            duration = Duration.parseReport(raw.payload[3]);
+        }
+        return new ColorSwitchCCReport_1({
+            nodeId: ctx.sourceNodeId,
+            colorComponent,
+            currentValue,
+            targetValue,
+            duration,
+        });
+    }
+    persistValues(ctx) {
+        // Duration is stored globally instead of per component
+        if (!super.persistValues(ctx))
+            return false;
+        // Update compound current value
+        const colorTableKey = colorComponentToTableKey(this.colorComponent);
+        if (colorTableKey) {
+            const compoundCurrentColorValue = ColorSwitchCCValues.currentColor;
+            const compoundCurrentColor = this.getValue(ctx, compoundCurrentColorValue) ?? {};
+            compoundCurrentColor[colorTableKey] = this.currentValue;
+            this.setValue(ctx, compoundCurrentColorValue, compoundCurrentColor);
+            // and target value
+            if (this.targetValue != undefined) {
+                const compoundTargetColorValue = ColorSwitchCCValues.targetColor;
+                const compoundTargetColor = this.getValue(ctx, compoundTargetColorValue) ?? {};
+                compoundTargetColor[colorTableKey] = this.targetValue;
+                this.setValue(ctx, compoundTargetColorValue, compoundTargetColor);
+            }
+        }
+        // Update collective hex value if required
+        const supportsHex = !!this.getValue(ctx, ColorSwitchCCValues.supportsHexColor);
+        if (supportsHex
+            && (this.colorComponent === ColorComponent.Red
+                || this.colorComponent === ColorComponent.Green
+                || this.colorComponent === ColorComponent.Blue)) {
+            const hexColorValue = ColorSwitchCCValues.hexColor;
+            const hexValue = this.getValue(ctx, hexColorValue)
+                ?? "000000";
+            const byteOffset = ColorComponent.Blue - this.colorComponent;
+            const byteMask = 0xff << (byteOffset * 8);
+            let hexValueNumeric = parseInt(hexValue, 16);
+            hexValueNumeric = (hexValueNumeric & ~byteMask)
+                | (this.currentValue << (byteOffset * 8));
+            this.setValue(ctx, hexColorValue, hexValueNumeric.toString(16).padStart(6, "0"));
+        }
+        return true;
+    }
+    colorComponent;
+    currentValue;
+    targetValue;
+    duration;
+    serialize(ctx) {
+        this.payload = Bytes.from([
+            this.colorComponent,
+            this.currentValue,
+        ]);
+        if (this.targetValue != undefined && this.duration != undefined) {
+            this.payload = Bytes.concat([
+                this.payload,
+                Bytes.from([
+                    this.targetValue ?? 0xfe,
+                    (this.duration ?? Duration.default()).serializeReport(),
+                ]),
+            ]);
+        }
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        const message = {
+            "color component": getEnumMemberName(ColorComponent, this.colorComponent),
+            "current value": this.currentValue,
+        };
+        if (this.targetValue != undefined) {
+            message["target value"] = this.targetValue;
+        }
+        if (this.duration != undefined) {
+            message.duration = this.duration.toString();
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+__decorate([
+    ccValue(ColorSwitchCCValues.currentColorChannel, (self) => [self.colorComponent])
+], ColorSwitchCCReport.prototype, "currentValue", void 0);
+__decorate([
+    ccValue(ColorSwitchCCValues.targetColorChannel, (self) => [self.colorComponent])
+], ColorSwitchCCReport.prototype, "targetValue", void 0);
+__decorate([
+    ccValue(ColorSwitchCCValues.duration)
+], ColorSwitchCCReport.prototype, "duration", void 0);
+ColorSwitchCCReport = ColorSwitchCCReport_1 = __decorate([
+    CCCommand(ColorSwitchCommand.Report)
+], ColorSwitchCCReport);
+export { ColorSwitchCCReport };
+function testResponseForColorSwitchGet(sent, received) {
+    return sent.colorComponent === received.colorComponent;
+}
+let ColorSwitchCCGet = ColorSwitchCCGet_1 = class ColorSwitchCCGet extends ColorSwitchCC {
+    constructor(options) {
+        super(options);
+        this._colorComponent = options.colorComponent;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const colorComponent = raw.payload[0];
+        return new ColorSwitchCCGet_1({
+            nodeId: ctx.sourceNodeId,
+            colorComponent,
+        });
+    }
+    _colorComponent;
+    get colorComponent() {
+        return this._colorComponent;
+    }
+    set colorComponent(value) {
+        if (!ColorComponent[value]) {
+            throw new ZWaveError("colorComponent must be a valid color component index.", ZWaveErrorCodes.Argument_Invalid);
+        }
+        this._colorComponent = value;
+    }
+    serialize(ctx) {
+        this.payload = Bytes.from([this._colorComponent]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "color component": getEnumMemberName(ColorComponent, this.colorComponent),
+            },
+        };
+    }
+};
+ColorSwitchCCGet = ColorSwitchCCGet_1 = __decorate([
+    CCCommand(ColorSwitchCommand.Get),
+    expectedCCResponse(ColorSwitchCCReport, testResponseForColorSwitchGet)
+], ColorSwitchCCGet);
+export { ColorSwitchCCGet };
+let ColorSwitchCCSet = ColorSwitchCCSet_1 = class ColorSwitchCCSet extends ColorSwitchCC {
+    constructor(options) {
+        super(options);
+        // Populate properties from options object
+        if ("hexColor" in options) {
+            const match = hexColorRegex.exec(options.hexColor);
+            if (!match) {
+                throw new ZWaveError(`${options.hexColor} is not a valid HEX color string`, ZWaveErrorCodes.Argument_Invalid);
+            }
+            this.colorTable = {
+                red: parseInt(match.groups.red, 16),
+                green: parseInt(match.groups.green, 16),
+                blue: parseInt(match.groups.blue, 16),
+            };
+        }
+        else {
+            this.colorTable = pick(options, colorTableKeys);
+        }
+        this.duration = Duration.from(options.duration);
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const populatedColorCount = raw.payload[0] & 0b11111;
+        validatePayload(raw.payload.length >= 1 + populatedColorCount * 2);
+        const colorTable = {};
+        let offset = 1;
+        for (let color = 0; color < populatedColorCount; color++) {
+            const component = raw.payload[offset];
+            const value = raw.payload[offset + 1];
+            const key = colorComponentToTableKey(component);
+            // @ts-expect-error
+            if (key)
+                this.colorTable[key] = value;
+            offset += 2;
+        }
+        let duration;
+        if (raw.payload.length > offset) {
+            duration = Duration.parseSet(raw.payload[offset]);
+        }
+        return new ColorSwitchCCSet_1({
+            nodeId: ctx.sourceNodeId,
+            ...colorTable,
+            duration,
+        });
+    }
+    colorTable;
+    duration;
+    serialize(ctx) {
+        const populatedColorCount = Object.keys(this.colorTable).length;
+        this.payload = new Bytes(1 + populatedColorCount * 2 + 1);
+        this.payload[0] = populatedColorCount & 0b11111;
+        let i = 1;
+        for (const [key, value] of Object.entries(this.colorTable)) {
+            const component = colorTableKeyToComponent(key);
+            this.payload[i] = component;
+            this.payload[i + 1] = clamp(value, 0, 0xff);
+            i += 2;
+        }
+        this.payload[i] = (this.duration ?? Duration.default()).serializeSet();
+        const ccVersion = getEffectiveCCVersion(ctx, this);
+        if (ccVersion < 2 && ctx.getDeviceConfig?.(this.nodeId)?.compat?.encodeCCsUsingTargetVersion) {
+            // When forcing CC version 1, omit the duration byte
+            this.payload = this.payload.subarray(0, -1);
+        }
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        const message = {};
+        for (const [key, value] of Object.entries(this.colorTable)) {
+            const realKey = key in ColorComponentMap
+                ? ColorComponent[ColorComponentMap[key]]
+                : ColorComponent[key];
+            message[realKey] = value;
+        }
+        if (this.duration != undefined) {
+            message.duration = this.duration.toString();
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+ColorSwitchCCSet = ColorSwitchCCSet_1 = __decorate([
+    CCCommand(ColorSwitchCommand.Set),
+    useSupervision()
+], ColorSwitchCCSet);
+export { ColorSwitchCCSet };
+let ColorSwitchCCStartLevelChange = ColorSwitchCCStartLevelChange_1 = class ColorSwitchCCStartLevelChange extends ColorSwitchCC {
+    constructor(options) {
+        super(options);
+        this.duration = Duration.from(options.duration);
+        this.ignoreStartLevel = options.ignoreStartLevel;
+        this.startLevel = options.startLevel ?? 0;
+        this.direction = options.direction;
+        this.colorComponent = options.colorComponent;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 3);
+        const ignoreStartLevel = !!((raw.payload[0] & 0b0_0_1_00000) >>> 5);
+        const direction = ((raw.payload[0] & 0b0_1_0_00000) >>> 6)
+            ? "down"
+            : "up";
+        const colorComponent = raw.payload[1];
+        const startLevel = raw.payload[2];
+        let duration;
+        if (raw.payload.length >= 4) {
+            duration = Duration.parseSet(raw.payload[3]);
+        }
+        return new ColorSwitchCCStartLevelChange_1({
+            nodeId: ctx.sourceNodeId,
+            ignoreStartLevel,
+            direction,
+            colorComponent,
+            startLevel,
+            duration,
+        });
+    }
+    duration;
+    startLevel;
+    ignoreStartLevel;
+    direction;
+    colorComponent;
+    serialize(ctx) {
+        const controlByte = (LevelChangeDirection[this.direction] << 6)
+            | (this.ignoreStartLevel ? 0b0010_0000 : 0);
+        this.payload = Bytes.from([
+            controlByte,
+            this.colorComponent,
+            this.startLevel,
+            (this.duration ?? Duration.default()).serializeSet(),
+        ]);
+        const ccVersion = getEffectiveCCVersion(ctx, this);
+        if (ccVersion < 3 && ctx.getDeviceConfig?.(this.nodeId)?.compat?.encodeCCsUsingTargetVersion) {
+            // When forcing CC version 1 or 2, omit the duration byte
+            this.payload = this.payload.subarray(0, -1);
+        }
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        const message = {
+            "color component": getEnumMemberName(ColorComponent, this.colorComponent),
+            "start level": `${this.startLevel}${this.ignoreStartLevel ? " (ignored)" : ""}`,
+            direction: this.direction,
+        };
+        if (this.duration != undefined) {
+            message.duration = this.duration.toString();
+        }
+        return {
+            ...super.toLogEntry(ctx),
+            message,
+        };
+    }
+};
+ColorSwitchCCStartLevelChange = ColorSwitchCCStartLevelChange_1 = __decorate([
+    CCCommand(ColorSwitchCommand.StartLevelChange),
+    useSupervision()
+], ColorSwitchCCStartLevelChange);
+export { ColorSwitchCCStartLevelChange };
+let ColorSwitchCCStopLevelChange = ColorSwitchCCStopLevelChange_1 = class ColorSwitchCCStopLevelChange extends ColorSwitchCC {
+    constructor(options) {
+        super(options);
+        this.colorComponent = options.colorComponent;
+    }
+    static from(raw, ctx) {
+        validatePayload(raw.payload.length >= 1);
+        const colorComponent = raw.payload[0];
+        return new ColorSwitchCCStopLevelChange_1({
+            nodeId: ctx.sourceNodeId,
+            colorComponent,
+        });
+    }
+    colorComponent;
+    serialize(ctx) {
+        this.payload = Bytes.from([this.colorComponent]);
+        return super.serialize(ctx);
+    }
+    toLogEntry(ctx) {
+        return {
+            ...super.toLogEntry(ctx),
+            message: {
+                "color component": getEnumMemberName(ColorComponent, this.colorComponent),
+            },
+        };
+    }
+};
+ColorSwitchCCStopLevelChange = ColorSwitchCCStopLevelChange_1 = __decorate([
+    CCCommand(ColorSwitchCommand.StopLevelChange),
+    useSupervision()
+], ColorSwitchCCStopLevelChange);
+export { ColorSwitchCCStopLevelChange };
+//# sourceMappingURL=ColorSwitchCC.js.map