@ray-js/lamp-schedule-core 1.0.1-beta-10 → 1.0.2-beta-1

package/lib/conflict/ConflictResolver.js

@@ -62,18 +62,28 @@ function doRangesOverlap(aStart, aEnd, bStart, bEnd) {
     return true;
   }
 
-  // 情况2: 两个范围都跨天
-  // 当两个范围都跨天时，它们一定会重叠，因为都覆盖了午夜时间点
-  if (aIsCrossDay && bIsCrossDay) {
+  // 情况2: 单时间点的特殊处理
+  // 如果两个时间范围都是单点（开始等于结束），且时间点相同，则认为冲突
+  if (aStartMin === aEndMin && bStartMin === bEndMin && aStartMin === bStartMin) {
     return true;
   }
 
-  // 情况3: 一个范围跨天，一个不跨天
-  // 这种情况下，我们已经将跨天范围标准化为连续分钟数
-  // 所以可以直接使用标准区间重叠判断
+  // 情况3: 单点与时间范围的重叠判断
+  // 如果一个是单点，一个是范围，单点在范围内（包含边界）则冲突
+  if (aStartMin === aEndMin) {
+    // a是单点，判断是否在b范围内（考虑跨天场景）
+    const normalizedPoint = bIsCrossDay && aStartMin < bStartMin ? aStartMin + 1440 : aStartMin;
+    return normalizedPoint >= bStartMin && normalizedPoint <= bEndMin;
+  }
+  if (bStartMin === bEndMin) {
+    // b是单点，判断是否在a范围内（考虑跨天场景）
+    const normalizedPoint = aIsCrossDay && bStartMin < aStartMin ? bStartMin + 1440 : bStartMin;
+    return normalizedPoint >= aStartMin && normalizedPoint <= aEndMin;
+  }
 
-  // 情况4: 两个范围都不跨天
+  // 情况4: 标准区间重叠判断
   // 使用标准区间重叠判断: [a1,a2] 和 [b1,b2] 重叠当且仅当 a2 > b1 && b2 > a1
+  // 注意：这里已经处理了跨天情况（通过标准化为连续分钟数）
   return aEndMin > bStartMin && bEndMin > aStartMin;
 }
 
@@ -127,18 +137,39 @@ function convertToTimeRanges(schedules) {
           const endMinutes = parseTimeToMinutes(endTime);
           const isCrossDay = endMinutes < startMinutes;
 
-          // 如果定时状态为关闭，则设置星期，忽略冲突判断
-          const dayOfWeek = daysOfWeek[isCrossDay ? (week + 1) % 7 : week];
-          return [{
+          // 单次任务使用当前星期
+          const currentDayOfWeek = daysOfWeek[week];
+          const result = [];
+
+          // 添加当天的时间范围
+          result.push({
             id: schedule.id,
             type: schedule.type,
-            dayOfWeek: dayOfWeek,
+            dayOfWeek: currentDayOfWeek,
             status: schedule.data.status,
             startMinutes,
             endMinutes,
             originalSchedule: schedule,
             isCrossDay
-          }];
+          });
+
+          // 如果是跨天任务，还需要添加下一天的时间范围（从午夜到结束时间）
+          if (isCrossDay) {
+            const nextDayOfWeek = daysOfWeek[(week + 1) % 7];
+            result.push({
+              id: schedule.id,
+              type: schedule.type,
+              dayOfWeek: nextDayOfWeek,
+              status: schedule.data.status,
+              startMinutes: 0,
+              // 从午夜开始
+              endMinutes: endMinutes,
+              // 到结束时间
+              originalSchedule: schedule,
+              isCrossDay: false // 这部分不再是跨天
+            });
+          }
+          return result;
         } catch (error) {
           scheduleLogger.error('Error processing single task:', error, schedule);
           return [];
@@ -252,21 +283,17 @@ export function checkConflicts(scheduleList, currentSchedule) {
     scheduleLogger.debug('checkConflicts otherRanges:', otherRanges);
     currentRanges.forEach(current => {
       otherRanges.forEach(other => {
-        var _rule$shouldIgnore, _current$originalSche, _current$originalSche2;
+        var _rule$shouldIgnore, _current$originalSche;
         // 应用规则中的忽略条件
         if ((_rule$shouldIgnore = rule.shouldIgnore) !== null && _rule$shouldIgnore !== void 0 && _rule$shouldIgnore.call(rule, current, other)) {
           return;
         }
         const currentPreId = current === null || current === void 0 || (_current$originalSche = current.originalSchedule) === null || _current$originalSche === void 0 ? void 0 : _current$originalSche.prevId;
-        const currentId = current === null || current === void 0 || (_current$originalSche2 = current.originalSchedule) === null || _current$originalSche2 === void 0 ? void 0 : _current$originalSche2.id;
         const otherId = other.id;
-        // 针对定时，如果当前定时自身修改 且 与自身冲突  则忽略
-        if (currentPreId && currentId === currentPreId && current.type === 'timer') {
-          return;
-        }
-        // FIXME:还是存在bug
-        // 如果当前定时自身修改 且 与自身冲突 并且其他定时不等于当前定时id 则忽略
-        if (currentPreId && currentId === currentPreId && otherId !== currentId) {
+
+        // 如果是更新操作，忽略与旧版本自身的冲突判断
+        // 这里通过 prevId 来标识这是一个更新操作，并且要忽略与旧版本的冲突
+        if (currentPreId && otherId === currentPreId) {
           return;
         }
         if (current.dayOfWeek && current.status && other.status && current.dayOfWeek === other.dayOfWeek && rule.isConflict(current, other)) {

package/lib/conflict/__test__/ConflictResolver.test.js

@@ -88,6 +88,55 @@ describe('ConflictResolver', () => {
       const conflicts = checkConflicts([schedule1], schedule2);
       expect(conflicts.length).toBe(1);
     });
+    it('should detect conflicts when cross-day range overlaps single point schedule', () => {
+      const crossDaySchedule = {
+        id: 'timer_1',
+        type: EScheduleFunctionType.TIMER,
+        data: {
+          status: true,
+          weeks: [1, 0, 0, 0, 0, 0, 0],
+          startTime: '23:00',
+          endTime: '01:00'
+        }
+      };
+      const singlePointSchedule = {
+        id: 'timer_2',
+        type: EScheduleFunctionType.TIMER,
+        data: {
+          status: true,
+          weeks: [0, 1, 0, 0, 0, 0, 0],
+          startTime: '00:30',
+          endTime: '00:30'
+        }
+      };
+      const conflicts = checkConflicts([crossDaySchedule], singlePointSchedule);
+      expect(conflicts.length).toBe(1);
+      expect(conflicts[0].other).toBe(crossDaySchedule);
+    });
+    it('should not detect conflicts when single point lies outside cross-day range', () => {
+      const crossDaySchedule = {
+        id: 'timer_1',
+        type: EScheduleFunctionType.TIMER,
+        data: {
+          status: true,
+          weeks: [1, 0, 0, 0, 0, 0, 0],
+          startTime: '23:00',
+          endTime: '01:00'
+        }
+      };
+      const singlePointSchedule = {
+        id: 'timer_2',
+        type: EScheduleFunctionType.TIMER,
+        data: {
+          status: true,
+          weeks: [0, 1, 0, 0, 0, 0, 0],
+          startTime: '01:30',
+          endTime: '01:30'
+        }
+      };
+      const conflicts = checkConflicts([crossDaySchedule], singlePointSchedule);
+      expect(conflicts.length).toBe(0);
+    });
 
     // 测试关闭状态的计划不会产生冲突
     it('should not detect conflicts with schedules that are turned off', () => {

package/lib/conflict/__test__/scheduleDataManager.test.js

@@ -100,6 +100,72 @@ describe('ScheduleDataManager', () => {
     expect(data.length).toBe(1);
     expect(data[0]).toEqual(schedule2); // 应该是更新后的数据
   });
+  it('should keep only the latest item when duplicate ids are provided in one call', () => {
+    const instance = ScheduleDataManager.getInstance();
+    const first = {
+      id: 'dup',
+      type: EScheduleFunctionType.TIMER,
+      data: {
+        status: true,
+        weeks: [1, 0, 0, 0, 0, 0, 0],
+        startTime: '08:00',
+        endTime: '08:30'
+      }
+    };
+    const second = {
+      id: 'dup',
+      type: EScheduleFunctionType.TIMER,
+      data: {
+        status: true,
+        weeks: [1, 0, 0, 0, 0, 0, 0],
+        startTime: '09:00',
+        endTime: '09:30'
+      }
+    };
+    instance.setData([first, second]);
+    const data = instance.getData();
+    expect(data.length).toBe(1);
+    expect(data[0]).toEqual(second);
+  });
+  it('should flatten nested arrays and deduplicate by id with last occurrence winning', () => {
+    const instance = ScheduleDataManager.getInstance();
+    const version1 = {
+      id: 'nested',
+      type: EScheduleFunctionType.TIMER,
+      data: {
+        status: true,
+        weeks: [1, 0, 0, 0, 0, 0, 0],
+        startTime: '07:00',
+        endTime: '07:30'
+      }
+    };
+    const version2 = {
+      id: 'nested',
+      type: EScheduleFunctionType.TIMER,
+      data: {
+        status: true,
+        weeks: [1, 0, 0, 0, 0, 0, 0],
+        startTime: '10:00',
+        endTime: '10:30'
+      }
+    };
+    const another = {
+      id: 'another',
+      type: EScheduleFunctionType.TIMER,
+      data: {
+        status: true,
+        weeks: [0, 1, 0, 0, 0, 0, 0],
+        startTime: '12:00',
+        endTime: '12:30'
+      }
+    };
+    instance.setData([[version1], [version2, another]]);
+    const data = instance.getData();
+    expect(data.length).toBe(2);
+    expect(data).toContainEqual(version2);
+    expect(data).toContainEqual(another);
+    expect(data).not.toContainEqual(version1);
+  });
 
   // 测试清空数据
   it('should clear all data', () => {

package/lib/conflict/__test__/transform.test.js

@@ -48,7 +48,11 @@ describe('transform', () => {
         status: true,
         weeks: [1, 0, 0, 0, 0, 0, 0],
         startTime: '10:00',
-        endTime: '10:00'
+        endTime: '10:00',
+        dps: {},
+        aliasName: 'aliasName',
+        isAppPush: false,
+        id: '1'
       });
       expect(result.id).toMatch(/^timer_/);
     });

package/lib/conflict/index.js

@@ -30,6 +30,13 @@ export class Conflict {
     const instance = ScheduleDataManager.getInstance();
     const preList = instance.getData() || [];
     const [cur] = transScheduleListToConflictList([current]);
+    if (!cur) {
+      scheduleLogger.error('Conflict.add: 无法转换当前日程', current);
+      return {
+        isConflict: false,
+        conflictList: []
+      };
+    }
     scheduleLogger.debug('Conflict.add cur, current:', cur, current);
     const conflictList = checkConflicts(preList, cur, Conflict.rule);
     const isConflict = conflictList.length > 0;
@@ -69,17 +76,30 @@ export class Conflict {
     const instance = ScheduleDataManager.getInstance();
     const [cur, prev] = transScheduleListToConflictList([current, prevSchedule]);
     scheduleLogger.debug('Conflict.update1:', cur, prev);
+
+    // 先删除旧数据，避免在冲突检测时干扰
     const preList = instance.getData() || [];
-    const _current = _objectSpread(_objectSpread({}, cur), {}, {
+    let preItem;
+    if (prev && prev.id) {
+      preItem = preList.find(i => i.id === prev.id);
+      if (preItem) {
+        instance.deleteData(preItem);
+      }
+    }
+
+    // 使用清理后的列表进行冲突检测
+    const updatedPreList = instance.getData() || [];
+    const _current = _objectSpread(_objectSpread({}, cur), prev && prev.id ? {
       prevId: prev.id
-    });
-    const conflictList = checkConflicts(preList, _current, Conflict.rule);
+    } : {});
+    const conflictList = checkConflicts(updatedPreList, _current, Conflict.rule);
     const isConflict = conflictList.length > 0;
-    if (!isConflict && prev) {
-      //  如果没有冲突说明可以更新，需要删除之前的项，防止之前项目一致存在影响正常判断冲突
-      const preItem = preList.find(i => i.id === prev.id);
-      preItem && instance.deleteData(preItem);
+    if (!isConflict) {
+      // 如果没有冲突，添加新数据
       instance.setData(_current);
+    } else if (preItem) {
+      // 如果有冲突，恢复旧数据
+      instance.setData(preItem);
     }
     return {
       isConflict,

package/lib/conflict/scheduleDataManager.js

@@ -18,42 +18,37 @@ export class ScheduleDataManager {
       return;
     }
 
-    // 创建一个新的列表，而不是修改现有列表
-    let newList = [...ScheduleDataManager.list];
-    if (Array.isArray(value)) {
-      value.forEach(item => {
-        if (Array.isArray(item)) {
-          item.forEach(_item => {
-            if (!_item || !_item.id) {
-              return;
-            }
-            // 如果跟之前id相同需要先删除
-            newList = newList.filter(i => i.id !== _item.id);
-            // 添加新项
-            newList.push(_item);
-          });
-        } else {
-          if (!item || !item.id) {
-            return;
-          }
-          // 如果跟之前id相同需要先删除
-          newList = newList.filter(i => i.id !== item.id);
-          // 添加新项
-          newList.push(item);
-        }
-      });
-    } else {
-      if (!value || !value.id) {
+    // 收集所有要处理的项目，并按照最后一次出现的顺序去重
+    const itemsMap = new Map();
+    const addItem = item => {
+      if (!item || !item.id) {
         return;
       }
-      // 如果跟之前id相同需要先删除
-      newList = newList.filter(i => i.id !== value.id);
-      // 添加新项
-      newList.push(value);
+      if (itemsMap.has(item.id)) {
+        itemsMap.delete(item.id);
+      }
+      itemsMap.set(item.id, item);
+    };
+    const collectItems = input => {
+      if (Array.isArray(input)) {
+        input.forEach(subItem => {
+          if (Array.isArray(subItem)) {
+            collectItems(subItem);
+          } else {
+            addItem(subItem);
+          }
+        });
+      } else {
+        addItem(input);
+      }
+    };
+    collectItems(value);
+    if (itemsMap.size === 0) {
+      return;
     }
-
-    // 更新列表
-    ScheduleDataManager.list = newList;
+    const idsToAdd = new Set(itemsMap.keys());
+    const filteredList = ScheduleDataManager.list.filter(item => !idsToAdd.has(item.id));
+    ScheduleDataManager.list = [...filteredList, ...itemsMap.values()];
   }
   clearData() {
     ScheduleDataManager.list = [];

package/lib/context/rhythms/actions.d.ts

@@ -1,20 +1,16 @@
-import { ERhythm } from '../../types/rhythms';
-interface IReturn {
-    type: ERhythm;
-    payload: any;
-}
-export declare const updateRhythmsMessage: (data: Record<string, any>) => IReturn;
-export declare const updateRhythms: (data: Record<string, any>) => IReturn;
-export declare const updateLocalMessage: (data: Record<string, any>) => IReturn;
-export declare const updateUI: (data: Record<string, any>) => IReturn;
-export declare const initSystemInfo: (data: Record<string, any>) => IReturn;
-export declare const updateDp: (data: Record<string, any>) => IReturn;
+import { RhythmAction, RhythmMessage, TRhythmData, LocalMessage, IState } from '../../types/rhythms';
+export declare const updateRhythmsMessage: (data: RhythmMessage) => RhythmAction;
+export declare const updateRhythms: (data: TRhythmData[]) => RhythmAction;
+export declare const updateLocalMessage: (data: LocalMessage) => RhythmAction;
+export declare const updateUI: (data: Partial<IState>) => RhythmAction;
+export declare const initSystemInfo: (data: any) => RhythmAction;
+export declare const updateDp: (data: Record<string, any>) => RhythmAction;
 declare const _default: {
-    updateLocalMessage: (data: Record<string, any>) => IReturn;
-    updateRhythms: (data: Record<string, any>) => IReturn;
-    updateRhythmsMessage: (data: Record<string, any>) => IReturn;
-    updateUI: (data: Record<string, any>) => IReturn;
-    initSystemInfo: (data: Record<string, any>) => IReturn;
-    updateDp: (data: Record<string, any>) => IReturn;
+    updateLocalMessage: (data: LocalMessage) => RhythmAction;
+    updateRhythms: (data: TRhythmData[]) => RhythmAction;
+    updateRhythmsMessage: (data: RhythmMessage) => RhythmAction;
+    updateUI: (data: Partial<IState>) => RhythmAction;
+    initSystemInfo: (data: any) => RhythmAction;
+    updateDp: (data: Record<string, any>) => RhythmAction;
 };
 export default _default;

package/lib/context/rhythms/reducer.d.ts

@@ -1,24 +1,3 @@
 /// <reference types="react" />
-import { IState } from '../../types/rhythms';
-export declare const useRhythmReducer: (init: IState) => [IState | {
-    localMessage: Partial<IState> | undefined;
-    rhythms: [] | import("../../types/rhythms").TRhythmData[];
-    rhythmsMessage: import("../../types/rhythms").RhythmMessage;
-    systemInfo: any;
-    dpState: Record<string, any>;
-} | {
-    rhythms: Partial<IState> | undefined;
-    localMessage: import("../../types/rhythms").LocalMessage;
-    rhythmsMessage: import("../../types/rhythms").RhythmMessage;
-    systemInfo: any;
-    dpState: Record<string, any>;
-} | {
-    rhythmsMessage: Partial<IState> | undefined;
-    localMessage: import("../../types/rhythms").LocalMessage;
-    rhythms: [] | import("../../types/rhythms").TRhythmData[];
-    systemInfo: any;
-    dpState: Record<string, any>;
-}, import("react").Dispatch<{
-    type: string;
-    payload?: Partial<IState> | undefined;
-}>];
+import { IState, RhythmAction } from '../../types/rhythms';
+export declare const useRhythmReducer: (init: IState) => [IState, import("react").Dispatch<RhythmAction>];

package/lib/context/rhythms/reducer.js

@@ -6,28 +6,27 @@ import { ERhythm } from '../../types/rhythms';
 // 默认值
 export const useRhythmReducer = init => {
   const rhythmReducer = useCallback((state, action) => {
-    const oldState = _objectSpread({}, state);
     switch (action.type) {
       case ERhythm.UPDATE_LOCAL_MESSAGE:
-        return _objectSpread(_objectSpread({}, oldState), {}, {
+        return _objectSpread(_objectSpread({}, state), {}, {
           localMessage: action.payload
         });
       case ERhythm.UPDATE_RHYTHMS:
-        return _objectSpread(_objectSpread({}, oldState), {}, {
+        return _objectSpread(_objectSpread({}, state), {}, {
           rhythms: action.payload
         });
       case ERhythm.UPDATE_DP:
-        return _objectSpread(_objectSpread({}, oldState), {}, {
-          dpState: _objectSpread(_objectSpread({}, oldState.dpState), action.payload)
+        return _objectSpread(_objectSpread({}, state), {}, {
+          dpState: _objectSpread(_objectSpread({}, state.dpState), action.payload)
         });
       case ERhythm.UPDATE_RHYTHMS_MESSAGE:
-        return _objectSpread(_objectSpread({}, oldState), {}, {
+        return _objectSpread(_objectSpread({}, state), {}, {
           rhythmsMessage: action.payload
         });
       case ERhythm.UPDATE_UI:
-        return _objectSpread(_objectSpread({}, oldState), action.payload);
+        return _objectSpread(_objectSpread({}, state), action.payload);
       case ERhythm.INIT_SYSTEM_INFO:
-        return _objectSpread(_objectSpread({}, oldState), {}, {
+        return _objectSpread(_objectSpread({}, state), {}, {
           systemInfo: action.payload
         });
       default:

package/lib/context/schedule/reducer.d.ts

@@ -1,8 +1,11 @@
 import { Dispatch } from 'react';
 import { TTimerData } from '../../types';
+type TTimerDataWithId = TTimerData & {
+    id?: string;
+};
 type TTimerReducer = {
-    commonFlatTimerList: TTimerData[];
-    commonFoldTimerList: TTimerData[];
+    commonFlatTimerList: TTimerDataWithId[];
+    commonFoldTimerList: TTimerDataWithId[];
     randomList: any[];
     rhythmList: any[];
     sleepList: any[];

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

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

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

@@ -0,0 +1,45 @@
+const sleepParserStub = {
+  parser: jest.fn(),
+  formatter: jest.fn()
+};
+const wakeUpParserStub = {
+  parser: jest.fn(),
+  formatter: jest.fn()
+};
+jest.mock('../sleep', () => ({
+  getSleepParser: jest.fn(() => sleepParserStub)
+}));
+jest.mock('../wakeup', () => ({
+  getWakeUpParser: jest.fn(() => wakeUpParserStub)
+}));
+import { autoDispatchTransDpFun, randomParser, rhythmParser, rtcTimerParser, timerReportParser } from '../index';
+import { scheduleDpCodes } from '../../config/dpCodes';
+describe('autoDispatchTransDpFun', () => {
+  it('returns random parser for RANDOM_TIMING', () => {
+    expect(autoDispatchTransDpFun(scheduleDpCodes.RANDOM_TIMING)).toBe(randomParser);
+  });
+  it('returns rhythm parser for RHYTHM_MODE', () => {
+    expect(autoDispatchTransDpFun(scheduleDpCodes.RHYTHM_MODE)).toBe(rhythmParser);
+  });
+  it('returns sleep parser singleton for SLEEP_MODE', () => {
+    const first = autoDispatchTransDpFun(scheduleDpCodes.SLEEP_MODE);
+    const second = autoDispatchTransDpFun(scheduleDpCodes.SLEEP_MODE);
+    expect(first).toBe(sleepParserStub);
+    expect(second).toBe(sleepParserStub);
+  });
+  it('returns RTC parser for RTC_TIMER', () => {
+    expect(autoDispatchTransDpFun(scheduleDpCodes.RTC_TIMER)).toBe(rtcTimerParser);
+  });
+  it('returns timer report parser for TIMER_REPORT', () => {
+    expect(autoDispatchTransDpFun(scheduleDpCodes.TIMER_REPORT)).toBe(timerReportParser);
+  });
+  it('returns wake up parser singleton for WAKE_UP_MODE', () => {
+    const first = autoDispatchTransDpFun(scheduleDpCodes.WAKE_UP_MODE);
+    const second = autoDispatchTransDpFun(scheduleDpCodes.WAKE_UP_MODE);
+    expect(first).toBe(wakeUpParserStub);
+    expect(second).toBe(wakeUpParserStub);
+  });
+  it('returns null for unsupported dpCode', () => {
+    expect(autoDispatchTransDpFun('UNKNOWN_DP_CODE')).toBeNull();
+  });
+});

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

@@ -1,26 +1,43 @@
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.for-each.js";
 import { rhythmParser } from '../rhythms';
-// Mock ScheduleLogger
-jest.mock('../../utils/ScheduleLogger', () => ({
-  scheduleLogger: {
+import { scheduleDpCodes } from '../../config/dpCodes';
+jest.mock('../../utils/ScheduleLogger', () => {
+  const logger = {
     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
+    scheduleLogger: logger
   };
-};
+});
 jest.mock('../../hooks/useCommonSupport', () => ({
-  getSupportIns: jest.fn(() => mockSupport(false, true))
+  getSupportIns: jest.fn()
 }));
+const {
+  scheduleLogger
+} = require('../../utils/ScheduleLogger');
+const {
+  getSupportIns
+} = require('../../hooks/useCommonSupport');
 describe('RhythmParser', () => {
+  const createSupport = function () {
+    let isSupportTemp = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;
+    return {
+      isSigMeshDevice: jest.fn().mockReturnValue(false),
+      isSupportDp: jest.fn().mockImplementation(dp => {
+        if (dp === scheduleDpCodes.TEMPERATURE) {
+          return isSupportTemp;
+        }
+        return true;
+      })
+    };
+  };
+  beforeEach(() => {
+    getSupportIns.mockReturnValue(createSupport(true));
+    Object.values(scheduleLogger).forEach(fn => fn.mockClear());
+  });
   describe('parser', () => {
     it('should return default data for empty DP string', () => {
       const result = rhythmParser.parser('');
@@ -31,12 +48,71 @@ describe('RhythmParser', () => {
       expect(result).toHaveProperty('number');
       expect(result).toHaveProperty('rhythms');
     });
+    it('should return default data when support instance is missing', () => {
+      getSupportIns.mockReturnValueOnce(null);
+      const result = rhythmParser.parser('001122334455');
+      expect(result).toHaveProperty('version', 0);
+      expect(result).toHaveProperty('rhythms');
+    });
+    it('should handle parser errors and log them', () => {
+      const panelUtils = require('@ray-js/panel-sdk/lib/utils');
+      const stepSpy = jest.spyOn(panelUtils, 'generateDpStrStep').mockImplementation(() => {
+        throw new Error('step error');
+      });
+      const result = rhythmParser.parser('0123456789abcdef0123456789ab');
+      expect(result).toEqual({});
+      expect(scheduleLogger.error).toHaveBeenCalledWith('rhythmParser parser error', expect.any(Error));
+      stepSpy.mockRestore();
+    });
   });
   describe('formatter', () => {
     it('should return empty string if data is null', () => {
       const result = rhythmParser.formatter(null);
       expect(result).toBe('');
     });
+    it('should return empty string when support instance is missing', () => {
+      getSupportIns.mockReturnValueOnce(null);
+      const result = rhythmParser.formatter({
+        version: 1,
+        power: true,
+        mode: 2,
+        weeks: [1, 1, 1, 1, 1, 1, 1, 1],
+        number: 1,
+        rhythms: [{
+          power: true,
+          hour: 8,
+          minute: 30,
+          hue: 100,
+          saturation: 90,
+          value: 80,
+          brightness: 70,
+          temperature: 60
+        }]
+      });
+      expect(result).toBe('');
+      expect(scheduleLogger.error).toHaveBeenCalledWith('协议解析 rhythms formatter =====', '数据为空');
+    });
+    it('should force temperature to 100 when device does not support temperature DP', () => {
+      getSupportIns.mockReturnValueOnce(createSupport(false));
+      const result = rhythmParser.formatter({
+        version: 0,
+        power: true,
+        mode: 1,
+        weeks: [1, 1, 1, 1, 1, 1, 1, 1],
+        number: 1,
+        rhythms: [{
+          power: true,
+          hour: 6,
+          minute: 15,
+          hue: 20,
+          saturation: 1,
+          value: 2,
+          brightness: 3,
+          temperature: 4
+        }]
+      });
+      expect(result.slice(-2)).toBe('64');
+    });
     it('should format a valid TRhythmData object', () => {
       const result = rhythmParser.formatter({
         version: 0,