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

package/lib/context/timer/reducer.js

@@ -0,0 +1,70 @@
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.filter.js";
+import "core-js/modules/esnext.iterator.for-each.js";
+/* eslint-disable no-case-declarations */
+import { useReducer, useCallback } from 'react';
+import { cloneDeep } from 'lodash-es';
+import { ECouldTimer, ERtcTimer } from './type';
+import { scheduleLogger as ScheduleLogger } from '../../utils/ScheduleLogger';
+
+// 普通定时器 Reducer
+
+export const useTimerReducer = init => {
+  const timerReducer = useCallback((state, action) => {
+    ScheduleLogger.debug('TIMER_REDUCER RUN:', action);
+    switch (action.type) {
+      // 本地定时更新 Start
+      case ERtcTimer.ADD_RTC_TIMER:
+        // eslint-disable-next-line no-case-declarations
+        const _newTimers = cloneDeep(state.rtcTimerList);
+        const index = _newTimers.findIndex(i => {
+          var _action$payload;
+          return i.timerId === ((_action$payload = action.payload) === null || _action$payload === void 0 ? void 0 : _action$payload.timerId);
+        });
+        index > -1 && _newTimers.splice(index, 1);
+        // 添加
+        _newTimers.push(action.payload);
+        return _objectSpread(_objectSpread({}, state), {}, {
+          rtcTimerList: [..._newTimers]
+        });
+      case ERtcTimer.REMOVE_RTC_TIMER:
+        // eslint-disable-next-line no-case-declarations
+        const _data = action.payload;
+        // eslint-disable-next-line no-case-declarations
+        const rNewTimers = state.rtcTimerList.filter(item => item.timerId !== (_data === null || _data === void 0 ? void 0 : _data.timerId));
+        return _objectSpread(_objectSpread({}, state), {}, {
+          rtcTimerList: [...rNewTimers]
+        });
+      case ERtcTimer.UPDATE_RTC_TIMER:
+        // eslint-disable-next-line no-case-declarations
+        const data = action.payload;
+        // eslint-disable-next-line no-case-declarations
+        const newTimers = state.rtcTimerList;
+        newTimers.forEach((item, index) => {
+          if (item.timerId === (data === null || data === void 0 ? void 0 : data.timerId)) {
+            newTimers[index] = data;
+          }
+        });
+        return _objectSpread(_objectSpread({}, state), {}, {
+          rtcTimerList: [...newTimers]
+        });
+      case ERtcTimer.FLUSH_RTC_TIMER_LIST:
+        return _objectSpread(_objectSpread({}, state), {}, {
+          rtcTimerList: action.payload
+        });
+      // 本地定时器更新 End
+
+      // 云定时器 更新 Start
+      case ECouldTimer.FLUSH_CLOUD_TIMER_LIST:
+        return _objectSpread(_objectSpread({}, state), {}, {
+          cloudTimerList: action.payload
+        });
+      // 云定时器 更新 End
+
+      default:
+        return state;
+    }
+  }, []);
+  return useReducer(timerReducer, init);
+};

package/lib/context/timer/type.d.ts

@@ -0,0 +1,46 @@
+import { Dispatch } from 'react';
+import { TTimerData, TTimerDataAdd, TTimerDataUpdate } from '../../types/index';
+export declare enum ERtcTimer {
+    ADD_RTC_TIMER = "ADD_RTC_TIMER",
+    REMOVE_RTC_TIMER = "REMOVE_RTC_TIMER",
+    UPDATE_RTC_TIMER = "UPDATE_RTC_TIMER",
+    CLOSE_ALL_RTC_TIMER = "CLOSE_ALL_RTC_TIMER",
+    FLUSH_RTC_TIMER_LIST = "FLUSH_RTC_TIMER_LIST"
+}
+export declare enum ETimer {
+}
+export declare enum ECouldTimer {
+    FLUSH_CLOUD_TIMER_LIST = "FLUSH_CLOUD_TIMER_LIST"
+}
+export interface IState {
+    rtcTimerList: TTimerData[];
+    cloudTimerList: TTimerData[];
+}
+export interface ILocalTimerReturn {
+    type: ERtcTimer;
+    payload: any;
+}
+export interface ICloudTimerReturn {
+    type: ECouldTimer;
+    payload: any;
+}
+export interface ITimerReturn {
+    type: ETimer;
+    payload: any;
+}
+export type TActions = {
+    addRtcTimer: (data: TTimerDataAdd) => ILocalTimerReturn;
+    removeRtcTimer: (timerId: string) => ILocalTimerReturn;
+    updateRtcTimer: (data: TTimerDataUpdate) => ILocalTimerReturn;
+    closeAllRtcTimer: (timerIdList: string[]) => ILocalTimerReturn;
+    flushRtcTimerList: (data: TTimerData[]) => ILocalTimerReturn;
+    flushCloudTimerList: (data: TTimerData[]) => ICloudTimerReturn;
+};
+export interface IContext {
+    state: IState;
+    dispatch: Dispatch<{
+        type: string;
+        payload?: ILocalTimerReturn | ICloudTimerReturn;
+    }>;
+    actions?: TActions;
+}

package/lib/context/timer/type.js

@@ -0,0 +1,24 @@
+// 本地定时器类型
+export let ERtcTimer = /*#__PURE__*/function (ERtcTimer) {
+  ERtcTimer["ADD_RTC_TIMER"] = "ADD_RTC_TIMER";
+  ERtcTimer["REMOVE_RTC_TIMER"] = "REMOVE_RTC_TIMER";
+  ERtcTimer["UPDATE_RTC_TIMER"] = "UPDATE_RTC_TIMER";
+  ERtcTimer["CLOSE_ALL_RTC_TIMER"] = "CLOSE_ALL_RTC_TIMER";
+  ERtcTimer["FLUSH_RTC_TIMER_LIST"] = "FLUSH_RTC_TIMER_LIST";
+  return ERtcTimer;
+}({});
+
+// 通用定时类型
+export let ETimer = /*#__PURE__*/function (ETimer) {
+  return ETimer;
+}({});
+
+// 云定时器类型
+export let ECouldTimer = /*#__PURE__*/function (ECouldTimer) {
+  ECouldTimer["FLUSH_CLOUD_TIMER_LIST"] = "FLUSH_CLOUD_TIMER_LIST";
+  return ECouldTimer;
+}({});
+
+// 本地定时器返回
+
+// 云定时器返回

package/lib/dpParser/README.md

@@ -0,0 +1,63 @@
+# 复杂 dp 协议解析
+
+## dp 解析函数
+- 名称:generateDpStrStep
+  - 描述: raw 型或 string 型 DP 解析步进函数
+
+请求参数
+
+|参数	|数据类型	|说明|	是否必填|
+|--|--|--|--|
+|value|	string|	16进制值|	是|
+
+返回参数
+
+|参数	|数据类型	|说明|
+|--|--|--|
+result	|Function|	步进函数|
+
+```ts
+import { utils } from '@ray-js/panel-sdk';
+const { generateDpStrStep } = utils;
+
+generateDpStrStep(value);
+// Example:
+ const step = generateDpStrStep('3264');
+ const val1 = step().value; // 50
+ const val2 = step(2).value; // 100
+
+```
+
+```ts
+// 输出的函数
+class XxxParser {
+  constructor() {
+    this.dpCode = 'xxx';
+  }
+  parser(str: string) {
+    // 这里是将 dp string 的数据转为对象对数据格式
+    // str 为16进制的字符串，输出为10进制的数据
+  }
+  formatter(data: {[key: string]: any }) {
+    // 这里是将 解析的dp数据进行 hex 化，用来下发给设备
+    // 最后输出为16进制字符串
+  }
+}
+
+const xxxParser = new XxxParser();
+
+```
+
+## dp 协议类型
+- raw 类型
+```ts
+
+```
+- string 类型
+
+- value/number 类型
+
+- enum 类型
+
+- bool 类型
+

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

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

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

@@ -0,0 +1,258 @@
+import { cycleParser, getCycleParser } from '../cycle/index';
+// Mock config module
+jest.mock('../../config/dpCodes', () => ({
+  scheduleDpCodes: {
+    CYCLE_TIMING: 'cycle_timing'
+  }
+}));
+const DEFAULT_EMPTY_DATA = {
+  version: 0,
+  length: 16,
+  nodes: []
+};
+describe('CycleTimerParser', () => {
+  describe('parser', () => {
+    it('should parse a DP string with single node', () => {
+      // version=0, length=16
+      // powerChannel=0x03 (channel=1, onOff=true), weeks=0x7f (all days)
+      // startTime=0x0384 (900), endTime=0x04b0 (1200)
+      // startTimeDuration=0x003c (60), endTimeDuration=0x003c (60)
+      // color: hue=0x0078 (120), sat=0x64 (100), val=0x32 (50), bright=0x50 (80), temp=0x3c (60)
+      const dpValue = '0010037f038404b0003c003c00786432503c';
+
+      // 获取实际解析结果，用于调试
+      const actual = cycleParser.parser(dpValue);
+      console.log('Actual parsed result (single node):', JSON.stringify(actual, null, 2));
+      expect(cycleParser.parser(dpValue)).toEqual({
+        version: 0,
+        length: 16,
+        nodes: [{
+          onOff: true,
+          channel: 1,
+          loops: '1111111',
+          startTime: 900,
+          endTime: 1200,
+          startTimeDuration: 60,
+          endTimeDuration: 60,
+          index: 0,
+          color: {
+            brightness: 80,
+            hue: 120,
+            saturation: 100,
+            temperature: 60,
+            value: 50
+          }
+        }]
+      });
+    });
+    it('should parse a DP string with multiple nodes', () => {
+      // version=0, length=16
+      // Node 1: as above
+      // Node 2: powerChannel=0x05 (channel=2, onOff=true), weeks=0x01 (Sun)
+      // startTime=0x0514 (1300), endTime=0x05dc (1500)
+      // startTimeDuration=0x001e (30), endTimeDuration=0x001e (30)
+      // color: hue=0x0000 (0), sat=0x00 (0), val=0x64 (100), bright=0x64 (100), temp=0x64 (100)
+      const dpValue = '0010037f038404b0003c003c00786432503c0501051405dc001e001e000000646464';
+
+      // 获取实际解析结果，用于调试
+      const actual = cycleParser.parser(dpValue);
+      console.log('Actual parsed result (multiple nodes):', JSON.stringify(actual, null, 2));
+      expect(cycleParser.parser(dpValue)).toEqual({
+        version: 0,
+        length: 16,
+        nodes: [{
+          onOff: true,
+          channel: 1,
+          loops: '1111111',
+          startTime: 900,
+          endTime: 1200,
+          startTimeDuration: 60,
+          endTimeDuration: 60,
+          index: 0,
+          color: {
+            hue: 120,
+            saturation: 100,
+            value: 50,
+            brightness: 80,
+            temperature: 60
+          }
+        }, {
+          endTime: 1500,
+          endTimeDuration: 30,
+          index: 1,
+          channel: 2,
+          loops: '1000000',
+          onOff: true,
+          startTime: 1300,
+          startTimeDuration: 30,
+          color: {
+            hue: 0,
+            saturation: 0,
+            value: 100,
+            brightness: 100,
+            temperature: 100
+          }
+        }]
+      });
+    });
+    it('should return default data for empty DP string', () => {
+      expect(cycleParser.parser('')).toEqual(DEFAULT_EMPTY_DATA);
+    });
+    it('should return default data for DP string with incorrect length', () => {
+      // Valid header, but node data is incomplete
+      // Missing last byte
+      expect(cycleParser.parser('0010037f038404b0003c003c007864325')).toEqual(DEFAULT_EMPTY_DATA);
+    });
+    it('should handle power off and specific channel', () => {
+      // version=0, length=16
+      // Node 1: powerChannel=0x02 (channel=1, onOff=false), weeks=0x40 (Sat)
+      // startTime=0x0100 (256), endTime=0x0200 (512)
+      // startTimeDuration=0x0014 (20), endTimeDuration=0x001e (30)
+      // color: hue=0x0000, sat=0x00, val=0x00, bright=0x00, temp=0x00
+      const dpValue = '00100240010002000014001e000000000000';
+
+      // 获取实际解析结果，用于调试
+      const actual = cycleParser.parser(dpValue);
+      console.log('Actual parsed result:', JSON.stringify(actual, null, 2));
+      expect(cycleParser.parser(dpValue)).toEqual({
+        version: 0,
+        length: 16,
+        nodes: [{
+          onOff: false,
+          channel: 1,
+          loops: '0000001',
+          startTime: 256,
+          endTime: 512,
+          startTimeDuration: 20,
+          endTimeDuration: 30,
+          index: 0,
+          color: {
+            hue: 0,
+            saturation: 0,
+            value: 0,
+            brightness: 0,
+            temperature: 0
+          }
+        }]
+      });
+    });
+  });
+  describe('formatter', () => {
+    it('should format TCycleData into a DP string', () => {
+      // version=00, length=10
+      // Node 1: powerChannel=03 (channel=1, onOff=true -> 00000011), weeks=7f (1111111 -> 01111111)
+      // startTime=0384, endTime=04b0
+      // startTimeDuration=003c, endTimeDuration=003c
+      // color: hue=0078, sat=64, val=32, bright=50, temp=3c
+
+      expect(cycleParser.formatter({
+        version: 0,
+        length: 16,
+        // This is fixed in the class, but we set it for clarity
+        nodes: [{
+          onOff: true,
+          channel: 1,
+          loops: '1111111',
+          startTime: 900,
+          endTime: 1200,
+          startTimeDuration: 60,
+          endTimeDuration: 60,
+          index: 0,
+          color: {
+            hue: 120,
+            saturation: 100,
+            value: 50,
+            brightness: 80,
+            temperature: 60
+          }
+        }]
+      })).toBe('0010037f038404b0003c003c00786432503c');
+    });
+    it('should format TCycleData with multiple nodes', () => {
+      // Node1: 037f038404b0003c003c00786432503c
+      // Node2: powerChannel=05 (channel=2, onOff=true -> 00000101), weeks=01 (1000000 -> 00000001)
+      // startTime=0514, endTime=05dc
+      // startTimeDuration=001e, endTimeDuration=001e
+      // color: hue=0000, sat=00, val=64, bright=64, temp=64
+
+      expect(cycleParser.formatter({
+        version: 0,
+        length: 16,
+        nodes: [{
+          onOff: true,
+          channel: 1,
+          loops: '1111111',
+          startTime: 900,
+          endTime: 1200,
+          startTimeDuration: 60,
+          endTimeDuration: 60,
+          index: 0,
+          color: {
+            hue: 120,
+            saturation: 100,
+            value: 50,
+            brightness: 80,
+            temperature: 60
+          }
+        }, {
+          onOff: true,
+          channel: 2,
+          loops: '1000000',
+          // Sunday
+          startTime: 1300,
+          endTime: 1500,
+          startTimeDuration: 30,
+          endTimeDuration: 30,
+          index: 1,
+          color: {
+            hue: 0,
+            saturation: 0,
+            value: 100,
+            brightness: 100,
+            temperature: 100
+          }
+        }]
+      })).toBe('0010037f038404b0003c003c00786432503c0501051405dc001e001e000000646464');
+    });
+    it('should format TCycleData with empty nodes array', () => {
+      // version=01, length=10
+      expect(cycleParser.formatter({
+        version: 1,
+        length: 16,
+        nodes: []
+      })).toBe('0110');
+    });
+    it('should handle channel 0 (default to 1 in formatter)', () => {
+      // powerChannel=03 (channel=1, onOff=true), weeks=40 (0000001 -> 01000000)
+
+      expect(cycleParser.formatter({
+        version: 0,
+        length: 16,
+        nodes: [{
+          onOff: true,
+          channel: 0,
+          // will be treated as 1
+          loops: '0000001',
+          // Saturday
+          startTime: 100,
+          endTime: 200,
+          startTimeDuration: 10,
+          endTimeDuration: 10,
+          index: 0,
+          color: {
+            hue: 0,
+            saturation: 0,
+            value: 0,
+            brightness: 0,
+            temperature: 0
+          }
+        }]
+      })).toBe('00100340006400c8000a000a000000000000');
+    });
+  });
+  describe('getCycleParser', () => {
+    it('should return the cycleParser instance', () => {
+      expect(getCycleParser()).toBe(cycleParser);
+    });
+  });
+});

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

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

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

@@ -0,0 +1,211 @@
+import { randomParser } from '../random/index';
+const DEFAULT_EMPTY_DATA = {
+  version: 0,
+  length: 12,
+  nodes: []
+};
+describe('RandomTimerParser', () => {
+  describe('parser', () => {
+    it('should parse a valid DP string into TRandomData', () => {
+      // version=0, length=12 (0x0c)
+      // Node 1: powerChannel=0x00 (channel=0, onOff=false), weeks=0x7f (all days), startTime=0x0384 (900), endTime=0x04b0 (1200)
+      // color: hue=0x0078 (120), sat=0x64 (100), val=0x32 (50), bright=0x50 (80), temp=0x3c (60)
+
+      expect(randomParser.parser('000c007f038404b000786432503c')).toEqual({
+        version: 0,
+        length: 12,
+        nodes: [{
+          onOff: false,
+          channel: 0,
+          loops: '1111111',
+          startTime: 900,
+          endTime: 1200,
+          index: 0,
+          color: {
+            hue: 120,
+            saturation: 100,
+            value: 50,
+            brightness: 80,
+            temperature: 60
+          }
+        }]
+      });
+    });
+    it('should parse a DP string with multiple nodes', () => {
+      // version=0, length=12
+      // Node 1: as above
+      // Node 2: powerChannel=0x05 (channel=2, onOff=true), weeks=0x01 (Sun), startTime=0x0514 (1300), endTime=0x05dc (1500)
+      // color: hue=0x0000 (0), sat=0x00 (0), val=0x64 (100), bright=0x64 (100), temp=0x64 (100)
+
+      expect(randomParser.parser('000c037f038404b000786432503c0501051405dc000000646464')).toEqual({
+        version: 0,
+        length: 12,
+        nodes: [{
+          onOff: true,
+          channel: 1,
+          loops: '1111111',
+          startTime: 900,
+          endTime: 1200,
+          index: 0,
+          color: {
+            hue: 120,
+            saturation: 100,
+            value: 50,
+            brightness: 80,
+            temperature: 60
+          }
+        }, {
+          onOff: true,
+          channel: 2,
+          loops: '1000000',
+          startTime: 1300,
+          endTime: 1500,
+          index: 1,
+          color: {
+            hue: 0,
+            saturation: 0,
+            value: 100,
+            brightness: 100,
+            temperature: 100
+          }
+        }]
+      });
+    });
+    it('should return default data for empty DP string', () => {
+      expect(randomParser.parser('')).toEqual(DEFAULT_EMPTY_DATA);
+    });
+    it('should return default data for DP string with incorrect length', () => {
+      // Valid header, but node data is incomplete
+      // Missing last byte
+      expect(randomParser.parser('000c037f038404b00078643250')).toEqual(DEFAULT_EMPTY_DATA);
+    });
+    it('should handle power off and specific channel', () => {
+      // version=0, length=12
+      // Node 1: powerChannel=0x02 (channel=1, onOff=false), weeks=0x40 (Sat), startTime=0x0100 (256), endTime=0x0200 (512)
+      // color: hue=0x0000, sat=0x00, val=0x00, bright=0x00, temp=0x00
+
+      expect(randomParser.parser('000c024001000200000000000000')).toEqual({
+        version: 0,
+        length: 12,
+        nodes: [{
+          onOff: false,
+          channel: 1,
+          loops: '0000001',
+          startTime: 256,
+          endTime: 512,
+          index: 0,
+          color: {
+            hue: 0,
+            saturation: 0,
+            value: 0,
+            brightness: 0,
+            temperature: 0
+          }
+        }]
+      });
+    });
+  });
+  describe('formatter', () => {
+    it('should format TRandomData into a DP string', () => {
+      // version=00, length=0c
+      // Node 1: powerChannel=03 (channel=1, onOff=true -> 00000011), weeks=7f (1111111 -> 01111111)
+      // startTime=0384, endTime=04b0
+      // color: hue=0078, sat=64, val=32, bright=50, temp=3c
+
+      expect(randomParser.formatter({
+        version: 0,
+        length: 12,
+        // This is fixed in the class, but we set it for clarity
+        nodes: [{
+          onOff: true,
+          channel: 1,
+          loops: '1111111',
+          startTime: 900,
+          endTime: 1200,
+          index: 0,
+          color: {
+            hue: 120,
+            saturation: 100,
+            value: 50,
+            brightness: 80,
+            temperature: 60
+          }
+        }]
+      })).toBe('000c037f038404b000786432503c');
+    });
+    it('should format TRandomData with multiple nodes', () => {
+      // Node1: 037f038404b000786432503c
+      // Node2: powerChannel=05 (channel=2, onOff=true -> 00000101), weeks=01 (1000000 -> 00000001)
+      // startTime=0514, endTime=05dc
+      // color: hue=0000, sat=00, val=64, bright=64, temp=64
+
+      expect(randomParser.formatter({
+        version: 0,
+        length: 12,
+        nodes: [{
+          onOff: true,
+          channel: 1,
+          loops: '1111111',
+          startTime: 900,
+          endTime: 1200,
+          index: 0,
+          color: {
+            hue: 120,
+            saturation: 100,
+            value: 50,
+            brightness: 80,
+            temperature: 60
+          }
+        }, {
+          onOff: true,
+          channel: 2,
+          loops: '1000000',
+          // Sunday
+          startTime: 1300,
+          endTime: 1500,
+          index: 1,
+          color: {
+            hue: 0,
+            saturation: 0,
+            value: 100,
+            brightness: 100,
+            temperature: 100
+          }
+        }]
+      })).toBe('000c037f038404b000786432503c0501051405dc000000646464');
+    });
+    it('should format TRandomData with empty nodes array', () => {
+      // version=01, length=0c
+      expect(randomParser.formatter({
+        version: 1,
+        length: 12,
+        nodes: []
+      })).toBe('010c');
+    });
+    it('should handle channel 0 (default to 1 in formatter)', () => {
+      // powerChannel=03 (channel=1, onOff=true), weeks=40 (0000001 -> 01000000)
+
+      expect(randomParser.formatter({
+        version: 0,
+        length: 12,
+        nodes: [{
+          onOff: true,
+          channel: 0,
+          // will be treated as 1
+          loops: '0000001',
+          // Saturday
+          startTime: 100,
+          endTime: 200,
+          index: 0,
+          color: {
+            hue: 0,
+            saturation: 0,
+            value: 0,
+            brightness: 0,
+            temperature: 0
+          }
+        }]
+      })).toBe('000c0340006400c8000000000000');
+    });
+  });
+});

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

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