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

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

@@ -121,6 +121,26 @@ describe('RtcTimerFormatter', () => {
         }
       });
     });
+    it('should parse a colour light timer with dual white params (dataType=09)', () => {
+      // ID: 85 (status=true, timerId=5)
+      // loops: 02 (Mon), time: 0064 (100 mins -> 01:40)
+      // deviceAction: 09 (dual white)
+      // bright_value: 0x46 (70), temp_value: 0x1E (30)
+      // bright_value1: 0x3C (60), temp_value1: 0x14 (20)
+
+      expect(formatterInstance.parser('85010200006409461E3C14')).toEqual({
+        timerId: '5',
+        status: true,
+        loops: '0100000',
+        time: '01:40',
+        dps: {
+          bright_value: 70,
+          temp_value: 30,
+          bright_value1: 60,
+          temp_value1: 20
+        }
+      });
+    });
   });
   describe('formatter', () => {
     it('should format a power (switch_led) timer to DP string', () => {
@@ -200,6 +220,21 @@ describe('RtcTimerFormatter', () => {
         }
       })).toBe('8401020000640400f0501e4b28');
     });
+    it('should format a timer with dual white params (dataType=09)', () => {
+      const result = formatterInstance.formatter({
+        timerId: '5',
+        status: true,
+        loops: '0100000',
+        time: '01:40',
+        dps: {
+          bright_value: 70,
+          temp_value: 30,
+          bright_value1: 60,
+          temp_value1: 20
+        }
+      });
+      expect(result.toLowerCase()).toBe('85010200006409461e3c14');
+    });
     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.

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

@@ -1,4 +1,5 @@
 import { SleepParser } from '../sleep';
+import { sleepParser as sleepParserCommon } from '../sleep/sleepCommon';
 describe('SleepParser', () => {
   const parser = new SleepParser();
   it('should return default value when parsing empty string', () => {
@@ -68,4 +69,20 @@ describe('SleepParser', () => {
     '0120050e500028640a0000');
     expect(result.nodes.length).toBe(4);
   });
+  it('should delegate parser and formatter to sleepParserCommon implementation', () => {
+    const parserSpy = jest.spyOn(sleepParserCommon, 'parser');
+    const formatterSpy = jest.spyOn(sleepParserCommon, 'formatter');
+    const input = '0000';
+    parser.parser(input);
+    expect(parserSpy).toHaveBeenCalledWith(input);
+    const data = {
+      version: 0,
+      length: 0,
+      nodes: []
+    };
+    parser.formatter(data);
+    expect(formatterSpy).toHaveBeenCalledWith(data);
+    parserSpy.mockRestore();
+    formatterSpy.mockRestore();
+  });
 });

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

@@ -1,4 +1,5 @@
 import { WakeUpParser } from '../wakeup';
+import { wakeupParser as wakeupParserCommon } from '../wakeup/wakeupCommon';
 describe('WakeUpParser', () => {
   const parser = new WakeUpParser();
   it('should return default value when parsing empty string', () => {
@@ -62,8 +63,20 @@ describe('WakeUpParser', () => {
     '0120050e500000640a000005');
     expect(result.nodes.length).toBe(4);
   });
-
-  // 注意: Sigmesh 相关的测试需要模拟 support.isSigMeshDevice() 返回 true
-  // 由于当前 SleepParser 和 WakeUpParser 的实现中 Sigmesh 部分被注释掉了，
-  // 我们暂时无法直接测试 Sigmesh 的逻辑。如果需要测试，需要解除注释并可能需要 mock `getSupportIns`。
+  it('should delegate parser and formatter to wakeupParserCommon implementation', () => {
+    const parserSpy = jest.spyOn(wakeupParserCommon, 'parser');
+    const formatterSpy = jest.spyOn(wakeupParserCommon, 'formatter');
+    const input = '0000';
+    parser.parser(input);
+    expect(parserSpy).toHaveBeenCalledWith(input);
+    const data = {
+      version: 0,
+      number: 0,
+      nodes: []
+    };
+    parser.formatter(data);
+    expect(formatterSpy).toHaveBeenCalledWith(data);
+    parserSpy.mockRestore();
+    formatterSpy.mockRestore();
+  });
 });

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

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

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

@@ -0,0 +1,126 @@
+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 { wakeupParserSigmesh, WakeUpSigmesh } from '../wakeup/wakeupSigmesh';
+const loopsToHex = loops => {
+  const binary = loops.split('').reverse().join('');
+  return parseInt(binary, 2);
+};
+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, node.duration].map(v => v.toString(16).padStart(2, '0')).join('')).join('');
+  return `${header}${body}`;
+};
+describe('WakeUpSigmesh parser & formatter', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  it('returns default value when dp string is empty', () => {
+    expect(wakeupParserSigmesh.parser('')).toEqual(new WakeUpSigmesh().defaultValue);
+  });
+  it('returns default value when dp string length invalid', () => {
+    // header + incomplete node data (not multiple of 8)
+
+    expect(wakeupParserSigmesh.parser('0102011234')).toEqual(new WakeUpSigmesh().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,
+      duration: 12
+    }, {
+      onOff: 0,
+      loops: loopsToHex('0100000'),
+      step: 5,
+      hour: 7,
+      minute: 45,
+      brightness: 60,
+      temperature: 70,
+      duration: 8
+    }];
+    const dpStr = buildDpStr(nodes, 1, 2);
+    const result = wakeupParserSigmesh.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,
+      duration: 12,
+      index: 0
+    });
+    expect(result.nodes[1]).toMatchObject({
+      onOff: false,
+      loops: '0100000',
+      index: 1
+    });
+  });
+  it('formats nodes back to dp string', () => {
+    const result = wakeupParserSigmesh.formatter({
+      version: 1,
+      dataMode: '03',
+      length: 1,
+      nodes: [{
+        onOff: true,
+        loops: '1000000',
+        step: 10,
+        hour: 5,
+        minute: 15,
+        brightness: 90,
+        temperature: 50,
+        duration: 20,
+        index: 0
+      }]
+    });
+    expect(result).toBe(buildDpStr([{
+      onOff: 1,
+      loops: loopsToHex('1000000'),
+      step: 10,
+      hour: 5,
+      minute: 15,
+      brightness: 90,
+      temperature: 50,
+      duration: 20
+    }], 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,
+      duration: 24
+    }];
+    const dpStr = buildDpStr(nodes, 2, 3);
+    const parsed = wakeupParserSigmesh.parser(dpStr);
+    const formatted = wakeupParserSigmesh.formatter(parsed);
+    expect(formatted).toBe(dpStr);
+  });
+});

package/lib/hooks/__test__/useBaseLightDp.test.d.ts

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

package/lib/hooks/__test__/useBaseLightDp.test.js

@@ -0,0 +1,251 @@
+import { act, renderHook } from '@testing-library/react-hooks';
+import { useBaseLightDp, getDpDataByMesh, fetchDpData, useFetchDpDataByMesh, useFetchDpData } from '../useBaseLightDp';
+import { DP_CHANGE_EVENT_KEY } from '../../constant';
+import { devIdOrGroupIdCache } from '../../utils/ScheduleCache';
+import { getDpIdByDpCode } from '../../utils/ScheduleUtils';
+import { getDpState, setDpState } from '../../utils/dpState';
+import { isInitFn, useSupport } from '../useCommonSupport';
+import { updateDeviceDp } from '../../conflict/updateDeviceDp';
+import { queryDps } from '@ray-js/ray';
+jest.mock('../../utils/ScheduleLogger', () => ({
+  scheduleLogger: {
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    info: jest.fn()
+  }
+}));
+jest.mock('../../utils/ScheduleCache', () => ({
+  devIdOrGroupIdCache: {
+    get: jest.fn().mockReturnValue({
+      devId: 'device-1',
+      groupId: ''
+    })
+  }
+}));
+const listeners = {};
+jest.mock('../../utils/ScheduleEmit', () => ({
+  emitter: {
+    on: jest.fn((event, cb) => {
+      listeners[event] = cb;
+    }),
+    off: jest.fn(event => {
+      delete listeners[event];
+    })
+  }
+}));
+jest.mock('../../conflict/updateDeviceDp', () => ({
+  updateDeviceDp: jest.fn()
+}));
+jest.mock('../../utils/ScheduleUtils', () => ({
+  getDpIdByDpCode: jest.fn()
+}));
+jest.mock('../../utils/dpState', () => ({
+  getDpState: jest.fn(),
+  setDpState: jest.fn()
+}));
+jest.mock('../useCommonSupport', () => ({
+  isInitFn: jest.fn(),
+  useSupport: jest.fn()
+}));
+jest.mock('@ray-js/ray', () => ({
+  queryDps: jest.fn()
+}));
+describe('useBaseLightDp', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    devIdOrGroupIdCache.get.mockReturnValue({
+      devId: 'device-1',
+      groupId: ''
+    });
+    isInitFn.mockReturnValue(true);
+    getDpIdByDpCode.mockReturnValue(10);
+    getDpState.mockReturnValue(undefined);
+  });
+  it('subscribes to emitter and updates state when dp changes', () => {
+    const {
+      result
+    } = renderHook(() => useBaseLightDp('bright_value', 0));
+    act(() => {
+      var _listeners$DP_CHANGE_;
+      (_listeners$DP_CHANGE_ = listeners[DP_CHANGE_EVENT_KEY]) === null || _listeners$DP_CHANGE_ === void 0 || _listeners$DP_CHANGE_.call(listeners, {
+        dps: {
+          10: 50
+        }
+      });
+    });
+    expect(setDpState).toHaveBeenCalledWith('bright_value', 50);
+    expect(result.current.dpValue).toBe(50);
+  });
+  it('filters duplicate emitter values', () => {
+    const {
+      result
+    } = renderHook(() => useBaseLightDp('bright_value', 0));
+    act(() => {
+      var _listeners$DP_CHANGE_2, _listeners$DP_CHANGE_3;
+      (_listeners$DP_CHANGE_2 = listeners[DP_CHANGE_EVENT_KEY]) === null || _listeners$DP_CHANGE_2 === void 0 || _listeners$DP_CHANGE_2.call(listeners, {
+        dps: {
+          10: 60
+        }
+      });
+      (_listeners$DP_CHANGE_3 = listeners[DP_CHANGE_EVENT_KEY]) === null || _listeners$DP_CHANGE_3 === void 0 || _listeners$DP_CHANGE_3.call(listeners, {
+        dps: {
+          10: 60
+        }
+      });
+    });
+    expect(result.current.dpValue).toBe(60);
+    expect(setDpState).toHaveBeenCalledTimes(1);
+  });
+  it('loads initial dp value from cache when available', () => {
+    getDpState.mockReturnValue(70);
+    const {
+      result
+    } = renderHook(() => useBaseLightDp('bright_value'));
+    expect(result.current.dpValue).toBe(70);
+  });
+  it('updateDp dispatches dp command when dpId exists', () => {
+    const {
+      result
+    } = renderHook(() => useBaseLightDp('bright_value'));
+    act(() => {
+      result.current.updateDp(90);
+    });
+    expect(updateDeviceDp).toHaveBeenCalledWith('device-1', '', {
+      10: 90
+    });
+  });
+  it('updateDp graceful when dpId missing', () => {
+    getDpIdByDpCode.mockReturnValue(undefined);
+    const errorSpy = jest.fn();
+    const {
+      result
+    } = renderHook(() => useBaseLightDp('unknown'));
+    act(() => {
+      result.current.updateDp(1, errorSpy);
+    });
+    expect(updateDeviceDp).not.toHaveBeenCalled();
+    expect(errorSpy).not.toHaveBeenCalled();
+  });
+  it('updateDp handles exception with callback', () => {
+    getDpIdByDpCode.mockImplementation(() => {
+      throw new Error('failed');
+    });
+    const errorSpy = jest.fn();
+    const {
+      result
+    } = renderHook(() => useBaseLightDp('error_dp'));
+    act(() => {
+      result.current.updateDp(1, errorSpy);
+    });
+    expect(errorSpy).toHaveBeenCalled();
+  });
+});
+describe('getDpDataByMesh', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    devIdOrGroupIdCache.get.mockReturnValue({
+      devId: 'device-1',
+      groupId: ''
+    });
+    getDpIdByDpCode.mockImplementation(code => code === 'bright_value' ? 1 : null);
+  });
+  it('logs error when dpCodes is not array', () => {
+    getDpDataByMesh(null);
+    expect(queryDps).not.toHaveBeenCalled();
+  });
+  it('warns when groupId present', () => {
+    devIdOrGroupIdCache.get.mockReturnValue({
+      devId: 'device-1',
+      groupId: 'group-1'
+    });
+    getDpDataByMesh(['switch']);
+    expect(queryDps).not.toHaveBeenCalled();
+  });
+  it('warns when deviceId missing', () => {
+    devIdOrGroupIdCache.get.mockReturnValue({
+      devId: '',
+      groupId: ''
+    });
+    getDpDataByMesh(['switch']);
+    expect(queryDps).not.toHaveBeenCalled();
+  });
+  it('queries dp when ids resolved', () => {
+    getDpDataByMesh(['bright_value']);
+    expect(queryDps).toHaveBeenCalledWith(expect.objectContaining({
+      deviceId: 'device-1',
+      dpIds: ['1']
+    }));
+  });
+});
+describe('fetchDpData', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    devIdOrGroupIdCache.get.mockReturnValue({
+      devId: 'device-1',
+      groupId: ''
+    });
+    getDpIdByDpCode.mockImplementation(code => code === 'bright_value' ? 2 : null);
+  });
+  it('validates dpCodes argument', () => {
+    fetchDpData(null);
+    expect(queryDps).not.toHaveBeenCalled();
+  });
+  it('requires deviceId', () => {
+    devIdOrGroupIdCache.get.mockReturnValue({
+      devId: '',
+      groupId: ''
+    });
+    fetchDpData(['switch']);
+    expect(queryDps).not.toHaveBeenCalled();
+  });
+  it('runs query when dp ids exist', () => {
+    fetchDpData(['bright_value']);
+    expect(queryDps).toHaveBeenCalledWith(expect.objectContaining({
+      deviceId: 'device-1',
+      dpIds: ['2']
+    }));
+  });
+});
+describe('useFetch hooks', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    getDpIdByDpCode.mockReturnValue(3);
+    devIdOrGroupIdCache.get.mockReturnValue({
+      devId: 'device-1',
+      groupId: ''
+    });
+    useSupport.mockReturnValue({
+      isSigMeshDevice: () => true,
+      deviceType: 'sigmesh'
+    });
+  });
+  it('useFetchDpDataByMesh triggers fetch on mount and refresh', () => {
+    const {
+      result
+    } = renderHook(() => useFetchDpDataByMesh(['bright_value']));
+    expect(queryDps).toHaveBeenCalledTimes(1);
+    act(() => {
+      result.current.refresh();
+    });
+    expect(queryDps).toHaveBeenCalledTimes(2);
+  });
+  it('useFetchDpDataByMesh skips when not sigmesh', () => {
+    useSupport.mockReturnValue({
+      isSigMeshDevice: () => false,
+      deviceType: 'wifi'
+    });
+    renderHook(() => useFetchDpDataByMesh(['bright_value']));
+    expect(queryDps).not.toHaveBeenCalled();
+  });
+  it('useFetchDpData triggers fetch on mount and refresh', () => {
+    const {
+      result
+    } = renderHook(() => useFetchDpData(['bright_value']));
+    expect(queryDps).toHaveBeenCalledTimes(1);
+    act(() => {
+      result.current.refresh();
+    });
+    expect(queryDps).toHaveBeenCalledTimes(2);
+  });
+});

package/lib/hooks/__test__/useCommonSupport.test.d.ts

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

package/lib/hooks/__test__/useCommonSupport.test.js

@@ -0,0 +1,204 @@
+import { act, renderHook } from '@testing-library/react-hooks';
+import { useScheduleInit, useSupport, useCommonSupport, resetIsInit } from '../useCommonSupport';
+import { emitter } from '../../utils/ScheduleEmit';
+const initStorageMock = jest.fn().mockResolvedValue(undefined);
+const getGroupDpsInfosMock = jest.fn().mockResolvedValue({});
+const registerDeviceListListenerMock = jest.fn();
+const registerGroupChangeMock = jest.fn();
+const onDpDataChangeMock = jest.fn();
+const onGroupDpDataChangeEventMock = jest.fn();
+const offDpDataChangeMock = jest.fn();
+const offGroupDpDataChangeEventMock = jest.fn();
+const getDeviceInfoMock = jest.fn();
+const getTimerListWithFlushMock = jest.fn();
+const initDpStateMock = jest.fn();
+jest.mock('../../context/timer/context', () => ({
+  useTimerContext: jest.fn().mockReturnValue({
+    dispatch: jest.fn(),
+    actions: {}
+  })
+}));
+const supportInitMock = jest.fn();
+const supportIsSupportDpMock = jest.fn();
+jest.mock('../../utils/ScheduleSupport', () => ({
+  Support: jest.fn(() => ({
+    init: supportInitMock,
+    isSupportDp: supportIsSupportDpMock
+  }))
+}));
+jest.mock('../../utils/storage', () => ({
+  initStorage: function () {
+    return initStorageMock(...arguments);
+  }
+}));
+jest.mock('../../utils/dpState', () => ({
+  initDpState: function () {
+    return initDpStateMock(...arguments);
+  }
+}));
+jest.mock('../../hooks/useTimerOperateLocal', () => ({
+  getTimerListWithFlush: function () {
+    return getTimerListWithFlushMock(...arguments);
+  }
+}));
+jest.mock('../../utils/ScheduleUtils', () => ({
+  getDpCodeByDpId: dpId => `code_${dpId}`
+}));
+jest.mock('@ray-js/ray', () => ({
+  getDeviceInfo: function () {
+    return getDeviceInfoMock(...arguments);
+  },
+  getGroupDpsInfos: function () {
+    return getGroupDpsInfosMock(...arguments);
+  },
+  registerDeviceListListener: function () {
+    return registerDeviceListListenerMock(...arguments);
+  },
+  registerGroupChange: function () {
+    return registerGroupChangeMock(...arguments);
+  },
+  onDpDataChange: function () {
+    return onDpDataChangeMock(...arguments);
+  },
+  onGroupDpDataChangeEvent: function () {
+    return onGroupDpDataChangeEventMock(...arguments);
+  },
+  offDpDataChange: function () {
+    return offDpDataChangeMock(...arguments);
+  },
+  offGroupDpDataChangeEvent: function () {
+    return offGroupDpDataChangeEventMock(...arguments);
+  }
+}));
+jest.mock('../../utils/ScheduleLogger', () => {
+  const loggerMock = {
+    info: jest.fn(),
+    debug: jest.fn(),
+    warn: jest.fn(),
+    error: jest.fn(),
+    setLogLevel: jest.fn(),
+    setLogPrefix: jest.fn(),
+    formatMessage: jest.fn()
+  };
+  return {
+    scheduleLogger: loggerMock,
+    ScheduleLogger: class {
+      info = (() => loggerMock.info)();
+      debug = (() => loggerMock.debug)();
+      warn = (() => loggerMock.warn)();
+      error = (() => loggerMock.error)();
+      setLogLevel = (() => loggerMock.setLogLevel)();
+      setLogPrefix = (() => loggerMock.setLogPrefix)();
+      formatMessage = (() => loggerMock.formatMessage)();
+    }
+  };
+});
+describe('useCommonSupport suite', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    resetIsInit();
+    supportInitMock.mockResolvedValue(true);
+    supportIsSupportDpMock.mockImplementation(code => code === 'a' || code === 'code_1');
+    registerDeviceListListenerMock.mockImplementation(_ref => {
+      let {
+        success
+      } = _ref;
+      return success === null || success === void 0 ? void 0 : success();
+    });
+    registerGroupChangeMock.mockImplementation(_ref2 => {
+      let {
+        success
+      } = _ref2;
+      return success === null || success === void 0 ? void 0 : success();
+    });
+    getDeviceInfoMock.mockImplementation(_ref3 => {
+      let {
+        success
+      } = _ref3;
+      return success === null || success === void 0 ? void 0 : success({
+        dps: {
+          1: true
+        }
+      });
+    });
+    getGroupDpsInfosMock.mockResolvedValue({
+      1: true
+    });
+  });
+  it('initializes device support and sets ready state', async () => {
+    const {
+      result
+    } = renderHook(() => useScheduleInit({
+      devId: 'dev-1'
+    }));
+    await act(async () => {
+      await Promise.resolve();
+    });
+    expect(result.current.isReady).toBe(true);
+    expect(initStorageMock).toHaveBeenCalledWith('dev-1', undefined);
+    expect(getDeviceInfoMock).toHaveBeenCalled();
+  });
+  it('initializes group support and fetches group dps', async () => {
+    const {
+      result
+    } = renderHook(() => useScheduleInit({
+      devId: '',
+      groupId: 'group-1'
+    }));
+    await act(async () => {
+      await Promise.resolve();
+    });
+    expect(result.current.isReady).toBe(true);
+    expect(getGroupDpsInfosMock).toHaveBeenCalledWith('group-1');
+    expect(initDpStateMock).toHaveBeenCalled();
+  });
+  it('handles support init failure', async () => {
+    supportInitMock.mockRejectedValueOnce(new Error('fail'));
+    const {
+      result
+    } = renderHook(() => useScheduleInit({
+      devId: 'dev-1'
+    }));
+    await act(async () => {
+      await Promise.resolve();
+    });
+    expect(result.current.isReady).toBe(false);
+  });
+  it('useSupport updates after initDone event', async () => {
+    const {
+      result: initResult
+    } = renderHook(() => useScheduleInit({
+      devId: 'dev-1'
+    }));
+    await act(async () => {
+      await Promise.resolve();
+    });
+    expect(initResult.current.isReady).toBe(true);
+    const {
+      result
+    } = renderHook(() => useSupport());
+    act(() => {
+      emitter.emit('initDone');
+    });
+    expect(result.current).not.toBeNull();
+  });
+  it('useCommonSupport respects checkType and dp list', async () => {
+    const {
+      result: initResult
+    } = renderHook(() => useScheduleInit({
+      devId: 'dev-1'
+    }));
+    await act(async () => {
+      await Promise.resolve();
+    });
+    expect(initResult.current.isReady).toBe(true);
+    const {
+      result: someResult
+    } = renderHook(() => useCommonSupport(['a']));
+    expect(someResult.current.isSupport).toBe(true);
+    const {
+      result: everyResult
+    } = renderHook(() => useCommonSupport(['a', 'b'], ['a', 'b'], 'every'));
+    expect(everyResult.current.isSupport).toBe(false);
+  });
+});

package/lib/hooks/__test__/useTimerFlushList.test.d.ts

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