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

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

@@ -0,0 +1,69 @@
+import { WakeUpParser } from '../wakeup';
+describe('WakeUpParser', () => {
+  const parser = new WakeUpParser();
+  it('should return default value when parsing empty string', () => {
+    const result = parser.parser('');
+    expect(result).toEqual({
+      version: 0,
+      number: 0,
+      nodes: []
+    });
+  });
+  it('should format default value correctly', () => {
+    const result = parser.formatter({
+      version: 0,
+      number: 0,
+      nodes: []
+    });
+    // 根据 wakeupCommon.ts 的 formatter 逻辑，空数据会返回 '0000'
+    expect(result).toBe('0000');
+  });
+  it('should parse a valid dpStr and format it back for WakeUpCommon', () => {
+    // 示例 dpStr: 版本0, 节点数1, 节点1: 开, 周一, 步进1, 10:30, H:120,S:50,V:80,B:0,T:0, 持续时间1
+    const dpStr = '00010102010a1e012c3250000001';
+    const expectedParsedData = {
+      version: 0,
+      number: 1,
+      nodes: [{
+        onOff: true,
+        loops: '0100000',
+        // Monday
+        step: 1,
+        hour: 10,
+        minute: 30,
+        hue: 144,
+        saturation: 50,
+        value: 80,
+        brightness: 0,
+        temperature: 0,
+        duration: 1,
+        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 more than 4 nodes by taking only first 4 for WakeUpCommon', () => {
+    // 版本0, 节点数4 (即使dpStr包含5个节点数据)
+
+    // node 5 (this one should be ignored by parser if number is 4)
+    const result = parser.parser('0004' +
+    // version 0, number 4
+    '0102010a1e012c3250000001' +
+    // node 1
+    '0104020b2801181e32000002' +
+    // node 2
+    '0008030c3c00000a19000003' +
+    // node 3
+    '0110040d460000000f000004' +
+    // node 4
+    '0120050e500000640a000005');
+    expect(result.nodes.length).toBe(4);
+  });
+
+  // 注意: Sigmesh 相关的测试需要模拟 support.isSigMeshDevice() 返回 true
+  // 由于当前 SleepParser 和 WakeUpParser 的实现中 Sigmesh 部分被注释掉了，
+  // 我们暂时无法直接测试 Sigmesh 的逻辑。如果需要测试，需要解除注释并可能需要 mock `getSupportIns`。
+});

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

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

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

@@ -0,0 +1,131 @@
+import { wakeupParser } from '../wakeup/wakeupCommon';
+describe('WakeUp Parser', () => {
+  test('应该返回默认值当输入为空字符串时', () => {
+    const result = wakeupParser.parser('');
+    expect(result).toEqual({
+      version: 0,
+      number: 0,
+      nodes: []
+    });
+  });
+  test('应该正确解析单个节点的数据', () => {
+    // 用 formatter 生成一组数据
+    const data = {
+      version: 1,
+      number: 1,
+      nodes: [{
+        onOff: true,
+        loops: '0000010',
+        // 周一
+        step: 1,
+        hour: 8,
+        minute: 30,
+        hue: 180,
+        saturation: 50,
+        value: 50,
+        brightness: 50,
+        temperature: 50,
+        duration: 30,
+        index: 0
+      }]
+    };
+    const dpStr = wakeupParser.formatter(data);
+    const result = wakeupParser.parser(dpStr);
+    expect(result.version).toBe(1);
+    expect(result.number).toBe(1);
+    expect(result.nodes).toHaveLength(1);
+    expect(result.nodes[0]).toEqual(data.nodes[0]);
+  });
+  test('应该正确格式化数据', () => {
+    const data = {
+      version: 1,
+      number: 1,
+      nodes: [{
+        onOff: true,
+        loops: '0000010',
+        // 周一
+        step: 1,
+        hour: 8,
+        minute: 30,
+        hue: 180,
+        saturation: 50,
+        value: 50,
+        brightness: 50,
+        temperature: 50,
+        duration: 30,
+        index: 0
+      }]
+    };
+    const result = wakeupParser.formatter(data);
+    // 直接用 parser 解析，验证一致性
+    const parsed = wakeupParser.parser(result);
+    expect(parsed.nodes[0]).toEqual(data.nodes[0]);
+  });
+  test('应该处理多个节点的情况', () => {
+    const data = {
+      version: 1,
+      number: 2,
+      nodes: [{
+        onOff: true,
+        loops: '0000010',
+        // 周一
+        step: 1,
+        hour: 8,
+        minute: 30,
+        hue: 180,
+        saturation: 50,
+        value: 50,
+        brightness: 50,
+        temperature: 50,
+        duration: 30,
+        index: 0
+      }, {
+        onOff: true,
+        loops: '0100000',
+        // 周六
+        step: 2,
+        hour: 9,
+        minute: 0,
+        hue: 200,
+        saturation: 60,
+        value: 60,
+        brightness: 60,
+        temperature: 60,
+        duration: 45,
+        index: 1
+      }]
+    };
+    const result = wakeupParser.formatter(data);
+    const parsed = wakeupParser.parser(result);
+    expect(parsed.version).toBe(data.version);
+    expect(parsed.number).toBe(data.number);
+    expect(parsed.nodes).toHaveLength(2);
+    expect(parsed.nodes[0]).toEqual(data.nodes[0]);
+    expect(parsed.nodes[1]).toEqual(data.nodes[1]);
+  });
+  test('应该处理默认颜色值', () => {
+    const result = wakeupParser.formatter({
+      version: 1,
+      number: 1,
+      nodes: [{
+        onOff: true,
+        loops: '0000010',
+        step: 1,
+        hour: 8,
+        minute: 30,
+        hue: 0,
+        saturation: 0,
+        value: 0,
+        brightness: 0,
+        temperature: 0,
+        duration: 30,
+        index: 0
+      }]
+    });
+    const parsed = wakeupParser.parser(result);
+    expect(parsed.nodes[0].saturation).toBe(0);
+    expect(parsed.nodes[0].value).toBe(0);
+    expect(parsed.nodes[0].brightness).toBe(0);
+    expect(parsed.nodes[0].temperature).toBe(0);
+  });
+});

package/lib/dpParser/cycle/index.d.ts

@@ -0,0 +1,15 @@
+import { TCycleData, TCycleNode } from '../../types';
+declare class CycleTimerParser {
+    parser(dpValue: string): TCycleData;
+    formatter(data: TCycleData): string;
+}
+export declare const cycleParser: {
+    parser: (dpValue: string) => {
+        version: number;
+        length: number;
+        nodes: TCycleNode[];
+    };
+    formatter: (data: TCycleData) => string;
+};
+export declare const getCycleParser: () => CycleTimerParser;
+export {};

package/lib/dpParser/cycle/index.js

@@ -0,0 +1,134 @@
+import "core-js/modules/esnext.iterator.map.js";
+import padStart from 'lodash/padStart';
+import padEnd from 'lodash/padEnd';
+import { generateDpStrStep } from '@ray-js/panel-sdk/lib/utils';
+import { scheduleDpCodes } from '../../config/dpCodes';
+import { scheduleLogger as ScheduleLogger } from '../../utils/ScheduleLogger';
+import { numToBinStrPad8, numToHexPad2, numToHexPad4, numToBinStrPad } from '../utils';
+const {
+  CYCLE_TIMING
+} = scheduleDpCodes;
+const LENGTH = 16;
+class CycleTimerParser {
+  parser(dpValue) {
+    ScheduleLogger.debug(`CycleTimerParser dpValue: ${dpValue}`);
+    if (!dpValue) {
+      ScheduleLogger.warn(`无法解析数据, 请检查数据是否合规1【${CYCLE_TIMING}】: ${dpValue}`);
+      return {
+        version: 0,
+        length: LENGTH,
+        nodes: []
+      };
+    }
+    if (dpValue.length <= 4 || (dpValue.length - 4) % 32 !== 0) {
+      ScheduleLogger.warn(`节点数量不匹配, 请检查数据是否合规【${CYCLE_TIMING}】: ${dpValue}`);
+      return {
+        version: 0,
+        length: LENGTH,
+        nodes: []
+      };
+    }
+    const step = generateDpStrStep(dpValue);
+    const version = step().value;
+    const length = step().value;
+    // 节点数
+    const count = (dpValue.length - 4) / length / 2;
+    const nodes = [];
+    for (let i = 0; i < count; i++) {
+      const powerNum = step().value;
+      const powerInfo = numToBinStrPad8(powerNum);
+      const powerBits = powerInfo.split('');
+      const onOff = !!Number(powerBits[powerBits.length - 1]);
+      // 通道号
+      const channel = parseInt(powerBits.slice(1, powerBits.length - 1).join(''), 2);
+      const repeatInt = step(2).value; // 单次定时任务bit0-bit6全为0，bit0-bit6某位为1时，表示对应周几周期定时 bit0 => 周日
+      const loops = padEnd(repeatInt.toString(2).split('').reverse().join(''), 7, '0');
+      const startTime = step(4).value;
+      const endTime = step(4).value;
+      const startTimeDuration = step(4).value; // 开始时间持续时间，单位：s
+      const endTimeDuration = step(4).value; // 结束时间持续时间，单位：s
+
+      const hue = step(4).value;
+      const saturation = step().value;
+      const {
+        value
+      } = step();
+      const brightness = step().value;
+      const temperatureStep = step();
+      const temperature = temperatureStep.value;
+      const node = {
+        onOff,
+        channel,
+        loops,
+        startTime,
+        endTime,
+        startTimeDuration,
+        endTimeDuration,
+        index: i,
+        color: {
+          hue,
+          saturation,
+          value,
+          brightness,
+          temperature
+        }
+      };
+      nodes.push(node);
+      if (temperatureStep.done) {
+        break;
+      }
+    }
+    return {
+      version,
+      length,
+      nodes
+    };
+  }
+  formatter(data) {
+    const {
+      version,
+      nodes
+    } = data;
+    const versionStr = numToHexPad2(version);
+    const lengthStr = numToHexPad2(LENGTH);
+    const nodesStr = nodes.map(_ref => {
+      let {
+        onOff,
+        channel,
+        loops,
+        startTime,
+        startTimeDuration,
+        endTime,
+        endTimeDuration,
+        color
+      } = _ref;
+      const channelStr = numToBinStrPad(channel || 1, 7);
+      const powerChannel = parseInt(`${channelStr}${onOff ? 1 : 0}`, 2);
+      const powerChannelStr = numToHexPad2(powerChannel);
+      const weeksValue = padStart([...loops.split('')].reverse().join(''), 8, '0');
+      const weeksStr = numToHexPad2(parseInt(weeksValue, 2));
+      const startTimeStr = numToHexPad4(startTime);
+      const endTimeStr = numToHexPad4(endTime);
+      const startTimeDurationStr = numToHexPad4(startTimeDuration);
+      const endTimeDurationStr = numToHexPad4(endTimeDuration);
+      const {
+        hue,
+        saturation,
+        value,
+        brightness,
+        temperature
+      } = color;
+      const hueStr = numToHexPad4(hue);
+      const saturationStr = numToHexPad2(saturation);
+      const valueStr = numToHexPad2(value);
+      const brightnessStr = numToHexPad2(brightness);
+      const temperatureStr = numToHexPad2(temperature);
+      return `${powerChannelStr}${weeksStr}${startTimeStr}${endTimeStr}${startTimeDurationStr}${endTimeDurationStr}${hueStr}${saturationStr}${valueStr}${brightnessStr}${temperatureStr}`;
+    }).join('');
+    return `${versionStr}${lengthStr}${nodesStr}`;
+  }
+}
+export const cycleParser = new CycleTimerParser();
+export const getCycleParser = () => {
+  return cycleParser;
+};

package/lib/dpParser/index.d.ts

@@ -0,0 +1,23 @@
+/** dp 解析 */
+import { scheduleDpCodes } from '../config/dpCodes';
+export { randomParser, getRandomParser } from './random';
+export { rhythmParser, getRhythmParser } from './rhythms';
+export { sleepParserCommon as sleepParser, getSleepParser, SleepParser } from './sleep';
+export { rtcTimerParser, getRtcParser } from './rtcTimer';
+export { cycleParser, getCycleParser } from './cycle';
+export { wakeupParserCommon as wakeupParser, getWakeUpParser, WakeUpParser } from './wakeup';
+export { timerReportParser } from './timerReport';
+type DpCode = keyof typeof scheduleDpCodes;
+/**
+ * 自动匹配 dp 解析函数
+ *
+ * // 解析函数
+ * @returns {
+ *   parser: (dpValue: string) => Record<string, any>;
+ *   formatter: (dp: Record<string, any>) => string;
+ * }
+ */
+export declare const autoDispatchTransDpFun: (dpCode: DpCode | string) => {
+    parser: (dpValue: string) => any;
+    formatter: (dp: Record<string, any>) => string;
+} | null;

package/lib/dpParser/index.js

@@ -0,0 +1,43 @@
+/** dp 解析 */
+
+import { scheduleDpCodes } from '../config/dpCodes';
+import { randomParser } from './random';
+import { rhythmParser } from './rhythms';
+import { getSleepParser } from './sleep';
+import { rtcTimerParser } from './rtcTimer';
+import { timerReportParser } from './timerReport';
+import { getWakeUpParser } from './wakeup';
+export { randomParser, getRandomParser } from './random';
+export { rhythmParser, getRhythmParser } from './rhythms';
+export { sleepParserCommon as sleepParser, getSleepParser, SleepParser } from './sleep';
+export { rtcTimerParser, getRtcParser } from './rtcTimer';
+export { cycleParser, getCycleParser } from './cycle';
+export { wakeupParserCommon as wakeupParser, getWakeUpParser, WakeUpParser } from './wakeup';
+export { timerReportParser } from './timerReport';
+/**
+ * 自动匹配 dp 解析函数
+ *
+ * // 解析函数
+ * @returns {
+ *   parser: (dpValue: string) => Record<string, any>;
+ *   formatter: (dp: Record<string, any>) => string;
+ * }
+ */
+export const autoDispatchTransDpFun = dpCode => {
+  switch (dpCode) {
+    case scheduleDpCodes.RANDOM_TIMING:
+      return randomParser;
+    case scheduleDpCodes.RHYTHM_MODE:
+      return rhythmParser;
+    case scheduleDpCodes.SLEEP_MODE:
+      return getSleepParser();
+    case scheduleDpCodes.RTC_TIMER:
+      return rtcTimerParser;
+    case scheduleDpCodes.TIMER_REPORT:
+      return timerReportParser;
+    case scheduleDpCodes.WAKE_UP_MODE:
+      return getWakeUpParser();
+    default:
+      return null;
+  }
+};

package/lib/dpParser/random/index.d.ts

@@ -0,0 +1,15 @@
+import { TRandomData, TRandomNode } from '../../types';
+declare class RandomTimerParser {
+    parser(dpValue: string): TRandomData;
+    formatter(data: TRandomData): string;
+}
+export declare const randomParser: {
+    parser: (dpValue: string) => {
+        version: number;
+        length: number;
+        nodes: TRandomNode[];
+    };
+    formatter: (data: TRandomData) => string;
+};
+export declare const getRandomParser: () => RandomTimerParser;
+export {};

package/lib/dpParser/random/index.js

@@ -0,0 +1,127 @@
+import "core-js/modules/esnext.iterator.map.js";
+/* eslint-disable no-console */
+import padStart from 'lodash/padStart';
+import { generateDpStrStep } from '@ray-js/panel-sdk/lib/utils';
+import padEnd from 'lodash/padEnd';
+import { scheduleDpCodes } from '../../config/dpCodes';
+import { scheduleLogger as ScheduleLogger } from '../../utils/ScheduleLogger';
+import { numToBinStrPad8, numToHexPad2, numToHexPad4, numToBinStrPad } from '../utils';
+const {
+  RANDOM_TIMING
+} = scheduleDpCodes;
+const LENGTH = 12;
+class RandomTimerParser {
+  parser(dpValue) {
+    ScheduleLogger.debug(`RandomTimerParser dpValue: ${dpValue}`);
+    if (!dpValue) {
+      ScheduleLogger.warn(`无法解析数据, 请检查数据是否合规1【${RANDOM_TIMING}】: ${dpValue}`);
+      return {
+        version: 0,
+        length: LENGTH,
+        nodes: []
+      };
+    }
+    const step = generateDpStrStep(dpValue);
+    const version = step().value;
+    const length = step().value;
+    if (!dpValue || (dpValue.length - 4) % 24 !== 0) {
+      console.log('decodeRandomTask 数据有问题，无法解析');
+      // 返回默认值
+      return {
+        version: 0,
+        length: 12,
+        nodes: []
+      };
+    }
+    const nodes = [];
+    // 节点数
+    const count = (dpValue.length - 4) / LENGTH / 2;
+    for (let i = 0; i < count; i++) {
+      const powerNum = step().value;
+      const powerInfo = numToBinStrPad8(powerNum);
+      const powerBits = powerInfo.split('');
+      const onOff = !!Number(powerBits[powerBits.length - 1]);
+      // 通道号
+      const channel = parseInt(powerBits.slice(1, powerBits.length - 1).join(''), 2);
+      const repeatInt = step(2).value; // 单次定时任务bit0-bit6全为0，bit0-bit6某位为1时，表示对应周几周期定时 bit0 => 周日
+      const loops = padEnd(repeatInt.toString(2).split('').reverse().join(''), 7, '0');
+      const startTime = step(4).value;
+      const endTime = step(4).value;
+      const hue = step(4).value;
+      const saturation = step().value;
+      const {
+        value
+      } = step();
+      const brightness = step().value;
+      const temperatureStep = step();
+      const temperature = temperatureStep.value;
+      const node = {
+        onOff,
+        channel,
+        loops,
+        startTime,
+        endTime,
+        index: i,
+        color: {
+          hue,
+          saturation,
+          value,
+          brightness,
+          temperature
+        }
+      };
+      nodes.push(node);
+      if (temperatureStep.done) {
+        break;
+      }
+    }
+    return {
+      version,
+      length,
+      nodes
+    };
+  }
+  formatter(data) {
+    const {
+      version,
+      nodes
+    } = data;
+    const versionStr = numToHexPad2(version);
+    const lengthStr = numToHexPad2(LENGTH);
+    const nodesStr = nodes.map(_ref => {
+      let {
+        onOff,
+        channel,
+        loops,
+        startTime,
+        endTime,
+        color
+      } = _ref;
+      const channelStr = numToBinStrPad(channel || 1, 7);
+      const powerChannel = parseInt(`${channelStr}${onOff ? 1 : 0}`, 2);
+      const powerChannelStr = numToHexPad2(powerChannel);
+      const weeksValue = padStart([...loops.split('')].reverse().join(''), 8, '0');
+      const weeksStr = numToHexPad2(parseInt(weeksValue, 2));
+      const startTimeStr = numToHexPad4(startTime);
+      const endTimeStr = numToHexPad4(endTime);
+      const {
+        hue,
+        saturation,
+        value,
+        brightness,
+        temperature
+      } = color;
+      const hueStr = numToHexPad4(hue);
+      const saturationStr = numToHexPad2(saturation);
+      const valueStr = numToHexPad2(value);
+      const brightnessStr = numToHexPad2(brightness);
+      const temperatureStr = numToHexPad2(temperature);
+      return `${powerChannelStr}${weeksStr}${startTimeStr}${endTimeStr}${hueStr}${saturationStr}${valueStr}${brightnessStr}${temperatureStr}`;
+    }).join('');
+    return `${versionStr}${lengthStr}${nodesStr}`;
+  }
+}
+export const randomParser = new RandomTimerParser();
+export const getRandomParser = () => {
+  return randomParser;
+};

package/lib/dpParser/rhythms.d.ts

@@ -0,0 +1,41 @@
+import { TRhythmData } from '../types/rhythms';
+export default class RhythmFormatter {
+    uuid: string;
+    defaultValue: any;
+    constructor(uuid?: "rhythm_mode", defaultValue?: null);
+    parser(dpValue?: string): {
+        version: number;
+        power: boolean;
+        mode: number;
+        weeks: number[];
+        number: number;
+        rhythms: {
+            key: number;
+            version: number;
+            power: boolean;
+            mode: number;
+            weeks: number[];
+            number: number;
+            rhythms: {
+                power: boolean;
+                hour: number;
+                minute: number;
+                hue: number;
+                saturation: number;
+                value: number;
+                brightness: number;
+                temperature: number;
+            }[];
+        }[];
+    } | {
+        version: any;
+        power: boolean;
+        mode: any;
+        weeks: number[];
+        number: any;
+        rhythms: never[];
+    };
+    formatter(data: TRhythmData): string;
+}
+export declare const rhythmParser: RhythmFormatter;
+export declare const getRhythmParser: () => RhythmFormatter;