@ray-js/lamp-schedule-core 1.0.4-beta-15 → 1.0.5-beta.2

package/lib/config/dpCodes.d.ts

@@ -19,7 +19,7 @@ export declare const scheduleDpCodes: {
     readonly CYCLE_TIMING: "cycle_timing";
     /** 通用本地定时 */
     readonly LOCAL_TIMER: "local_timer";
-    /** 灯带本地定时 */
+    /** 灯带本地定时 Beacon */
     readonly STRIP_LOCAL_TIMER: "strip_local_timer";
     /** 定时同步 一般用于 Beacon */
     readonly TIMER_SYNC: "timer_sync";
@@ -33,6 +33,10 @@ export declare const scheduleDpCodes: {
     readonly BRIGHTNESS: "bright_value";
     /** 彩光 */
     readonly COLOUR_DATA: "colour_data";
+    /** 彩光原始数据 Beacon */
+    readonly COLOUR_DATA_RAW: "colour_data_raw";
+    /** 亮度调节 Beacon */
+    readonly BRIGHT_ADJUST_DATA: "bright_adjust_data";
     /** 模式 */
     readonly WORK_MODE: "work_mode";
 };

package/lib/config/dpCodes.js

@@ -22,7 +22,7 @@ export const scheduleDpCodes = {
   [EScheduleType.CYCLE_TIMING]: 'cycle_timing',
   /** 通用本地定时 */
   [EScheduleType.LOCAL_TIMER]: 'local_timer',
-  /** 灯带本地定时 */
+  /** 灯带本地定时 Beacon */
   [EScheduleType.STRIP_LOCAL_TIMER]: 'strip_local_timer',
   /** 定时同步 一般用于 Beacon */
   [EScheduleType.TIMER_SYNC]: 'timer_sync',
@@ -36,6 +36,10 @@ export const scheduleDpCodes = {
   BRIGHTNESS: 'bright_value',
   /** 彩光 */
   COLOUR_DATA: 'colour_data',
+  /** 彩光原始数据 Beacon */
+  COLOUR_DATA_RAW: 'colour_data_raw',
+  /** 亮度调节 Beacon */
+  BRIGHT_ADJUST_DATA: 'bright_adjust_data',
   /** 模式 */
   WORK_MODE: 'work_mode'
 };

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

@@ -71,7 +71,9 @@ describe('RhythmParser', () => {
       expect(result).toBe('');
     });
     it('should return empty string when support instance is missing', () => {
-      getSupportIns.mockReturnValueOnce(null);
+      // getSupportIns is called in both the dispatcher and the common formatter,
+      // so we need to mock it for all calls within this test
+      getSupportIns.mockReturnValue(null);
       const result = rhythmParser.formatter({
         version: 1,
         power: true,
@@ -91,9 +93,12 @@ describe('RhythmParser', () => {
       });
       expect(result).toBe('');
       expect(scheduleLogger.error).toHaveBeenCalledWith('协议解析 rhythms formatter =====', '数据为空');
+      // Restore default mock
+      getSupportIns.mockReturnValue(createSupport(true));
     });
     it('should force temperature to 100 when device does not support temperature DP', () => {
-      getSupportIns.mockReturnValueOnce(createSupport(false));
+      // getSupportIns is called in both the dispatcher and the common formatter
+      getSupportIns.mockReturnValue(createSupport(false));
       const result = rhythmParser.formatter({
         version: 0,
         power: true,

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

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

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

@@ -0,0 +1,263 @@
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.map.js";
+jest.mock('@ray-js/panel-sdk/lib/utils', () => ({
+  generateDpStrStep: jest.fn(str => {
+    let index = 0;
+    return len => {
+      const segment = str.slice(index, index + len);
+      index += len;
+      return {
+        value: parseInt(segment, 16)
+      };
+    };
+  }),
+  numToHexString: jest.fn(num => num.toString(16).padStart(2, '0'))
+}));
+jest.mock('../../utils/ScheduleLogger', () => {
+  const logger = {
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    info: jest.fn()
+  };
+  return {
+    scheduleLogger: logger
+  };
+});
+jest.mock('../../hooks/useCommonSupport', () => ({
+  getSupportIns: jest.fn()
+}));
+jest.mock('../../utils/getDPByProtocol', () => ({
+  getDPByProtocol: jest.fn().mockReturnValue({
+    TEMPERATURE: 'temp_value'
+  })
+}));
+import { rhythmParserSigmesh, RhythmSigmesh } from '../rhythms/rhythmsSigmesh';
+const {
+  getSupportIns
+} = require('../../hooks/useCommonSupport');
+const createSupport = function () {
+  let isSupportTemp = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+  return {
+    isSigMeshDevice: jest.fn().mockReturnValue(true),
+    isSupportDp: jest.fn().mockImplementation(dp => {
+      if (dp === 'temp_value') {
+        return isSupportTemp;
+      }
+      return true;
+    })
+  };
+};
+
+/**
+ * 构建 sigmesh rhythms DP 字符串
+ * 格式: version(2) + power(2) + mode(2) + weeks(2) + paramMode(2) + number(2)
+ *       + nodes[valid(2) + hour(2) + minute(2) + brightness(2) + temperature(2)]
+ */
+const buildDpStr = function (nodes) {
+  let version = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+  let power = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+  let mode = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 0;
+  let weeks = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : 0x7f;
+  let paramMode = arguments.length > 5 && arguments[5] !== undefined ? arguments[5] : 1;
+  const header = [version, power, mode, weeks, paramMode, nodes.length].map(v => v.toString(16).padStart(2, '0')).join('');
+  const body = nodes.map(node => [node.valid, node.hour, node.minute, node.brightness, node.temperature].map(v => v.toString(16).padStart(2, '0')).join('')).join('');
+  return `${header}${body}`;
+};
+describe('RhythmSigmesh parser & formatter', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    getSupportIns.mockReturnValue(createSupport(true));
+  });
+  describe('parser', () => {
+    it('returns default value when dp string is empty', () => {
+      const result = rhythmParserSigmesh.parser('');
+      expect(result).toEqual(new RhythmSigmesh().defaultValue);
+    });
+    it('returns default value when dp string length is invalid', () => {
+      // Too short
+      const result = rhythmParserSigmesh.parser('010100');
+      expect(result).toEqual(new RhythmSigmesh().defaultValue);
+    });
+    it('returns default value when node data is not aligned', () => {
+      // Header (12 chars) + partial node data (not multiple of 10)
+      // 14 chars header + 2 chars body (not 10)
+      const result = rhythmParserSigmesh.parser('01010000007f0104' + '01');
+      expect(result).toEqual(new RhythmSigmesh().defaultValue);
+    });
+    it('parses valid dp string with 4 nodes', () => {
+      const dpStr = buildDpStr([{
+        valid: 1,
+        hour: 6,
+        minute: 30,
+        brightness: 100,
+        temperature: 50
+      }, {
+        valid: 1,
+        hour: 11,
+        minute: 30,
+        brightness: 100,
+        temperature: 100
+      }, {
+        valid: 1,
+        hour: 17,
+        minute: 0,
+        brightness: 70,
+        temperature: 50
+      }, {
+        valid: 1,
+        hour: 20,
+        minute: 30,
+        brightness: 70,
+        temperature: 50
+      }]);
+      const result = rhythmParserSigmesh.parser(dpStr);
+      expect(result.version).toBe(1);
+      expect(result.power).toBe(true);
+      expect(result.mode).toBe(0);
+      expect(result.paramMode).toBe(1);
+      expect(result.number).toBe(4);
+      expect(result.rhythms).toHaveLength(4);
+      expect(result.rhythms[0]).toMatchObject({
+        power: true,
+        hour: 6,
+        minute: 30,
+        brightness: 100,
+        temperature: 50
+      });
+      expect(result.rhythms[3]).toMatchObject({
+        power: true,
+        hour: 20,
+        minute: 30,
+        brightness: 70,
+        temperature: 50
+      });
+    });
+    it('parses power=false correctly', () => {
+      const dpStr = buildDpStr([{
+        valid: 0,
+        hour: 8,
+        minute: 0,
+        brightness: 50,
+        temperature: 30
+      }], 1, 0);
+      const result = rhythmParserSigmesh.parser(dpStr);
+      expect(result.power).toBe(false);
+      expect(result.rhythms[0].power).toBe(false);
+    });
+  });
+  describe('formatter', () => {
+    it('returns empty string when data is null', () => {
+      const result = rhythmParserSigmesh.formatter(null);
+      expect(result).toBe('');
+    });
+    it('returns empty string when support is null', () => {
+      getSupportIns.mockReturnValueOnce(null);
+      const result = rhythmParserSigmesh.formatter({
+        version: 1,
+        power: true,
+        mode: 0,
+        weeks: [1, 1, 1, 1, 1, 1, 1, 0],
+        paramMode: 1,
+        number: 1,
+        rhythms: [{
+          power: true,
+          hour: 6,
+          minute: 30,
+          brightness: 100,
+          temperature: 50
+        }]
+      });
+      expect(result).toBe('');
+    });
+    it('formats valid data to dp string', () => {
+      const result = rhythmParserSigmesh.formatter({
+        version: 1,
+        power: true,
+        mode: 0,
+        weeks: [1, 1, 1, 1, 1, 1, 1, 0],
+        paramMode: 1,
+        number: 2,
+        rhythms: [{
+          power: true,
+          hour: 6,
+          minute: 30,
+          brightness: 100,
+          temperature: 50
+        }, {
+          power: false,
+          hour: 20,
+          minute: 0,
+          brightness: 70,
+          temperature: 30
+        }]
+      });
+      const expected = buildDpStr([{
+        valid: 1,
+        hour: 6,
+        minute: 30,
+        brightness: 100,
+        temperature: 50
+      }, {
+        valid: 0,
+        hour: 20,
+        minute: 0,
+        brightness: 70,
+        temperature: 30
+      }], 1, 1, 0, 0x7f, 1);
+      expect(result).toBe(expected);
+    });
+    it('forces temperature to 100 when device does not support temperature DP', () => {
+      getSupportIns.mockReturnValueOnce(createSupport(false));
+      const result = rhythmParserSigmesh.formatter({
+        version: 1,
+        power: true,
+        mode: 0,
+        weeks: [1, 1, 1, 1, 1, 1, 1, 0],
+        paramMode: 1,
+        number: 1,
+        rhythms: [{
+          power: true,
+          hour: 6,
+          minute: 0,
+          brightness: 50,
+          temperature: 30
+        }]
+      });
+      // temperature should be 100 (0x64), not 30 (0x1e)
+      expect(result.slice(-2)).toBe('64');
+    });
+  });
+  describe('round-trip', () => {
+    it('round-trips dp string through parser and formatter', () => {
+      const dpStr = buildDpStr([{
+        valid: 1,
+        hour: 6,
+        minute: 30,
+        brightness: 100,
+        temperature: 50
+      }, {
+        valid: 1,
+        hour: 11,
+        minute: 30,
+        brightness: 100,
+        temperature: 100
+      }, {
+        valid: 1,
+        hour: 17,
+        minute: 0,
+        brightness: 70,
+        temperature: 50
+      }, {
+        valid: 1,
+        hour: 20,
+        minute: 30,
+        brightness: 70,
+        temperature: 50
+      }]);
+      const parsed = rhythmParserSigmesh.parser(dpStr);
+      const formatted = rhythmParserSigmesh.formatter(parsed);
+      expect(formatted).toBe(dpStr);
+    });
+  });
+});

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

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

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

@@ -0,0 +1,183 @@
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.map.js";
+jest.mock('@ray-js/panel-sdk/lib/utils', () => ({
+  generateDpStrStep: jest.fn(str => {
+    let index = 0;
+    return len => {
+      const segment = str.slice(index, index + len);
+      index += len;
+      return {
+        value: parseInt(segment, 16)
+      };
+    };
+  }),
+  numToHexString: jest.fn(num => num.toString(16).padStart(2, '0'))
+}));
+import { sleepParserSigmesh, SleepSigmesh } from '../sleep/sleepSigmesh';
+const loopsToHex = loops => {
+  const binary = loops.split('').reverse().join('');
+  return parseInt(binary, 2);
+};
+
+/**
+ * 构建 sigmesh sleep DP 字符串
+ * 格式: version(2) + dataMode(2) + length(2) + nodes[onOff(2) + loops(2) + step(2) + hour(2) + minute(2) + brightness(2) + temperature(2)]
+ * 注意: sleep 模式不含 duration 字段（与 wakeup 的区别）
+ */
+const buildDpStr = function (nodes) {
+  let version = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1;
+  let dataMode = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 1;
+  const header = [version, dataMode, nodes.length].map(v => v.toString(16).padStart(2, '0')).join('');
+  const body = nodes.map(node => [node.onOff, node.loops, node.step, node.hour, node.minute, node.brightness, node.temperature].map(v => v.toString(16).padStart(2, '0')).join('')).join('');
+  return `${header}${body}`;
+};
+describe('SleepSigmesh parser & formatter', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  it('returns default value when dp string is empty', () => {
+    expect(sleepParserSigmesh.parser('')).toEqual(new SleepSigmesh().defaultValue);
+  });
+  it('returns default value when dp string length invalid', () => {
+    // header + incomplete node data (not multiple of 14 after header)
+
+    expect(sleepParserSigmesh.parser('01020112345')).toEqual(new SleepSigmesh().defaultValue);
+  });
+  it('parses valid dp string into nodes', () => {
+    const nodes = [{
+      onOff: 1,
+      loops: loopsToHex('1000000'),
+      step: 3,
+      hour: 6,
+      minute: 30,
+      brightness: 80,
+      temperature: 90
+    }, {
+      onOff: 0,
+      loops: loopsToHex('0100000'),
+      step: 5,
+      hour: 7,
+      minute: 45,
+      brightness: 60,
+      temperature: 70
+    }];
+    const dpStr = buildDpStr(nodes, 1, 2);
+    const result = sleepParserSigmesh.parser(dpStr);
+    expect(result.version).toBe(1);
+    expect(result.dataMode).toBe(2);
+    expect(result.length).toBe(2);
+    expect(result.nodes).toHaveLength(2);
+    expect(result.nodes[0]).toMatchObject({
+      onOff: true,
+      loops: '1000000',
+      step: 3,
+      hour: 6,
+      minute: 30,
+      brightness: 80,
+      temperature: 90,
+      index: 0
+    });
+    expect(result.nodes[1]).toMatchObject({
+      onOff: false,
+      loops: '0100000',
+      step: 5,
+      hour: 7,
+      minute: 45,
+      brightness: 60,
+      temperature: 70,
+      index: 1
+    });
+  });
+  it('does NOT parse duration field (sleep has no duration)', () => {
+    const nodes = [{
+      onOff: 1,
+      loops: loopsToHex('1111111'),
+      step: 2,
+      hour: 22,
+      minute: 0,
+      brightness: 50,
+      temperature: 30
+    }];
+    const dpStr = buildDpStr(nodes, 1, 1);
+    const result = sleepParserSigmesh.parser(dpStr);
+
+    // The parsed node should NOT have a duration field
+    expect(result.nodes[0]).not.toHaveProperty('duration');
+    expect(result.nodes).toHaveLength(1);
+  });
+  it('formats nodes back to dp string', () => {
+    const result = sleepParserSigmesh.formatter({
+      version: 1,
+      dataMode: '03',
+      length: 1,
+      nodes: [{
+        onOff: true,
+        loops: '1000000',
+        step: 10,
+        hour: 5,
+        minute: 15,
+        brightness: 90,
+        temperature: 50,
+        index: 0
+      }]
+    });
+    expect(result).toBe(buildDpStr([{
+      onOff: 1,
+      loops: loopsToHex('1000000'),
+      step: 10,
+      hour: 5,
+      minute: 15,
+      brightness: 90,
+      temperature: 50
+    }], 1, 3));
+  });
+  it('round-trips dp string through parser and formatter', () => {
+    const nodes = [{
+      onOff: 1,
+      loops: loopsToHex('1111111'),
+      step: 2,
+      hour: 12,
+      minute: 0,
+      brightness: 100,
+      temperature: 40
+    }];
+    const dpStr = buildDpStr(nodes, 2, 3);
+    const parsed = sleepParserSigmesh.parser(dpStr);
+    const formatted = sleepParserSigmesh.formatter(parsed);
+    expect(formatted).toBe(dpStr);
+  });
+  it('handles multiple nodes correctly', () => {
+    const nodes = [{
+      onOff: 1,
+      loops: loopsToHex('1010101'),
+      step: 1,
+      hour: 21,
+      minute: 30,
+      brightness: 80,
+      temperature: 60
+    }, {
+      onOff: 1,
+      loops: loopsToHex('0101010'),
+      step: 4,
+      hour: 22,
+      minute: 0,
+      brightness: 40,
+      temperature: 20
+    }, {
+      onOff: 0,
+      loops: loopsToHex('0000000'),
+      step: 6,
+      hour: 23,
+      minute: 15,
+      brightness: 10,
+      temperature: 100
+    }];
+    const dpStr = buildDpStr(nodes, 1, 1);
+    const parsed = sleepParserSigmesh.parser(dpStr);
+    expect(parsed.nodes).toHaveLength(3);
+    expect(parsed.nodes[2].onOff).toBe(false);
+    expect(parsed.nodes[2].brightness).toBe(10);
+    const formatted = sleepParserSigmesh.formatter(parsed);
+    expect(formatted).toBe(dpStr);
+  });
+});

package/lib/dpParser/brightAdjustData.d.ts

@@ -0,0 +1,10 @@
+import { TBrightAdjustData } from '../types';
+export declare class BrightAdjustDataFormatter {
+    parser(dpValue: string): TBrightAdjustData;
+    formatter(data: TBrightAdjustData): string;
+}
+export declare const brightAdjustDataParser: {
+    parser: (dpValue: string) => TBrightAdjustData;
+    formatter: (data: TBrightAdjustData) => string;
+};
+export declare const getBrightAdjustDataParser: () => BrightAdjustDataFormatter;

package/lib/dpParser/brightAdjustData.js

@@ -0,0 +1,43 @@
+/* eslint-disable no-console */
+
+import { scheduleLogger as ScheduleLogger } from '../utils/ScheduleLogger';
+export class BrightAdjustDataFormatter {
+  parser(dpValue) {
+    try {
+      ScheduleLogger.debug('dpParser ===> BrightAdjustDataFormatter parser dpValue:', dpValue);
+      if (!dpValue || dpValue.length < 6) {
+        return {
+          mode: 0,
+          brightness: 0
+        };
+      }
+      const mode = parseInt(dpValue.substring(0, 2), 16);
+      const brightness = parseInt(dpValue.substring(2, 6), 16);
+      return {
+        mode,
+        brightness
+      };
+    } catch (error) {
+      ScheduleLogger.error('dpParser ===> BrightAdjustDataFormatter parser error:', error);
+      return {
+        mode: 0,
+        brightness: 0
+      };
+    }
+  }
+  formatter(data) {
+    try {
+      ScheduleLogger.debug('dpParser ===> BrightAdjustDataFormatter formatter data:', data);
+      const modeStr = data.mode.toString(16).padStart(2, '0');
+      const brightnessStr = data.brightness.toString(16).padStart(4, '0');
+      return `${modeStr}${brightnessStr}`;
+    } catch (error) {
+      ScheduleLogger.error('dpParser ===> BrightAdjustDataFormatter formatter error:', error);
+      return '';
+    }
+  }
+}
+export const brightAdjustDataParser = new BrightAdjustDataFormatter();
+export const getBrightAdjustDataParser = () => {
+  return brightAdjustDataParser;
+};

package/lib/dpParser/colourDataRaw.d.ts

@@ -0,0 +1,14 @@
+import { TColourDataRaw } from '../types';
+export declare class ColourDataRawFormatter {
+    parser(dpValue: string): TColourDataRaw;
+    formatter(data: {
+        hue: number;
+        saturation: number;
+        value: number;
+    } | TColourDataRaw): string;
+}
+export declare const colourDataRawParser: {
+    parser: (dpValue: string) => TColourDataRaw;
+    formatter: (data: any) => string;
+};
+export declare const getColourDataRawParser: () => ColourDataRawFormatter;

package/lib/dpParser/colourDataRaw.js

@@ -0,0 +1,56 @@
+/* eslint-disable no-console */
+import { numToHexString } from '@ray-js/panel-sdk/lib/utils';
+import { scheduleLogger as ScheduleLogger } from '../utils/ScheduleLogger';
+const toHex = function (value) {
+  let len = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 2;
+  return numToHexString(value).padStart(len, '0');
+};
+export class ColourDataRawFormatter {
+  parser(dpValue) {
+    try {
+      ScheduleLogger.debug('dpParser ===> ColourDataRawFormatter parser dpValue:', dpValue);
+      if (!dpValue || dpValue.length < 8) {
+        return {
+          hue: 0,
+          saturation: 1000,
+          value: 1000
+        };
+      }
+      const hue = parseInt(dpValue.substring(0, 4), 16);
+      const saturation = parseInt(dpValue.substring(4, 6), 16) * 10;
+      const value = parseInt(dpValue.substring(6, 8), 16) * 10;
+      return {
+        hue,
+        saturation,
+        value
+      };
+    } catch (error) {
+      ScheduleLogger.error('dpParser ===> ColourDataRawFormatter parser error:', error);
+      return {
+        hue: 0,
+        saturation: 1000,
+        value: 1000
+      };
+    }
+  }
+  formatter(data) {
+    try {
+      ScheduleLogger.debug('dpParser ===> ColourDataRawFormatter formatter data:', data);
+      // 兼容两种数据格式: { hue, saturation, value } 或 { h, s, v }
+      const h = 'hue' in data ? data.hue : data.h;
+      const s = 'saturation' in data ? data.saturation : data.s;
+      const v = 'value' in data ? data.value : data.v;
+      const hStr = toHex(Math.floor(h), 4);
+      const sStr = toHex(Math.floor(s / 10), 2);
+      const vStr = toHex(Math.floor(v / 10), 2);
+      return `${hStr}${sStr}${vStr}`;
+    } catch (error) {
+      ScheduleLogger.error('dpParser ===> ColourDataRawFormatter formatter error:', error);
+      return '';
+    }
+  }
+}
+export const colourDataRawParser = new ColourDataRawFormatter();
+export const getColourDataRawParser = () => {
+  return colourDataRawParser;
+};

package/lib/dpParser/index.d.ts

@@ -2,11 +2,14 @@
 import { scheduleDpCodes } from '../config/dpCodes';
 export { randomParser, getRandomParser } from './random';
 export { rhythmParser, getRhythmParser } from './rhythms';
-export { sleepParserCommon as sleepParser, getSleepParser, SleepParser } from './sleep';
+export { sleepParserCommon as sleepParser, getSleepParser, SleepParser, sleepParserSigmesh, } from './sleep';
 export { rtcTimerParser, getRtcParser } from './rtcTimer';
 export { cycleParser, getCycleParser } from './cycle';
 export { wakeupParserCommon as wakeupParser, getWakeUpParser, WakeUpParser } from './wakeup';
 export { timerReportParser } from './timerReport';
+export { stripLocalTimerParser, getStripLocalTimerParser } from './stripLocalTimer';
+export { brightAdjustDataParser, getBrightAdjustDataParser } from './brightAdjustData';
+export { colourDataRawParser, getColourDataRawParser } from './colourDataRaw';
 type DpCode = keyof typeof scheduleDpCodes;
 /**
  * 自动匹配 dp 解析函数