@ray-js/lamp-schedule-core 1.0.0-beta-1

package/lib/dpParser/__test__/rhythms.test.js

@@ -0,0 +1,71 @@
+import { rhythmParser } from '../rhythms';
+// Mock ScheduleLogger
+jest.mock('../../utils/ScheduleLogger', () => ({
+  scheduleLogger: {
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn()
+  }
+}));
+
+// Mock getSupportIns
+const mockSupport = function () {
+  let isSigMesh = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;
+  let isSupportTemp = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;
+  return {
+    isSigMeshDevice: () => isSigMesh,
+    isSupportDp: () => isSupportTemp
+  };
+};
+jest.mock('../../hooks/useCommonSupport', () => ({
+  getSupportIns: jest.fn(() => mockSupport(false, true))
+}));
+describe('RhythmParser', () => {
+  describe('parser', () => {
+    it('should return default data for empty DP string', () => {
+      const result = rhythmParser.parser('');
+      expect(result).toHaveProperty('version', 0);
+      expect(result).toHaveProperty('power', false);
+      expect(result).toHaveProperty('mode', 0);
+      expect(result).toHaveProperty('weeks');
+      expect(result).toHaveProperty('number');
+      expect(result).toHaveProperty('rhythms');
+    });
+  });
+  describe('formatter', () => {
+    it('should return empty string if data is null', () => {
+      const result = rhythmParser.formatter(null);
+      expect(result).toBe('');
+    });
+    it('should format a valid TRhythmData object', () => {
+      const result = rhythmParser.formatter({
+        version: 0,
+        power: true,
+        mode: 1,
+        weeks: [1, 0, 1, 0, 1, 0, 1, 0],
+        number: 2,
+        rhythms: [{
+          power: true,
+          hour: 6,
+          minute: 0,
+          hue: 10,
+          saturation: 20,
+          value: 30,
+          brightness: 40,
+          temperature: 50
+        }, {
+          power: false,
+          hour: 7,
+          minute: 30,
+          hue: 11,
+          saturation: 21,
+          value: 31,
+          brightness: 41,
+          temperature: 51
+        }]
+      });
+      expect(typeof result).toBe('string');
+      expect(result.length).toBeGreaterThan(0);
+    });
+  });
+});

package/lib/dpParser/__test__/rtcTimer.test.d.ts

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

package/lib/dpParser/__test__/rtcTimer.test.js

@@ -0,0 +1,235 @@
+import "core-js/modules/esnext.iterator.map.js";
+import { RtcTimerFormatter, rtcTimerParser } from '../rtcTimer';
+jest.mock('../../utils/isInIDE', () => ({
+  isInIDEFun: jest.fn().mockReturnValue(false)
+}));
+const DEFAULT_RTC_TIMER_VALUE = {
+  timerId: '1',
+  status: false,
+  loops: '1111111',
+  time: '08:30',
+  dps: {
+    switch_led: false
+  }
+};
+
+// Helper to convert HH:mm to minutes
+const timeToMinute = timeStr => {
+  const [hour, min] = timeStr.split(':').map(Number);
+  return hour * 60 + min;
+};
+describe('RtcTimerFormatter', () => {
+  let formatterInstance;
+  beforeEach(() => {
+    formatterInstance = new RtcTimerFormatter();
+    jest.clearAllMocks();
+  });
+  describe('parser', () => {
+    it('should return default value for empty string', () => {
+      expect(formatterInstance.parser('')).toEqual(DEFAULT_RTC_TIMER_VALUE);
+    });
+    it('should return default value for invalid length string', () => {
+      expect(formatterInstance.parser('0102030405')).toEqual(DEFAULT_RTC_TIMER_VALUE);
+    });
+    it('should parse a delete timer DP string (4 chars)', () => {
+      // ID: 82 (status=true, timerId=2)
+      // Minimal delete command, assuming 00 is padding or ignored by parser for delete
+
+      expect(formatterInstance.parser('8200')).toEqual({
+        timerId: '2',
+        status: true
+      });
+    });
+    it('should parse a power (switch_led) timer DP string (14 chars)', () => {
+      // ID: 81 (status=true, timerId=1)
+      // timer_type: 01
+      // loops: 7f (all days)
+      // startTimeType: 00
+      // time: 0384 (900 mins -> 15:00)
+      // deviceAction: 00 (off) or 01 (on)
+
+      expect(formatterInstance.parser('81017f00038401')).toEqual({
+        timerId: '1',
+        status: true,
+        loops: '1111111',
+        time: '15:00',
+        dps: {
+          switch_led: false
+        }
+      });
+    });
+    it('should parse a bright light timer DP string (18 chars)', () => {
+      // ID: 82 (status=true, timerId=2)
+      // timer_type: 01, loops: 40 (Sat), startTimeType: 00, time: 012C (300 mins -> 05:00)
+      // deviceAction: 02 (white light)
+      // bright_value: 64 (100), temp_value: 32 (50)
+
+      expect(formatterInstance.parser('82014000012C026432')).toEqual({
+        timerId: '2',
+        status: true,
+        loops: '0000001',
+        // Saturday
+        time: '05:00',
+        dps: {
+          bright_value: 100,
+          temp_value: 50
+        }
+      });
+    });
+    it('should parse a colour light timer DP string (22 chars)', () => {
+      // ID: 83 (status=true, timerId=3)
+      // timer_type: 01, loops: 01 (Sun), startTimeType: 00, time: 04B0 (1200 mins -> 20:00)
+      // deviceAction: 03 (colour light)
+      // hue: 0078 (120), saturation: 64 (100), value: 32 (50)
+
+      expect(formatterInstance.parser('8301010004B00300786432')).toEqual({
+        timerId: '3',
+        status: true,
+        loops: '1000000',
+        // Sunday
+        time: '20:00',
+        dps: {
+          colour_data: {
+            hue: 120,
+            saturation: 100,
+            value: 50
+          }
+        }
+      });
+    });
+    it('should parse a mix light timer DP string (26 chars)', () => {
+      // ID: 84 (status=true, timerId=4)
+      // timer_type: 01, loops: 02 (Mon), startTimeType: 00, time: 0064 (100 mins -> 01:40)
+      // deviceAction: 04 (mix light)
+      // hue: 00F0 (240), sat: 50 (80), val: 1E (30)
+      // bright_value: 4B (75), temp_value: 28 (40)
+
+      expect(formatterInstance.parser('8401020000640400F0501E4B28')).toEqual({
+        timerId: '4',
+        status: true,
+        loops: '0100000',
+        // Monday
+        time: '01:40',
+        dps: {
+          colour_data: {
+            hue: 240,
+            saturation: 80,
+            value: 30
+          },
+          bright_value: 75,
+          temp_value: 40
+        }
+      });
+    });
+  });
+  describe('formatter', () => {
+    it('should format a power (switch_led) timer to DP string', () => {
+      // id: 81 (status=1, id=1)
+      // timer_type: 01 (fixed in formatter)
+      // loops: 7f (1111111)
+      // startTimeType: 00 (fixed in formatter)
+      // time: 0384 (900 mins)
+      // deviceAction: 01 (from dps.switch_led = true)
+
+      expect(formatterInstance.formatter({
+        timerId: '1',
+        status: true,
+        loops: '1111111',
+        time: '15:00',
+        dps: {
+          switch_led: true
+        }
+      })).toBe('81017f00038401');
+    });
+    it('should format a bright light timer to DP string', () => {
+      // id: 82, type:01, loops:40, startTimeType:00, time:012c
+      // deviceAction: 02
+      // bright:64, temp:32
+
+      expect(formatterInstance.formatter({
+        timerId: '2',
+        status: true,
+        loops: '0000001',
+        // Sat
+        time: '05:00',
+        dps: {
+          bright_value: 100,
+          temp_value: 50
+        }
+      })).toBe('82014000012c026432');
+    });
+    it('should format a colour light timer to DP string', () => {
+      // id: 83, type:01, loops:01, startTimeType:00, time:04b0
+      // deviceAction: 03
+      // hue:0078, sat:64, val:32
+
+      expect(formatterInstance.formatter({
+        timerId: '3',
+        status: true,
+        loops: '1000000',
+        // Sun
+        time: '20:00',
+        dps: {
+          colour_data: {
+            hue: 120,
+            saturation: 100,
+            value: 50
+          }
+        }
+      })).toBe('8301010004b00300786432');
+    });
+    it('should format a mix light timer to DP string', () => {
+      // id: 84, type:01, loops:02, startTimeType:00, time:0064
+      // deviceAction: 04
+      // hue:00f0, sat:50, val:1e, bright:4b, temp:28
+
+      expect(formatterInstance.formatter({
+        timerId: '4',
+        status: true,
+        loops: '0100000',
+        // Mon
+        time: '01:40',
+        dps: {
+          colour_data: {
+            hue: 240,
+            saturation: 80,
+            value: 30
+          },
+          bright_value: 75,
+          temp_value: 40
+        }
+      })).toBe('8401020000640400f0501e4b28');
+    });
+    it('should format a timer to be deleted (status=false, no dps, specific id)', () => {
+      // The formatter is designed to create full timer strings.
+      // To delete a timer, one typically sends a short command with just ID and status=false.
+      // However, the formatter will construct a full string. If the intention is to format a delete *command*,
+      // the formatter logic would need to be different. This tests formatting a timer that is 'off'.
+
+      // id: 05 (status=0, id=5)
+      // type:01, loops:00, startTimeType:00, time:0000
+      // deviceAction: 00 (from dps.switch_led = false)
+
+      expect(formatterInstance.formatter({
+        timerId: '5',
+        status: false,
+        // This status is part of the ID byte
+        loops: '0000000',
+        // No repeat
+        time: '00:00',
+        dps: {
+          switch_led: false
+        } // Default dps for an 'off' timer
+      })).toBe('05010000000000');
+    });
+    it('should handle string input by returning it directly', () => {
+      const dpString = 'alreadyFormattedString';
+      expect(formatterInstance.formatter(dpString)).toBe(dpString);
+    });
+  });
+  describe('rtcTimerParser instance', () => {
+    it('should be an instance of RtcTimerFormatter', () => {
+      expect(rtcTimerParser).toBeInstanceOf(RtcTimerFormatter);
+    });
+  });
+});

package/lib/dpParser/__test__/sleep.test.d.ts

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

package/lib/dpParser/__test__/sleep.test.js

@@ -0,0 +1,71 @@
+import { SleepParser } from '../sleep';
+describe('SleepParser', () => {
+  const parser = new SleepParser();
+  it('should return default value when parsing empty string', () => {
+    const result = parser.parser('');
+    expect(result).toEqual({
+      version: 0,
+      length: 0,
+      nodes: []
+    });
+  });
+  it('should format default value correctly', () => {
+    const result = parser.formatter({
+      version: 0,
+      length: 0,
+      nodes: []
+    });
+    // 根据 sleepCommon.ts 的 formatter 逻辑，空数据会返回 '0000'
+    expect(result).toBe('0000');
+  });
+  it('should parse a valid dpStr and format it back', () => {
+    const dpStr = '0101017f01010a010a0b0c0d0e';
+    const expectedParsedData = {
+      version: 1,
+      length: 1,
+      nodes: [{
+        onOff: true,
+        loops: '1111111',
+        step: 1,
+        hour: 1,
+        minute: 10,
+        hue: 110,
+        saturation: 11,
+        value: 12,
+        brightness: 13,
+        temperature: 14,
+        index: 0
+      }]
+    };
+    const parsedResult = parser.parser(dpStr);
+    expect(parsedResult).toEqual(expectedParsedData);
+    const formattedResult = parser.formatter(expectedParsedData);
+    expect(formattedResult.toLowerCase()).toBe(dpStr.toLowerCase());
+  });
+  it('should handle dpStr with invalid length', () => {
+    // 少两位
+    const result = parser.parser('00010102010a1e0078325000');
+    expect(result).toEqual({
+      version: 0,
+      length: 0,
+      nodes: []
+    });
+  });
+  it('should handle dpStr with more than 4 nodes by taking only first 4', () => {
+    // 假设 dpStr 代表5个节点，但length字段为4
+
+    // node 5 (this one should be ignored by parser if length is 4)
+    const result = parser.parser('0004' +
+    // version 0, length 4
+    '0102010a1e007832500000' +
+    // node 1
+    '0104020b2800641e320000' +
+    // node 2
+    '0008030c3c00500a190000' +
+    // node 3
+    '0110040d46003c000f0000' +
+    // node 4
+    '0120050e500028640a0000');
+    expect(result.nodes.length).toBe(4);
+  });
+});

package/lib/dpParser/__test__/sleepCommon.test.d.ts

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

package/lib/dpParser/__test__/sleepCommon.test.js

@@ -0,0 +1,197 @@
+import { Sleep, sleepParser } from '../sleep/sleepCommon';
+const DEFAULT_EMPTY_SLEEP_DATA = {
+  version: 0,
+  length: 0,
+  nodes: []
+};
+describe('Sleep (Common)', () => {
+  let sleepInstance;
+  beforeEach(() => {
+    sleepInstance = new Sleep();
+    jest.clearAllMocks();
+  });
+  describe('parser', () => {
+    it('should parse a valid DP string into TSleepData', () => {
+      // version=00, length=01 (1 node)
+      // Node 1: onOff=01 (true), loops=42 (Sat, Sun - 01000010 -> reverse 01000010), step=01
+      // hour=0b (11), minute=15 (21)
+      // hueHundreds=00, hueTensOnes=00 (hue=0)
+      // sat=00, val=00, bright=00, temp=00
+      const dpValue = '00 01 01 42 01 0b 15 00 00 00 00 00 00'.replaceAll(' ', ''); // 2 + 2 + 22 = 26 bytes = 52 chars
+
+      expect(sleepInstance.parser(dpValue)).toEqual({
+        version: 0,
+        length: 1,
+        nodes: [{
+          onOff: true,
+          loops: '0100001',
+          step: 1,
+          hour: 11,
+          minute: 21,
+          hue: 0,
+          saturation: 0,
+          value: 0,
+          brightness: 0,
+          temperature: 0,
+          index: 0
+        }]
+      });
+    });
+    it('should parse a DP string with multiple nodes', () => {
+      // version=0, length=2
+      // Node 1: onOff=true, loops=Mon(00000100->04), step=1, time=10:30, color(120,100,50,80,60)
+      // Node 2: onOff=false, loops=Tue(00001000->08), step=2, time=12:00, color(0,0,0,0,0)
+
+      // Node 2
+
+      expect(sleepInstance.parser('0002' +
+      // version, length
+      '0104010a1e01146432503c' +
+      // Node 1
+      '0008020c00000000000000')).toEqual({
+        version: 0,
+        length: 2,
+        nodes: [{
+          onOff: true,
+          loops: '0010000',
+          step: 1,
+          hour: 10,
+          minute: 30,
+          hue: 120,
+          saturation: 100,
+          value: 50,
+          brightness: 80,
+          temperature: 60,
+          index: 0
+        }, {
+          onOff: false,
+          loops: '0001000',
+          step: 2,
+          hour: 12,
+          minute: 0,
+          hue: 0,
+          saturation: 0,
+          value: 0,
+          brightness: 0,
+          temperature: 0,
+          index: 1
+        }]
+      });
+    });
+    it('should return default data for empty DP string', () => {
+      expect(sleepInstance.parser('')).toEqual(DEFAULT_EMPTY_SLEEP_DATA);
+    });
+    it('should return default data for invalid DP string length', () => {
+      // Missing last few bytes
+      expect(sleepInstance.parser('00010142010b1500000000')).toEqual(DEFAULT_EMPTY_SLEEP_DATA);
+    });
+    it('should handle hue rounding', () => {
+      // hueHundreds=0001, hueTensOnes=0015 (hue=121)
+
+      const result = sleepInstance.parser('00010101010101011500000000');
+      expect(result.nodes[0].hue).toBe(121);
+    });
+    it('should cap length at 4 nodes', () => {
+      // version=0, length=5 (will be capped at 4)
+
+      // Node 5 (ignored)
+
+      const result = sleepInstance.parser('0005' +
+      // version, length (will be capped to 4)
+      '0104010a1e01146432503c' +
+      // Node 1
+      '0008020c00000000000000' +
+      // Node 2
+      '0000000000000000000000' +
+      // Node 3
+      '0000000000000000000000' +
+      // Node 4
+      '0000000000000000000000');
+      expect(result.length).toBe(4);
+      expect(result.nodes.length).toBe(4);
+    });
+  });
+  describe('formatter', () => {
+    it('should format TSleepData into a DP string', () => {
+      expect(sleepInstance.formatter({
+        version: 0,
+        length: 1,
+        nodes: [{
+          onOff: true,
+          loops: '0100001',
+          step: 1,
+          hour: 11,
+          minute: 21,
+          hue: 0,
+          saturation: 0,
+          value: 0,
+          brightness: 0,
+          temperature: 0,
+          index: 0
+        }]
+      })).toBe('00010142010b15000000000000');
+    });
+    it('should format TSleepData with multiple nodes', () => {
+      expect(sleepInstance.formatter({
+        version: 0,
+        length: 2,
+        nodes: [{
+          onOff: true,
+          loops: '0010000',
+          step: 1,
+          hour: 10,
+          minute: 30,
+          hue: 120,
+          saturation: 100,
+          value: 50,
+          brightness: 80,
+          temperature: 60,
+          index: 0
+        }, {
+          onOff: false,
+          loops: '0001000',
+          step: 2,
+          hour: 12,
+          minute: 0,
+          hue: 0,
+          saturation: 0,
+          value: 0,
+          brightness: 0,
+          temperature: 0,
+          index: 1
+        }]
+      })).toBe('00020104010a1e01146432503c0008020c00000000000000');
+    });
+    it('should format TSleepData with empty nodes array', () => {
+      expect(sleepInstance.formatter({
+        version: 1,
+        length: 0,
+        nodes: []
+      })).toBe('0100');
+    });
+    it('should use default color values if all color props are 0', () => {
+      expect(sleepInstance.formatter({
+        version: 0,
+        length: 1,
+        nodes: [{
+          onOff: true,
+          loops: '1000000',
+          step: 1,
+          hour: 8,
+          minute: 0,
+          hue: 0,
+          saturation: 0,
+          value: 0,
+          brightness: 0,
+          temperature: 0,
+          index: 0
+        }]
+      })).toBe('00010101010800000000000000');
+    });
+  });
+  describe('sleepParser instance', () => {
+    it('should be an instance of Sleep', () => {
+      expect(sleepParser).toBeInstanceOf(Sleep);
+    });
+  });
+});

package/lib/dpParser/__test__/timerReport.test.d.ts

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

package/lib/dpParser/__test__/timerReport.test.js

@@ -0,0 +1,100 @@
+import { TimerReportFormatter, timerReportParser } from '../timerReport';
+describe('TimerReportFormatter', () => {
+  let formatterInstance;
+  beforeEach(() => {
+    formatterInstance = new TimerReportFormatter();
+  });
+  describe('parser', () => {
+    it('should parse a valid DP string into TTimerReport array', () => {
+      // 81 -> 10000001 (status=true, id=1)
+      // 02 -> 00000010 (status=false, id=2)
+      // 8F -> 10001111 (status=true, id=15)
+
+      expect(formatterInstance.parser('81028f')).toEqual([{
+        status: true,
+        id: 1
+      }, {
+        status: false,
+        id: 2
+      }, {
+        status: true,
+        id: 15
+      }]);
+    });
+    it('should return default empty array for empty DP string', () => {
+      expect(formatterInstance.parser('')).toEqual([]);
+    });
+    it('should return default empty array for undefined DP string', () => {
+      expect(formatterInstance.parser(undefined)).toEqual([]);
+    });
+    it('should handle a DP string with a single report', () => {
+      // C3 -> 11000011 (status=true, id=67)
+
+      expect(formatterInstance.parser('c3')).toEqual([{
+        status: true,
+        id: 3
+      }]);
+    });
+  });
+  describe('formatter', () => {
+    it('should format TTimerReport array into a DP string', () => {
+      expect(formatterInstance.formatter([{
+        status: true,
+        id: 1
+      },
+      // 10000001 -> 81
+      {
+        status: false,
+        id: 2
+      },
+      // 00000010 -> 02
+      {
+        status: true,
+        id: 15
+      } // 10001111 -> 8f
+      ])).toBe('81028f');
+    });
+    it('should format an empty TTimerReport array into an empty string', () => {
+      expect(formatterInstance.formatter([])).toBe('');
+    });
+    it('should handle a single task in TTimerReport array', () => {
+      // 11000011 -> c3
+
+      expect(formatterInstance.formatter([{
+        status: true,
+        id: 67
+      }])).toBe('c3');
+    });
+    it('should handle id 0', () => {
+      // 10000000 -> 80
+
+      expect(formatterInstance.formatter([{
+        status: true,
+        id: 0
+      }])).toBe('80');
+    });
+    it('should handle max id (127)', () => {
+      // 01111111 -> 7f
+
+      expect(formatterInstance.formatter([{
+        status: false,
+        id: 127
+      }])).toBe('7f');
+    });
+  });
+  describe('timerReportParser instance', () => {
+    it('should be an instance of TimerReportFormatter', () => {
+      // The exported timerReportParser is an instance of TimerReportFormatter.
+      // We can check if it has the parser and formatter methods.
+      expect(timerReportParser.parser).toBeInstanceOf(Function);
+      expect(timerReportParser.formatter).toBeInstanceOf(Function);
+
+      // To be more precise, we can check if the constructor name matches,
+      // though this can be brittle if the class is wrapped or transpiled differently.
+      // expect(timerReportParser.constructor.name).toBe('TimerReportFormatter');
+      // Or, more robustly, check if it behaves like an instance:
+      const testInstance = new TimerReportFormatter();
+      expect(Object.getPrototypeOf(timerReportParser)).toBe(Object.getPrototypeOf(testInstance));
+    });
+  });
+});

package/lib/dpParser/__test__/wakeup.test.d.ts

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