edilkamin 1.7.3 → 1.8.0

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

@@ -0,0 +1,547 @@
+"use strict";
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = require("assert");
+const pako_1 = __importDefault(require("pako"));
+const sinon_1 = __importDefault(require("sinon"));
+const library_1 = require("../src/library");
+const constants_1 = require("./constants");
+/**
+ * Helper to create a gzip-compressed Buffer object for testing.
+ */
+const createGzippedBuffer = (data) => {
+    const json = JSON.stringify(data);
+    const compressed = pako_1.default.gzip(json);
+    return {
+        type: "Buffer",
+        data: Array.from(compressed),
+    };
+};
+/**
+ * Helper to create a mock Response object for fetch.
+ */
+const mockResponse = (data, status = 200) => ({
+    ok: status >= 200 && status < 300,
+    status,
+    statusText: status >= 200 && status < 300 ? "OK" : "Error",
+    json: () => Promise.resolve(data),
+});
+describe("library", () => {
+    let fetchStub;
+    const expectedToken = "mockJwtToken";
+    beforeEach(() => {
+        fetchStub = sinon_1.default.stub(globalThis, "fetch");
+    });
+    afterEach(() => {
+        sinon_1.default.restore();
+    });
+    describe("signIn", () => {
+        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_1.default.stub().resolves({ isSignedIn: true });
+            const signOut = sinon_1.default.stub();
+            const fetchAuthSession = sinon_1.default.stub().resolves({
+                tokens: {
+                    idToken: { toString: () => expectedToken },
+                    accessToken: { toString: () => "accessToken" },
+                },
+            });
+            const authStub = {
+                signIn,
+                signOut,
+                fetchAuthSession,
+            };
+            // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+            const authService = (0, library_1.createAuthService)(authStub);
+            const token = yield authService.signIn(expectedUsername, expectedPassword);
+            assert_1.strict.deepEqual(authStub.signOut.args, [[]]);
+            assert_1.strict.deepEqual(signIn.args, [
+                [{ username: expectedUsername, password: expectedPassword }],
+            ]);
+            assert_1.strict.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_1.default.stub().resolves({ isSignedIn: true });
+            const signOut = sinon_1.default.stub();
+            const fetchAuthSession = sinon_1.default.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 = (0, library_1.createAuthService)(authStub);
+            const token = yield authService.signIn(expectedUsername, expectedPassword, true);
+            assert_1.strict.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";
+            const signIn = sinon_1.default.stub().resolves({ isSignedIn: false });
+            const signOut = sinon_1.default.stub();
+            const fetchAuthSession = sinon_1.default.stub().resolves({
+                tokens: {
+                    accessToken: { toString: () => expectedToken },
+                },
+            });
+            const authStub = {
+                signIn,
+                signOut,
+                fetchAuthSession,
+            };
+            // eslint-disable-next-line  @typescript-eslint/no-explicit-any
+            const authService = (0, library_1.createAuthService)(authStub);
+            yield assert_1.strict.rejects(() => __awaiter(void 0, void 0, void 0, function* () { return authService.signIn(expectedUsername, expectedPassword); }), {
+                name: "AssertionError",
+                message: "Sign-in failed",
+            });
+        }));
+    });
+    describe("getSession", () => {
+        it("should return idToken by default", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockAuth = {
+                signIn: sinon_1.default.stub().resolves({ isSignedIn: true }),
+                signOut: sinon_1.default.stub().resolves(),
+                fetchAuthSession: sinon_1.default.stub().resolves({
+                    tokens: {
+                        idToken: { toString: () => "mock-id-token" },
+                        accessToken: { toString: () => "mock-access-token" },
+                    },
+                }),
+            };
+            const { getSession, signIn } = (0, library_1.createAuthService)(mockAuth);
+            yield signIn("user", "pass");
+            const token = yield getSession();
+            assert_1.strict.equal(token, "mock-id-token");
+        }));
+        it("should return accessToken when legacy=true", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockAuth = {
+                signIn: sinon_1.default.stub().resolves({ isSignedIn: true }),
+                signOut: sinon_1.default.stub().resolves(),
+                fetchAuthSession: sinon_1.default.stub().resolves({
+                    tokens: {
+                        idToken: { toString: () => "mock-id-token" },
+                        accessToken: { toString: () => "mock-access-token" },
+                    },
+                }),
+            };
+            const { getSession, signIn } = (0, library_1.createAuthService)(mockAuth);
+            yield signIn("user", "pass");
+            const token = yield getSession(false, true);
+            assert_1.strict.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_1.default.stub().resolves({ isSignedIn: true }),
+                signOut: sinon_1.default.stub().resolves(),
+                fetchAuthSession: sinon_1.default.stub().resolves({ tokens: null }),
+            };
+            const { getSession } = (0, library_1.createAuthService)(mockAuth);
+            yield assert_1.strict.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_1.default.stub().resolves({ isSignedIn: true }),
+                signOut: sinon_1.default.stub().resolves(),
+                fetchAuthSession: sinon_1.default.stub().resolves({
+                    tokens: {
+                        idToken: { toString: () => "mock-id-token" },
+                        accessToken: { toString: () => "mock-access-token" },
+                    },
+                }),
+            };
+            const { getSession, signIn } = (0, library_1.createAuthService)(mockAuth);
+            yield signIn("user", "pass");
+            yield getSession(true);
+            assert_1.strict.ok(mockAuth.fetchAuthSession.calledWith({ forceRefresh: true }));
+        }));
+    });
+    describe("configure", () => {
+        const expectedApi = [
+            "deviceInfo",
+            "registerDevice",
+            "editDevice",
+            "setPower",
+            "setPowerOff",
+            "setPowerOn",
+            "getPower",
+            "getEnvironmentTemperature",
+            "getTargetTemperature",
+            "setTargetTemperature",
+        ];
+        it("should create API methods with the correct baseURL", () => __awaiter(void 0, void 0, void 0, function* () {
+            const baseURL = "https://example.com/api/";
+            fetchStub.resolves(mockResponse({ test: "data" }));
+            const api = (0, library_1.configure)(baseURL);
+            assert_1.strict.deepEqual(Object.keys(api), expectedApi);
+            // Verify baseURL is used when making a request
+            yield api.deviceInfo(expectedToken, "mockMac");
+            assert_1.strict.ok(fetchStub.calledOnce);
+            assert_1.strict.ok(fetchStub.firstCall.args[0].startsWith(baseURL));
+        }));
+        it("should create API methods with the default baseURL", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.resolves(mockResponse({ test: "data" }));
+            const api = (0, library_1.configure)();
+            assert_1.strict.deepEqual(Object.keys(api), expectedApi);
+            // Verify default baseURL is used when making a request
+            yield api.deviceInfo(expectedToken, "mockMac");
+            assert_1.strict.ok(fetchStub.calledOnce);
+            assert_1.strict.ok(fetchStub.firstCall.args[0].startsWith(constants_1.API_URL));
+        }));
+    });
+    describe("API Methods", () => {
+        const mockDeviceInfo = {
+            status: {
+                commands: {
+                    power: true,
+                },
+                temperatures: {
+                    enviroment: 19,
+                },
+            },
+            nvm: {
+                user_parameters: {
+                    enviroment_1_temperature: 22,
+                },
+            },
+        };
+        it("should call fetch for deviceInfo", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.resolves(mockResponse(mockDeviceInfo));
+            const api = (0, library_1.configure)("https://example.com/api/");
+            const result = yield api.deviceInfo(expectedToken, "mockMacAddress");
+            assert_1.strict.ok(fetchStub.calledOnce);
+            assert_1.strict.equal(fetchStub.firstCall.args[0], "https://example.com/api/device/mockMacAddress/info");
+            assert_1.strict.deepEqual(fetchStub.firstCall.args[1], {
+                method: "GET",
+                headers: { Authorization: `Bearer ${expectedToken}` },
+            });
+            assert_1.strict.deepEqual(result, mockDeviceInfo);
+        }));
+        // Tests for setPowerOn and setPowerOff
+        [
+            {
+                method: "setPowerOn",
+                call: (api) => api.setPowerOn("mockToken", "mockMacAddress"),
+                expectedValue: 1,
+            },
+            {
+                method: "setPowerOff",
+                call: (api) => api.setPowerOff("mockToken", "mockMacAddress"),
+                expectedValue: 0,
+            },
+        ].forEach(({ method, call, expectedValue }) => {
+            it(`should call fetch for ${method}`, () => __awaiter(void 0, void 0, void 0, function* () {
+                fetchStub.resolves(mockResponse({ success: true }));
+                const api = (0, library_1.configure)("https://example.com/api/");
+                // Invoke the method using the mapped call function
+                yield call(api);
+                assert_1.strict.ok(fetchStub.calledOnce);
+                assert_1.strict.equal(fetchStub.firstCall.args[0], "https://example.com/api/mqtt/command");
+                assert_1.strict.deepEqual(fetchStub.firstCall.args[1], {
+                    method: "PUT",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: "Bearer mockToken",
+                    },
+                    body: JSON.stringify({
+                        mac_address: "mockMacAddress",
+                        name: "power",
+                        value: expectedValue,
+                    }),
+                });
+            }));
+        });
+        const getterTests = [
+            {
+                method: "getPower",
+                call: (api, token, mac) => api.getPower(token, mac),
+                expectedResult: true,
+            },
+            {
+                method: "getEnvironmentTemperature",
+                call: (api, token, mac) => api.getEnvironmentTemperature(token, mac),
+                expectedResult: 19,
+            },
+            {
+                method: "getTargetTemperature",
+                call: (api, token, mac) => api.getTargetTemperature(token, mac),
+                expectedResult: 22,
+            },
+        ];
+        getterTests.forEach(({ method, call, expectedResult }) => {
+            it(`should call fetch and return the correct value for ${method}`, () => __awaiter(void 0, void 0, void 0, function* () {
+                fetchStub.resolves(mockResponse(mockDeviceInfo));
+                const api = (0, library_1.configure)("https://example.com/api/");
+                const result = yield call(api, expectedToken, "mockMacAddress");
+                assert_1.strict.ok(fetchStub.calledOnce);
+                assert_1.strict.equal(fetchStub.firstCall.args[0], "https://example.com/api/device/mockMacAddress/info");
+                assert_1.strict.deepEqual(fetchStub.firstCall.args[1], {
+                    method: "GET",
+                    headers: { Authorization: `Bearer ${expectedToken}` },
+                });
+                assert_1.strict.equal(result, expectedResult);
+            }));
+        });
+        // Setter tests
+        const setterTests = [
+            {
+                method: "setTargetTemperature",
+                call: (api, token, mac, value) => api.setTargetTemperature(token, mac, value),
+                payload: {
+                    name: "enviroment_1_temperature",
+                    value: 20,
+                },
+            },
+        ];
+        setterTests.forEach(({ method, call, payload }) => {
+            it(`should call fetch and send the correct payload for ${method}`, () => __awaiter(void 0, void 0, void 0, function* () {
+                fetchStub.resolves(mockResponse({ success: true }));
+                const api = (0, library_1.configure)("https://example.com/api/");
+                yield call(api, expectedToken, "mockMacAddress", payload.value);
+                assert_1.strict.ok(fetchStub.calledOnce);
+                assert_1.strict.equal(fetchStub.firstCall.args[0], "https://example.com/api/mqtt/command");
+                assert_1.strict.deepEqual(fetchStub.firstCall.args[1], {
+                    method: "PUT",
+                    headers: {
+                        "Content-Type": "application/json",
+                        Authorization: `Bearer ${expectedToken}`,
+                    },
+                    body: JSON.stringify(Object.assign({ mac_address: "mockMacAddress" }, payload)),
+                });
+            }));
+        });
+    });
+    describe("registerDevice", () => {
+        it("should call POST /device with correct payload", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponseData = {
+                macAddress: "AABBCCDDEEFF",
+                deviceName: "Test Stove",
+                deviceRoom: "Living Room",
+                serialNumber: "EDK123",
+            };
+            fetchStub.resolves(mockResponse(mockResponseData));
+            const api = (0, library_1.configure)("https://example.com/api/");
+            const result = yield api.registerDevice(expectedToken, "AA:BB:CC:DD:EE:FF", "EDK123", "Test Stove", "Living Room");
+            assert_1.strict.ok(fetchStub.calledOnce);
+            assert_1.strict.equal(fetchStub.firstCall.args[0], "https://example.com/api/device");
+            assert_1.strict.deepEqual(fetchStub.firstCall.args[1], {
+                method: "POST",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${expectedToken}`,
+                },
+                body: JSON.stringify({
+                    macAddress: "AABBCCDDEEFF",
+                    deviceName: "Test Stove",
+                    deviceRoom: "Living Room",
+                    serialNumber: "EDK123",
+                }),
+            });
+            assert_1.strict.deepEqual(result, mockResponseData);
+        }));
+        it("should normalize MAC address by removing colons", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.resolves(mockResponse({}));
+            const api = (0, library_1.configure)("https://example.com/api/");
+            yield api.registerDevice(expectedToken, "AA:BB:CC:DD:EE:FF", "EDK123");
+            const body = JSON.parse(fetchStub.firstCall.args[1].body);
+            assert_1.strict.equal(body.macAddress, "AABBCCDDEEFF");
+        }));
+        it("should use empty strings as defaults for name and room", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.resolves(mockResponse({}));
+            const api = (0, library_1.configure)("https://example.com/api/");
+            yield api.registerDevice(expectedToken, "AABBCCDDEEFF", "EDK123");
+            const body = JSON.parse(fetchStub.firstCall.args[1].body);
+            assert_1.strict.equal(body.deviceName, "");
+            assert_1.strict.equal(body.deviceRoom, "");
+        }));
+    });
+    describe("editDevice", () => {
+        it("should call PUT /device/{mac} with correct payload", () => __awaiter(void 0, void 0, void 0, function* () {
+            const mockResponseData = {
+                macAddress: "AABBCCDDEEFF",
+                deviceName: "Updated Name",
+                deviceRoom: "Basement",
+                serialNumber: "EDK123",
+            };
+            fetchStub.resolves(mockResponse(mockResponseData));
+            const api = (0, library_1.configure)("https://example.com/api/");
+            const result = yield api.editDevice(expectedToken, "AA:BB:CC:DD:EE:FF", "Updated Name", "Basement");
+            assert_1.strict.ok(fetchStub.calledOnce);
+            assert_1.strict.equal(fetchStub.firstCall.args[0], "https://example.com/api/device/AABBCCDDEEFF");
+            assert_1.strict.deepEqual(fetchStub.firstCall.args[1], {
+                method: "PUT",
+                headers: {
+                    "Content-Type": "application/json",
+                    Authorization: `Bearer ${expectedToken}`,
+                },
+                body: JSON.stringify({
+                    deviceName: "Updated Name",
+                    deviceRoom: "Basement",
+                }),
+            });
+            assert_1.strict.deepEqual(result, mockResponseData);
+        }));
+        it("should use empty strings as defaults for name and room", () => __awaiter(void 0, void 0, void 0, function* () {
+            fetchStub.resolves(mockResponse({}));
+            const api = (0, library_1.configure)("https://example.com/api/");
+            yield api.editDevice(expectedToken, "AABBCCDDEEFF");
+            const body = JSON.parse(fetchStub.firstCall.args[1].body);
+            assert_1.strict.equal(body.deviceName, "");
+            assert_1.strict.equal(body.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 mockResponseData = {
+                status: createGzippedBuffer(statusData),
+                nvm: {
+                    user_parameters: {
+                        enviroment_1_temperature: 22,
+                    },
+                },
+            };
+            fetchStub.resolves(mockResponse(mockResponseData));
+            const api = (0, library_1.configure)("https://example.com/api/");
+            const result = yield api.deviceInfo(expectedToken, "mockMacAddress");
+            assert_1.strict.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 mockResponseData = {
+                status: {
+                    commands: { power: true },
+                    temperatures: { enviroment: 19 },
+                },
+                nvm: createGzippedBuffer(nvmData),
+            };
+            fetchStub.resolves(mockResponse(mockResponseData));
+            const api = (0, library_1.configure)("https://example.com/api/");
+            const result = yield api.deviceInfo(expectedToken, "mockMacAddress");
+            assert_1.strict.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 mockResponseData = {
+                status: createGzippedBuffer(statusData),
+                nvm: createGzippedBuffer(nvmData),
+            };
+            fetchStub.resolves(mockResponse(mockResponseData));
+            const api = (0, library_1.configure)("https://example.com/api/");
+            const result = yield api.deviceInfo(expectedToken, "mockMacAddress");
+            assert_1.strict.deepEqual(result.status, statusData);
+            assert_1.strict.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 mockResponseData = {
+                status: createGzippedBuffer(statusData),
+                nvm: { user_parameters: { enviroment_1_temperature: 22 } },
+            };
+            fetchStub.resolves(mockResponse(mockResponseData));
+            const api = (0, library_1.configure)("https://example.com/api/");
+            const result = yield api.getPower(expectedToken, "mockMacAddress");
+            assert_1.strict.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 mockResponseData = {
+                status: createGzippedBuffer(statusData),
+                nvm: { user_parameters: { enviroment_1_temperature: 22 } },
+            };
+            fetchStub.resolves(mockResponse(mockResponseData));
+            const api = (0, library_1.configure)("https://example.com/api/");
+            const result = yield api.getEnvironmentTemperature(expectedToken, "mockMacAddress");
+            assert_1.strict.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 mockResponseData = {
+                status: { commands: { power: true }, temperatures: { enviroment: 19 } },
+                nvm: createGzippedBuffer(nvmData),
+            };
+            fetchStub.resolves(mockResponse(mockResponseData));
+            const api = (0, library_1.configure)("https://example.com/api/");
+            const result = yield api.getTargetTemperature(expectedToken, "mockMacAddress");
+            assert_1.strict.equal(result, 22);
+        }));
+    });
+    describe("Error Handling", () => {
+        const errorTests = [
+            { status: 400, statusText: "Bad Request" },
+            { status: 401, statusText: "Unauthorized" },
+            { status: 404, statusText: "Not Found" },
+            { status: 500, statusText: "Internal Server Error" },
+        ];
+        errorTests.forEach(({ status, statusText }) => {
+            it(`should throw error when fetch returns ${status}`, () => __awaiter(void 0, void 0, void 0, function* () {
+                const errorResponse = {
+                    ok: false,
+                    status,
+                    statusText,
+                    json: () => Promise.resolve({ error: statusText }),
+                };
+                fetchStub.resolves(errorResponse);
+                const api = (0, library_1.configure)("https://example.com/api/");
+                yield assert_1.strict.rejects(() => __awaiter(void 0, void 0, void 0, function* () { return api.deviceInfo(expectedToken, "mockMac"); }), {
+                    message: `HTTP ${status}: ${statusText}`,
+                });
+            }));
+        });
+    });
+});

package/dist/cjs/src/serial-utils.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.serialNumberToHex = exports.serialNumberFromHex = exports.serialNumberDisplay = void 0;
+/**
+ * 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");
+};
+exports.serialNumberToHex = serialNumberToHex;
+/**
+ * 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");
+};
+exports.serialNumberFromHex = serialNumberFromHex;
+/**
+ * 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());
+};
+exports.serialNumberDisplay = serialNumberDisplay;

package/dist/cjs/src/serial-utils.test.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const assert_1 = require("assert");
+const serial_utils_1 = require("./serial-utils");
+describe("serial-utils", () => {
+    describe("serialNumberToHex", () => {
+        it("should convert ASCII string to hex", () => {
+            assert_1.strict.equal((0, serial_utils_1.serialNumberToHex)("EDK123"), "45444b313233");
+        });
+        it("should handle empty string", () => {
+            assert_1.strict.equal((0, serial_utils_1.serialNumberToHex)(""), "");
+        });
+        it("should convert string with non-printable chars", () => {
+            const input = "EDK\x00123";
+            const hex = (0, serial_utils_1.serialNumberToHex)(input);
+            assert_1.strict.equal(hex, "45444b00313233");
+        });
+    });
+    describe("serialNumberFromHex", () => {
+        it("should convert hex back to ASCII string", () => {
+            assert_1.strict.equal((0, serial_utils_1.serialNumberFromHex)("45444b313233"), "EDK123");
+        });
+        it("should handle empty string", () => {
+            assert_1.strict.equal((0, serial_utils_1.serialNumberFromHex)(""), "");
+        });
+        it("should round-trip with toHex", () => {
+            const original = "EDK\x00123\x1F";
+            const hex = (0, serial_utils_1.serialNumberToHex)(original);
+            const restored = (0, serial_utils_1.serialNumberFromHex)(hex);
+            assert_1.strict.equal(restored, original);
+        });
+    });
+    describe("serialNumberDisplay", () => {
+        it("should remove non-printable characters", () => {
+            assert_1.strict.equal((0, serial_utils_1.serialNumberDisplay)("EDK\x00123\x1F"), "EDK123");
+        });
+        it("should collapse whitespace", () => {
+            assert_1.strict.equal((0, serial_utils_1.serialNumberDisplay)("EDK  123"), "EDK 123");
+        });
+        it("should trim leading and trailing whitespace", () => {
+            assert_1.strict.equal((0, serial_utils_1.serialNumberDisplay)("  EDK123  "), "EDK123");
+        });
+        it("should handle empty string", () => {
+            assert_1.strict.equal((0, serial_utils_1.serialNumberDisplay)(""), "");
+        });
+        it("should preserve normal serial numbers", () => {
+            assert_1.strict.equal((0, serial_utils_1.serialNumberDisplay)("EDK12345678"), "EDK12345678");
+        });
+    });
+});