Alex2Node/dist/esm/AlexaStatusMessage.js

import { randomUUID } from "crypto";
import { AlexaInterfaceType } from "./AlexaInterface.js";
export var EndpointHealth;
(function (EndpointHealth) {
    EndpointHealth["OK"] = "OK";
    EndpointHealth["UNREACHABLE"] = "UNREACHABLE";
})(EndpointHealth || (EndpointHealth = {}));
export var ThermostatMode;
(function (ThermostatMode) {
    ThermostatMode["OFF"] = "OFF";
    ThermostatMode["HEAT"] = "HEAT";
    ThermostatMode["COOL"] = "COOL";
    ThermostatMode["AUTO"] = "AUTO";
    ThermostatMode["ECO"] = "ECO";
    ThermostatMode["CUSTOM"] = "CUSTOM";
})(ThermostatMode || (ThermostatMode = {}));
export var PowerController;
(function (PowerController) {
    PowerController["ON"] = "ON";
    PowerController["OFF"] = "OFF";
})(PowerController || (PowerController = {}));
export var TemperatureSensorScale;
(function (TemperatureSensorScale) {
    TemperatureSensorScale["CELSIUS"] = "CELSIUS";
    TemperatureSensorScale["FAHRENHEIT"] = "FAHRENHEIT";
})(TemperatureSensorScale || (TemperatureSensorScale = {}));
export class AlexaStatusMessage {
    constructor(correlationToken, rootTopic, endpointId, mqttClient, isResponse = false, isDeferred = false, changeCause = null) {
        this.context = { properties: [] };
        /** ChangeReport only: the properties that changed (payload.change.properties); the rest go to context. */
        this.changeProps = [];
        this.changeCause = null;
        this.target = "context";
        this.rootTopic = rootTopic;
        this.endpointId = endpointId;
        this.mqttClient = mqttClient;
        this.isDeferred = isDeferred;
        this.changeCause = changeCause;
        if (changeCause)
            this.target = "change";
        this.event = {
            header: {
                namespace: "Alexa",
                name: changeCause
                    ? "ChangeReport"
                    : isDeferred
                        ? "DeferredResponse"
                        : isResponse
                            ? "Response"
                            : "StateReport",
                payloadVersion: "3",
                messageId: randomUUID(),
                correlationToken,
            },
            endpoint: {
                endpointId,
            },
            payload: {},
        };
    }
    getTimestamp() {
        return new Date().toISOString();
    }
    addProperty(namespace, name, value, uncertaintyInMilliseconds = 0, instance) {
        const prop = {
            namespace,
            name,
            value,
            timeOfSample: this.getTimestamp(),
            uncertaintyInMilliseconds,
        };
        if (instance)
            prop.instance = instance;
        (this.target === "change" ? this.changeProps : this.context.properties).push(prop);
        return this;
    }
    /** ChangeReport: the add*Prop calls that follow describe what CHANGED (the default for a change report). */
    changed() {
        this.target = "change";
        return this;
    }
    /** ChangeReport: the add*Prop calls that follow describe the other, unchanged properties (context). */
    unchanged() {
        this.target = "context";
        return this;
    }
    /** True for a ChangeReport (Device.getChangeReport). */
    isChangeReport() {
        return this.changeCause !== null;
    }
    /** The message as it will be published (for tests and logging). */
    toJSON() {
        if (this.changeCause) {
            return {
                event: { ...this.event, payload: { change: { cause: { type: this.changeCause }, properties: this.changeProps } } },
                context: this.context,
            };
        }
        return { context: this.isDeferred ? null : this.context, event: this.event };
    }
    addModeControllerProp(instance, value, uncertaintyInMs = 0) {
        return this.addProperty(AlexaInterfaceType.MODE_CONTROLLER, "mode", value, uncertaintyInMs, instance);
    }
    addThermostatModeProp(mode, uncertaintyInMs = 0) {
        return this.addProperty(AlexaInterfaceType.THERMOSTAT_CONTROLLER, "thermostatMode", mode, uncertaintyInMs);
    }
    addEstimatedDeferralTime(seconds) {
        if (this.isDeferred) {
            this.event.payload = {
                estimatedDeferralInSeconds: seconds,
            };
        }
        else {
            console.warn("[AlexaStatusMessage.ts] Attempted to add estimated deferral time, but message is not marked as DeferredResponse.");
        }
        return this;
    }
    addThermostatControllerProp(name, scale, value, uncertaintyInMs = 0) {
        const tempValue = {
            value: scale === TemperatureSensorScale.FAHRENHEIT
                ? (value - 32) * (5 / 9)
                : value,
            scale: "CELSIUS",
        };
        return this.addProperty(AlexaInterfaceType.THERMOSTAT_CONTROLLER, name, tempValue, uncertaintyInMs);
    }
    /** Alexa.EndpointHealth connectivity: EndpointHealth.OK / UNREACHABLE (the plain strings "OK" / "UNREACHABLE" are accepted too). */
    addHealthProp(health, uncertaintyInMs = 0) {
        return this.addProperty(AlexaInterfaceType.ENDPOINT_HEALTH, "connectivity", { value: health }, uncertaintyInMs);
    }
    addPowerControllerProp(power, uncertaintyInMs = 0) {
        return this.addProperty(AlexaInterfaceType.POWER_CONTROLLER, "powerState", power, uncertaintyInMs);
    }
    addTemperatureSensorProp(scale, value, uncertaintyInMs = 0) {
        const tempValue = {
            value: scale === TemperatureSensorScale.FAHRENHEIT
                ? (value - 32) * (5 / 9)
                : value,
            scale: "CELSIUS",
        };
        return this.addProperty(AlexaInterfaceType.TEMPERATURE_SENSOR, "temperature", tempValue, uncertaintyInMs);
    }
    addBrightnessControllerProp(brightness, uncertaintyInMs = 0) {
        return this.addProperty(AlexaInterfaceType.BRIGHTNESS_CONTROLLER, "brightness", brightness, uncertaintyInMs);
    }
    addColorTemperatureControllerProp(colorTemp, uncertaintyInMs = 0) {
        return this.addProperty(AlexaInterfaceType.COLOR_TEMPERATURE_CONTROLLER, "colorTemperatureInKelvin", colorTemp, uncertaintyInMs);
    }
    addToggleControllerProp(state, instance, uncertaintyInMs = 0) {
        return this.addProperty(AlexaInterfaceType.TOGGLE_CONTROLLER, "toggleState", state, uncertaintyInMs, instance);
    }
    addContextProp(prop) {
        this.context.properties.push(prop);
        return this;
    }
    /**
     * Publish: a Response/StateReport to <root>/<endpoint>/alexaResponce (sendAsync: deferredResponse), a ChangeReport
     * to <root>/changeReport (Alex2MQTT adds the user's token and posts it to the Alexa event gateway). Resolves with
     * the topic, or "" when the publish failed - the error then goes to the bridge's "error" event (when listened to).
     * Never rejects (1.5.1 did, so an un-caught send() could kill the host).
     */
    send(sendAsync = false) {
        const payloadStr = JSON.stringify(this.toJSON());
        const topic = this.changeCause
            ? `${this.rootTopic}/changeReport`
            : `${this.rootTopic}/${this.endpointId}/${sendAsync ? "deferredResponse" : "alexaResponce"}`; //Yes this should be response but it is incorrect in both Alex2MQTT and Alex2ESP so for consistency is is wrong here too
        return new Promise((resolve) => {
            this.mqttClient.publish(topic, payloadStr, (err) => {
                if (!err)
                    return resolve(topic);
                if (this.onPublishError)
                    this.onPublishError(err); // -> the bridge's "error" event (when somebody listens)
                resolve(""); // 1.5.1 rejected here, and an un-caught send() then killed the host on any broker hiccup
            });
        });
    }
}