homebridge-plejd 1.6.1 → 1.7.0-beta

package/tests/plejdService.spec.ts

@@ -0,0 +1,125 @@
+import { Logger } from "homebridge/lib/logger";
+import { PlejdCommand, PlejdService } from "../src/plejdService";
+import { PLEJD_WRITE_TIMEOUT } from "../src/constants";
+
+describe("PlejdService updateState", () => {
+  let service: PlejdService;
+
+  beforeEach(() => {
+    service = new PlejdService(
+      {
+        devices: [],
+        cryptoKey: Buffer.from("FooBar", "utf8"),
+      },
+      Logger.withPrefix("PlejdServiceTests"),
+      () => {},
+    );
+  });
+
+  describe("Turn off scenarios", () => {
+    it.each([
+      ["isOn=false, brightness=undefined", false, undefined],
+      ["isOn=false, brightness=0", false, 0],
+      ["isOn=true, brightness=0", true, 0],
+      ["isOn=true, brightness=undefined", true, undefined],
+    ])("%s should queue a turn off command", async (_, isOn, brightness) => {
+      const deviceId = 42;
+      await service.updateState(deviceId, isOn, {
+        targetBrightness: brightness,
+      });
+
+      const queue = service.readQueue();
+      expect(queue.length).toBe(1);
+
+      const command = queue[0].toString("hex");
+      const expected =
+        deviceId.toString(16).padStart(2, "0") +
+        PlejdCommand.RequestNoResponse +
+        PlejdCommand.OnOffState +
+        "00";
+
+      expect(command).toBe(expected);
+    });
+  });
+
+  describe("Brightness transition scenarios", () => {
+    it("should return if no brightness change is made", async () => {
+      const deviceId = 42;
+      const brightness = 50; // 50% brightness
+      const transitionMS = 500;
+      await service.updateState(deviceId, true, {
+        currentBrightness: brightness,
+        targetBrightness: brightness,
+        transitionMS: transitionMS,
+      });
+      const queue = service.readQueue();
+      expect(queue.length).toBe(0);
+    });
+
+    it("should queue multiple brightness commands for a transition", async () => {
+      const deviceId = 42;
+      const brightness = 50; // 50% brightness
+      const transitionMS = 500;
+
+      await service.updateState(deviceId, true, {
+        targetBrightness: brightness,
+        transitionMS: transitionMS,
+      });
+
+      const queue = service.readQueue();
+
+      // Calculate expected number of steps
+      const expectedSteps = Math.round(transitionMS / PLEJD_WRITE_TIMEOUT);
+      expect(queue.length).toBe(expectedSteps);
+
+      // Check that all commands are brightness commands
+      queue.forEach((item) => {
+        const command = item.toString("hex");
+        expect(command.substring(2, 6)).toBe(PlejdCommand.RequestNoResponse);
+        expect(command.substring(6, 10)).toBe(PlejdCommand.Brightness);
+        expect(command.substring(10, 14)).toBe("0100"); // isOn = true
+      });
+
+      // Check that the brightness is distributed correctly
+      const newBrightness = Math.round(2.55 * brightness);
+      const brightnessStep = Math.round(newBrightness / expectedSteps);
+
+      queue.forEach((item) => {
+        const command = item.toString("hex");
+        const brightnessHex = command.substring(14, 18);
+        const brightnessValue = parseInt(brightnessHex, 16);
+        expect(brightnessValue).toBe(brightnessStep);
+      });
+    });
+
+    it("should handle a 1-second transition with default parameters", async () => {
+      const deviceId = 42;
+      const brightness = 100;
+
+      await service.updateState(deviceId, true, {
+        targetBrightness: brightness,
+        transitionMS: 1000,
+      });
+      const queue = service.readQueue();
+
+      // With default 1000ms and assuming PLEJD_WRITE_TIMEOUT = 100
+      const expectedSteps = 10;
+      expect(queue.length).toBe(expectedSteps);
+    });
+
+    it("should handle a 0-ms transition with default parameters", async () => {
+      const deviceId = 42;
+      const brightness = 100;
+
+      await service.updateState(deviceId, true, {
+        targetBrightness: brightness,
+      });
+
+      const queue = service.readQueue();
+
+      // With default 1000ms and assuming PLEJD_WRITE_TIMEOUT = 100
+      const expectedSteps = 1;
+      expect(queue.length).toBe(expectedSteps);
+    });
+  });
+});

package/tests/utils.spec.ts

@@ -0,0 +1,286 @@
+import {
+  isDimmable,
+  isAddon,
+  delay,
+  race,
+  plejdChallageResp as plejdChalResp,
+  plejdEncodeDecode,
+} from "../src/utils";
+
+describe("plejdChalResp", () => {
+  it("should produce consistent output for same key and challenge", () => {
+    const key = Buffer.from("0123456789abcdef0123456789abcdef", "hex");
+    const challenge = Buffer.from("fedcba9876543210fedcba9876543210", "hex");
+
+    const result1 = plejdChalResp(key, challenge);
+    const result2 = plejdChalResp(key, challenge);
+
+    expect(result1).toEqual(result2);
+  });
+
+  it("should produce different outputs for different challenges", () => {
+    const key = Buffer.from("0123456789abcdef0123456789abcdef", "hex");
+    const challenge1 = Buffer.from("1111111111111111111111111111111", "hex");
+    const challenge2 = Buffer.from("2222222222222222222222222222222", "hex");
+
+    const result1 = plejdChalResp(key, challenge1);
+    const result2 = plejdChalResp(key, challenge2);
+
+    expect(result1).not.toEqual(result2);
+  });
+
+  it("should produce different outputs for different keys", () => {
+    const key1 = Buffer.from("1111111111111111111111111111111", "hex");
+    const key2 = Buffer.from("2222222222222222222222222222222", "hex");
+    const challenge = Buffer.from("fedcba9876543210fedcba9876543210", "hex");
+
+    const result1 = plejdChalResp(key1, challenge);
+    const result2 = plejdChalResp(key2, challenge);
+
+    expect(result1).not.toEqual(result2);
+  });
+
+  it("should return 16-byte buffer", () => {
+    const key = Buffer.from("0123456789abcdef0123456789abcdef", "hex");
+    const challenge = Buffer.from("fedcba9876543210fedcba9876543210", "hex");
+
+    const result = plejdChalResp(key, challenge);
+
+    expect(result).toBeInstanceOf(Buffer);
+    expect(result.length).toBe(16);
+  });
+
+  it("should handle known test vector", () => {
+    // Test with zero key and challenge for predictable result
+    const key = Buffer.alloc(16, 0);
+    const challenge = Buffer.alloc(16, 0);
+
+    const result = plejdChalResp(key, challenge);
+
+    expect(result.length).toBe(16);
+    expect(result).toBeInstanceOf(Buffer);
+  });
+});
+
+describe("plejdEncodeDecode", () => {
+  const testKey = Buffer.from("0123456789abcdef0123456789abcdef", "hex");
+  const testAddress = Buffer.from("001122334455", "hex");
+
+  it("should produce consistent output for same inputs", () => {
+    const data = Buffer.from("hello world", "ascii");
+
+    const result1 = plejdEncodeDecode(testKey, testAddress, data);
+    const result2 = plejdEncodeDecode(testKey, testAddress, data);
+
+    expect(result1).toEqual(result2);
+  });
+
+  it("should be reversible (encode/decode)", () => {
+    const originalData = Buffer.from("test message", "ascii");
+
+    const encoded = plejdEncodeDecode(testKey, testAddress, originalData);
+    const decoded = plejdEncodeDecode(testKey, testAddress, encoded);
+
+    expect(decoded).toEqual(originalData);
+  });
+
+  it("should handle empty data", () => {
+    const emptyData = Buffer.alloc(0);
+
+    const result = plejdEncodeDecode(testKey, testAddress, emptyData);
+
+    expect(result).toEqual(Buffer.alloc(0));
+  });
+
+  it("should handle single byte", () => {
+    const data = Buffer.from([65]); // 'A'
+
+    const result = plejdEncodeDecode(testKey, testAddress, data);
+
+    expect(result.length).toBe(1);
+  });
+
+  it("should produce different output for different keys", () => {
+    const data = Buffer.from("test", "ascii");
+    const key2 = Buffer.from("fedcba9876543210fedcba9876543210", "hex");
+
+    const result1 = plejdEncodeDecode(testKey, testAddress, data);
+    const result2 = plejdEncodeDecode(key2, testAddress, data);
+
+    expect(result1).not.toEqual(result2);
+  });
+
+  it("should produce different output for different addresses", () => {
+    const data = Buffer.from("test", "ascii");
+    const address2 = Buffer.from("aabbccddeeff", "hex");
+
+    const result1 = plejdEncodeDecode(testKey, testAddress, data);
+    const result2 = plejdEncodeDecode(testKey, address2, data);
+
+    expect(result1).not.toEqual(result2);
+  });
+
+  it("should handle data longer than keystream (16 bytes)", () => {
+    const longData = Buffer.from(
+      "this is a very long message that exceeds sixteen bytes",
+      "ascii",
+    );
+
+    const encoded = plejdEncodeDecode(testKey, testAddress, longData);
+    const decoded = plejdEncodeDecode(testKey, testAddress, encoded);
+
+    expect(decoded).toEqual(longData);
+    expect(encoded.length).toBe(longData.length);
+  });
+
+  it("should handle binary data", () => {
+    const binaryData = Buffer.from([0x00, 0xff, 0x80, 0x7f, 0x01, 0xfe]);
+
+    const encoded = plejdEncodeDecode(testKey, testAddress, binaryData);
+    const decoded = plejdEncodeDecode(testKey, testAddress, encoded);
+
+    expect(decoded).toEqual(binaryData);
+  });
+
+  it("should create proper keystream buffer from address", () => {
+    // Use proper 6-byte MAC address format
+    const address = Buffer.from("001122334455", "hex"); // 6 bytes
+    const data = Buffer.from([0x00]); // XOR with 0 reveals keystream
+
+    const result = plejdEncodeDecode(testKey, address, data);
+
+    // Should return the first byte of the keystream
+    expect(result.length).toBe(1);
+  });
+
+  it("should repeat keystream every 16 bytes", () => {
+    // Create data that will reveal the keystream pattern
+    const data = Buffer.alloc(32, 0); // 32 zeros
+
+    const result = plejdEncodeDecode(testKey, testAddress, data);
+
+    // Bytes 0 and 16 should be the same (keystream repeats)
+    expect(result[0]).toBe(result[16]);
+    expect(result[15]).toBe(result[31]);
+  });
+});
+
+describe("delay", () => {
+  it("should resolve after specified milliseconds", async () => {
+    const start = Date.now();
+
+    await delay(100);
+
+    const elapsed = Date.now() - start;
+    expect(elapsed).toBeGreaterThanOrEqual(95); // Allow some tolerance
+    expect(elapsed).toBeLessThan(150);
+  });
+
+  it("should resolve immediately for 0ms delay", async () => {
+    const start = Date.now();
+
+    await delay(0);
+
+    const elapsed = Date.now() - start;
+    expect(elapsed).toBeLessThan(10);
+  });
+});
+
+describe("race", () => {
+  it("should resolve when operation completes before timeout", async () => {
+    const operation = async () => {
+      await delay(100);
+      return "success";
+    };
+
+    const result = await race(operation, 200);
+
+    expect(result).toBe("success");
+  });
+
+  it("should reject with timeout error when operation takes too long", async () => {
+    const operation = async () => {
+      await delay(200);
+      return "success";
+    };
+
+    await expect(race(operation, 100)).rejects.toThrow("BLE operation timeout");
+  });
+
+  it("should reject when operation throws before timeout", async () => {
+    const operation = async () => {
+      throw new Error("operation failed");
+    };
+
+    await expect(race(operation, 100)).rejects.toThrow("operation failed");
+  });
+
+  it("should handle operation that returns different types", async () => {
+    const numberOperation = async () => 42;
+    const objectOperation = async () => ({ key: "value" });
+
+    const numberResult = await race(numberOperation, 100);
+    const objectResult = await race(objectOperation, 100);
+
+    expect(numberResult).toBe(42);
+    expect(objectResult).toEqual({ key: "value" });
+  });
+});
+
+describe("Device Type Detection", () => {
+  describe("isDimmable", () => {
+    const testCases = [
+      { model: "DIM-01", expected: true },
+      { model: "DIM-02", expected: true },
+      { model: "LED-10", expected: true },
+      { model: "DIM-01-2P", expected: true },
+      { model: "LED-75", expected: true },
+      { model: "DIM-02-LC 2024 Q2", expected: true },
+      { model: "Dim 2.2.1 Release Candidate", expected: true },
+      { model: "RTR-01", expected: false },
+      { model: "WPH-01", expected: false },
+      { model: "UNKNOWN-MODEL", expected: false },
+    ];
+
+    testCases.forEach(({ model, expected }) => {
+      it(`should identify ${model} as ${expected ? "dimmable" : "non-dimmable"}`, () => {
+        expect(isDimmable(model)).toBe(expected);
+      });
+    });
+
+    // Test with real-world data
+    const realWorldDimmers = [
+      "DIM-02-LC 2024 Q2",
+      "Dim 2.2.1 Release Candidate",
+      "DIM-02",
+      "DIM-01",
+    ];
+
+    realWorldDimmers.forEach((model) => {
+      it(`should identify real-world model ${model} as dimmable`, () => {
+        expect(isDimmable(model)).toBe(true);
+      });
+    });
+  });
+
+  describe("isAddon", () => {
+    const testCases = [
+      { model: "RTR-01", expected: true },
+      { model: "WPH-01", expected: true },
+      { model: "WRT-01", expected: true },
+      { model: "MNT-01", expected: true },
+      { model: "MNT-02", expected: true },
+      { model: "GWY-01", expected: true },
+      { model: "BAT-01", expected: true },
+      { model: "EXT-01", expected: true },
+      { model: "DIM-01", expected: false },
+      { model: "UNKNOWN-MODEL", expected: false },
+    ];
+
+    testCases.forEach(({ model, expected }) => {
+      it(`should identify ${model} as ${expected ? "addon" : "non-addon"}`, () => {
+        expect(isAddon(model)).toBe(expected);
+      });
+    });
+  });
+});

package/dist/plejdUtils.d.ts

@@ -1,3 +0,0 @@
-export declare const plejdChalResp: (key: Buffer, chal: Buffer) => Buffer;
-export declare const plejdEncodeDecode: (key: Buffer, addressBuffer: Buffer, data: Buffer) => Buffer;
-export declare const reverseBuffer: (src: Buffer) => Buffer;

package/dist/plejdUtils.js

@@ -1,40 +0,0 @@
-import { createCipheriv, createHash } from 'crypto';
-export const plejdChalResp = (key, chal) => {
-    const intermediate = createHash('sha256').update(xor(key, chal)).digest();
-    const part1 = intermediate.slice(0, 16);
-    const part2 = intermediate.slice(16);
-    return xor(part1, part2);
-};
-export const plejdEncodeDecode = (key, addressBuffer, data) => {
-    const buf = Buffer.concat([
-        addressBuffer,
-        addressBuffer,
-        addressBuffer.subarray(0, 4),
-    ]);
-    const cipher = createCipheriv('aes-128-ecb', key, '');
-    cipher.setAutoPadding(false);
-    let ct = cipher.update(buf).toString('hex');
-    ct += cipher.final().toString('hex');
-    const ctBuff = Buffer.from(ct, 'hex');
-    let output = '';
-    for (let i = 0, length = data.length; i < length; i++) {
-        output += String.fromCharCode(data[i] ^ ctBuff[i % 16]);
-    }
-    return Buffer.from(output, 'ascii');
-};
-export const reverseBuffer = (src) => {
-    const buffer = Buffer.allocUnsafe(src.length);
-    for (let i = 0, j = src.length - 1; i <= j; ++i, --j) {
-        buffer[i] = src[j];
-        buffer[j] = src[i];
-    }
-    return buffer;
-};
-const xor = (first, second) => {
-    const result = Buffer.alloc(first.length);
-    for (let i = 0; i < first.length; i++) {
-        result[i] = first[i] ^ second[i];
-    }
-    return result;
-};
-//# sourceMappingURL=plejdUtils.js.map

package/dist/plejdUtils.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"plejdUtils.js","sourceRoot":"","sources":["../src/plejdUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,QAAQ,CAAC;AAEpD,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,GAAW,EAAE,IAAY,EAAE,EAAE;IACzD,MAAM,YAAY,GAAG,UAAU,CAAC,QAAQ,CAAC,CAAC,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,IAAI,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAE1E,MAAM,KAAK,GAAG,YAAY,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IACxC,MAAM,KAAK,GAAG,YAAY,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC;IAErC,OAAO,GAAG,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC;AAC3B,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAC/B,GAAW,EACX,aAAqB,EACrB,IAAY,EACJ,EAAE;IACV,MAAM,GAAG,GAAG,MAAM,CAAC,MAAM,CAAC;QACxB,aAAa;QACb,aAAa;QACb,aAAa,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,CAAC;KAC7B,CAAC,CAAC;IACH,MAAM,MAAM,GAAG,cAAc,CAAC,aAAa,EAAE,GAAG,EAAE,EAAE,CAAC,CAAC;IACtD,MAAM,CAAC,cAAc,CAAC,KAAK,CAAC,CAAC;IAE7B,IAAI,EAAE,GAAG,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IAC5C,EAAE,IAAI,MAAM,CAAC,KAAK,EAAE,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC;IACrC,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,EAAE,EAAE,KAAK,CAAC,CAAC;IAEtC,IAAI,MAAM,GAAG,EAAE,CAAC;IAChB,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC,MAAM,EAAE,CAAC,GAAG,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtD,MAAM,IAAI,MAAM,CAAC,YAAY,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;IAC1D,CAAC;IAED,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;AACtC,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,aAAa,GAAG,CAAC,GAAW,EAAU,EAAE;IACnD,MAAM,MAAM,GAAG,MAAM,CAAC,WAAW,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC;IAE9C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,GAAG,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC,IAAI,CAAC,EAAE,EAAE,CAAC,EAAE,EAAE,CAAC,EAAE,CAAC;QACrD,MAAM,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;QACnB,MAAM,CAAC,CAAC,CAAC,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC;IACrB,CAAC;IAED,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC;AAEF,MAAM,GAAG,GAAG,CAAC,KAAa,EAAE,MAAc,EAAU,EAAE;IACpD,MAAM,MAAM,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;IAC1C,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,GAAG,KAAK,CAAC,MAAM,EAAE,CAAC,EAAE,EAAE,CAAC;QACtC,MAAM,CAAC,CAAC,CAAC,GAAG,KAAK,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAAC;IACnC,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC,CAAC"}

package/dist/settings.js

@@ -1,47 +0,0 @@
-/**
- * This is the name of the platform that users will use to register the plugin in the Homebridge config.json
- */
-export const PLATFORM_NAME = "Plejd";
-/**
- * This must match the name of your plugin as defined the package.json
- */
-export const PLUGIN_NAME = "homebridge-plejd";
-export const PLEJD_WRITE_TIMEOUT = 200;
-export const PLEJD_PING_TIMEOUT = 3000;
-export const isDimmable = (type) => {
-    const normalizedType = type.toLowerCase();
-    // Check if the model starts with any of the basic dimmer types
-    return PLEJD_LIGHTS.some((light) => normalizedType.startsWith(light.toLowerCase()) ||
-        normalizedType.includes("dim"));
-};
-export const isAddon = (type) => {
-    for (const x of PLEJD_ADDONS) {
-        if (type.toLowerCase().includes(x.toLowerCase())) {
-            return true;
-        }
-    }
-    return false;
-};
-/**
- * Lights and switches from Plejd
- */
-const PLEJD_LIGHTS = ["DIM-01", "DIM-02", "LED-10", "DIM-01-2P", "LED-75"];
-// const PLEJD_SWITCHES = [
-//   "REL-01",
-//   "REL-02",
-//   "REL-01-2P",
-//   "DAL-01",
-//   "SPR-01",
-//   "CTR-01",
-// ];
-const PLEJD_ADDONS = [
-    "RTR-01",
-    "WPH-01",
-    "WRT-01",
-    "MNT-01",
-    "MNT-02",
-    "GWY-01",
-    "BAT-01",
-    "EXT-01",
-];
-//# sourceMappingURL=settings.js.map

package/dist/settings.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"settings.js","sourceRoot":"","sources":["../src/settings.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,OAAO,CAAC;AAErC;;GAEG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,kBAAkB,CAAC;AAE9C,MAAM,CAAC,MAAM,mBAAmB,GAAG,GAAG,CAAC;AACvC,MAAM,CAAC,MAAM,kBAAkB,GAAG,IAAI,CAAC;AAEvC,MAAM,CAAC,MAAM,UAAU,GAAG,CAAC,IAAY,EAAE,EAAE;IACzC,MAAM,cAAc,GAAG,IAAI,CAAC,WAAW,EAAE,CAAC;IAC1C,+DAA+D;IAC/D,OAAO,YAAY,CAAC,IAAI,CACtB,CAAC,KAAK,EAAE,EAAE,CACR,cAAc,CAAC,UAAU,CAAC,KAAK,CAAC,WAAW,EAAE,CAAC;QAC9C,cAAc,CAAC,QAAQ,CAAC,KAAK,CAAC,CACjC,CAAC;AACJ,CAAC,CAAC;AAEF,MAAM,CAAC,MAAM,OAAO,GAAG,CAAC,IAAY,EAAE,EAAE;IACtC,KAAK,MAAM,CAAC,IAAI,YAAY,EAAE,CAAC;QAC7B,IAAI,IAAI,CAAC,WAAW,EAAE,CAAC,QAAQ,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC;YACjD,OAAO,IAAI,CAAC;QACd,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AAEF;;GAEG;AACH,MAAM,YAAY,GAAG,CAAC,QAAQ,EAAE,QAAQ,EAAE,QAAQ,EAAE,WAAW,EAAE,QAAQ,CAAC,CAAC;AAE3E,2BAA2B;AAC3B,cAAc;AACd,cAAc;AACd,iBAAiB;AACjB,cAAc;AACd,cAAc;AACd,cAAc;AACd,KAAK;AAEL,MAAM,YAAY,GAAG;IACnB,QAAQ;IACR,QAAQ;IACR,QAAQ;IACR,QAAQ;IACR,QAAQ;IACR,QAAQ;IACR,QAAQ;IACR,QAAQ;CACT,CAAC"}

package/tests/settings.spec.ts

@@ -1,59 +0,0 @@
-import { isDimmable, isAddon } from "../src/settings";
-
-describe("Device Type Detection", () => {
-  describe("isDimmable", () => {
-    const testCases = [
-      { model: "DIM-01", expected: true },
-      { model: "DIM-02", expected: true },
-      { model: "LED-10", expected: true },
-      { model: "DIM-01-2P", expected: true },
-      { model: "LED-75", expected: true },
-      { model: "DIM-02-LC 2024 Q2", expected: true },
-      { model: "Dim 2.2.1 Release Candidate", expected: true },
-      { model: "RTR-01", expected: false },
-      { model: "WPH-01", expected: false },
-      { model: "UNKNOWN-MODEL", expected: false },
-    ];
-
-    testCases.forEach(({ model, expected }) => {
-      it(`should identify ${model} as ${expected ? "dimmable" : "non-dimmable"}`, () => {
-        expect(isDimmable(model)).toBe(expected);
-      });
-    });
-
-    // Test with real-world data
-    const realWorldDimmers = [
-      "DIM-02-LC 2024 Q2",
-      "Dim 2.2.1 Release Candidate",
-      "DIM-02",
-      "DIM-01",
-    ];
-
-    realWorldDimmers.forEach((model) => {
-      it(`should identify real-world model ${model} as dimmable`, () => {
-        expect(isDimmable(model)).toBe(true);
-      });
-    });
-  });
-
-  describe("isAddon", () => {
-    const testCases = [
-      { model: "RTR-01", expected: true },
-      { model: "WPH-01", expected: true },
-      { model: "WRT-01", expected: true },
-      { model: "MNT-01", expected: true },
-      { model: "MNT-02", expected: true },
-      { model: "GWY-01", expected: true },
-      { model: "BAT-01", expected: true },
-      { model: "EXT-01", expected: true },
-      { model: "DIM-01", expected: false },
-      { model: "UNKNOWN-MODEL", expected: false },
-    ];
-
-    testCases.forEach(({ model, expected }) => {
-      it(`should identify ${model} as ${expected ? "addon" : "non-addon"}`, () => {
-        expect(isAddon(model)).toBe(expected);
-      });
-    });
-  });
-});