edilkamin 1.8.0 → 1.9.0

package/dist/esm/src/library.test.js

@@ -182,9 +182,35 @@ describe("library", () => {
             "setPowerOff",
             "setPowerOn",
             "getPower",
+            "setPowerLevel",
+            "getPowerLevel",
+            "setFan1Speed",
+            "setFan2Speed",
+            "setFan3Speed",
+            "getFan1Speed",
+            "getFan2Speed",
+            "getFan3Speed",
+            "setAirkare",
+            "setRelax",
+            "setStandby",
+            "getStandby",
+            "setStandbyTime",
+            "getStandbyTime",
+            "setAuto",
+            "getAuto",
             "getEnvironmentTemperature",
             "getTargetTemperature",
             "setTargetTemperature",
+            "setEnvironment2Temperature",
+            "getEnvironment2Temperature",
+            "setEnvironment3Temperature",
+            "getEnvironment3Temperature",
+            "setMeasureUnit",
+            "getMeasureUnit",
+            "setLanguage",
+            "getLanguage",
+            "getPelletInReserve",
+            "getPelletAutonomyTime",
         ];
         it("should create API methods with the correct baseURL", () => __awaiter(void 0, void 0, void 0, function* () {
             const baseURL = "https://example.com/api/";
@@ -215,10 +241,27 @@ describe("library", () => {
                 temperatures: {
                     enviroment: 19,
                 },
+                flags: {
+                    is_pellet_in_reserve: false,
+                },
+                pellet: {
+                    autonomy_time: 180,
+                },
             },
             nvm: {
                 user_parameters: {
                     enviroment_1_temperature: 22,
+                    enviroment_2_temperature: 18,
+                    enviroment_3_temperature: 20,
+                    manual_power: 3,
+                    fan_1_ventilation: 2,
+                    fan_2_ventilation: 3,
+                    fan_3_ventilation: 4,
+                    is_standby_active: true,
+                    standby_waiting_time: 30,
+                    is_auto: true,
+                    is_fahrenheit: false,
+                    language: 2,
                 },
             },
         };
@@ -274,6 +317,26 @@ describe("library", () => {
                 call: (api, token, mac) => api.getPower(token, mac),
                 expectedResult: true,
             },
+            {
+                method: "getPowerLevel",
+                call: (api, token, mac) => api.getPowerLevel(token, mac),
+                expectedResult: 3,
+            },
+            {
+                method: "getFan1Speed",
+                call: (api, token, mac) => api.getFan1Speed(token, mac),
+                expectedResult: 2,
+            },
+            {
+                method: "getFan2Speed",
+                call: (api, token, mac) => api.getFan2Speed(token, mac),
+                expectedResult: 3,
+            },
+            {
+                method: "getFan3Speed",
+                call: (api, token, mac) => api.getFan3Speed(token, mac),
+                expectedResult: 4,
+            },
             {
                 method: "getEnvironmentTemperature",
                 call: (api, token, mac) => api.getEnvironmentTemperature(token, mac),
@@ -284,6 +347,51 @@ describe("library", () => {
                 call: (api, token, mac) => api.getTargetTemperature(token, mac),
                 expectedResult: 22,
             },
+            {
+                method: "getStandby",
+                call: (api, token, mac) => api.getStandby(token, mac),
+                expectedResult: true,
+            },
+            {
+                method: "getStandbyTime",
+                call: (api, token, mac) => api.getStandbyTime(token, mac),
+                expectedResult: 30,
+            },
+            {
+                method: "getAuto",
+                call: (api, token, mac) => api.getAuto(token, mac),
+                expectedResult: true,
+            },
+            {
+                method: "getEnvironment2Temperature",
+                call: (api, token, mac) => api.getEnvironment2Temperature(token, mac),
+                expectedResult: 18,
+            },
+            {
+                method: "getEnvironment3Temperature",
+                call: (api, token, mac) => api.getEnvironment3Temperature(token, mac),
+                expectedResult: 20,
+            },
+            {
+                method: "getMeasureUnit",
+                call: (api, token, mac) => api.getMeasureUnit(token, mac),
+                expectedResult: false,
+            },
+            {
+                method: "getLanguage",
+                call: (api, token, mac) => api.getLanguage(token, mac),
+                expectedResult: 2,
+            },
+            {
+                method: "getPelletInReserve",
+                call: (api, token, mac) => api.getPelletInReserve(token, mac),
+                expectedResult: false,
+            },
+            {
+                method: "getPelletAutonomyTime",
+                call: (api, token, mac) => api.getPelletAutonomyTime(token, mac),
+                expectedResult: 180,
+            },
         ];
         getterTests.forEach(({ method, call, expectedResult }) => {
             it(`should call fetch and return the correct value for ${method}`, () => __awaiter(void 0, void 0, void 0, function* () {
@@ -301,6 +409,38 @@ describe("library", () => {
         });
         // Setter tests
         const setterTests = [
+            {
+                method: "setPowerLevel",
+                call: (api, token, mac, value) => api.setPowerLevel(token, mac, value),
+                payload: {
+                    name: "power_level",
+                    value: 4,
+                },
+            },
+            {
+                method: "setFan1Speed",
+                call: (api, token, mac, value) => api.setFan1Speed(token, mac, value),
+                payload: {
+                    name: "fan_1_speed",
+                    value: 3,
+                },
+            },
+            {
+                method: "setFan2Speed",
+                call: (api, token, mac, value) => api.setFan2Speed(token, mac, value),
+                payload: {
+                    name: "fan_2_speed",
+                    value: 4,
+                },
+            },
+            {
+                method: "setFan3Speed",
+                call: (api, token, mac, value) => api.setFan3Speed(token, mac, value),
+                payload: {
+                    name: "fan_3_speed",
+                    value: 5,
+                },
+            },
             {
                 method: "setTargetTemperature",
                 call: (api, token, mac, value) => api.setTargetTemperature(token, mac, value),
@@ -309,6 +449,38 @@ describe("library", () => {
                     value: 20,
                 },
             },
+            {
+                method: "setStandbyTime",
+                call: (api, token, mac, value) => api.setStandbyTime(token, mac, value),
+                payload: {
+                    name: "standby_time",
+                    value: 45,
+                },
+            },
+            {
+                method: "setEnvironment2Temperature",
+                call: (api, token, mac, value) => api.setEnvironment2Temperature(token, mac, value),
+                payload: {
+                    name: "enviroment_2_temperature",
+                    value: 21,
+                },
+            },
+            {
+                method: "setEnvironment3Temperature",
+                call: (api, token, mac, value) => api.setEnvironment3Temperature(token, mac, value),
+                payload: {
+                    name: "enviroment_3_temperature",
+                    value: 23,
+                },
+            },
+            {
+                method: "setLanguage",
+                call: (api, token, mac, value) => api.setLanguage(token, mac, value),
+                payload: {
+                    name: "language",
+                    value: 2,
+                },
+            },
         ];
         setterTests.forEach(({ method, call, payload }) => {
             it(`should call fetch and send the correct payload for ${method}`, () => __awaiter(void 0, void 0, void 0, function* () {
@@ -327,6 +499,69 @@ describe("library", () => {
                 });
             }));
         });
+        // Boolean setter tests (for mode controls)
+        const booleanSetterTests = [
+            {
+                method: "setAirkare",
+                call: (api, token, mac, enabled) => api.setAirkare(token, mac, enabled),
+                truePayload: { name: "airkare_function", value: 1 },
+                falsePayload: { name: "airkare_function", value: 0 },
+            },
+            {
+                method: "setRelax",
+                call: (api, token, mac, enabled) => api.setRelax(token, mac, enabled),
+                truePayload: { name: "relax_mode", value: true },
+                falsePayload: { name: "relax_mode", value: false },
+            },
+            {
+                method: "setStandby",
+                call: (api, token, mac, enabled) => api.setStandby(token, mac, enabled),
+                truePayload: { name: "standby_mode", value: true },
+                falsePayload: { name: "standby_mode", value: false },
+            },
+            {
+                method: "setAuto",
+                call: (api, token, mac, enabled) => api.setAuto(token, mac, enabled),
+                truePayload: { name: "auto_mode", value: true },
+                falsePayload: { name: "auto_mode", value: false },
+            },
+            {
+                method: "setMeasureUnit",
+                call: (api, token, mac, enabled) => api.setMeasureUnit(token, mac, enabled),
+                truePayload: { name: "measure_unit", value: true },
+                falsePayload: { name: "measure_unit", value: false },
+            },
+        ];
+        booleanSetterTests.forEach(({ method, call, truePayload, falsePayload }) => {
+            it(`should call fetch with correct payload for ${method}(true)`, () => __awaiter(void 0, void 0, void 0, function* () {
+                fetchStub.resolves(mockResponse({ success: true }));
+                const api = configure("https://example.com/api/");
+                yield call(api, expectedToken, "mockMacAddress", true);
+                assert.ok(fetchStub.calledOnce);
+                assert.deepEqual(fetchStub.firstCall.args[1], {
+                    method: "PUT",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${expectedToken}`,
+                    },
+                    body: JSON.stringify(Object.assign({ mac_address: "mockMacAddress" }, truePayload)),
+                });
+            }));
+            it(`should call fetch with correct payload for ${method}(false)`, () => __awaiter(void 0, void 0, void 0, function* () {
+                fetchStub.resolves(mockResponse({ success: true }));
+                const api = configure("https://example.com/api/");
+                yield call(api, expectedToken, "mockMacAddress", false);
+                assert.ok(fetchStub.calledOnce);
+                assert.deepEqual(fetchStub.firstCall.args[1], {
+                    method: "PUT",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${expectedToken}`,
+                    },
+                    body: JSON.stringify(Object.assign({ mac_address: "mockMacAddress" }, falsePayload)),
+                });
+            }));
+        });
     });
     describe("registerDevice", () => {
         it("should call POST /device with correct payload", () => __awaiter(void 0, void 0, void 0, function* () {
@@ -515,6 +750,37 @@ describe("library", () => {
             const result = yield api.getTargetTemperature(expectedToken, "mockMacAddress");
             assert.equal(result, 22);
         }));
+        it("should work with getPelletInReserve on compressed response", () => __awaiter(void 0, void 0, void 0, function* () {
+            const statusData = {
+                commands: { power: true },
+                temperatures: { enviroment: 19 },
+                flags: { is_pellet_in_reserve: true },
+                pellet: { autonomy_time: 120 },
+            };
+            const mockResponseData = {
+                status: createGzippedBuffer(statusData),
+                nvm: { user_parameters: { enviroment_1_temperature: 22 } },
+            };
+            fetchStub.resolves(mockResponse(mockResponseData));
+            const api = configure("https://example.com/api/");
+            const result = yield api.getPelletInReserve(expectedToken, "mockMacAddress");
+            assert.equal(result, true);
+        }));
+        it("should work with getPelletAutonomyTime on response", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponseData = {
+                status: {
+                    commands: { power: true },
+                    temperatures: { enviroment: 19 },
+                    flags: { is_pellet_in_reserve: false },
+                    pellet: { autonomy_time: 240 },
+                },
+                nvm: { user_parameters: { enviroment_1_temperature: 22 } },
+            };
+            fetchStub.resolves(mockResponse(mockResponseData));
+            const api = configure("https://example.com/api/");
+            const result = yield api.getPelletAutonomyTime(expectedToken, "mockMacAddress");
+            assert.equal(result, 240);
+        }));
     });
     describe("Error Handling", () => {
         const errorTests = [

package/dist/esm/src/types.d.ts

@@ -13,9 +13,17 @@ interface TemperaturesType {
     board: number;
     enviroment: number;
 }
+interface GeneralFlagsType {
+    is_pellet_in_reserve: boolean;
+}
+interface PelletAutonomyType {
+    autonomy_time: number;
+}
 interface StatusType {
     commands: CommandsType;
     temperatures: TemperaturesType;
+    flags: GeneralFlagsType;
+    pellet: PelletAutonomyType;
 }
 interface UserParametersType {
     enviroment_1_temperature: number;
@@ -23,6 +31,14 @@ interface UserParametersType {
     enviroment_3_temperature: number;
     is_auto: boolean;
     is_sound_active: boolean;
+    manual_power: number;
+    fan_1_ventilation: number;
+    fan_2_ventilation: number;
+    fan_3_ventilation: number;
+    is_standby_active: boolean;
+    standby_waiting_time: number;
+    is_fahrenheit: boolean;
+    language: number;
 }
 interface DeviceInfoType {
     status: StatusType;
@@ -83,4 +99,4 @@ interface DiscoveredDevice {
     /** Signal strength in dBm (optional, not all platforms provide this) */
     rssi?: number;
 }
-export type { BufferEncodedType, CommandsType, DeviceAssociationBody, DeviceAssociationResponse, DeviceInfoRawType, DeviceInfoType, DiscoveredDevice, EditDeviceAssociationBody, StatusType, TemperaturesType, UserParametersType, };
+export type { BufferEncodedType, CommandsType, DeviceAssociationBody, DeviceAssociationResponse, DeviceInfoRawType, DeviceInfoType, DiscoveredDevice, EditDeviceAssociationBody, GeneralFlagsType, PelletAutonomyType, StatusType, TemperaturesType, UserParametersType, };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edilkamin",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "description": "",
   "main": "dist/cjs/src/index.js",
   "module": "dist/esm/src/index.js",
@@ -70,9 +70,9 @@
     "@eslint/eslintrc": "^3.2.0",
     "@eslint/js": "^9.16.0",
     "@types/mocha": "^10.0.10",
-    "@types/node": "^25.0.2",
+    "@types/node": "^24",
     "@types/pako": "^2.0.4",
-    "@types/sinon": "^17.0.3",
+    "@types/sinon": "^21.0.0",
     "@types/web-bluetooth": "^0.0.21",
     "@typescript-eslint/eslint-plugin": "^8.17.0",
     "@typescript-eslint/parser": "^8.17.0",
@@ -84,7 +84,7 @@
     "mocha": "^11.7.5",
     "nyc": "^17.1.0",
     "prettier": "^3.7.4",
-    "sinon": "^19.0.2",
+    "sinon": "^21.0.1",
     "ts-node": "^10.9.1",
     "typedoc": "^0.28.15",
     "typescript": "^5.7.2"

package/src/cli.ts

@@ -200,6 +200,15 @@ const createProgram = (): Command => {
         mac: string,
       ) => api.getPower(jwtToken, mac),
     },
+    {
+      commandName: "getPowerLevel",
+      description: "Retrieve manual power level (1-5)",
+      getter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+      ) => api.getPowerLevel(jwtToken, mac),
+    },
     {
       commandName: "getEnvironmentTemperature",
       description: "Retrieve environment temperature",
@@ -218,6 +227,115 @@ const createProgram = (): Command => {
         mac: string,
       ) => api.getTargetTemperature(jwtToken, mac),
     },
+    {
+      commandName: "getFan1Speed",
+      description: "Retrieve fan 1 speed",
+      getter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+      ) => api.getFan1Speed(jwtToken, mac),
+    },
+    {
+      commandName: "getFan2Speed",
+      description: "Retrieve fan 2 speed",
+      getter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+      ) => api.getFan2Speed(jwtToken, mac),
+    },
+    {
+      commandName: "getFan3Speed",
+      description: "Retrieve fan 3 speed",
+      getter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+      ) => api.getFan3Speed(jwtToken, mac),
+    },
+    {
+      commandName: "getStandby",
+      description: "Retrieve Standby mode status",
+      getter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+      ) => api.getStandby(jwtToken, mac),
+    },
+    {
+      commandName: "getStandbyTime",
+      description: "Retrieve standby waiting time in minutes",
+      getter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+      ) => api.getStandbyTime(jwtToken, mac),
+    },
+    {
+      commandName: "getAuto",
+      description: "Retrieve Auto mode status",
+      getter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+      ) => api.getAuto(jwtToken, mac),
+    },
+    {
+      commandName: "getEnvironment2Temperature",
+      description: "Retrieve Environment 2 target temperature",
+      getter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+      ) => api.getEnvironment2Temperature(jwtToken, mac),
+    },
+    {
+      commandName: "getEnvironment3Temperature",
+      description: "Retrieve Environment 3 target temperature",
+      getter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+      ) => api.getEnvironment3Temperature(jwtToken, mac),
+    },
+    {
+      commandName: "getMeasureUnit",
+      description: "Retrieve temperature unit (true=Fahrenheit, false=Celsius)",
+      getter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+      ) => api.getMeasureUnit(jwtToken, mac),
+    },
+    {
+      commandName: "getLanguage",
+      description: "Retrieve display language code (0-9)",
+      getter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+      ) => api.getLanguage(jwtToken, mac),
+    },
+    {
+      commandName: "getPelletInReserve",
+      description:
+        "Retrieve pellet reserve status (true=low/reserve, false=ok)",
+      getter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+      ) => api.getPelletInReserve(jwtToken, mac),
+    },
+    {
+      commandName: "getPelletAutonomyTime",
+      description: "Retrieve estimated pellet autonomy time",
+      getter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+      ) => api.getPelletAutonomyTime(jwtToken, mac),
+    },
   ].forEach(({ commandName, description, getter }) => {
     addLegacyOption(
       addMacOption(
@@ -237,6 +355,16 @@ const createProgram = (): Command => {
         value: number,
       ) => api.setPower(jwtToken, mac, value),
     },
+    {
+      commandName: "setPowerLevel",
+      description: "Set manual power level (1-5)",
+      setter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+        value: number,
+      ) => api.setPowerLevel(jwtToken, mac, value),
+    },
     {
       commandName: "setTargetTemperature",
       description: "Set the target temperature (degree celsius) for a device",
@@ -247,6 +375,127 @@ const createProgram = (): Command => {
         value: number,
       ) => api.setTargetTemperature(jwtToken, mac, value),
     },
+    {
+      commandName: "setFan1Speed",
+      description: "Set fan 1 speed (0-5)",
+      setter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+        value: number,
+      ) => api.setFan1Speed(jwtToken, mac, value),
+    },
+    {
+      commandName: "setFan2Speed",
+      description: "Set fan 2 speed (0-5)",
+      setter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+        value: number,
+      ) => api.setFan2Speed(jwtToken, mac, value),
+    },
+    {
+      commandName: "setFan3Speed",
+      description: "Set fan 3 speed (0-5)",
+      setter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+        value: number,
+      ) => api.setFan3Speed(jwtToken, mac, value),
+    },
+    {
+      commandName: "setAirkare",
+      description: "Enable/disable Airkare mode (1=on, 0=off)",
+      setter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+        value: number,
+      ) => api.setAirkare(jwtToken, mac, value === 1),
+    },
+    {
+      commandName: "setRelax",
+      description: "Enable/disable Relax mode (1=on, 0=off)",
+      setter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+        value: number,
+      ) => api.setRelax(jwtToken, mac, value === 1),
+    },
+    {
+      commandName: "setStandby",
+      description: "Enable/disable Standby mode (1=on, 0=off)",
+      setter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+        value: number,
+      ) => api.setStandby(jwtToken, mac, value === 1),
+    },
+    {
+      commandName: "setStandbyTime",
+      description: "Set standby waiting time in minutes",
+      setter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+        value: number,
+      ) => api.setStandbyTime(jwtToken, mac, value),
+    },
+    {
+      commandName: "setAuto",
+      description: "Enable/disable Auto mode (1=on, 0=off)",
+      setter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+        value: number,
+      ) => api.setAuto(jwtToken, mac, value === 1),
+    },
+    {
+      commandName: "setEnvironment2Temperature",
+      description: "Set Environment 2 target temperature (degrees Celsius)",
+      setter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+        value: number,
+      ) => api.setEnvironment2Temperature(jwtToken, mac, value),
+    },
+    {
+      commandName: "setEnvironment3Temperature",
+      description: "Set Environment 3 target temperature (degrees Celsius)",
+      setter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+        value: number,
+      ) => api.setEnvironment3Temperature(jwtToken, mac, value),
+    },
+    {
+      commandName: "setMeasureUnit",
+      description: "Set temperature unit (1=Fahrenheit, 0=Celsius)",
+      setter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+        value: number,
+      ) => api.setMeasureUnit(jwtToken, mac, value === 1),
+    },
+    {
+      commandName: "setLanguage",
+      description:
+        "Set display language (0=IT,1=FR,2=EN,3=ES,4=PT,5=DA,6=NL,7=DE,8=HU,9=PL)",
+      setter: (
+        api: ReturnType<typeof configure>,
+        jwtToken: string,
+        mac: string,
+        value: number,
+      ) => api.setLanguage(jwtToken, mac, value),
+    },
   ].forEach(({ commandName, description, setter }) => {
     addLegacyOption(
       addMacOption(