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

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

@@ -1,10 +1,23 @@
+import "core-js/modules/esnext.iterator.constructor.js";
+import "core-js/modules/esnext.iterator.for-each.js";
 import { renderHook, act } from '@testing-library/react-hooks';
-import { useLocalTimerAdd, useLocalTimerUpdate, useLocalTimerRemove, useLocalTimerList, useLocalTimerUpdateStatus } from '../useTimerOperateLocal';
-import { useLocalTimerCloudProperty } from '../../utils/ScheduleCloudProperty';
+import { useLocalTimerAdd, useLocalTimerUpdate, useLocalTimerRemove, useLocalTimerList, useLocalTimerUpdateStatus, getTimerListWithFlush } from '../useTimerOperateLocal';
 import { LOCAL_TIMER_CATEGORY } from '../../constant';
-import { getTimerState } from '../../context/timer/';
-
-// Mock dependencies
+const mockSet = jest.fn();
+const mockUpdate = jest.fn();
+const mockRemove = jest.fn();
+const mockUpdateStatus = jest.fn();
+const mockGetAllMethod = jest.fn();
+const mockStandaloneGetAll = jest.fn();
+const mockUseLocalTimerCloudProperty = jest.fn(() => ({
+  set: mockSet,
+  update: mockUpdate,
+  remove: mockRemove,
+  updateStatus: mockUpdateStatus,
+  getAll: mockGetAllMethod
+}));
+const mockGetTimerState = jest.fn();
+const mockGetTimerReducer = jest.fn();
 jest.mock('../../utils/ScheduleCache', () => ({
   devIdOrGroupIdCache: {
     get: jest.fn().mockReturnValue({
@@ -16,35 +29,58 @@ jest.mock('../../utils/ScheduleCache', () => ({
   getScheduleCache: jest.fn()
 }));
 jest.mock('../../context/timer/', () => ({
-  getTimerState: jest.fn() // 直接模拟返回值
+  getTimerState: function () {
+    return mockGetTimerState(...arguments);
+  },
+  getTimerReducer: function () {
+    return mockGetTimerReducer(...arguments);
+  }
 }));
-
-// Mock ray functions
 jest.mock('@ray-js/ray', () => ({
   offDpDataChange: jest.fn(),
   onDpDataChange: jest.fn()
 }));
 jest.mock('../../utils/ScheduleCloudProperty', () => ({
-  useLocalTimerCloudProperty: jest.fn().mockReturnValue({
-    set: jest.fn().mockResolvedValue(true),
-    update: jest.fn().mockResolvedValue(true),
-    remove: jest.fn().mockResolvedValue(true),
-    updateStatus: jest.fn().mockResolvedValue(true),
-    getAll: jest.fn().mockResolvedValue({
-      properties: {}
-    })
-  })
+  useLocalTimerCloudProperty: () => mockUseLocalTimerCloudProperty(),
+  getAll: () => mockStandaloneGetAll()
+}));
+jest.mock('../../utils/ScheduleLogger', () => ({
+  scheduleLogger: {
+    debug: jest.fn(),
+    error: jest.fn(),
+    warn: jest.fn(),
+    info: jest.fn()
+  }
 }));
+jest.mock('../../dpParser', () => ({
+  timerReportParser: {
+    parser: jest.fn()
+  }
+}));
+const mockedRay = jest.requireMock('@ray-js/ray');
+const mockScheduleLogger = jest.requireMock('../../utils/ScheduleLogger').scheduleLogger;
+const mockTimerReportParser = jest.requireMock('../../dpParser').timerReportParser.parser;
 describe('useTimerOperateLocal Hooks', () => {
   beforeEach(() => {
     jest.clearAllMocks();
+    mockSet.mockReset().mockResolvedValue(true);
+    mockUpdate.mockReset().mockResolvedValue(true);
+    mockRemove.mockReset().mockResolvedValue(true);
+    mockUpdateStatus.mockReset().mockResolvedValue(true);
+    mockGetAllMethod.mockReset().mockResolvedValue({
+      properties: {}
+    });
+    mockStandaloneGetAll.mockReset().mockResolvedValue({
+      properties: {}
+    });
+    mockUseLocalTimerCloudProperty.mockClear();
+    mockGetTimerState.mockReset();
+    mockGetTimerReducer.mockReset();
+    mockTimerReportParser.mockReset();
+    Object.values(mockScheduleLogger).forEach(fn => fn.mockReset());
   });
   describe('useLocalTimerAdd', () => {
     it('should add local timer successfully', async () => {
-      const mockSet = jest.fn().mockResolvedValue(true);
-      useLocalTimerCloudProperty.mockReturnValue({
-        set: mockSet
-      });
       const {
         result
       } = renderHook(() => useLocalTimerAdd(true));
@@ -64,10 +100,8 @@ describe('useTimerOperateLocal Hooks', () => {
       expect(result.current.isLoading).toBe(false);
     });
     it('should handle add timer error', async () => {
-      const mockSet = jest.fn().mockRejectedValue(new Error('Add failed'));
-      useLocalTimerCloudProperty.mockReturnValue({
-        set: mockSet
-      });
+      const error = new Error('Add failed');
+      mockSet.mockRejectedValueOnce(error);
       const {
         result
       } = renderHook(() => useLocalTimerAdd(true));
@@ -80,17 +114,20 @@ describe('useTimerOperateLocal Hooks', () => {
         aliasName: 'Test Timer',
         isAppPush: true
       };
-      await expect(act(async () => {
-        await result.current.addTimer(mockTimer);
-      })).rejects.toThrow('Add failed');
+      let caught = null;
+      await act(async () => {
+        try {
+          await result.current.addTimer(mockTimer);
+        } catch (err) {
+          caught = err;
+        }
+      });
+      expect(caught).toBe(error);
+      expect(result.current.isLoading).toBe(false);
     });
   });
   describe('useLocalTimerUpdate', () => {
     it('should update local timer successfully', async () => {
-      const mockUpdate = jest.fn().mockResolvedValue(true);
-      useLocalTimerCloudProperty.mockReturnValue({
-        update: mockUpdate
-      });
       const {
         result
       } = renderHook(() => useLocalTimerUpdate(true));
@@ -112,10 +149,6 @@ describe('useTimerOperateLocal Hooks', () => {
   });
   describe('useLocalTimerRemove', () => {
     it('should remove local timer successfully', async () => {
-      const mockRemove = jest.fn().mockResolvedValue(true);
-      useLocalTimerCloudProperty.mockReturnValue({
-        remove: mockRemove
-      });
       const {
         result
       } = renderHook(() => useLocalTimerRemove(true));
@@ -127,7 +160,7 @@ describe('useTimerOperateLocal Hooks', () => {
   });
   describe('useLocalTimerList', () => {
     it('should get local timer list successfully', async () => {
-      const mockGetAll = jest.fn().mockResolvedValue({
+      mockGetAllMethod.mockResolvedValueOnce({
         properties: {
           [`${LOCAL_TIMER_CATEGORY}_1`]: JSON.stringify({
             time: '12:00',
@@ -139,9 +172,6 @@ describe('useTimerOperateLocal Hooks', () => {
           })
         }
       });
-      useLocalTimerCloudProperty.mockReturnValue({
-        getAll: mockGetAll
-      });
       const {
         result
       } = renderHook(() => useLocalTimerList(true));
@@ -153,16 +183,13 @@ describe('useTimerOperateLocal Hooks', () => {
       });
     });
     it('should handle invalid timer data', async () => {
-      const mockGetAll = jest.fn().mockResolvedValue({
+      mockGetAllMethod.mockResolvedValueOnce({
         properties: {
           [`${LOCAL_TIMER_CATEGORY}_1`]: 'invalid_json',
           [`${LOCAL_TIMER_CATEGORY}_2`]: '1',
           [`${LOCAL_TIMER_CATEGORY}_3`]: 'null'
         }
       });
-      useLocalTimerCloudProperty.mockReturnValue({
-        getAll: mockGetAll
-      });
       const {
         result
       } = renderHook(() => useLocalTimerList(true));
@@ -172,12 +199,9 @@ describe('useTimerOperateLocal Hooks', () => {
       });
     });
     it('should get empty timer list when no timers exist', async () => {
-      const mockGetAll = jest.fn().mockResolvedValue({
+      mockGetAllMethod.mockResolvedValueOnce({
         properties: {}
       });
-      useLocalTimerCloudProperty.mockReturnValue({
-        getAll: mockGetAll
-      });
       const {
         result
       } = renderHook(() => useLocalTimerList(false));
@@ -189,11 +213,7 @@ describe('useTimerOperateLocal Hooks', () => {
   });
   describe('useLocalTimerUpdateStatus', () => {
     it('should update timer status successfully', async () => {
-      const mockUpdateStatus = jest.fn().mockResolvedValue(true);
-      useLocalTimerCloudProperty.mockReturnValue({
-        updateStatus: mockUpdateStatus
-      });
-      getTimerState.mockReturnValue({
+      mockGetTimerState.mockReturnValue({
         rtcTimerList: [{
           timerId: '1',
           time: '12:00',
@@ -213,4 +233,92 @@ describe('useTimerOperateLocal Hooks', () => {
       expect(result.current.isLoading).toBe(false);
     });
   });
+  describe('event handling and utilities', () => {
+    it('should flush rtc list when timer_report dp changes', () => {
+      const flushRtcTimerListMock = jest.fn().mockReturnValue('flush-action');
+      const dispatchMock = jest.fn();
+      mockGetTimerState.mockReturnValue({
+        rtcTimerList: [{
+          timerId: '1',
+          status: false,
+          time: '08:00',
+          loops: '0000000',
+          dps: {}
+        }]
+      });
+      mockGetTimerReducer.mockReturnValue({
+        dispatch: dispatchMock,
+        actions: {
+          flushRtcTimerList: flushRtcTimerListMock
+        }
+      });
+      mockTimerReportParser.mockReturnValue([{
+        id: '1',
+        status: true
+      }]);
+      const {
+        unmount
+      } = renderHook(() => useLocalTimerList(true));
+      const dpCallback = mockedRay.onDpDataChange.mock.calls[0][0];
+      dpCallback({
+        dps: {
+          38: '[{"id":"1","status":true}]'
+        }
+      });
+      expect(mockTimerReportParser).toHaveBeenCalledWith('[{"id":"1","status":true}]');
+      expect(flushRtcTimerListMock).toHaveBeenCalledWith([{
+        timerId: '1',
+        status: true,
+        time: '08:00',
+        loops: '0000000',
+        dps: {}
+      }]);
+      expect(dispatchMock).toHaveBeenCalledWith('flush-action');
+      unmount();
+    });
+    it('should warn when updating status without matching timer', async () => {
+      mockGetTimerState.mockReturnValue({
+        rtcTimerList: []
+      });
+      const {
+        result
+      } = renderHook(() => useLocalTimerUpdateStatus(true));
+      await act(async () => {
+        result.current.updateTimerStatus('not-exist', true);
+      });
+      expect(mockScheduleLogger.warn).toHaveBeenCalledWith('useLocalTimerUpdateStatus: currentTimer with timerId not-exist is undefined');
+      expect(mockUpdateStatus).not.toHaveBeenCalled();
+    });
+    it('should fetch timers and dispatch via getTimerListWithFlush', async () => {
+      mockStandaloneGetAll.mockResolvedValueOnce({
+        properties: {
+          [`${LOCAL_TIMER_CATEGORY}_5`]: JSON.stringify({
+            time: '10:10',
+            loops: '0101010',
+            status: false,
+            dps: {
+              brightness: 10
+            }
+          })
+        }
+      });
+      const dispatchMock = jest.fn();
+      const flushActionMock = jest.fn().mockReturnValue('action');
+      await getTimerListWithFlush(dispatchMock, {
+        flushRtcTimerList: flushActionMock
+      });
+      expect(flushActionMock).toHaveBeenCalledWith([{
+        timerId: '5',
+        time: '10:10',
+        loops: '0101010',
+        status: false,
+        dps: {
+          brightness: 10
+        },
+        aliasName: '',
+        isAppPush: false
+      }]);
+      expect(dispatchMock).toHaveBeenCalledWith('action');
+    });
+  });
 });

package/lib/types/rhythms.d.ts

@@ -45,24 +45,36 @@ interface IProps {
     onSave: (data: Record<string, any>[]) => void;
     onCancel: (data: Record<string, any>[]) => void;
 }
-interface IReturn {
-    type: ERhythm;
+export type RhythmAction = {
+    type: ERhythm.UPDATE_RHYTHMS_MESSAGE;
+    payload: RhythmMessage;
+} | {
+    type: ERhythm.UPDATE_RHYTHMS;
+    payload: TRhythmData[];
+} | {
+    type: ERhythm.UPDATE_LOCAL_MESSAGE;
+    payload: LocalMessage;
+} | {
+    type: ERhythm.UPDATE_UI;
+    payload: Partial<IState>;
+} | {
+    type: ERhythm.INIT_SYSTEM_INFO;
     payload: any;
-}
+} | {
+    type: ERhythm.UPDATE_DP;
+    payload: Record<string, any>;
+};
 export interface IContext {
     state: IState;
-    dispatch: Dispatch<{
-        type: string;
-        payload?: Partial<IState>;
-    }>;
+    dispatch: Dispatch<RhythmAction>;
     props: IProps;
     actions?: {
-        updateRhythmsMessage: (data: RhythmMessage) => IReturn;
-        updateRhythms: (data: TRhythmData[]) => IReturn;
-        updateLocalMessage: (data: LocalMessage) => IReturn;
-        updateUI: (data: any[]) => IReturn;
-        initSystemInfo: (data: any) => IReturn;
-        updateDp: (data: any) => IReturn;
+        updateRhythmsMessage: (data: RhythmMessage) => RhythmAction;
+        updateRhythms: (data: TRhythmData[]) => RhythmAction;
+        updateLocalMessage: (data: LocalMessage) => RhythmAction;
+        updateUI: (data: Partial<IState>) => RhythmAction;
+        initSystemInfo: (data: any) => RhythmAction;
+        updateDp: (data: Record<string, any>) => RhythmAction;
     };
 }
 export interface IState {

package/lib/types/ty.d.ts

@@ -0,0 +1,3 @@
+declare const ty: Record<string, any> & {
+  presetFunctionalData?: (options: { url: string; data: any }) => void;
+};

package/lib/utils/ScheduleDataSync.js

@@ -49,7 +49,10 @@ export const navigateToSchedule = (params, data, eventsMap) => {
     groupId
   } = params;
   if (!deviceId && !groupId) {
-    throw new Error('devId or groupId is required');
+    throw new Error(JSON.stringify({
+      params,
+      message: 'devId or groupId is required'
+    }));
   }
   let scheduleUrl = `${SCHEDULE_FUNCTIONAL_URL}?deviceId=${deviceId}`;
   if (groupId) {

package/lib/utils/ScheduleLogger.js

@@ -68,4 +68,4 @@ export class ScheduleLogger {
   }
 }
 export const scheduleLogger = new ScheduleLogger();
-scheduleLogger.setLogLevel(LogLevel.WARN);
+scheduleLogger.setLogLevel(LogLevel.DEBUG);

package/lib/utils/__test__/ScheduleDataSync.test.d.ts

@@ -0,0 +1,11 @@
+/// <reference types="jest" />
+declare const mockNavigateTo: jest.Mock<any, any, any>;
+declare const mockUsePageInstance: jest.Mock<any, any, any>;
+declare const mockLogger: {
+    debug: jest.Mock<any, any, any>;
+    error: jest.Mock<any, any, any>;
+};
+declare let navigateToSchedule: typeof import('../ScheduleDataSync').navigateToSchedule;
+declare let navigateToMainApp: typeof import('../ScheduleDataSync').navigateToMainApp;
+declare let functionalTransDataEventKey: typeof import('../ScheduleDataSync').functionalTransDataEventKey;
+declare const loadModule: () => void;

package/lib/utils/__test__/ScheduleDataSync.test.js

@@ -0,0 +1,137 @@
+const mockNavigateTo = jest.fn();
+const mockUsePageInstance = jest.fn();
+const mockLogger = {
+  debug: jest.fn(),
+  error: jest.fn()
+};
+let navigateToSchedule;
+let navigateToMainApp;
+let functionalTransDataEventKey;
+const loadModule = () => {
+  const moduleExports = require('../ScheduleDataSync');
+  ({
+    navigateToSchedule,
+    navigateToMainApp,
+    functionalTransDataEventKey
+  } = moduleExports);
+};
+describe('ScheduleDataSync utilities', () => {
+  beforeEach(() => {
+    jest.resetModules();
+    mockNavigateTo.mockReset();
+    mockUsePageInstance.mockReset();
+    mockLogger.debug.mockReset();
+    mockLogger.error.mockReset();
+    global.ty = {
+      presetFunctionalData: jest.fn()
+    };
+    jest.doMock('@ray-js/ray', () => ({
+      usePageInstance: mockUsePageInstance,
+      navigateTo: mockNavigateTo
+    }));
+    jest.doMock('../ScheduleLogger', () => ({
+      scheduleLogger: mockLogger
+    }));
+    loadModule();
+  });
+  afterEach(() => {
+    delete global.ty;
+  });
+  describe('navigateToSchedule', () => {
+    it('throws when both deviceId and groupId are missing', () => {
+      expect(() => navigateToSchedule({
+        deviceId: '',
+        groupId: ''
+      }, {})).toThrow('devId or groupId is required');
+    });
+    it('presets data with deviceId and forwards events', () => {
+      var _navigateArgs$success, _navigateArgs$fail;
+      const data = {
+        forceSupport: {
+          countdown: true
+        },
+        i18nKeyMap: {
+          key: 'value'
+        }
+      };
+      const eventsMap = {
+        timerDataChange: jest.fn()
+      };
+      navigateToSchedule({
+        deviceId: 'dev123',
+        groupId: ''
+      }, data, eventsMap);
+      expect(global.ty.presetFunctionalData).toHaveBeenCalledWith({
+        url: 'functional://LampScheduleSetFunction/home?deviceId=dev123',
+        data
+      });
+      expect(mockNavigateTo).toHaveBeenCalledTimes(1);
+      const navigateArgs = mockNavigateTo.mock.calls[0][0];
+      expect(navigateArgs.url).toBe('functional://LampScheduleSetFunction/home?deviceId=dev123');
+      expect(navigateArgs.events).toBe(eventsMap);
+      (_navigateArgs$success = navigateArgs.success) === null || _navigateArgs$success === void 0 || _navigateArgs$success.call(navigateArgs, 'ok');
+      expect(mockLogger.debug).toHaveBeenCalledWith(' success:', 'ok');
+      (_navigateArgs$fail = navigateArgs.fail) === null || _navigateArgs$fail === void 0 || _navigateArgs$fail.call(navigateArgs, 'err');
+      expect(mockLogger.error).toHaveBeenCalledWith('navigateToSchedule fail:', 'err');
+    });
+    it('uses groupId when provided', () => {
+      navigateToSchedule({
+        deviceId: 'dev123',
+        groupId: 'group456'
+      }, {});
+      expect(global.ty.presetFunctionalData).toHaveBeenCalledWith({
+        url: 'functional://LampScheduleSetFunction/home?groupId=group456',
+        data: {}
+      });
+      expect(mockNavigateTo).toHaveBeenCalledWith(expect.objectContaining({
+        url: 'functional://LampScheduleSetFunction/home?groupId=group456'
+      }));
+    });
+  });
+  describe('navigateToMainApp', () => {
+    it('throws when route does not start with slash', () => {
+      expect(() => navigateToMainApp('pages/index')).toThrow('route must start with /');
+    });
+    it('navigates with query params and triggers callback', () => {
+      const callback = jest.fn();
+      mockNavigateTo.mockImplementation(_ref => {
+        var _events$functionalTra;
+        let {
+          events,
+          success
+        } = _ref;
+        (_events$functionalTra = events[functionalTransDataEventKey]) === null || _events$functionalTra === void 0 || _events$functionalTra.call(events, {
+          dps: {
+            switch_led: true
+          },
+          foo: 'bar'
+        });
+        success === null || success === void 0 || success('success-result');
+      });
+      navigateToMainApp('/pages/index', {
+        foo: '1',
+        bar: '2'
+      }, callback);
+      expect(mockNavigateTo).toHaveBeenCalledTimes(1);
+      const navigateArgs = mockNavigateTo.mock.calls[0][0];
+      expect(navigateArgs.url).toBe('/pages/index?foo=1&bar=2&');
+      expect(callback).toHaveBeenCalledWith({
+        dps: {
+          switch_led: true
+        },
+        foo: 'bar'
+      });
+      expect(mockLogger.debug).toHaveBeenCalledWith('navigateToMainApp success: ', 'success-result');
+    });
+    it('logs error when navigation fails', () => {
+      mockNavigateTo.mockImplementation(_ref2 => {
+        let {
+          fail
+        } = _ref2;
+        return fail === null || fail === void 0 ? void 0 : fail('oops');
+      });
+      navigateToMainApp('/pages/index');
+      expect(mockLogger.error).toHaveBeenCalledWith('navigateToMainApp fail:', 'oops');
+    });
+  });
+});

package/lib/utils/__test__/ScheduleEmit.test.d.ts

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

package/lib/utils/__test__/ScheduleEmit.test.js

@@ -0,0 +1,35 @@
+import emitt, { emitter } from '../ScheduleEmit';
+describe('ScheduleEmit', () => {
+  it('registers and emits events to handlers', () => {
+    const localEmitter = emitt();
+    const handler = jest.fn();
+    localEmitter.on('event', handler);
+    localEmitter.emit('event', 1, 2);
+    expect(handler).toHaveBeenCalledWith(1, 2);
+  });
+  it('supports removing handlers', () => {
+    const localEmitter = emitt();
+    const handler = jest.fn();
+    localEmitter.on('event', handler);
+    localEmitter.off('event', handler);
+    localEmitter.emit('event', 'data');
+    expect(handler).not.toHaveBeenCalled();
+  });
+  it('invokes wildcard handlers after specific ones', () => {
+    const localEmitter = emitt();
+    const eventHandler = jest.fn();
+    const wildcardHandler = jest.fn();
+    localEmitter.on('event', eventHandler);
+    localEmitter.on('*', wildcardHandler);
+    localEmitter.emit('event', 'payload');
+    expect(eventHandler).toHaveBeenCalledWith('payload');
+    expect(wildcardHandler).toHaveBeenCalledWith('event', 'payload');
+  });
+  it('global emitter works as singleton', () => {
+    const handler = jest.fn();
+    emitter.on('global', handler);
+    emitter.emit('global', 123);
+    expect(handler).toHaveBeenCalledWith(123);
+    emitter.off('global', handler);
+  });
+});