edilkamin 1.6.1 → 1.7.2

package/dist/esm/library.d.ts

@@ -1,5 +1,5 @@
 import * as amplifyAuth from "aws-amplify/auth";
-import { DeviceInfoType } from "./types";
+import { DeviceAssociationResponse, DeviceInfoType } from "./types";
 /**
  * Generates headers with a JWT token for authenticated requests.
  * @param {string} jwtToken - The JWT token for authorization.
@@ -8,15 +8,27 @@ import { DeviceInfoType } from "./types";
 declare const headers: (jwtToken: string) => {
     Authorization: string;
 };
+/**
+ * Configures Amplify if not already configured.
+ * Uses a local flag to avoid calling getConfig() which prints a warning.
+ * @param {object} [storage] - Optional custom storage adapter for token persistence
+ */
+declare const configureAmplify: (storage?: {
+    setItem: (key: string, value: string) => Promise<void>;
+    getItem: (key: string) => Promise<string | null>;
+    removeItem: (key: string) => Promise<void>;
+    clear: () => Promise<void>;
+}) => void;
 /**
  * Creates an authentication service with sign-in functionality.
  * @param {typeof amplifyAuth} auth - The authentication module to use.
  * @returns {object} - An object containing authentication-related methods.
  */
 declare const createAuthService: (auth: typeof amplifyAuth) => {
-    signIn: (username: string, password: string) => Promise<string>;
+    signIn: (username: string, password: string, legacy?: boolean) => Promise<string>;
+    getSession: (forceRefresh?: boolean, legacy?: boolean) => Promise<string>;
 };
-declare const signIn: (username: string, password: string) => Promise<string>;
+declare const signIn: (username: string, password: string, legacy?: boolean) => Promise<string>, getSession: (forceRefresh?: boolean, legacy?: boolean) => Promise<string>;
 /**
  * Configures the library for API interactions.
  * Initializes API methods with a specified base URL.
@@ -30,6 +42,8 @@ declare const signIn: (username: string, password: string) => Promise<string>;
  */
 declare const configure: (baseURL?: string) => {
     deviceInfo: (jwtToken: string, macAddress: string) => Promise<DeviceInfoType>;
+    registerDevice: (jwtToken: string, macAddress: string, serialNumber: string, deviceName?: string, deviceRoom?: string) => Promise<DeviceAssociationResponse>;
+    editDevice: (jwtToken: string, macAddress: string, deviceName?: string, deviceRoom?: string) => Promise<DeviceAssociationResponse>;
     setPower: (jwtToken: string, macAddress: string, value: number) => Promise<import("axios").AxiosResponse<any, any, {}>>;
     setPowerOff: (jwtToken: string, macAddress: string) => Promise<import("axios").AxiosResponse<any, any, {}>>;
     setPowerOn: (jwtToken: string, macAddress: string) => Promise<import("axios").AxiosResponse<any, any, {}>>;
@@ -38,4 +52,4 @@ declare const configure: (baseURL?: string) => {
     getTargetTemperature: (jwtToken: string, macAddress: string) => Promise<number>;
     setTargetTemperature: (jwtToken: string, macAddress: string, temperature: number) => Promise<import("axios").AxiosResponse<any, any, {}>>;
 };
-export { configure, createAuthService, headers, signIn };
+export { configure, configureAmplify, createAuthService, getSession, headers, signIn, };

package/dist/esm/library.js

@@ -10,7 +10,9 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 import { strict as assert } from "assert";
 import { Amplify } from "aws-amplify";
 import * as amplifyAuth from "aws-amplify/auth";
+import { cognitoUserPoolsTokenProvider } from "aws-amplify/auth/cognito";
 import axios from "axios";
+import { processResponse } from "./buffer-utils";
 import { API_URL } from "./constants";
 const amplifyconfiguration = {
     aws_project_region: "eu-central-1",
@@ -23,15 +25,20 @@ const amplifyconfiguration = {
  * @returns {object} - The headers object with the Authorization field.
  */
 const headers = (jwtToken) => ({ Authorization: `Bearer ${jwtToken}` });
+let amplifyConfigured = false;
 /**
  * Configures Amplify if not already configured.
- * Ensures the configuration is only applied once.
+ * Uses a local flag to avoid calling getConfig() which prints a warning.
+ * @param {object} [storage] - Optional custom storage adapter for token persistence
  */
-const configureAmplify = () => {
-    const currentConfig = Amplify.getConfig();
-    if (Object.keys(currentConfig).length !== 0)
+const configureAmplify = (storage) => {
+    if (amplifyConfigured)
         return;
     Amplify.configure(amplifyconfiguration);
+    if (storage) {
+        cognitoUserPoolsTokenProvider.setKeyValueStorage(storage);
+    }
+    amplifyConfigured = true;
 };
 /**
  * Creates an authentication service with sign-in functionality.
@@ -43,26 +50,51 @@ const createAuthService = (auth) => {
      * Signs in a user with the provided credentials.
      * @param {string} username - The username of the user.
      * @param {string} password - The password of the user.
+     * @param {boolean} [legacy=false] - If true, returns accessToken for legacy API.
      * @returns {Promise<string>} - The JWT token of the signed-in user.
      * @throws {Error} - If sign-in fails or no tokens are retrieved.
      */
-    const signIn = (username, password) => __awaiter(void 0, void 0, void 0, function* () {
+    const signIn = (username_1, password_1, ...args_1) => __awaiter(void 0, [username_1, password_1, ...args_1], void 0, function* (username, password, legacy = false) {
         configureAmplify();
         yield auth.signOut(); // Ensure the user is signed out first
         const { isSignedIn } = yield auth.signIn({ username, password });
         assert.ok(isSignedIn, "Sign-in failed");
         const { tokens } = yield auth.fetchAuthSession();
         assert.ok(tokens, "No tokens found");
+        if (legacy) {
+            assert.ok(tokens.accessToken, "No access token found");
+            return tokens.accessToken.toString();
+        }
         assert.ok(tokens.idToken, "No ID token found");
         return tokens.idToken.toString();
     });
-    return { signIn };
+    /**
+     * Retrieves the current session, refreshing tokens if necessary.
+     * Requires a prior successful signIn() call.
+     * @param {boolean} [forceRefresh=false] - Force token refresh even if valid
+     * @param {boolean} [legacy=false] - If true, returns accessToken for legacy API
+     * @returns {Promise<string>} - The JWT token (idToken or accessToken)
+     * @throws {Error} - If no session exists (user needs to sign in)
+     */
+    const getSession = (...args_1) => __awaiter(void 0, [...args_1], void 0, function* (forceRefresh = false, legacy = false) {
+        configureAmplify();
+        const { tokens } = yield auth.fetchAuthSession({ forceRefresh });
+        assert.ok(tokens, "No session found - please sign in first");
+        if (legacy) {
+            assert.ok(tokens.accessToken, "No access token found");
+            return tokens.accessToken.toString();
+        }
+        assert.ok(tokens.idToken, "No ID token found");
+        return tokens.idToken.toString();
+    });
+    return { signIn, getSession };
 };
 // Create the default auth service using amplifyAuth
-const { signIn } = createAuthService(amplifyAuth);
+const { signIn, getSession } = createAuthService(amplifyAuth);
 const deviceInfo = (axiosInstance) => 
 /**
  * Retrieves information about a device by its MAC address.
+ * Automatically decompresses any gzip-compressed Buffer fields in the response.
  *
  * @param {string} jwtToken - The JWT token for authentication.
  * @param {string} macAddress - The MAC address of the device.
@@ -72,7 +104,8 @@ const deviceInfo = (axiosInstance) =>
     const response = yield axiosInstance.get(`device/${macAddress}/info`, {
         headers: headers(jwtToken),
     });
-    return response.data;
+    // Process response to decompress any gzipped Buffer fields
+    return processResponse(response.data);
 });
 const mqttCommand = (axiosInstance) => 
 // eslint-disable-next-line  @typescript-eslint/no-explicit-any
@@ -162,6 +195,47 @@ const setTargetTemperature = (axiosInstance) =>
     name: "enviroment_1_temperature",
     value: temperature,
 });
+const registerDevice = (axiosInstance) => 
+/**
+ * Registers a device with the user's account.
+ * This must be called before other device operations will work on the new API.
+ *
+ * @param {string} jwtToken - The JWT token for authentication.
+ * @param {string} macAddress - The MAC address of the device (colons optional).
+ * @param {string} serialNumber - The device serial number.
+ * @param {string} deviceName - User-friendly name for the device (default: empty string).
+ * @param {string} deviceRoom - Room name for the device (default: empty string).
+ * @returns {Promise<DeviceAssociationResponse>} - A promise that resolves to the registration response.
+ */
+(jwtToken_1, macAddress_1, serialNumber_1, ...args_1) => __awaiter(void 0, [jwtToken_1, macAddress_1, serialNumber_1, ...args_1], void 0, function* (jwtToken, macAddress, serialNumber, deviceName = "", deviceRoom = "") {
+    const body = {
+        macAddress: macAddress.replace(/:/g, ""),
+        deviceName,
+        deviceRoom,
+        serialNumber,
+    };
+    const response = yield axiosInstance.post("device", body, { headers: headers(jwtToken) });
+    return response.data;
+});
+const editDevice = (axiosInstance) => 
+/**
+ * Updates a device's name and room.
+ *
+ * @param {string} jwtToken - The JWT token for authentication.
+ * @param {string} macAddress - The MAC address of the device (colons optional).
+ * @param {string} deviceName - New name for the device (default: empty string).
+ * @param {string} deviceRoom - New room for the device (default: empty string).
+ * @returns {Promise<DeviceAssociationResponse>} - A promise that resolves to the update response.
+ */
+(jwtToken_1, macAddress_1, ...args_1) => __awaiter(void 0, [jwtToken_1, macAddress_1, ...args_1], void 0, function* (jwtToken, macAddress, deviceName = "", deviceRoom = "") {
+    const normalizedMac = macAddress.replace(/:/g, "");
+    const body = {
+        deviceName,
+        deviceRoom,
+    };
+    const response = yield axiosInstance.put(`device/${normalizedMac}`, body, { headers: headers(jwtToken) });
+    return response.data;
+});
 /**
  * Configures the library for API interactions.
  * Initializes API methods with a specified base URL.
@@ -176,6 +250,8 @@ const setTargetTemperature = (axiosInstance) =>
 const configure = (baseURL = API_URL) => {
     const axiosInstance = axios.create({ baseURL });
     const deviceInfoInstance = deviceInfo(axiosInstance);
+    const registerDeviceInstance = registerDevice(axiosInstance);
+    const editDeviceInstance = editDevice(axiosInstance);
     const setPowerInstance = setPower(axiosInstance);
     const setPowerOffInstance = setPowerOff(axiosInstance);
     const setPowerOnInstance = setPowerOn(axiosInstance);
@@ -185,6 +261,8 @@ const configure = (baseURL = API_URL) => {
     const setTargetTemperatureInstance = setTargetTemperature(axiosInstance);
     return {
         deviceInfo: deviceInfoInstance,
+        registerDevice: registerDeviceInstance,
+        editDevice: editDeviceInstance,
         setPower: setPowerInstance,
         setPowerOff: setPowerOffInstance,
         setPowerOn: setPowerOnInstance,
@@ -194,4 +272,4 @@ const configure = (baseURL = API_URL) => {
         setTargetTemperature: setTargetTemperatureInstance,
     };
 };
-export { configure, createAuthService, headers, signIn };
+export { configure, configureAmplify, createAuthService, getSession, headers, signIn, };

package/dist/esm/library.test.js

@@ -9,9 +9,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 import { strict as assert } from "assert";
 import axios from "axios";
+import pako from "pako";
 import sinon from "sinon";
 import { configure, createAuthService } from "../src/library";
 import { API_URL } from "./constants";
+/**
+ * Helper to create a gzip-compressed Buffer object for testing.
+ */
+const createGzippedBuffer = (data) => {
+    const json = JSON.stringify(data);
+    const compressed = pako.gzip(json);
+    return {
+        type: "Buffer",
+        data: Array.from(compressed),
+    };
+};
 describe("library", () => {
     let axiosStub;
     const expectedToken = "mockJwtToken";
@@ -26,7 +38,7 @@ describe("library", () => {
         sinon.restore();
     });
     describe("signIn", () => {
-        it("should sign in and return the JWT token", () => __awaiter(void 0, void 0, void 0, function* () {
+        it("should sign in and return the ID token by default", () => __awaiter(void 0, void 0, void 0, function* () {
             const expectedUsername = "testuser";
             const expectedPassword = "testpassword";
             const signIn = sinon.stub().resolves({ isSignedIn: true });
@@ -34,6 +46,7 @@ describe("library", () => {
             const fetchAuthSession = sinon.stub().resolves({
                 tokens: {
                     idToken: { toString: () => expectedToken },
+                    accessToken: { toString: () => "accessToken" },
                 },
             });
             const authStub = {
@@ -50,6 +63,27 @@ describe("library", () => {
             ]);
             assert.equal(token, expectedToken);
         }));
+        it("should sign in and return the access token in legacy mode", () => __awaiter(void 0, void 0, void 0, function* () {
+            const expectedUsername = "testuser";
+            const expectedPassword = "testpassword";
+            const signIn = sinon.stub().resolves({ isSignedIn: true });
+            const signOut = sinon.stub();
+            const fetchAuthSession = sinon.stub().resolves({
+                tokens: {
+                    accessToken: { toString: () => expectedToken },
+                    idToken: { toString: () => "idToken" },
+                },
+            });
+            const authStub = {
+                signIn,
+                signOut,
+                fetchAuthSession,
+            };
+            // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+            const authService = createAuthService(authStub);
+            const token = yield authService.signIn(expectedUsername, expectedPassword, true);
+            assert.equal(token, expectedToken);
+        }));
         it("should throw an error if sign-in fails", () => __awaiter(void 0, void 0, void 0, function* () {
             const expectedUsername = "testuser";
             const expectedPassword = "testpassword";
@@ -73,9 +107,73 @@ describe("library", () => {
             });
         }));
     });
+    describe("getSession", () => {
+        it("should return idToken by default", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockAuth = {
+                signIn: sinon.stub().resolves({ isSignedIn: true }),
+                signOut: sinon.stub().resolves(),
+                fetchAuthSession: sinon.stub().resolves({
+                    tokens: {
+                        idToken: { toString: () => "mock-id-token" },
+                        accessToken: { toString: () => "mock-access-token" },
+                    },
+                }),
+            };
+            const { getSession, signIn } = createAuthService(mockAuth);
+            yield signIn("user", "pass");
+            const token = yield getSession();
+            assert.equal(token, "mock-id-token");
+        }));
+        it("should return accessToken when legacy=true", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockAuth = {
+                signIn: sinon.stub().resolves({ isSignedIn: true }),
+                signOut: sinon.stub().resolves(),
+                fetchAuthSession: sinon.stub().resolves({
+                    tokens: {
+                        idToken: { toString: () => "mock-id-token" },
+                        accessToken: { toString: () => "mock-access-token" },
+                    },
+                }),
+            };
+            const { getSession, signIn } = createAuthService(mockAuth);
+            yield signIn("user", "pass");
+            const token = yield getSession(false, true);
+            assert.equal(token, "mock-access-token");
+        }));
+        it("should throw error when no session exists", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockAuth = {
+                signIn: sinon.stub().resolves({ isSignedIn: true }),
+                signOut: sinon.stub().resolves(),
+                fetchAuthSession: sinon.stub().resolves({ tokens: null }),
+            };
+            const { getSession } = createAuthService(mockAuth);
+            yield assert.rejects(() => __awaiter(void 0, void 0, void 0, function* () { return getSession(); }), {
+                name: "AssertionError",
+                message: "No session found - please sign in first",
+            });
+        }));
+        it("should pass forceRefresh to fetchAuthSession", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockAuth = {
+                signIn: sinon.stub().resolves({ isSignedIn: true }),
+                signOut: sinon.stub().resolves(),
+                fetchAuthSession: sinon.stub().resolves({
+                    tokens: {
+                        idToken: { toString: () => "mock-id-token" },
+                        accessToken: { toString: () => "mock-access-token" },
+                    },
+                }),
+            };
+            const { getSession, signIn } = createAuthService(mockAuth);
+            yield signIn("user", "pass");
+            yield getSession(true);
+            assert.ok(mockAuth.fetchAuthSession.calledWith({ forceRefresh: true }));
+        }));
+    });
     describe("configure", () => {
         const expectedApi = [
             "deviceInfo",
+            "registerDevice",
+            "editDevice",
             "setPower",
             "setPowerOff",
             "setPowerOn",
@@ -242,4 +340,226 @@ describe("library", () => {
             }));
         });
     });
+    describe("registerDevice", () => {
+        it("should call POST /device with correct payload", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = {
+                macAddress: "AABBCCDDEEFF",
+                deviceName: "Test Stove",
+                deviceRoom: "Living Room",
+                serialNumber: "EDK123",
+            };
+            const mockAxios = {
+                post: sinon.stub().resolves({ data: mockResponse }),
+                get: sinon.stub(),
+                put: sinon.stub(),
+            };
+            axiosStub.returns(mockAxios);
+            const api = configure("https://example.com/api");
+            const result = yield api.registerDevice(expectedToken, "AA:BB:CC:DD:EE:FF", "EDK123", "Test Stove", "Living Room");
+            assert.deepEqual(mockAxios.post.args, [
+                [
+                    "device",
+                    {
+                        macAddress: "AABBCCDDEEFF",
+                        deviceName: "Test Stove",
+                        deviceRoom: "Living Room",
+                        serialNumber: "EDK123",
+                    },
+                    { headers: { Authorization: `Bearer ${expectedToken}` } },
+                ],
+            ]);
+            assert.deepEqual(result, mockResponse);
+        }));
+        it("should normalize MAC address by removing colons", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockAxios = {
+                post: sinon.stub().resolves({ data: {} }),
+                get: sinon.stub(),
+                put: sinon.stub(),
+            };
+            axiosStub.returns(mockAxios);
+            const api = configure("https://example.com/api");
+            yield api.registerDevice(expectedToken, "AA:BB:CC:DD:EE:FF", "EDK123");
+            assert.equal(mockAxios.post.args[0][1].macAddress, "AABBCCDDEEFF");
+        }));
+        it("should use empty strings as defaults for name and room", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockAxios = {
+                post: sinon.stub().resolves({ data: {} }),
+                get: sinon.stub(),
+                put: sinon.stub(),
+            };
+            axiosStub.returns(mockAxios);
+            const api = configure("https://example.com/api");
+            yield api.registerDevice(expectedToken, "AABBCCDDEEFF", "EDK123");
+            assert.equal(mockAxios.post.args[0][1].deviceName, "");
+            assert.equal(mockAxios.post.args[0][1].deviceRoom, "");
+        }));
+    });
+    describe("editDevice", () => {
+        it("should call PUT /device/{mac} with correct payload", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponse = {
+                macAddress: "AABBCCDDEEFF",
+                deviceName: "Updated Name",
+                deviceRoom: "Basement",
+                serialNumber: "EDK123",
+            };
+            const mockAxios = {
+                put: sinon.stub().resolves({ data: mockResponse }),
+                get: sinon.stub(),
+                post: sinon.stub(),
+            };
+            axiosStub.returns(mockAxios);
+            const api = configure("https://example.com/api");
+            const result = yield api.editDevice(expectedToken, "AA:BB:CC:DD:EE:FF", "Updated Name", "Basement");
+            assert.deepEqual(mockAxios.put.args, [
+                [
+                    "device/AABBCCDDEEFF",
+                    {
+                        deviceName: "Updated Name",
+                        deviceRoom: "Basement",
+                    },
+                    { headers: { Authorization: `Bearer ${expectedToken}` } },
+                ],
+            ]);
+            assert.deepEqual(result, mockResponse);
+        }));
+        it("should use empty strings as defaults for name and room", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockAxios = {
+                put: sinon.stub().resolves({ data: {} }),
+                get: sinon.stub(),
+                post: sinon.stub(),
+            };
+            axiosStub.returns(mockAxios);
+            const api = configure("https://example.com/api");
+            yield api.editDevice(expectedToken, "AABBCCDDEEFF");
+            assert.equal(mockAxios.put.args[0][1].deviceName, "");
+            assert.equal(mockAxios.put.args[0][1].deviceRoom, "");
+        }));
+    });
+    describe("deviceInfo with compressed responses", () => {
+        it("should decompress Buffer-encoded status field", () => __awaiter(void 0, void 0, void 0, function* () {
+            const statusData = {
+                commands: { power: true },
+                temperatures: { enviroment: 19, board: 25 },
+            };
+            const mockResponse = {
+                status: createGzippedBuffer(statusData),
+                nvm: {
+                    user_parameters: {
+                        enviroment_1_temperature: 22,
+                    },
+                },
+            };
+            const mockAxios = {
+                get: sinon.stub().resolves({ data: mockResponse }),
+            };
+            axiosStub.returns(mockAxios);
+            const api = configure("https://example.com/api");
+            const result = yield api.deviceInfo(expectedToken, "mockMacAddress");
+            assert.deepEqual(result.status, statusData);
+        }));
+        it("should decompress Buffer-encoded nvm field", () => __awaiter(void 0, void 0, void 0, function* () {
+            const nvmData = {
+                user_parameters: {
+                    enviroment_1_temperature: 22,
+                    enviroment_2_temperature: 0,
+                    enviroment_3_temperature: 0,
+                    is_auto: false,
+                    is_sound_active: true,
+                },
+            };
+            const mockResponse = {
+                status: {
+                    commands: { power: true },
+                    temperatures: { enviroment: 19 },
+                },
+                nvm: createGzippedBuffer(nvmData),
+            };
+            const mockAxios = {
+                get: sinon.stub().resolves({ data: mockResponse }),
+            };
+            axiosStub.returns(mockAxios);
+            const api = configure("https://example.com/api");
+            const result = yield api.deviceInfo(expectedToken, "mockMacAddress");
+            assert.deepEqual(result.nvm, nvmData);
+        }));
+        it("should handle fully compressed response (status and nvm)", () => __awaiter(void 0, void 0, void 0, function* () {
+            const statusData = {
+                commands: { power: false },
+                temperatures: { enviroment: 21, board: 30 },
+            };
+            const nvmData = {
+                user_parameters: {
+                    enviroment_1_temperature: 20,
+                    enviroment_2_temperature: 0,
+                    enviroment_3_temperature: 0,
+                    is_auto: true,
+                    is_sound_active: false,
+                },
+            };
+            const mockResponse = {
+                status: createGzippedBuffer(statusData),
+                nvm: createGzippedBuffer(nvmData),
+            };
+            const mockAxios = {
+                get: sinon.stub().resolves({ data: mockResponse }),
+            };
+            axiosStub.returns(mockAxios);
+            const api = configure("https://example.com/api");
+            const result = yield api.deviceInfo(expectedToken, "mockMacAddress");
+            assert.deepEqual(result.status, statusData);
+            assert.deepEqual(result.nvm, nvmData);
+        }));
+        it("should work with getPower on compressed response", () => __awaiter(void 0, void 0, void 0, function* () {
+            const statusData = {
+                commands: { power: true },
+                temperatures: { enviroment: 19 },
+            };
+            const mockResponse = {
+                status: createGzippedBuffer(statusData),
+                nvm: { user_parameters: { enviroment_1_temperature: 22 } },
+            };
+            const mockAxios = {
+                get: sinon.stub().resolves({ data: mockResponse }),
+            };
+            axiosStub.returns(mockAxios);
+            const api = configure("https://example.com/api");
+            const result = yield api.getPower(expectedToken, "mockMacAddress");
+            assert.equal(result, true);
+        }));
+        it("should work with getEnvironmentTemperature on compressed response", () => __awaiter(void 0, void 0, void 0, function* () {
+            const statusData = {
+                commands: { power: true },
+                temperatures: { enviroment: 19, board: 25 },
+            };
+            const mockResponse = {
+                status: createGzippedBuffer(statusData),
+                nvm: { user_parameters: { enviroment_1_temperature: 22 } },
+            };
+            const mockAxios = {
+                get: sinon.stub().resolves({ data: mockResponse }),
+            };
+            axiosStub.returns(mockAxios);
+            const api = configure("https://example.com/api");
+            const result = yield api.getEnvironmentTemperature(expectedToken, "mockMacAddress");
+            assert.equal(result, 19);
+        }));
+        it("should work with getTargetTemperature on compressed response", () => __awaiter(void 0, void 0, void 0, function* () {
+            const nvmData = {
+                user_parameters: {
+                    enviroment_1_temperature: 22,
+                },
+            };
+            const mockResponse = {
+                status: { commands: { power: true }, temperatures: { enviroment: 19 } },
+                nvm: createGzippedBuffer(nvmData),
+            };
+            const mockAxios = {
+                get: sinon.stub().resolves({ data: mockResponse }),
+            };
+            axiosStub.returns(mockAxios);
+            const api = configure("https://example.com/api");
+            const result = yield api.getTargetTemperature(expectedToken, "mockMacAddress");
+            assert.equal(result, 22);
+        }));
+    });
 });

package/dist/esm/serial-utils.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Converts a raw serial number string to hex-encoded format.
+ * This is useful when serial numbers contain non-printable characters.
+ *
+ * @param serial - The raw serial number string
+ * @returns Hex-encoded string representation
+ *
+ * @example
+ * serialNumberToHex("EDK123") // returns "45444b313233"
+ */
+declare const serialNumberToHex: (serial: string) => string;
+/**
+ * Converts a hex-encoded serial number back to raw string format.
+ *
+ * @param hex - The hex-encoded serial number
+ * @returns Raw serial number string
+ *
+ * @example
+ * serialNumberFromHex("45444b313233") // returns "EDK123"
+ */
+declare const serialNumberFromHex: (hex: string) => string;
+/**
+ * Produces a display-friendly version of a serial number by removing
+ * non-printable characters and collapsing whitespace.
+ *
+ * @param serial - The raw serial number string
+ * @returns Display-friendly serial number
+ *
+ * @example
+ * serialNumberDisplay("EDK\x00123\x1F") // returns "EDK123"
+ */
+declare const serialNumberDisplay: (serial: string) => string;
+export { serialNumberDisplay, serialNumberFromHex, serialNumberToHex };

package/dist/esm/serial-utils.js

@@ -0,0 +1,45 @@
+/**
+ * Converts a raw serial number string to hex-encoded format.
+ * This is useful when serial numbers contain non-printable characters.
+ *
+ * @param serial - The raw serial number string
+ * @returns Hex-encoded string representation
+ *
+ * @example
+ * serialNumberToHex("EDK123") // returns "45444b313233"
+ */
+const serialNumberToHex = (serial) => {
+    return Buffer.from(serial, "utf-8").toString("hex");
+};
+/**
+ * Converts a hex-encoded serial number back to raw string format.
+ *
+ * @param hex - The hex-encoded serial number
+ * @returns Raw serial number string
+ *
+ * @example
+ * serialNumberFromHex("45444b313233") // returns "EDK123"
+ */
+const serialNumberFromHex = (hex) => {
+    return Buffer.from(hex, "hex").toString("utf-8");
+};
+/**
+ * Produces a display-friendly version of a serial number by removing
+ * non-printable characters and collapsing whitespace.
+ *
+ * @param serial - The raw serial number string
+ * @returns Display-friendly serial number
+ *
+ * @example
+ * serialNumberDisplay("EDK\x00123\x1F") // returns "EDK123"
+ */
+const serialNumberDisplay = (serial) => {
+    // Remove non-printable characters (ASCII 0-31, 127)
+    // Keep printable ASCII (32-126) and extended characters
+    return (serial
+        // eslint-disable-next-line no-control-regex
+        .replace(/[\x00-\x1F\x7F]/g, "")
+        .replace(/\s+/g, " ")
+        .trim());
+};
+export { serialNumberDisplay, serialNumberFromHex, serialNumberToHex };

package/dist/esm/serial-utils.test.d.ts

@@ -0,0 +1 @@
+export {};